Lưu trữ Lập Trình - Trang 19 trên 19

Tổng quan Trong Android, Service là một thành phần ứng dụng đặc biệt được thiết kế để thực hiện công việc dài hạn ở nền (background) mà không cần giao diện người dùng. Dưới đây là tổng quan về Service trong Android, […]

Tagged #android

Tổng quan

Trong Android, Service là một thành phần ứng dụng đặc biệt được thiết kế để thực hiện công việc dài hạn ở nền (background) mà không cần giao diện người dùng. Dưới đây là tổng quan về Service trong Android, giúp hiểu rõ hơn về vai trò và cách thức hoạt động của nó:

Loại Services:

Foreground Service: Chạy ở tiền cảnh và hiển thị một thông báo, đảm bảo rằng người dùng luôn biết service đang thực hiện công việc gì.
Background Service: Thực hiện các nhiệm vụ ở nền mà không cần người dùng tương tác trực tiếp. Lưu ý rằng, từ Android 8.0 (API level 26) trở đi, hệ thống hạn chế việc sử dụng background services.
Bound Service: Liên kết trực tiếp với một hoặc nhiều thành phần ứng dụng thông qua một giao diện gọi lại IBinder, chia sẻ trạng thái hoặc cho phép tương tác.

Vòng Đời của Service:

onCreate(): Gọi khi service được tạo lần đầu tiên.
onStartCommand(): Khi service được khởi động bởi startService(). Service có thể bắt đầu thực hiện một công việc dài hạn và không phải dừng cho đến khi công việc hoàn thành hoặc được yêu cầu dừng.
onBind(): Khi một thành phần khác muốn liên kết với service bằng bindService(). Phương thức này trả về một IBinder cho phép thành phần tương tác trực tiếp với service.
onUnbind(): Gọi khi tất cả các thành phần đã liên kết với service ngừng liên kết.
onRebind(): Gọi khi một thành phần liên kết lại với service sau khi đã có một lần onUnbind().
onDestroy(): Gọi khi service không còn được sử dụng và đang tiến tới bị hủy. Là cơ hội cuối cùng để dọn dẹp tài nguyên.

Quản Lý Service:

StartService(): Dùng để khởi động một service mà không cần liên kết với bất kỳ thành phần nào. Service sẽ tiếp tục chạy cho đến khi nó tự dừng lại hoặc được dừng bằng stopService() hoặc stopSelf().
BindService(): Cho phép một thành phần liên kết trực tiếp với service, thực hiện giao tiếp hai chiều.

Sử Dụng Service:

Thực hiện các nhiệm vụ nền như tải dữ liệu, phát nhạc, thực hiện I/O, thực hiện tính toán lớn.
Phục vụ cho các mục đích khác như tương tác với hardware (Bluetooth, GPS), thực hiện các công việc liên tục mà không cần tương tác của người dùng.

Service trong Android là công cụ mạnh mẽ cho phép ứng dụng thực hiện các công việc phức tạp ở nền mà không ảnh hưởng đến giao diện người dùng. Điều quan trọng là phải quản lý chúng một cách hiệu quả để không làm giảm hiệu suất của ứng dụng hoặc hệ thống.

Một service là một thành phần ứng dụng có thể thực hiện các thao tác nặng trong thời gian dài dưới background.
Service không có giao diện người dùng mà nó chạy ẩn, một khi đã start thì service sẽ tiếp tục chạy, ngay cả khi người dùng chuyển sang ứng dụng khác.
Hơn nữa, một thành phần có thể liên kết với một service để tương tác với nó hoặc thực hiện một giao tiếp liên tiến trình.
Một service có thể thực hiện các thao tác xử lý giao dịch mạng, chơi nhạc, đọc ghi dữ liệu, tương tác với content provider, tất cả thực hiện dưới background.

Các kiểu services

Có 3 loại service:
- Foreground service.
- Background service.
- Bound service.

Foreground

Foreground service là một service thực hiện một vài thao tác nào đó có thể được quan sát thấy bởi người dùng.
Ví dụ ứng dụng phát nhạc sử dụng foreground service để phát các bài hát.
Foreground service phải hiển thị một thông báo tới người dùng.
Foreground service tiếp tục chạy ngay cả khi người dùng không tương tác với ứng dụng.
Khi sử dụng foreground service, ta phải hiển thị một thông báo để người dùng nhận ra rằng service đang hoạt động.
Thông báo này không thể bị ẩn đi trừ khi service stop hoặc bị xóa khỏi foreground.

Background

Một background service thực hiện một thao tác không trực tiếp quan sát thấy bởi người dùng. Ví dụ, ứng dụng có thể sử dụng background service để nén ổ lưu trữ.
Nếu ứng dụng của ta nhắm mục tiêu API level 26 trở lên, hệ thống sẽ hạn chế chạy background service khi ứng dụng không ở foreground. Trong hầu hết trường hợp như truy cập thông tin vị trí từ background, ta nên sử dụng WorkManager thay vì background service.

Bound

Một bound service bị ràng buộc khi một thành phần ứng dụng nào đó liên kết với nó bằng cách gọi bindService().
Một bound service đề xuất một giao diện client-server cho phép các thành phần tương tác với service, gửi yêu cầu, nhận kết quả và ngay cả trường hợp liên tiến trình.
Một bound service còn hoạt động chừng nào thành phần ứng dụng còn liên kết với nó.
Nhiều thành phần ứng dụng có thẻ liên kết tới một service tại 1 thời điểm nhưng khi tất cả các thành phần hủy liên kết, service sẽ bị hủy.

Một service có thể là started service, bound service hoặc cả hai. Ta có thể start một service bằng cách sử dụng Intent như cách ta start một activity.

Lựa chọn giữa một service và một thread

Một service đơn giản là một thành phần có thể chạy độc lập dưới background ngay cả khi người dùng không tương tác với ứng dụng của ta. Do đó ta nên sử dụng service nếu đó là những gì ta muốn.
Nếu ta phải thực hiện công việc ngoài luồng chính nhưng chỉ khi người dùng tương tác với ứng dụng của ta, ta nên tạo một thread trong ngữ cảnh của các thành phần ứng dụng khác.
Ví dụ, nếu ta muốn phát nhạc nhưng chỉ khi activity đang hoạt động, ta có thể tạo một thread ở onCreate(), start nó ở onStart() và stop nó trong callback onStop(). Ta cũng cân nhắc sử dụng thread pool và trình xử lý từ gói java.util.concurrent hoặc Kotlin coroutines thay vì sử dụng Thread truyền thống.
Lưu ý rằng, nếu ta sử dụng service, nó cũng vẫn chạy trên main thread theo mặc định. Do đó ta vẫn nên tạo một thread trong service nếu nó thực hiện một tác vụ nặng hoặc các hoạt động có thể gây phong tỏa ứng dụng.

Nền tảng của service

