document.txt

setTimeout(() => {
    console.log(`hello word`);
}, 5000); // Sau 5000 mini Giây thì nó sẽ thực thi câu lệnh.

SetInterval(()=>{
    console.log(`hello word`)
}, 1000); // Sau 1000 mini giây thì nó sẽ thực hiện lại câu lệnh đó. Đến khi nào stop chương trình thì thôi

#################################################
// Việc thay thuộc tính kế thừa và thuộc tính bao đóng trong node JS cụ thể sẽ như sau.
const nameVariable = require('./fileName')  ~~~~ Đây là câu lệnh tương dương với lệnh import.
Cho phép truy cập vào tài nguyên của 1 file nào đó
*************************************************
Ở trong file được import vào
module.exports {variableNames/functionName....(Những cái gì được cấp quyền share ra ngoài thì nhét nó vào đây)}.
==> {
        Thằng khác muốn xài thì phải khai báo var/let/const variableNames = require('./fileName') ra thì mới dùng được.
            Xài theo syntax đối tượng 
                +variableNames.properties.
}

-------------------------------------------------------------------------------------------------------------------------
Cách để thêm nhiều đối tượng vào module.exports {}

Tạo 1 đối tượng trong file js, thay vì khai báo bằng const/let/var thì hãy khai báo trực tiếp bằng:
                                                module.exports.variableNames = {
                                                    thuộc tính: giá trị
                                                }
                                            Hoặc
                                                const/let/var variableNames={
                                                    properties: value,
                                                }
                                            module.exports.anotherVariableName = variableNames
-------------------------------------------------------------------------------------------------------------------------
Ngày thứ 3 học node js:
Module fs ----> Module đọc ghi file trong node js 

const {readFileSync, writeFileSync} require('fs')

2 thằng này làm nhiệm vụ đọc file và ghi file. Tụi nó sử dụng các hàm hỗ trợ theo tụi nó, khá giống với thư viện

Module path ===> module cho phép show hoặc đưa đường dẫn đến nơi hiện tại

const {path} require ('path')

thằng này làm nhiệm vụ show thông tin chi tiết đường dẫn mà mình muốn.
-------------------------------------------------------------------------------------------------------------------------
                                SYNC ================== ASYNC
    Sự khác biết của 2 thằng này đều nằm ở việc cách xử lý vấn đề của nó.
    SYNC thì xử lý thuần từ trên xuống dưới. Cái này đang chạy thì phải chạy xong rồi mới chạy cái tiếp theo.
    
    ASYNC thì xử lý nhanh hơn, hàm nào đang chạy mất thời gian thì kệ con mẹ nó, nó đi chạy thằng khác, mỗi thằng chạy mỗi phần
    đếch quan tâm làm gì cho mệt
        ==> Bất đồng bộ và Đồng bộ  

-------------------------------------------------------------------------------------------------------------------------

Http module: Là module để khởi tạo server phía back-end. Có chứa rất nhiều object trong req.

khi tạo server thì cần phải tạo const hằng số = http.createServer( (param trả về, ....)=> { code hoạt động chính nằm ở đây 
                                                                        http.end() ~~ dùng để kết thúc quá trình gửi request, nếu 
                                                                        trong quá trình kết thúc mà vẫn còn data thì sẽ bị gửi hết ra luồng chạy,
                                                                        Nếu đang chạy mà có callBack() là nó hủy luồng chạy
                                                                                        } )
                
                ()=> {} : Cái này lão john simlga gọi là rollback()
-------------------------------------------------------------------------------------------------------------------------

package.json là file lưu các cáu hình của project, các phiên bản để sau này cập nhập chỉ cần update nó lại thì tránh trường hợp bị lỗi code
-------------------------------------------------------------------------------------------------------------------------

