6 sự khác nhau giữa setinterval và settimeout là gì

Nếu bạn không muốn một hàm của mình thực hiện ở thời điểm hiện tại mà sẽ thực hiện ở một thời điểm khác thì trong Javascript có 2 phương thức để làm việc đó là:

• function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000); 1 cho phép chạy một chức năng một lần sau khoảng thời gian.
• function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000); 2 cho phép chúng ta chạy một hàm lặp đi lặp lại, bắt đầu sau khoảng thời gian, sau đó lặp lại liên tục trong khoảng thời gian đó.

setTimeout()

Cú pháp

let demo = setTimeout(func|code, [delay], [arg1], [arg2], ...) Trong đó:

• func|code: Hàm hoặc code thực thi
• delay: Độ trễ thời gian chạy chương trình, tính bằng mili giây (1000 ms = 1 giây), theo mặc định là 0
• arg1, arg2, ... : Đối số cho hàm

Ví dụ sau đây sẽ giúp bạn dễ hình dung hơn:

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

Hàm sayHi() sẽ được gọi sau thời gian 1 giây.

Ví dụ với hàm có tham số:

function sayHi(thamso1, thamso2) { alert( thamso1+ ', ' + thamso2); } setTimeout(sayHi, 1000, "Hello", "Thái"); // Kết quả

Nếu đối số đầu tiên là một chuỗi, thì JavaScript sẽ tạo một hàm từ nó. Do đó bạn cũng có thể làm như sau:

setTimeout("alert('Hello')", 1000);

Hoặc bạn có thể sử dung arrow functions như sau:

setTimeout(() => alert('Hello'), 1000);

Lỗi mà mọi người thường gặp trong quá trình sử dụng setTimeout() là việc thêm dấu

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

3 vào sau hàm:

setTimeout(sayHi(), 1000); // Kết quả undefined

\==> Vì

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

1 mong đợi một tham chiếu đến một hàm. Và ở đây

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

5chạy hàm, và kết quả thực thi của nó được chuyển tới

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

1. Vì thế, kết quả của

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

5 là

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

8 , vì vậy không có gì được lên lịch.

clearTimeout()

Khi sử dụng setTimeout nó cũng sẽ trả về một timerId mà chúng ta có thể sử dụng để hủy bỏ việc thực thi.

Cú pháp

let timerId = setTimeout(...); clearTimeout(timerId);

Ví dụ

let timerId = setTimeout(() => alert("Hủy bỏ !"), 1000); alert(timerId); clearTimeout(timerId); alert(timerId);

Trong đoạn code trên tôi đã lên lịch cho chức năng và sau đó hủy bỏ nó, vậy nên sẽ không có gì xảy ra. Kết quả trả về của tôi sẽ chỉ là 1 số nào đó.

setInterval()

Cú pháp

let demo = setInterval(func|code, [delay], [arg1], [arg2], ...)

Các đối số của setInterval() cũng giống với setTimeout(), nhưng thay thay vì chạy chức năng một lần thì nó sẽ chạy thường xuyên sau một khoảng thời gian nhất định.

Ví dụ

var demo = setInterval(runAfter, 1000); function runAfter() { alert("Hello world!"); }

Sau 1 giây thì hàm runAfter() sẽ chạy và lặp lại liên tục

Để dừng việc lặp lại này ta có thể sử dụng

• clearInterval(timerId)

Ví dụ

function sayHi() { alert('Hello'); } setTimeout(sayHi, 1000);

0

Với đoạn code trên thì sau mỗi 2 giây sẽ hiển thị thông báo 1 lần và sau 5 giây thì hàm sẽ dừng lại.

Hy vọng bài viết giúp bạn hiểu rõ hơn về setInterval() và setTimeout(). Nếu cảm thấy bài viết có ích hãy chia sẻ để mọi người cùng biết nha!

Tag: Tim hieu ham setTimeout va setInterval trong JavaScript, cach su dung ham clearTimeout va clearInterval trong Javascript va su khac biet cua no. Huong dan hoc Javascript , Hoc Javascript truc tuyen , Tu hoc Javascript , Video huong dan hoc Javascript , download tai lieu hoc Javascript , hoc Javascript mien phi , hoc Javascript online , hoc Javascript truc tuyen , hoc Javascript co ban , hoc Javascript nang cao , tai lieu hoc Javascript , Ebook hoc Javascript , hoc Javascript can ban , sach hoc javascript , học lập trình javascript.