Để tạo một service ta phải tạo một lớp con của Service hoặc sử dụng một trong các lớp con có sẵn của nó.
Trong triển khai, ta cần ghi đè vài callback để xử lý các thao tác chính trong vòng đời của service và cung cấp một kĩ thuật cho phép các thành phần liên kết tới service nếu phù hợp.
Các callback chính đó là:
- onStartCommand(): hệ thống gọi phương thức này bằng cách gọi tới startService() khi một thành phần ứng dụng khác như activity yêu cầu service phải được start. Khi phương thức này được thực thi, service đã được start và có thể chạy trong background vô thời hạn. Nếu ta triển khai callback này, ta phải kết thúc service khi công việc hoàn tất bằng cách gọi tới stopSelf() hoặc stopService(). Nếu ta chỉ muốn cung cấp liên kết với service, không cần triển khai callback này.
- onBind(): hệ thống gọi tới phương thức này bằng cách gọi bindService() khi một thành phần ứng dụng khác muốn liên kết với service. Trong triển khai của phương thức này, ta phải cung cấp giao diện trong đó mã khách có thể giao tiếp với service bằng cách trả về một IBinder. Ta luôn phải triển khai phương thức này, tuy nhiên nếu ta không muốn cho phép liên kết, ta nên return null.
- onCreate(): hệ thống gọi phương thức này để thực hiện các thủ tục thiết lập 1 lần khi service được khởi tạo(trước khi gọi onStartCommand() hoặc onBind()). Nếu service đã ở trạng thái đang hoạt động, phương thức này sẽ không được gọi.
- onDestroy(): hệ thống gọi phương thức này khi service không còn được sử dụng nữa và đang tiến tới bị hủy bỏ. Service của ta nên triển khai phương thức này để dọn dẹp tài nguyên như các thread, các trình lắng nghe sự kiện, các receiver. Đây là nơi nhận lời gọi cuối trước khi một service bị hủy bỏ hoàn toàn.
Nếu một thành phần ứng dụng khởi chạy service bằng lời gọi tới startService(), thì sau đó service sẽ tiếp tục hoạt động cho tới khi nó tự kết thúc với stopSelf() hoặc một thành phần khác kết thúc nó qua phương thức stopService().
Nếu một thành phần gọi bindService() để tạo service và onStartCommand() không được gọi, service chỉ hoạt động trong thời gian đúng bằng thời gian tồn tại của thành phần liên kết với nó. Sau khi tất cả các mã khách hủy liên kết(unbind), service sẽ kết thúc.
Hệ thống Android chỉ stop một service khi bộ nhớ quá ít và cần thu hồi tài nguyên cho các thành phần khác sử dụng. Nếu service đang liên kết tới một activity người dùng đang focus, nó hiếm khi bị kill.
Nếu service khai báo để chạy ở foreground, nó cũng hiếm khi bị kill.
Nếu service đã started và đang thực hiện thao tác chạy dài(long running), hệ thống sẽ đẩy nó xuống các vị trí thấp hơn trong danh sách các background task theo thời gian, và service trở nên có khả năng cao bị kill một khi đã started do vậy ta cần thiết kế sao cho nó có thể khởi động lại dễ dàng bởi hệ thống.
Nếu hệ thống kill một service, hệ thống sẽ khởi động lại service đó ngay khi tài nguyên sẵn sàng, nhưng điều này cũng còn tùy thuộc vào giá trị ta trả về từ trong onStartCommand().

Khai báo một service trong file manifest

Ta phải khai báo tất cả các service trong file manifest trước khi có thể sử dụng được chúng, giống như khai báo activity vậy.
Để khai báo service, ta sử dụng thẻ <service> đặt trong phần tử <application>. Ví dụ:

<manifest ... >
...
<application ... >
<service android:name=".ExampleService" />
...
</application>
</manifest>

Ta có thể bổ sung các thuộc tính khác của service như permission. Thuộc tính bắt buộc duy nhất phải có là android:name để chỉ định tên lớp Service.
Sau khi publish ứng dụng, đảm bảo rằng tên này không thay đổi để tránh lỗi code khi thực hiện các thao tác start, bind service.
Luôn sử dụng các intent tường minh để start service và không khai báo intent filter cho các service.
Nếu ta chỉ muốn service sẵn dùng với duy nhất ứng dụng của ta, hãy thêm thuộc tính android:exported=”false”.

Tạo một started service

https://youtube.com/watch?v=n5YCp1QWSCk%3Ffeature%3Doembed

Một started service là một service được thành phần ứng dụng khác khởi chạy bằng lời gọi tới startService() sau đó dẫn tới lời gọi onStartCommand().
Khi một service started, nó có vòng đời độc lập với thành phần đã start nó. Service có thể chạy dưới background vô hạn ngay cả khi thành phần start nó đã bị hủy.
Do đó service nên tự kết thúc bản thân nó khi hoàn tất công việc bằng cách gọi tới stopSelf() hoặc thành phần khác chủ động gọi stopService().
Một thành phần ứng dụng như activity có thể start service bằng cách gọi startService() và truyền vào đối tượng Intent chứa service cần khởi chạy và các dữ liệu mà service cần sử dụng. Service nhận intent này trong onStartCommand().
Ví dụ: activity cần lưu dữ liệu lên database online, nó có thể start service, gửi dữ liệu cần lưu vào Intent sau đó đẩy vào service. Service sẽ tiến hành nhận intent, kết nối internet, thực hiện giao tác database sau đó kết thúc và hủy đi.
Lớp Service là lớp cha của mọi service trong Android. Khi ta kế thừa lớp này, ta cần tạo một thread mới để thực hiện tất cả các công việc cần thiết. Theo mặc định, service sử dụng main thread, điều này có thể làm giảm hiệu năng của các activity đang chạy trong ứng dụng.
Android framework cung cấp JobIntentService thay thế cho IntentService tương thích với mọi phiên bản Android. Lớp này sử dụng một worker thread để xử lý tất cả các yêu cầu gửi đến, từng yêu cầu một theo thứ tự. IntentService đã lỗi thời từ Android 11, ta không nên sử dụng nữa.
Các phần sau đây sẽ mô tả cách thức triển khai service của riêng ta, tuy nhiên khuyến nghị cân nhắc sử dụng WorkManager thay thế trong hầu hết các trường hợp.

Kế thừa Service

Ta có thể kế thừa Service để xử lý các intent gửi tới. Code Kotlin:

class HelloService : Service() {
private var serviceLooper: Looper? = null
private var serviceHandler: ServiceHandler? = null
// Xử lý các thông tin nhận được trong thread
private inner class ServiceHandler(looper: Looper) : Handler(looper) {
override fun handleMessage(msg: Message) {
// ta thực hiện các công việc cần thiết ở đây. để đơn giản ta cho sleep 5s
try {
Thread.sleep(5000)
} catch (e: InterruptedException) {
// khôi phục trạng thái bị ngắt quãng.
Thread.currentThread().interrupt()
}
// stop service dựa trên startId do đó ta sẽ không stop nhầm
// sang service khác khi đang trong quá trình xử lý dở
stopSelf(msg.arg1)
}
}
override fun onCreate() {
// start thread để xử lý công việc tránh phong tỏa UI.
HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
start()
serviceLooper = looper
serviceHandler = ServiceHandler(looper)
}
}
override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show()
// sử dụng định danh startId để biết ta đang dừng ở yêu cầu nào
serviceHandler?.obtainMessage()?.also { msg ->
msg.arg1 = startId
serviceHandler?.sendMessage(msg)
}
// nếu bị kill, sau đó restart
return START_STICKY
}
override fun onBind(intent: Intent): IBinder? {
// không cung cấp binding, return null
return null
}
override fun onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show()
}
}

Ví dụ trên xử lý tất cả các lời gọi tới trong onStartCommand() và đẩy công việc xử lý cho Handler chạy trong một background thread. Nó hoạt động như IntentService và xử lý tất cả các yêu cầu một cách tuần tự, từng yêu cầu một. Ta có thể chỉnh sửa code cho phép chạy xử lý đồng thời nhiều yêu cầu.
Lưu ý rằng onStartCommand() cần trả về một giá trị số nguyên. Giá trị này dùng để mô tả cách hệ thống nên tiếp tục service trong trường hợp hệ thống kill service để thu hồi tài nguyên.
Giá trị trả về phải là một trong các hằng số sau:
- START_NOT_STICKY: nếu hệ thống kill service sau khi onStartCommand() trả về, không tái tạo service trừ khi có pending intent gửi đi. Đây là tùy chọn an toàn nhất để tránh chạy service không cần thiết và khi ứng dụng của ta có thể đơn giản khởi động lại bất kì công việc nào chưa hoàn tất.
- START_STICKY: nếu hệ thống kill service của ta sau khi onStartCommand() trả về, tái tạo lại service và gọi onStartCommand() nhưng không gửi lại intent cuối. Thay vào đó hệ thống gọi onStartCommand() với intent là null trừ khi có pending intent để khởi động service. Trong trường hợp đó các intent đã được gửi đi. Loại này phù hợp với trình phát media trong đó không thực thi lệnh nhưng chạy vô hạn và chờ một công việc mới để thực hiện.
- START_REDELIVER: nếu hệ thống kill service sau khi gọi onStartCommand() trả về, tái tạo lại service và gọi onStartCommand() với intent cuối trước đó đã gửi tới service. Bất kì pending intent nào còn lại sẽ được gửi tới lần lượt theo thứ tự. Loại này phù hợp với các service thực hiện các thao tác ngay lập tức cần khôi phục như tải một file từ internet.