Event Loop trong node js.
 -- Mỗi một người dùng gửi dữ liệu đến| thực hiện request đến phía server thì được xem như là 1 event.
 Các event Loop sẽ nhận các request rồi gửi xuống phía C++ thread pool.

 Rồi các thread pool của c++ sẽ trả lại theo cơ thế của first in first out (QUEUE của JAVA) 
 Mỗi event loop sẽ luôn đi kèm với hàm callBack() để khi nó thực hiện xong chức năng thì cái hàm call back này sẽ được gọi lại để thực hiện lần tiếp theo.
-------------------------------------------------------------------------------------------------------------------------

Luồng chạy đồng bộ và luồng chạy bất đồng bộ.
Bản chất JS là chạy single thread. Cho nên nó sẽ xử lý từ trên xuống dưới (rất chậm).
Cho nên nó đưa giải pháp đó là cho nó chạy bất đồng bộ. Nhưng mà bản chất đã là chạy đồng bộ rồi thì bây giờ nó có các xử lý bất đồng bộ khác

Cách node JS xử bất đồng bộ
- Khi bạn gọi 1 chức năng- Thì chức năng xử lý bằng cách truyền vào stack - stack sẽ xử lý hết cho đến khi stack trống.
nhưng ở trên google thì sẽ có 1 bộ xử lý của google.

Khi mà chạy các function thì phía browser sẽ nhận các function đó và gửi về phía stack,
web APIs browser sẽ tạo ra bộ đếm thời gian và xử lý xong thì gửi xuống queue luôn. Khi đó thì queue sẽ đưa về event loop và trả lại stack

* Lưu ý. tuyệt đối không được tạo một xử lý nào đó tại event loop khiến event loop chạy quá lâu.

-------------------------------------------------------------------------------------------------------------------------
const nameVariable = new Promise ((resolve, reject) =>{
    code thực hiện
})

nameVariable( param nếu có).then( nếu như code thực hiện thành công thì sẽ trả về đây).catch(nếu code có lỗi thì sẽ rơi vào catch)

* Tóm tắt: Promise gần giống với try catch, dùng để thực hiện code bất đồng bộ và bắt lỗi tại lúc thực hiện và trả về 2 tham số

* Ưu điểm hơn so với callBack.

-------------------------------------------------------------------------------------------------------------------------
20220905: tổng kết lại cả ngày hôm nay

Bắt đầu từ bài số 40.
Tình trạng bắt đầu không hiểu nó đang làm cc gì xuất hiện.
--
Event emitter: Thằng này nằm trong module event

Có chức năng là bắt sự kiện trong quá trình thực hiện của node js. Nó thể hiện được thông qua từ khoá event.on()
Trong từ khoá on() có 1 eventName: string và callBack function
Trong eventEmitter có nhiều hàm, có thể sử dụng. Cho phép chúng ta đặt tên điều kiện thông qua hàm on('tên đk', callBack)
rồi qua đó sử dụng .emit() để gọi ra cái điều kiện đó. 
Có một cái hay nữa, là các tham số trong hàm callBack sẽ thể hiện sự đa hình - nạp chồng cho các sự kiện cùng tên.
-------------------------------------------------------------------------------------------------------------------------
http cũng có sự kiện riêng của nó

Sự kiện request. Khi mà server chạy, thì nếu như người dùng hoặc chúng ta tác động/truy cập vào site thì phía site sẽ đưa 
về 1 event mặc định mang tên request. Vì vậy thằng server.on() nó sẽ bắt cái sự kiện đó

-------------------------------------------------------------------------------------------------------------------------

Streams trong node js
Một dạng collection của node js.
streams thì không tồn tại cùng một thời điểm, cho nên streams khá là tốt cho bộ nhớ, rất hiệu quả khi làm việc với các file dữ liệu lớn, big data 
Ngoài 4 cái sự kiện, thì còn 1 thằng nữa là on('open') thằng này sẽ chờ cho đến khi nào file đó mở được và bắt đầu đọc
thì mới thực hiện các tác vụ tiếp theo

.pipe() thằng này dùng để gửi dữ liệu được đọc từ trong cái file đó ra phía client

-------------------------------------------------------------------------------------------------------------------------