Đôi khi bạn cần phải thực hiện hành động sau một khoảng thời gian nhất định. Để thực hiện điều này, bạn có thể sử dụng phương thức

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0. Sau đây là cách khai báo và sử dụng setTimeout trong JavaScript.

Cú pháp hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 là:

  let timerId = setTimeout(func|code, [delay], [arg1], [arg2], ...)

Trong đó:

• function sayHi(message, who) { console.log(${message}, ${who});

  } setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

  2: là hàm hoặc string mô tả code để thực thi. Cách sử dụng thông thường là hàm. Cách sử dụng string được phép nhưng không khuyến khích.
• function sayHi(message, who) { console.log(${message}, ${who});

  } setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

  3: là thời gian trì hoãn trước khi hành động được thực hiện, tính theo mili giây. Giá trị mặc định của

  function sayHi(message, who) { console.log(${message}, ${who});

  } setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

  3 là

  function sayHi(message, who) { console.log(${message}, ${who});

  } setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

  5.
• function sayHi(message, who) { console.log(${message}, ${who});

  } setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

  6: là danh sách các tham số truyền vào hàm.

Ví dụ đoạn code sau gọi hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

7 sau 1 giây:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

Ví dụ với tham số truyền vào hàm:

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

Nếu tham số đầu tiên là string, JavaScript engine sẽ tạo hàm từ string đó để thực thi, ví dụ:

setTimeout("console.log('Hello')", 1000);

Tuy nhiên, cách sử dụng string là không được khuyến khích, bạn có thể thay thế bằng arrow function như sau:

setTimeout(() => console.log("Hello"), 1000);

Chú ý: Tham số đầu tiên là hàm, chứ không phải kết quả của việc gọi hàm, nhiều bạn hay bị nhầm lẫn như sau:

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

Khi gọi hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

8 như trên, kết quả của hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

8 được truyền vào hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0. Mà hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 chỉ chấp nhận truyền vào là function. Do đó, đoạn code trên sẽ không thực hiện gì sau 1 giây.

Khi bạn gọi hàm setTimeout trong JavaScript, kết quả trả về là một số nguyên

setTimeout("console.log('Hello')", 1000);

2 - định danh cho hành động với timeout. Để hủy bỏ hành động, bạn chỉ cần gọi

setTimeout("console.log('Hello')", 1000);

3 như sau:

let timerId = setTimeout(...);
    clearTimeout(timerId);

Ví dụ bạn dự định gọi một hàm sau khoảng thời gian delay là 1 giây. Nhưng sau đó, bạn lại hủy bỏ hành động này:

let timerId = setTimeout(() => console.log("sẽ không được gọi"), 1000);
console.log(timerId); // định danh cho timer
clearTimeout(timerId);
console.log(timerId); // timerId không đổi sau khi clearTimeout

Hàm

setTimeout("console.log('Hello')", 1000);

4 có cú pháp tương tự như hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0:

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

Trong đó, tất cả tham số đều có ý nghĩa giống với hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0.

Nhưng khác với hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 là chỉ thực hiện hành động một lần, hàm

setTimeout("console.log('Hello')", 1000);

4 sẽ gọi hàm thường xuyên sau mỗi khoảng thời gian delay.

Để dừng hành động, bạn chỉ cần gọi hàm

setTimeout("console.log('Hello')", 1000);

9.

Ví dụ sau hiển thị

setTimeout(() => console.log("Hello"), 1000);

0 sau mỗi 2 giây và sau đó 5 giây thì dừng lại:

// lặp lại với thời gian là 2000 ms (2 giây)
let timerId = setInterval(() => console.log("Hello"), 2000);
// sau 5 giây thì dừng lại
setTimeout(() => {
  clearInterval(timerId);
  console.log("stop");
}, 5000);

Ngoài cách sử dụng

setTimeout("console.log('Hello')", 1000);

4 để thực hiện một hành động lặp đi lặp lại, bạn có thể sử dụng hàm setTimeout trong JavaScript theo cách lồng nhau như sau:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