Khởi chạy service

Ta có thể khởi chạy service từ một activity hoặc từ ứng dụng khác bằng cách truyền Intent vào phương thức startService() hoặc startForegroundService().
Ví dụ sau khởi chạy service đã tạo ở phần trên:

Intent(this, HelloService::class.java).also { intent ->
startService(intent)
}

Phương thức startService() ngay lập tức trả về, hệ thống Android sẽ gọi tiếp onStartCommand(). Nếu service chưa chạy thì hệ thống sẽ gọi onCreate() sau đó gọi onStartCommand().
Nếu service không cung cấp binding, intent cung cấp ở startService() chỉ sử dụng ở chế độ giao tiếp giữa thành phần ứng dụng và service.
Nếu ta muốn service gửi về một kết quả, mã khách start service có thể tạo một PendingIntent với broadcast và gửi nó vào service trong Intent dùng để start service. Service sau đó có thể sử dụng broadcast nhận được để gửi kết quả.
Nhiều lời gọi start service dẫn tới nhiều lần onStartCommand() được gọi, tuy nhiên chỉ cần 1 yêu cầu để dừng service với stopSelf() hoặc stopService().

Kết thúc một service

Một service được start phải tự quản lý vòng đời của chính nó, tức là hệ thống không stop hoặc hủy service trừ khi cần thu hồi tài nguyên và service tiếp tục hoạt động sau khi onStartCommand() trả về.
Service cần tự kết thúc nó với lời gọi stopSelf() hoặc bị kết thúc bởi các thành phần ứng dụng khác qua phương thức stopService().
Ngay khi nhận được yêu cầu stop service với một trong hai phương thức trên, hệ thống sẽ hủy service ngay khi có thể.
Nếu service của ta xử lý nhiều yêu cầu đồng thời gửi tới onStartCommand(), ta không nên stop service khi ta thực hiện xong việc xử lý một yêu cầu gửi tới vì có thể nhận thêm một yêu cầu khác khi đang hủy hoặc hủy giữa chừng khi đang thực hiện dở các yêu cầu khác.
Để tránh vấn đề này, ta sử dụng stopSelf(int) và truyền vào định danh của yêu cầu gửi tới để đảm bảo chỉ stop service dựa trên yêu cầu đang được thực thi khi thực hiện xong công việc. Các yêu cầu khác có startId không khớp sẽ không stop service chưa hoàn tất công việc.
Lưu ý rằng luôn kết thúc service chủ động bằng 1 trong hai cách thức đã trình bày ở trên để tiết kiệm pin, và các tài nguyên khác của thiết bị.

Tạo một bound service

Một bound service là service cho phép các thành phần ứng dụng khác kết nối tới nó qua lời gọi bindService() để tạo một kết nối ổn định dài hạn. Nó thường không cho phép các thành phần khác start nó bằng lời gọi startService().
Ta tạo một bound service khi ta muốn tương tác với service từ activity và các thành phần khác trong ứng dụng hoặc để cung cấp các tính năng trong ứng dụng của ta đến các ứng dụng khác qua giao tiếp liên tiến trình(IPC).
Để tạo bound service, triển khai callback onBind() và trả về một đối tượng IBinder định nghĩa giao diện cho phép giao tiếp giữa hai service. Các thành phần ứng dụng khác có thể gọi bindService() để truy cập vào giao diện và bắt đầu gọi các phương thức trong service.
Service này tồn tại chỉ để phục vụ thành phần ứng dụng liên kết tới nó. Do vậy khi không có thành phần nào liên kết tới service, hệ thống sẽ hủy bỏ service.
Ta không cần stop một bound service theo cách mà ta phải làm với các service khởi chạy với onStartCommand().
Để tạo bound service ta phải định nghĩa một interface chỉ định cách mã khách có thể giao tiếp với service. Interface này phải là một triển khai của IBinder và phải được trả về từ callback onBind(). Sau khi mã khách nhận được IBinder, nó có thể bắt đầu tương tác với service qua interface đó.
Nhiều mã khách có thể bind tới service đồng thời. Khi một mã khách kết thúc tương tác với service, nó gọi unbindService() để kết thúc liên kết. Khi không còn client nào liên kết tới bound service, hệ thống hủy bỏ service.
Có nhiều cách triển khai bound service và triển khai này phức tạp hơn nhiều so với started service. Chi tiết ta sẽ tìm hiểu trong bài học sau của chương này.

Gửi thông báo tới người dùng

Khi một service đang hoạt động nó có thể gửi thông báo tới cho người dùng ngay cả khi sử dụng snackbar notification hoặc status bar notification.
Một snackbar notification là một thông điệp xuất hiện trên bề mặt của cửa sổ hiện tại trong khoảng thời gian ngắn trước khi biến mất.
Một status bar notification cung cấp một icon trên thanh trạng thái với một thông báo mà người dùng có thể chọn để thực hiện một hành động.
Thông thường một thông báo trên thanh trạng thái là công nghệ tốt nhất để sử dụng khi thực hiện một công việc background ví dụ download file hoàn tất và người dùng giờ có thể thao tác với file đó.
Khi người dùng lựa chọn thông báo từ view mở rộng, thông báo đó có thể start một activity.

Quản lý vòng đời của một service

Vòng đời của một service đơn giản hơn nhiều so với của activity. Tuy nhiên ta cần lưu ý tới cách mà service được tạo và bị hủy đi bời vì một service có thể chạy trong background mà người dùng không hay biết.
Vòng đời của service từ khi được tạo ra tới khi bị hủy đi gồm hai phần:
- Started service: service được tạo khi một thành phần khác gọi startService(). Sau đó service chạy vô hạn và phải tự kết thúc bản thân nó với lời gọi tới stopSelf(). Một thành phần ứng dụng khác có thể kết thúc service bằng lời gọi tới stopService(). Khi service stop, hệ thống sẽ hủy bỏ nó.
- Bound service: service được tạo khi một mã khách gọi tới bindService(). Sau đó mã khách có thể giao tiếp với service thông qua interface IBinder. Mã khách có thể đóng kết nối với unbindService(). Nhiều mã khách có thể liên kết tới cùng một service và khi tất cả chúng hủy kết nối tới service này, hệ thống sẽ hủy bỏ service. Service không cần tự kết thúc bản thân nó.
Hai phần trên không hoàn toàn tách biệt nhau. Ta có thể liên kết tới một service đã được started trước đó với startService(). Ví dụ, ta có thể start một background music service bằng cách gọi tới startService() với một Intent chỉ định bài nhạc cần phát. Sau đó khi người dùng muốn mở rộng điều khiển để xem thông tin thêm về bài hát hiện tại, activity có thể bind tới service qua lời gọi bindService(). Trong trường hợp như này, stopService() hoặc stopSelf() không stop service cho tới khi tất cả các mã khách hủy liên kết tới service.

Triển khai callback vòng đời

Ta có thể triển khai các callback trong vòng đời của service để giám sát các thay đổi trong trạng thái và thực hiện các công việc vào thời điểm phù hợp.
Ví dụ sau cho ta cái nhìn cụ thể hơn:

class ExampleService : Service() {
private var startMode: Int = 0             // Chỉ định cách thức hoạt động khi service bị kill
private var binder: IBinder? = null        // interface cho mã khách liên kết tới
private var allowRebind: Boolean = false   // chỉ định liệu onRebind có được sử dụng
override fun onCreate() {
// tạo mới service
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
// service đang bắt đầu chạy
return startMode
}
override fun onBind(intent: Intent): IBinder? {
// mã khách đang liên kết tới service
return binder
}
override fun onUnbind(intent: Intent): Boolean {
// tất cả mã khách gọi phương thức này để hủy liên kết
return allowRebind
}
override fun onRebind(intent: Intent) {
// mã khách liên kết lại tới service sau khi gọi onUnbind()
}
override fun onDestroy() {
// service không còn được sử dụng và đang bị hủy
}
}