___EXPRESS JS___
-------------------------------------------------------------------------------------------------------------------------
Các phương thức HTTP get/post/patch/put/delete.
*Lưu ý: 'khi khởi tạo 1 server trong node js thì bắt buộc cần ít nhất 1 câu lệnh res.end() thì lúc này phía server nó mới load được. Nếu như không thì phía serve vẫn sẽ nhận yêu cầu muốn vào website của mình nhưng nó sẽ ở trạng thái treo chứ không hề xuất ra 1 trang trắng như mình tưởng.'

-------------------------------------------------------------------------------------------------------------------------
Các api cơ bản của thằng express js.
Nói chung cũng không có gì cao siêu cả, làm quen với mấy thằng app.get/put/post/patch

tiếp đến là việc sử dụng tham số, có sự khác lạ đối chút so với thằng java đó là mình đéo khai báo kiểu dữ liệu cho tham số

Thằng quần què js này nó tự hiểu luôn
mọi việc chúng ta cần làm| app.get('/api/abc/:nameParam')
:nameParam khi được nhập trên website nó sẽ tự động hiểu luôn
<=> :nameParam = {'cái đéo gì đó bạn nhập trên web'}
nhưng để tiện cho việc sử dụng hoặc điều kiện hóa cái nameParam đó
thì cần phải khai báo nó (dĩ nhiên rồi, đéo khai báo mà đòi dùng thì có cc nhé)
cú pháp =>   const {:nameParam} = req.param ~~~~~ Thấy ngôn ngữ này có nứng l k cơ chứ :))

-------------------------------------------------------------------------------------------------------------------------

Thứ gọi là middleware: Nghe fancy vãi cả buồi nhưng thực ra đó là service đó :> 
Vâng~ service của java, tên nghe technology vãi cả bìu nhưng hóa ra là bình mới rượu cũ

vì cơ bản nó là service nên đéo cần phải giải thích thêm.

Cơ mà thay vì lúc trước xài @controller, @requestMapping("/api/v1")
Thì thằng này xử dụng 1 thứ khác.
const logger = require('./một cái file nào đó mà m viết ở một thư mục nào đó) .         ------> là thứ chó này nè :)))
app.use('đây là cái chỗ điều kiện, để cho thằng use này nó hiểu nó sẽ chạy khi nào', tên của cái mày mới khai báo)

thứ củ lìn này sẽ chạy nếu như cái request của m, có chứa cái đoạn điều kiện đó

ví dụ như url = https://tênmiền/api/user/cái quần què gì đó

app.use('user', thêm mới nhân vật)

Vì url có chữ user nên nó làm cho con dog app.use chạy
bất ngờ chưa, bất ngờ vl
-------------------------------------------------------------------------------------------------------------------------

Tóm tắt lại sau khi hoàn thành khoá express tutorial.

Khi sử dụng express thì gần như là bản syntax thu gọn của js trong node js

flow của express js cũng rất đơn giản

user gửi 1 request xuống phía dưới server. Sau đó thì routes sẽ xử lý các request đó.
1-Request: User gửi request xuống.
2-middleware: Đây giống như là phần service trong spring, được xử dụng để lọc các request, validate, bắt các exception.
3-response: Sau khi các middleware đã xử lý hết các request không đúng quy định. Thì chỉ còn các request được chấp nhận và phía server sẽ trả lại các kết quả/phản hồi mà request hoặc chức năng đó yêu cầu.
....
Cách phân chia bố cục và hầu hết là theo mô hình MVC

đầu tiên là file app.js. Đây sẽ là file chạy toàn bộ dự án tương tương main()
Tiếp theo sẽ là các controller.
Tạo các controller rồi trả cho thằng routes để nó gọi, 
Dưới controller thì gọi tiếp middleware để nó xử lý và phía database để nó trả vè những gì nó muốn.

------------------------------------------------------------------------------------------------------------------------------------

Viết API task manager với front-end lấy từ git hub của lão john về