0

Trong ví dụ trên, cứ sau mỗi 2 giây thì hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

7 sẽ được gọi. Mà ở cuối hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

7 mình lại gọi tiếp

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 với hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

7 - tương tự cách gọi hàm đệ quy.

Cách gọi hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 lồng nhau như trên giúp bạn xử lý

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3 linh hoạt hơn so với cách dùng

setTimeout("console.log('Hello')", 1000);

4. Vì bạn có thể tùy chỉnh thời gian

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3 cho mỗi lần lặp.

Giả sử bạn cần tạo request lên server sau mỗi 5 giây để cập nhật dữ liệu. Tuy nhiên, server có thể bị quá tải. Dựa vào trạng thái server hiện tại, bạn có thể tăng thời gian delay lên 10, 20, 30, giây... cho phù hợp, ví dụ:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

1

► Cách sử dụng

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 lồng nhau cho phép

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3 chính xác hơn giữa mỗi lần thực hiện hành động so với cách dùng

setTimeout("console.log('Hello')", 1000);

4.

Ví dụ dùng

setTimeout("console.log('Hello')", 1000);

4:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

2

Ví dụ dùng

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 lồng nhau:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

3

Hàm

setTimeout("console.log('Hello')", 1000);

4 thực hiện hành động

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 sau mỗi 100ms. Tuy nhiên, hành động

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 cũng chiếm thời gian. Do đó, thời gian thực tế giữa hai lần chạy

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 là nhỏ hơn 100ms.

Thậm chí là thời gian chạy

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 có thể nhiều hơn 100ms thì lần chạy

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 tiếp theo sẽ được gọi ngay lập tức sau lần gọi trước. Nói cách khác là không có thời gian delay giữa hai lần chạy

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6.

Nhưng với cách sử dụng hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 lồng nhau thì khác. Với cách này, hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 tiếp theo chỉ được gọi khi hàm

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 thực hiện xong. Nghĩa là thời gian giữa hai lần chạy

// gọi hàm sayHi() thay vì truyền vào hàm sayHi
setTimeout(sayHi(), 1000);

6 sẽ đảm bảo khoảng 100ms.

Như mình đã nói trong bài viết về garbage collection trong JavaScript, khi một giá trị là không thể tiếp cận thì nó sẽ được giải phóng khỏi bộ nhớ.

Đối với hàm truyền vào

let timerId = setTimeout(...);
    clearTimeout(timerId);

6, JavaScript engine sẽ tạo một tham chiếu nội bộ tới hàm thực thi để đảm bảo hàm này không bị giải phóng.

Với hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0, hàm truyền vào sẽ được giữ trong bộ nhớ cho tới khi hàm được gọi:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

4

Với hàm

setTimeout("console.log('Hello')", 1000);

4, hàm truyền vào được giải phóng khỏi bộ nhớ sau khi gọi

let timerId = setTimeout(...);
    clearTimeout(timerId);

9.

Giả sử hàm truyền vào

setTimeout("console.log('Hello')", 1000);

4 tham chiếu đến biến bên ngoài. Vì hàm này luôn tồn tại cho đến khi gọi

let timerId = setTimeout(...);
    clearTimeout(timerId);

9, nên biến được tham chiếu đến cũng sẽ không được giải phóng.

Có một trường hợp đặc biệt với hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 là thời gian

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3 bằng 0.

Theo lý thuyết, khi

let timerId = setTimeout(() => console.log("sẽ không được gọi"), 1000);
console.log(timerId); // định danh cho timer
clearTimeout(timerId);
console.log(timerId); // timerId không đổi sau khi clearTimeout

4 thì hành động được thực hiện ngay lập tức. Nhưng thực tế, hành động sẽ được thực hiện ngay khi code luồng chính thực hiện xong, ví dụ:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

5

Trong ví dụ trên, câu lệnh

let timerId = setTimeout(() => console.log("sẽ không được gọi"), 1000);
console.log(timerId); // định danh cho timer
clearTimeout(timerId);
console.log(timerId); // timerId không đổi sau khi clearTimeout

5 được thực hiện trước. Và ngay sau khi câu lệnh này thực hiện xong thì câu lệnh