Điểm khác biệt của callback activity và callback của service là trong callback của service ta không phải gọi tới super() như trong callback của activity.
Sau đây là mô tả vòng đời của started service và bound service:

Trong hình trên phân tách rạch ròi giữa hai loại service nhưng lưu ý rằng cho dù được start bởi cách nào thì một service sau đó có thể được liên kết bằng lời gọi tới onBind().
Bằng cách triển khai các phương thức trên, ta có thể giám sát 2 vòng lặp lồng nhau của vòng đời service:
- Toàn bộ vòng đời của một service diễn ra giữa thời điểm onCreate() được gọi và thời điểm onDestroy() trả về. Giống như vòng đời activty, service khởi tạo vòng đời với onCreate() và giải phóng toàn bộ tài nguyên trong onDestroy(). Ví dụ service chơi nhạc có thể tạo các thread phát nhạc trong onCreate() và stop các thread đó trong onDestroy().
- Thời gian active của một service bắt đầu với lời gọi tới onStartCommand() hoặc onBind(). Mỗi phương thức xử lý Intent đã truyền vào startService() hoặc bindService(). Nếu service là started, thời gian active kết thúc cùng thời điểm kết thúc của toàn bộ vòng đời. Nếu service là bound service, thời gian active kết thúc khi onUnbind() trả về.

BigO là gì? Tất tần tật về BigO trong cấu trúc dữ liệu và giải thuật! Kèm ví dụ + code

Cấu Trúc Dữ Liệu & Giải Thuật

Lập Trình

4 min
2 năm ago
1
4

Chào các bạn, chắc hẳn khi bước vào ngành lập trình này các bạn đều quen với cụm từ BigO. Vậy BigO là gì và nó có ý nghĩa như nào thì mời bạn chiêm nghiệm bài viết của mình ngay sau […]

Tagged #ctdl&gt

Top Câu Hỏi Phỏng Vấn Cấu Trúc Dữ Liệu & Giải Thuật Mới Nhất, Hay Gặp Nhất!

Cấu Trúc Dữ Liệu & Giải Thuật

Lập Trình

25 min
2 năm ago
4

Hi guys, hôm nay phaken.com chia sẻ cho các bạn bộ câu hỏi phỏng vấn cấu trúc dữ liệu & giải thuật. Đây là bộ câu hỏi với tỷ lệ gặp khá cao 70%, không những vậy nó còn là kiến thức […]

Tagged #ctdl&gt

Hi guys, hôm nay phaken.com chia sẻ cho các bạn bộ câu hỏi phỏng vấn cấu trúc dữ liệu & giải thuật. Đây là bộ câu hỏi với tỷ lệ gặp khá cao 70%, không những vậy nó còn là kiến thức cơ bản để các bạn có thể ứng dụng trong công việc và học tập. Mời mọi người cùng tham khảo nhé! Còn về code thì trong bài này mình dùng javascript cho tiện nhé!

Tìm phần tử ở giữa Linked List sau 1 lần duyệt

Để tìm phần tử ở giữa của một danh sách liên kết (Linked List) chỉ sau một lần duyệt, bạn có thể sử dụng phương pháp “Pointer chạy nhanh và chạy chậm” (Fast and Slow Pointer method). Ý tưởng là bạn sẽ có hai con trỏ: một con trỏ chạy nhanh (fast pointer) di chuyển 2 nút/lần và một con trỏ chạy chậm (slow pointer) di chuyển 1 nút/lần. Khi con trỏ nhanh đến cuối danh sách, con trỏ chậm sẽ ở giữa danh sách. Dưới đây là cách thực hiện:

Khởi tạo hai con trỏ, slow và fast, cùng trỏ đến đầu danh sách liên kết.
Trong mỗi bước lặp, di chuyển slow 1 nút và fast 2 nút.
Khi fast đến cuối danh sách (nghĩa là fast là NULL hoặc fast.next là NULL), slow sẽ ở vị trí giữa của danh sách.

Dưới đây là một ví dụ về mã giả (pseudocode) thực hiện phương pháp này:

function findMiddle(head) {
if (head == null) {
return null; // Danh sách rỗng không có phần tử giữa
}
slow = head;
fast = head;
while (fast != null && fast.next != null) {
slow = slow.next; // Di chuyển slow 1 bước
fast = fast.next.next; // Di chuyển fast 2 bước
}
// Khi vòng lặp kết thúc, slow sẽ ở vị trí giữa của danh sách
return slow;
}

Lưu ý: Trong trường hợp danh sách có số lượng phần tử chẵn, có hai phần tử có thể được coi là “ở giữa”. Phương pháp trên sẽ trả về phần tử đầu tiên trong hai phần tử giữa đó.

Bạn có thể đọc thêm kiến thứ LinkList ở đây!

LinkList javascript:

Làm thế nào đế xác định một danh sách liên kết vòng?

Để xác định một danh sách liên kết có chứa vòng hay không, bạn cũng có thể sử dụng thuật toán “Tortoise and Hare” (Rùa và Thỏ), giống như khi tìm phần tử giữa. Trong trường hợp này, thuật toán hoạt động dựa trên nguyên tắc sau: nếu có một vòng trong danh sách, thì con trỏ “Thỏ” (di chuyển nhanh gấp đôi so với “Rùa”) cuối cùng sẽ gặp lại “Rùa” ở một điểm nào đó trong vòng.

Dưới đây là cách thực hiện thuật toán này bằng JavaScript:

class ListNode {
constructor(value) {
this.value = value;
this.next = null;
}
}
function hasCycle(head) {
let slow = head;
let fast = head;
while (fast !== null && fast.next !== null) {
slow = slow.next; // Di chuyển slow 1 bước
fast = fast.next.next; // Di chuyển fast 2 bước
// Nếu slow và fast gặp nhau, có nghĩa là danh sách có vòng
if (slow === fast) {
return true;
}
}
// Nếu fast chạy đến cuối danh sách mà không gặp slow, danh sách không có vòng
return false;
}
// Ví dụ sử dụng
const head = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
head.next.next.next = new ListNode(4);
head.next.next.next.next = head.next; // Tạo một vòng
console.log(hasCycle(head)); // In ra true, vì danh sách có vòng

Trong ví dụ trên, một danh sách liên kết được tạo với một vòng: nút cuối cùng liên kết trở lại nút thứ hai, tạo thành một vòng. Hàm hasCycle sẽ trả về true khi phát hiện vòng và false nếu không có vòng trong danh sách liên kết.

Xác định giá trị 2 phần tử trùng nhau trong một mảng các số nguyên (từ 1-100)

Để xác định giá trị của 2 phần tử trùng nhau trong một mảng các số nguyên từ 1 đến 100, bạn có thể sử dụng một số phương pháp khác nhau. Một trong những cách đơn giản và hiệu quả là sử dụng một bảng hash (trong JavaScript, đó có thể là một đối tượng hoặc một Set) để theo dõi các số đã xuất hiện trong mảng. Khi gặp một số đã tồn tại trong bảng hash, bạn đã tìm thấy số trùng lặp.

Dưới đây là cách thực hiện bằng JavaScript:

function findDuplicate(nums) {
const seen = new Set();
for (const num of nums) {
if (seen.has(num)) {
return num; // Số này đã xuất hiện trước đó, do đó nó là giá trị trùng lặp
}
seen.add(num);
}
return null; // Không tìm thấy số trùng lặp
}
// Ví dụ sử dụng
const nums = [1, 3, 4, 2, 5, 3]; // Mảng số nguyên với 3 là số trùng lặp
console.log(findDuplicate(nums)); // In ra 3

Phương pháp này có độ phức tạp về thời gian là O(n) và độ phức tạp về không gian là O(n), với n là số lượng phần tử trong mảng. Điều này là do bạn cần duyệt qua mỗi phần tử một lần và lưu trữ các phần tử đã thấy trong một cấu trúc dữ liệu bổ sung.

Nếu mảng chỉ chứa các số nguyên từ 1 đến 100 và chỉ có một giá trị trùng lặp, bạn cũng có thể sử dụng một phương pháp toán học bằng cách tính tổng của tất cả các số từ 1 đến 100 và so sánh nó với tổng thực tế của mảng. Sự chênh lệch giữa hai tổng này sẽ là giá trị trùng lặp. Tuy nhiên, phương pháp này chỉ hiệu quả khi chỉ có một giá trị trùng lặp.

Đảo một xâu ký tự?

Để đảo một xâu ký tự trong JavaScript, bạn có thể sử dụng một số phương pháp khác nhau. Một trong những cách đơn giản nhất là sử dụng các phương thức chuỗi và mảng có sẵn như split, reverse, và join. Dưới đây là cách thực hiện:

function reverseString(s) {
// Chuyển đổi xâu ký tự thành mảng, đảo mảng, và sau đó nối lại thành xâu ký tự
return s.split('').reverse().join('');
}
// Ví dụ sử dụng
const originalString = "Hello, World!";
const reversedString = reverseString(originalString);
console.log(reversedString); // "!dlroW ,olleH"

Trong đoạn mã trên, hàm reverseString nhận vào một xâu ký tự s, sau đó:

Sử dụng split('') để chuyển đổi xâu ký tự thành một mảng của các ký tự.
Sử dụng reverse() để đảo ngược thứ tự của các ký tự trong mảng.
Cuối cùng, sử dụng join('') để nối các ký tự trong mảng đảo ngược lại thành một xâu ký tự mới.

Phương pháp này là một cách đơn giản và hiệu quả để đảo một xâu ký tự trong JavaScript.

Stack vs Queue? ứng dụng trong các bài toán nào thực tế, ví dụ, sự giống và khác nhau, nên dung cái nào?

Stack (Ngăn xếp) và Queue (Hàng đợi)

Stack và Queue là hai cấu trúc dữ liệu cơ bản được sử dụng rộng rãi trong lập trình và có ứng dụng trong nhiều bài toán thực tế. Chúng khác nhau chủ yếu ở cách thức tổ chức và quản lý dữ liệu.

Stack

Đặc điểm: LIFO (Last In, First Out) – phần tử cuối cùng được thêm vào là phần tử đầu tiên được lấy ra.
Ứng dụng:
Quản lý các hoạt động gọi hàm trong các ngôn ngữ lập trình.
Giải bài toán đảo ngược, như đảo ngược chuỗi.
Xử lý biểu thức toán học (ví dụ, chuyển đổi từ biểu thức infix sang postfix).
Duyệt cây theo thứ tự sâu (Depth-First Search).

Queue

Đặc điểm: FIFO (First In, First Out) – phần tử đầu tiên được thêm vào là phần tử đầu tiên được lấy ra.
Ứng dụng:
Quản lý các tiến trình trong hệ điều hành.
Xử lý các yêu cầu trên máy chủ, như trong các hệ thống hàng đợi.
Duyệt cây theo chiều rộng (Breadth-First Search).
Mô phỏng hàng đợi trong thực tế, như hàng đợi tại ngân hàng.

Sự Giống và Khác Nhau

Giống nhau: Cả hai đều là cấu trúc dữ liệu dùng để lưu trữ và quản lý dữ liệu. Trong cả hai cấu trúc, việc thêm (enqueue/push) và lấy ra (dequeue/pop) dữ liệu tuân theo một trật tự nhất định.
Khác nhau:
Trật tự thao tác: Stack tuân theo LIFO, trong khi Queue tuân theo FIFO.
Ứng dụng: Stack thường được sử dụng trong các tình huống xử lý có tính chất “ngược”, còn Queue được ứng dụng trong các tình huống xử lý có tính chất “tuần tự”.

Nên Dùng Cái Nào?

Lựa chọn phụ thuộc vào bài toán cụ thể bạn đang giải quyết:
Sử dụng Stack khi bạn cần xử lý dữ liệu theo trật tự ngược lại hoặc cần duyệt cây/theo dõi các phần tử theo thứ tự sâu.
Sử dụng Queue khi bạn cần xử lý dữ liệu theo thứ tự chúng được thêm vào hoặc khi mô phỏng các tình huống hàng đợi trong thực tế.

Cả hai cấu trúc này đều có vai trò quan trọng trong việc giải quyết các vấn đề lập trình và thiết kế thuật toán, và việc lựa chọn sử dụng cái nào phụ thuộc vào yêu cầu cụ thể của bài toán bạn đang đối mặt.

Xác định nhiều phần tử trùng giá trị trong mảng bất kỳ

Để xác định nhiều phần tử trùng giá trị trong một mảng bất kỳ trong JavaScript, bạn có thể sử dụng một đối tượng để lưu trữ số lần xuất hiện của mỗi phần tử. Đối với các giá trị dạng số nguyên và chuỗi, việc này khá đơn giản. Tuy nhiên, để so sánh các đối tượng, bạn cần một cách để biểu diễn chúng dưới dạng chuỗi hoặc sử dụng một phương pháp so sánh đối tượng tùy chỉnh, vì JavaScript không so sánh trực tiếp được đối tượng theo giá trị.

Dưới đây là cách bạn có thể xác định các phần tử trùng giá trị trong mảng cho cả số nguyên, chuỗi, và đối tượng:

function findDuplicates(arr) {
const elementCount = {};
const duplicates = [];
arr.forEach(item => {
// Biểu diễn đối tượng dưới dạng chuỗi JSON để so sánh
const key = typeof item === 'object' ? JSON.stringify(item) : item;
elementCount[key] = (elementCount[key] || 0) + 1;
});
for (const [key, count] of Object.entries(elementCount)) {
if (count > 1) {
// Chuyển đổi chuỗi JSON trở lại thành đối tượng nếu cần
duplicates.push(typeof arr[0] === 'object' ? JSON.parse(key) : key);
}
}
return duplicates;
}
// Ví dụ sử dụng
const arr = [1, "apple", 1, "banana", "apple", { id: 1, name: "John" }, { id: 1, name: "John" }];
console.log(findDuplicates(arr));

Trong ví dụ trên:

Chúng tôi sử dụng JSON.stringify để biểu diễn các đối tượng dưới dạng chuỗi, cho phép chúng ta sử dụng chuỗi này làm khóa trong đối tượng elementCount. Điều này giúp so sánh giá trị của các đối tượng.
forEach được sử dụng để duyệt qua mỗi phần tử trong mảng và đếm số lần xuất hiện của chúng.
Cuối cùng, chúng tôi duyệt qua đối tượng elementCount để xác định những phần tử xuất hiện nhiều hơn một lần và thêm chúng vào mảng duplicates.

Lưu ý: Phương pháp này có một số hạn chế khi sử dụng JSON.stringify với đối tượng, như không xác định được sự khác biệt giữa các đối tượng có cùng cấu trúc nhưng khác tham chiếu và có thể không hoạt động đúng với các đối tượng chứa các thuộc tính có giá trị là hàm hoặc các loại đặc biệt khác.

Singly Linked List – Danh sách liên kết đơn VS Doubly Linked List – Danh sách liên kết kép ứng dụng trong các bài toán nào thực tế, ví dụ, sự giống và khác nhau, nen dung cái nào?

Singly Linked List (Danh sách liên kết đơn) và Doubly Linked List (Danh sách liên kết kép)

Cả Singly Linked List và Doubly Linked List đều là những cấu trúc dữ liệu cơ bản được sử dụng để lưu trữ một dãy các đối tượng một cách linh hoạt với khả năng thêm hoặc loại bỏ các phần tử một cách dễ dàng.

Singly Linked List

Đặc điểm: Mỗi nút (node) chứa dữ liệu và một liên kết (link) đến nút tiếp theo trong danh sách. Không có liên kết trở lại nút trước đó.
Ứng dụng:
Quản lý các tác vụ trong hệ điều hành.
Triển khai stack.
Các ứng dụng cần dễ dàng thêm hoặc xoá các phần tử ở đầu danh sách.