let timerId = setTimeout(() => console.log("sẽ không được gọi"), 1000);
console.log(timerId); // định danh cho timer
clearTimeout(timerId);
console.log(timerId); // timerId không đổi sau khi clearTimeout

6 được thực hiện.

Đối với cách gọi hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 lồng nhau, sau 5 lần gọi hàm, thời gian delay sẽ được set bằng 4ms, ví dụ:

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

6

Xem kết quả trên, bạn thấy rằng thời gian delay giữa mỗi lần gọi trong 5 lần đầu tiên là khoảng 2ms. Nhưng sau 5 lần thì thời gian delay tăng lên là khoảng 4ms.

Đây chính là giới hạn của hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 trên trình duyệt. Và giới hạn này cũng gặp phải khi sử dụng hàm

setTimeout("console.log('Hello')", 1000);

4.

Ở môi trường khác như phía server, giới hạn này không gặp phải vì trên Node.js có hàm .

Hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

0 trong JavaScript cho phép thực hiện hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

1 một lần sau một khoảng thời gian

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3 với các tham số truyền vào là

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

3.

Hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

4 cũng tương tự như hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0, nhưng hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

1 được thực hiện sau mỗi lần

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3.

Để hủy bỏ không gọi hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

1 nữa, bạn có thể gọi hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

9 hoặc

setTimeout("console.log('Hello')", 1000);

9 với

setTimeout("console.log('Hello')", 1000);

2 là kết quả trả về sau khi gọi hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 hoặc

setTimeout("console.log('Hello')", 1000);

4.

Việc gọi hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 lồng nhau giúp bạn xử lý linh hoạt giá trị

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

3 hơn so với cách sử dụng

setTimeout("console.log('Hello')", 1000);

4.

Trường hợp gọi hàm

// lặp lại với thời gian là 2000 ms (2 giây)
let timerId = setInterval(() => console.log("Hello"), 2000);
// sau 5 giây thì dừng lại
setTimeout(() => {
  clearInterval(timerId);
  console.log("stop");
}, 5000);

7 với giá trị

let timerId = setTimeout(() => console.log("sẽ không được gọi"), 1000);
console.log(timerId); // định danh cho timer
clearTimeout(timerId);
console.log(timerId); // timerId không đổi sau khi clearTimeout

4, tương đương với

// lặp lại với thời gian là 2000 ms (2 giây)
let timerId = setInterval(() => console.log("Hello"), 2000);
// sau 5 giây thì dừng lại
setTimeout(() => {
  clearInterval(timerId);
  console.log("stop");
}, 5000);

9 sẽ thực hiện hàm

let timerId = setInterval(func|code, [delay], [arg1], [arg2], ...)

1 ngay sau khi luồng code chính thực hiện xong.

Đối với trình duyệt, sau 5 lần gọi hàm

// lặp lại với thời gian là 2000 ms (2 giây)
let timerId = setInterval(() => console.log("Hello"), 2000);
// sau 5 giây thì dừng lại
setTimeout(() => {
  clearInterval(timerId);
  console.log("stop");
}, 5000);

9 lồng nhau hoặc với

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

02 thì thời gian delay được set khoảng 4ms.

Viết hàm

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

03 để in ra một số từ

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

04 đến

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

05 sau mỗi 1 giây theo hai cách:

1. Sử dụng

   setTimeout("console.log('Hello')", 1000);

   4.
2. Sử dụng function sayHi(message, who) { console.log(${message}, ${who});

   } setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

   0.

Xem đáp án

► Cách 1: sử dụng

setTimeout("console.log('Hello')", 1000);

4

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

7

► Cách 2: sử dụng

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

8

Trong đoạn code sau, hàm

function sayHi(message, who) {
  console.log(`${message}, ${who}`);
}
setTimeout(sayHi, 1000, "Hello", "Alex"); // Hello, Alex

0 được gọi với thời gian delay là 100ms.

Sau đó là một vòng lặp

function sayHi() {
  console.log("Hello");
}
setTimeout(sayHi, 1000); // Hello

11 với số lần lặp khoảng 100000000 lần. Mà thời gian thực hiện vòng lặp lớn này thường hơn 100ms.