Doubly Linked List

Đặc điểm: Mỗi nút chứa dữ liệu, một liên kết đến nút tiếp theo và một liên kết đến nút trước đó. Điều này cho phép duyệt danh sách theo cả hai hướng.
Ứng dụng:
Triển khai các cấu trúc dữ liệu như hàng đợi (queue) và deque.
Cần duyệt hoặc chỉnh sửa danh sách từ cả hai hướng.
Quản lý các ứng dụng có yêu cầu cao về thao tác trên danh sách như trình duyệt web, ứng dụng soạn thảo văn bản.

Sự Giống và Khác Nhau

Giống nhau: Cả hai đều lưu trữ dữ liệu theo dạng danh sách, cho phép thêm và loại bỏ phần tử một cách linh hoạt không cần phải dịch chuyển các phần tử như trong mảng.
Khác nhau:
Singly Linked List chỉ cho phép duyệt từ đầu đến cuối danh sách, làm cho việc truy cập hoặc xóa một nút ở cuối danh sách trở nên kém hiệu quả.
Doubly Linked List cho phép duyệt từ cả hai hướng, từ đầu đến cuối hoặc ngược lại, làm tăng khả năng linh hoạt nhưng đồng thời cũng tăng chi phí bộ nhớ do cần lưu thêm liên kết đến nút trước đó.

Nên Dùng Cái Nào?

Lựa chọn tùy thuộc vào yêu cầu cụ thể của bài toán:
Singly Linked List thích hợp cho các ứng dụng đơn giản, nơi chỉ cần duyệt danh sách theo một hướng và không yêu cầu truy cập nhanh đến các nút trước đó.
Doubly Linked List phù hợp với các ứng dụng phức tạp hơn, cần truy cập hoặc chỉnh sửa danh sách từ cả hai hướng, hoặc khi cần thực hiện các thao tác trên danh sách một cách linh hoạt và hiệu quả hơn.

Cả hai loại danh sách liên kết đều có những ưu và nhược điểm riêng biệt, do đó việc lựa chọn sử dụng loại nào phụ thuộc vào yêu cầu cụ thể của ứng dụng và bài toán cần giải quyết.

List video về Single LinkList :

List video về Double LinkList :

Viết một chương trình in ra màn hình dãy Fibonacci

Dãy Fibonacci là một dãy số trong đó, mỗi số là tổng của hai số trước đó. Dãy bắt đầu từ 0 và 1. Dưới đây là một chương trình JavaScript đơn giản để in ra dãy Fibonacci:

function fibonacci(n) {
let n1 = 0, n2 = 1, nextTerm;
console.log('Dãy Fibonacci:');
for (let i = 1; i <= n; i++) {
console.log(n1);
nextTerm = n1 + n2;
n1 = n2;
n2 = nextTerm;
}
}
// Gọi hàm và in dãy Fibonacci với n số đầu tiên
fibonacci(10); // Thay đổi giá trị này để in nhiều hoặc ít số hơn

Chương trình này sử dụng một vòng lặp for để tính và in ra n số đầu tiên trong dãy Fibonacci. n1 và n2 lần lượt là hai số đầu tiên trong dãy, và nextTerm được sử dụng để lưu trữ tổng của hai số này, tức là số tiếp theo trong dãy.

Bạn chỉ cần thay đổi giá trị trong lời gọi hàm fibonacci(10); để in ra số lượng số Fibonacci mà bạn muốn.

Viết chương trình kiểm tra một số có phải là Palindrome không?

Dưới đây là một chương trình JavaScript để kiểm tra xem một số có phải là palindrome không. Một số được coi là palindrome nếu nó đọc giống nhau từ trái sang phải và từ phải sang trái.

function isPalindrome(number) {
// Chuyển đổi số thành chuỗi
const str = number.toString();
// Kiểm tra chuỗi đó có giống với chuỗi đảo ngược của nó không
const reversedStr = str.split('').reverse().join('');
// So sánh và trả về kết quả
return str === reversedStr;
}
// Ví dụ
const number = 12321;
console.log(`${number} là palindrome?`, isPalindrome(number)); // true
const anotherNumber = 123456;
console.log(`${anotherNumber} là palindrome?`, isPalindrome(anotherNumber)); // false

Chương trình này hoạt động bằng cách đầu tiên chuyển đổi số được kiểm tra thành một chuỗi. Sau đó, nó tạo một chuỗi đảo ngược bằng cách sử dụng các phương thức split(), reverse(), và join() của JavaScript. Cuối cùng, nó so sánh chuỗi ban đầu với chuỗi đảo ngược để xác định xem số đó có phải là palindrome không.

Trình bày về cây nhị phân tìm kiếm – Binary search tree. sơ đồ + hình ảnh, ứng dụng trong các bài toán nào thực tế, ví dụ, sự giống và khác nhau?

Cây Nhị Phân Tìm Kiếm (Binary Search Tree – BST)

Cây nhị phân tìm kiếm là một cấu trúc dữ liệu cây, trong đó mỗi nút có tối đa hai nút con, được gọi là nút con trái và nút con phải. Cây BST có tính chất đặc biệt là giá trị của mỗi nút phải lớn hơn tất cả các giá trị trong cây con trái của nó và nhỏ hơn (hoặc bằng, tùy thuộc vào định nghĩa) tất cả các giá trị trong cây con phải của nó. Tính chất này giúp việc tìm kiếm, thêm, và xóa các phần tử trong BST trở nên hiệu quả hơn so với các cấu trúc dữ liệu không có cấu trúc.

Ứng Dụng

BST được sử dụng rộng rãi trong các bài toán thực tế như:

Cơ sở dữ liệu: Quản lý dữ liệu có cấu trúc giúp việc tìm kiếm và cập nhật dữ liệu nhanh chóng.
Các hệ thống tìm kiếm: Phân loại và lưu trữ thông tin để tối ưu hóa việc truy xuất dữ liệu.
Tối ưu hóa truy xuất dữ liệu: Cung cấp cách tiếp cận hiệu quả để tìm kiếm và truy xuất dữ liệu.
Autocomplete: Sử dụng cây Trie (một biến thể của BST) để tìm kiếm nhanh các từ khóa gợi ý.
Cấu trúc dữ liệu trong trò chơi: Quản lý các đối tượng trong trò chơi để tối ưu hóa việc truy vấn và cập nhật trạng thái.

Sơ Đồ và Hình Ảnh

Dưới đây là mô tả sơ đồ của một cây nhị phân tìm kiếm cơ bản:

        8
/ \
3   10
/ \    \
1   6    14
/ \   /
4   7 13

Trong sơ đồ này:

Mỗi nút chứa một giá trị.
Nút con trái của một nút có giá trị nhỏ hơn nút đó.
Nút con phải của một nút có giá trị lớn hơn nút đó.

Sự Giống và Khác Nhau so với Các Cấu Trúc Dữ Liệu Khác

Giống: Giống như các cấu trúc dữ liệu cây khác, BST cho phép lưu trữ dữ liệu theo cách có cấu trúc, giúp tối ưu hóa việc truy xuất.
Khác:
So với cây nhị phân thông thường, BST có thêm tính chất tìm kiếm, làm cho việc tìm kiếm dữ liệu nhanh chóng và hiệu quả hơn.
So với danh sách liên kết, BST cho phép truy xuất dữ liệu nhanh hơn với độ phức tạp thời gian trung bình là O(log n) cho các thao tác tìm kiếm, thêm, và xóa, so với O(n) của danh sách liên kết.

Đảo vị trí các phần tử trong danh sách liên kết sử dụng đệ quy và duyệt tuần tự?

Để đảo ngược một danh sách liên kết sử dụng đệ quy và duyệt tuần tự, chúng ta sẽ xem xét hai cách tiếp cận khác nhau: một là sử dụng đệ quy, và một là sử dụng duyệt tuần tự (iterative). Cả hai phương pháp này đều có cùng mục đích nhưng theo hai cách thức hoạt động khác nhau.

Đảo Ngược Danh Sách Liên Kết Sử Dụng Đệ Quy

Trong cách tiếp cận này, chúng ta sẽ “đẩy” các phần tử vào call stack thông qua các lời gọi đệ quy và sau đó “pop” chúng ra trong quá trình quay lui (backtracking), đạt được việc đảo ngược danh sách.

class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
class Solution {
public ListNode reverseListRecursive(ListNode head) {
if (head == null || head.next == null) return head;
ListNode newHead = reverseListRecursive(head.next);
head.next.next = head;
head.next = null;
return newHead;
}
}

Đảo Ngược Danh Sách Liên Kết Sử Dụng Duyệt Tuần Tự

Trong cách tiếp cận này, chúng ta sẽ sử dụng một vòng lặp để di chuyển qua danh sách liên kết từ đầu đến cuối, đảo ngược liên kết giữa các nút một cách tuần tự.

class Solution {
public ListNode reverseListIterative(ListNode head) {
ListNode prev = null;
ListNode current = head;
while (current != null) {
ListNode nextTemp = current.next;
current.next = prev;
prev = current;
current = nextTemp;
}
return prev; // prev sẽ là new head của danh sách sau khi đảo ngược
}
}

Sự Khác Biệt

Đệ Quy:
Dễ đọc và hiểu hơn.
Có thể gặp vấn đề về stack overflow với danh sách liên kết rất dài do sử dụng bộ nhớ stack cho mỗi lời gọi đệ quy.
Duyệt Tuần Tự:
Hiệu quả hơn về mặt bộ nhớ vì không sử dụng bộ nhớ stack thêm cho mỗi lời gọi hàm.
Cách tiếp cận này ít trực quan hơn so với đệ quy nhưng tốt hơn cho danh sách liên kết có kích thước lớn.

Lựa Chọn Phương Pháp

Sử dụng đệ quy cho các danh sách liên kết có kích thước nhỏ đến trung bình để tận hưởng mã nguồn gọn gàng và dễ hiểu.
Sử dụng duyệt tuần tự cho các danh sách liên kết lớn để tránh vấn đề với giới hạn độ sâu của

Cài đặt Stack trong js

Để cài đặt một Stack (Ngăn xếp) trong JavaScript, bạn có thể sử dụng một mảng để lưu trữ các phần tử. Stack là một cấu trúc dữ liệu tuân theo nguyên tắc LIFO (Last In, First Out), tức là phần tử cuối cùng được thêm vào là phần tử đầu tiên được lấy ra. Dưới đây là một ví dụ về cách cài đặt Stack sử dụng mảng trong JavaScript:

class Stack {
constructor() {
this.items = []; // Mảng để lưu trữ các phần tử trong Stack
}
// Thêm một phần tử vào đỉnh của Stack
push(element) {
this.items.push(element);
}
// Xóa và trả về phần tử ở đỉnh của Stack
pop() {
if (this.items.length == 0) {
return "Underflow"; // Stack rỗng
}
return this.items.pop();
}
// Trả về phần tử ở đỉnh của Stack mà không xóa nó
peek() {
return this.items[this.items.length - 1];
}
// Kiểm tra xem Stack có rỗng không
isEmpty() {
return this.items.length == 0;
}
// Trả về kích thước của Stack
size() {
return this.items.length;
}
// Xóa tất cả phần tử khỏi Stack
clear() {
this.items = [];
}
// In ra các phần tử của Stack
print() {
console.log(this.items.toString());
}
}
// Sử dụng Stack
const stack = new Stack();
console.log(stack.isEmpty()); // true
stack.push(10);
stack.push(20);
stack.push(30);
console.log(stack.peek()); // 30
console.log(stack.pop()); // 30
console.log(stack.size()); // 2
stack.print(); // 10,20

Trong ví dụ trên, Stack được cài đặt với các phương thức sau:

push(element): Thêm một phần tử vào đỉnh của Stack.
pop(): Xóa và trả về phần tử ở đỉnh của Stack.
peek(): Trả về phần tử ở đỉnh của Stack mà không xóa nó.
isEmpty(): Kiểm tra xem Stack có rỗng không.
size(): Trả về kích thước của Stack.
clear(): Xóa tất cả phần tử khỏi Stack.
print(): In ra các phần tử của Stack.

Cách tiếp cận này cho phép bạn quản lý một Stack một cách linh hoạt và hiệu quả trong JavaScript.

Cài đặt QUEUE trong js

Để cài đặt một Queue (Hàng đợi) trong JavaScript, bạn có thể sử dụng mảng để lưu trữ các phần tử. Queue là một cấu trúc dữ liệu tuân theo nguyên tắc FIFO (First In, First Out), tức là phần tử đầu tiên được thêm vào là phần tử đầu tiên được lấy ra. Dưới đây là một ví dụ về cách cài đặt Queue sử dụng mảng trong JavaScript:

class Queue {
constructor() {
this.items = []; // Mảng để lưu trữ các phần tử trong Queue
}
// Thêm một phần tử vào cuối Queue
enqueue(element) {
this.items.push(element);
}
// Xóa và trả về phần tử đầu tiên của Queue
dequeue() {
if (this.isEmpty()) {
return "Underflow"; // Queue rỗng
}
return this.items.shift();
}
// Trả về phần tử đầu tiên của Queue mà không xóa nó
front() {
if (this.isEmpty()) {
return "No elements in Queue";
}
return this.items[0];
}
// Kiểm tra xem Queue có rỗng không
isEmpty() {
return this.items.length === 0;
}
// Trả về kích thước của Queue
size() {
return this.items.length;
}
// Xóa tất cả phần tử khỏi Queue
clear() {
this.items = [];
}
// In ra các phần tử của Queue
print() {
console.log(this.items.toString());
}
}
// Sử dụng Queue
const queue = new Queue();
console.log(queue.isEmpty()); // true
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
console.log(queue.front()); // 10
console.log(queue.dequeue()); // 10
console.log(queue.size()); // 2
queue.print(); // 20,30

Trong ví dụ trên, Queue được cài đặt với các phương thức sau:

enqueue(element): Thêm một phần tử vào cuối Queue.
dequeue(): Xóa và trả về phần tử đầu tiên của Queue.
front(): Trả về phần tử đầu tiên của Queue mà không xóa nó.
isEmpty(): Kiểm tra xem Queue có rỗng không.
size(): Trả về kích thước của Queue.
clear(): Xóa tất cả phần tử khỏi Queue.
print(): In ra các phần tử của Queue.

Cách tiếp cận này giúp quản lý một Queue một cách linh hoạt và hiệu quả trong JavaScript, cho phép thực hiện các thao tác hàng đợi cơ bản như thêm, xóa và truy cập phần tử.

Nếu bạn nào chưa vững kiến thức về stack và queue thì đây là list video dành cho bạn nhé:

DeepLink Là Gì? Cách Config Deeplink Trong React Native!

Lập Trình

Lập Trình Mobile

React Native

13 min
2 năm ago
1
1

Chào anh em, nếu anh em nào đã làm việc với react native lâu rồi thì sẽ thấy có 1 số task người ta thường nhăc tới phải dùng deeplink,… Vậy thì deeplink là gì, ứng dụng trong những trường hợp nào và cách config deeplink cho phù hợp. Tất cả sẽ có trong bài viết này của mình mời ae tham khảo nhé!

Deeplink là gì ?

Deep linking trong React Native là một kỹ thuật cho phép người dùng mở một ứng dụng di động bằng cách sử dụng một URL cụ thể. Điều này có nghĩa là bạn có thể cung cấp một liên kết trực tiếp đến một phần cụ thể trong ứng dụng của mình từ một ứng dụng khác, một trang web, hoặc thậm chí từ một tin nhắn. Deep linking không chỉ giúp cải thiện trải nghiệm người dùng bằng cách giảm bớt số bước cần thiết để đạt được nội dung cụ thể mà họ quan tâm mà còn giúp tăng khả năng tương tác và giữ chân người dùng.

Có hai loại deep linking trong React Native:

1. Deep Linking Truyền Thống

Deep linking truyền thống cho phép mở ứng dụng thông qua một URL. Nếu ứng dụng không được cài đặt, quy trình này thường sẽ dẫn người dùng đến App Store hoặc Google Play Store để tải ứng dụng. Khi ứng dụng đã được cài đặt, mở URL sẽ khởi chạy ứng dụng và, nếu được cấu hình đúng cách, điều hướng người dùng đến nội dung cụ thể.

2. Universal Links (iOS) và App Links (Android)

Universal Links và App Links là những cải tiến so với deep linking truyền thống, cho phép liên kết mở trực tiếp trong ứng dụng mà không cần thông qua trình duyệt web. Điều này tạo ra trải nghiệm người dùng mượt mà hơn, vì nó loại bỏ các bước trung gian không cần thiết. Để sử dụng chúng, bạn cần cấu hình một số cài đặt trên cả server và ứng dụng.

Deeplink dùng trong những trường hợp nào?

Deep linking là một kỹ thuật cho phép ứng dụng di động được mở hoặc điều hướng đến một view cụ thể bằng cách sử dụng một URL duy nhất. Trong phát triển ứng dụng React Native, deep linking được sử dụng rộng rãi với nhiều mục đích khác nhau. Dưới đây là một số trường hợp sử dụng chính của deep linking:

1. Khuyến mãi và Quảng cáo

Deep linking cho phép các nhà tiếp thị tạo ra các chiến dịch quảng cáo điều hướng người dùng trực tiếp đến một phần cụ thể trong ứng dụng, như một trang sản phẩm cụ thể hoặc một chương trình khuyến mãi, từ một liên kết ngoài (ví dụ: từ một email, một bài viết trên mạng xã hội, hoặc một quảng cáo trực tuyến).

2. Chia sẻ Nội dung

Deep linking cho phép người dùng chia sẻ nội dung cụ thể từ bên trong ứng dụng của họ với người khác thông qua các ứng dụng nhắn tin hoặc mạng xã hội. Người nhận có thể nhấp vào liên kết để mở ứng dụng và xem nội dung đó ngay lập tức, ngay cả khi họ chưa từng cài đặt ứng dụng trước đó.

3. Tích hợp với Dịch vụ Bên Ngoài

Deep linking được sử dụng để tích hợp ứng dụng với các dịch vụ bên ngoài hoặc các ứng dụng khác. Ví dụ, một ứng dụng thanh toán có thể cho phép người dùng mở liên kết và thực hiện thanh toán trực tiếp trong ứng dụng từ một email hóa đơn.

4. Điều hướng Từ Thông báo Push

Deep linking rất hữu ích trong việc điều hướng người dùng từ thông báo push đến một phần cụ thể của ứng dụng. Điều này giúp tăng cường trải nghiệm người dùng bằng cách cung cấp một lối tắt trực tiếp đến nội dung hoặc chức năng liên quan đến thông báo.

5. Tái kích hoạt Người dùng

Deep linking có thể được sử dụng trong các chiến dịch tái kích hoạt để khuyến khích người dùng quay trở lại ứng dụng sau một thời gian không sử dụng. Các liên kết sâu có thể điều hướng họ đến các tính năng mới, ưu đãi đặc biệt, hoặc nội dung hấp dẫn để tăng cơ hội họ tương tác lại với ứng dụng.

6. Xử lý Liên kết Mở rộng

Trong một số trường hợp, deep linking được sử dụng để xử lý các liên kết mở rộng (universal links trên iOS và app links trên Android), cho phép ứng dụng của bạn mở liên kết từ trình duyệt web trực tiếp vào ứng dụng, nếu ứng dụng đã được cài đặt.

Deep linking tăng cường khả năng tương tác và sự tiện lợi cho người dùng cuối bằng cách cung cấp một cách thức nhanh chóng và trực tiếp để truy cập nội dung và chức năng trong ứng dụng, từ bên ngoài ứng dụng. Điều này không chỉ cải thiện trải nghiệm người dùng mà còn hỗ trợ các mục tiêu kinh doanh và marketing bằng cách tăng cường sự tương tác và giữ chân người dùng.

Cách Thiết Lập Deep Linking trong React Native

Cấu hình deep linking trong React Native cho phép ứng dụng của bạn mở từ một URL đặc biệt hoặc một liên kết từ một trang web, một ứng dụng khác, hoặc thậm chí từ một tin nhắn. Điều này tạo điều kiện cho người dùng truy cập trực tiếp vào một phần cụ thể trong ứng dụng của bạn mà không cần phải đi qua trang chủ hoặc menu chính. Dưới đây là cách bạn có thể cấu hình deep linking cho ứng dụng React Native của mình, sử dụng React Navigation, một thư viện phổ biến cho việc điều hướng trong React Native.

1. Cài đặt React Navigation

Nếu bạn chưa cài đặt React Navigation, hãy bắt đầu bằng cách cài đặt nó:

npm install @react-navigation/native

Cài đặt các dependencies cần thiết cho expo hoặc react-native-cli:

Với Expo:

expo install react-native-screens react-native-safe-area-context

Với React Native CLI:

npm install react-native-screens react-native-safe-area-context
npx pod-install

2. Cấu Hình Deep Linking

Sau khi đã cài đặt React Navigation, bạn có thể tiếp tục cấu hình deep linking. Đầu tiên, bạn cần xác định cấu trúc liên kết cho ứng dụng của mình:

const config = {
screens: {
Home: 'home',
Details: 'details/:id',
// Thêm các màn hình khác tại đây
},
};
const linking = {
prefixes: ['https://example.com', 'myapp://'],
config,
};

Trong ví dụ trên, prefixes chứa các URL mà ứng dụng của bạn sẽ phản hồi. config xác định cấu trúc URL cho từng màn hình trong ứng dụng.

3. Áp Dụng Cấu Hình vào Navigator

Tiếp theo, hãy áp dụng cấu hình deep linking vào navigator của bạn:

import { NavigationContainer } from '@react-navigation/native';
function App() {
return (
<NavigationContainer linking={linking}>
{/* Nội dung Navigator của bạn ở đây */}
</NavigationContainer>
);
}

4. Xử Lý Deep Link Trong Mã Native

Android

Mở file android/app/src/main/AndroidManifest.xml và thêm intent filter vào activity chính của bạn:

<activity
android:name=".MainActivity"
android:launchMode="singleTask">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<!-- Xử lý liên kết từ trình duyệt -->
<data android:scheme="https"
android:host="example.com" />
<!-- Xử lý liên kết tùy chỉnh myapp:// -->
<data android:scheme="myapp" />
</intent-filter>
</activity>

iOS

Mở file ios/<Tên Dự Án>/Info.plist và thêm cấu hình URL scheme:

<key>CFBundleURLTypes</key>
<array>
<dict>
<key>CFBundleURLSchemes</key>
<array>
<string>myapp</string>
</array>
</dict>
</array>

Và cho Universal Links:

<key>com.apple.developer.associated-domains</key>
<array>
<string>applinks:example.com</string>
</array>

Bằng cách cấu hình như trên, bạn đã thiết lập cơ bản cho việc xử lý deep linking trong ứng dụng React Native của mình. Người dùng có thể mở ứng dụng từ các liên kết có cấu trúc theo định nghĩa của bạn, dẫn họ đến nội dung cụ thể trong ứng dụng.

Ngoài ra, bạn có thể tham khảo các video khá dễ hiểu và dễ làm dưới đây:

Phá Kén

Danh mục: Lập Trình

Tổng quan về Service trong Android

BigO là gì? Tất tần tật về BigO trong cấu trúc dữ liệu và giải thuật! Kèm ví dụ + code

Top Câu Hỏi Phỏng Vấn Cấu Trúc Dữ Liệu & Giải Thuật Mới Nhất, Hay Gặp Nhất!

DeepLink Là Gì? Cách Config Deeplink Trong React Native!