Tổng hợp 500+ câu hỏi phỏng vấn Javascript

Trong Javascript, Javascript là một ngôn ngữ lập trình.

Trong JavaScript, null và undefined là hai giá trị đại diện cho sự không có giá trị.

Null là một giá trị phân biệt, khi bạn gán giá trị null cho một biến, nghĩa là bạn hiểu rõ rằng biến đó không có giá trị hoặc không tồn tại. Ví dụ:

let x = null; console.log(x); // null

Undefined là một giá trị mặc định của một biến khi nó được khai báo nhưng chưa được gán giá trị nào. Nó cũng có thể xuất hiện khi bạn truy cập vào một biến chưa được khai báo. Ví dụ:

let y; console.log(y); // undefined

Trong một số trường hợp, cả null và undefined có thể được coi là giống nhau như là sự không có giá trị. Tuy nhiên, null thường được sử dụng khi ta muốn rõ rằng biến không có giá trị, trong khi undefined thường được sử dụng khi cái biến vẫn chưa định nghĩa hoặc như một giá trị mặc định.

Trong Javascript, let, const và var là ba từ khóa được sử dụng để khai báo biến. Chúng khác nhau như sau:

1. var: Biến được khai báo bằng từ khóa var có phạm vi toàn cục (global scope) hoặc phạm vi hàm (function scope). Biến đó có thể được khai báo lại và gán giá trị mới, cũng như có thể được truy cập từ bất kỳ đâu trong phạm vi của nó.

Ví dụ:

var x = 5;
console.log(x); // Output: 5

function myFunc() {
  var y = 10;
  console.log(y); // Output: 10
}

console.log(y); // Error: y is not defined

2. let: Biến được khai báo bằng từ khóa let có phạm vi chỉ là khối mã (block scope) trong đó nó được khai báo. Biến có thể được khai báo lại nhưng chỉ trong phạm vi của khối mã đó.

Ví dụ:

let x = 5;
console.log(x); // Output: 5

if (true) {
  let y = 10;
  console.log(y); // Output: 10
}

console.log(y); // Error: y is not defined

3. const: Biến được khai báo bằng từ khóa const cũng có phạm vi khối mã (block scope) tương tự như let, nhưng khác biệt là biến const không thể được gán giá trị mới sau khi đã được khởi tạo.

Ví dụ:

const PI = 3.14159;
console.log(PI); // Output: 3.14159

PI = 3.14; // Error: Assignment to constant variable.

const myArr = [1, 2, 3];
myArr.push(4);
console.log(myArr); // Output: [1, 2, 3, 4]

Strict mode trong JavaScript là một cơ chế để kiểm tra lỗi và các chủ đề khiến mã JavaScript được thực thi trong một phiên bản phải tuân thủ các quy tắc nghiêm ngặt hơn. Dưới đây là một số lí do nên sử dụng strict mode trong JavaScript:

1. Hiệu suất nhanh hơn: Strict mode loại bỏ một số tính năng bất kỳ và sửa nó thành các lỗi. Điều này giúp trình duyệt biên dịch mã JavaScript nhanh hơn và cải thiện hiệu suất.

2. Kiểm tra lỗi: Strict mode giúp phát hiện các lỗi cú pháp phổ biến và cung cấp các thông báo lỗi rõ ràng hơn. Điều này giúp phát hiện và khắc phục lỗi một cách dễ dàng hơn.

3. Ngăn chặn việc sử dụng biến không được khai báo: Trong non-strict mode, việc sử dụng các biến chưa được khai báo sẽ tạo ra các biến toàn cục ngầm định, dẫn đến việc gây ra các lỗi khó dò mà không có lỗi ngoại lệ nào được ném ra. Strict mode tắt tính năng này và đưa ra một lỗi rõ ràng khi sử dụng biến chưa được khai báo.

4. Hạn chế việc sử dụng các từ khóa có ý nghĩa trong tương lai: Strict mode loại bỏ sự sử dụng các từ khóa có ý nghĩa trong tương lai như "implements", "interface" và "let" như tên biến.

5. Ngăn chặn việc ghi đè lên các hàm toàn cục: Strict mode không cho phép ghi đè lên các hàm toàn cục bằng cách khai báo biến có cùng tên với tên hàm. Điều này giúp tránh các lỗi xảy ra do việc sử dụng trùng tên biến.

6. Kiểm soát chặt chẽ hơn về việc sử dụng "this": Trong strict mode, khi "this" được sử dụng trong một hàm không được gọi thông qua phương thức của một đối tượng, nó sẽ là giá trị undefined thay vì đối tượng toàn cục như trong non-strict mode. Điều này giúp tránh việc sử dụng "this" một cách sai lầm và gây ra các lỗi không mong muốn.

Tổng quan, strict mode trong JavaScript giúp kiểm tra lỗi cú pháp, cung cấp các thông báo lỗi rõ ràng hơn, ngăn chặn việc sử dụng các tính năng không an toàn và cải thiện hiệu suất của mã JavaScript.

Trong Javascript, phương thức split() và join() được sử dụng cho xử lý chuỗi.

Phương thức split() có tác dụng chia một chuỗi thành một mảng các phần tử dựa trên một ký tự hoặc biểu thức chính quy được chỉ định. Ví dụ, nếu bạn có một chuỗi "Hello, World!", bạn có thể sử dụng phương thức split(',') để chia chuỗi thành một mảng ["Hello", " World!"]. Điều này hữu ích khi bạn muốn xử lý từng phần tử của chuỗi một cách riêng biệt.

Phương thức join() được sử dụng để kết hợp các phần tử của một mảng thành một chuỗi, và tách chúng bằng một ký tự hoặc biểu thức chính quy được chỉ định. Ví dụ, nếu bạn có một mảng ["Hello", " World!"], bạn có thể sử dụng phương thức join(' ') để kết hợp các phần tử thành chuỗi "Hello World!". Điều này hữu ích khi bạn muốn tạo một chuỗi từ một mảng các phần tử.

Đúng là JavaScript là một ngôn ngữ lập trình thông dịch, phía người dùng hoặc môi trường chạy. Được phát triển chủ yếu cho việc tạo ra các trang web tương tác và tiện ích động.

Trong JavaScript, null và undefined là hai giá trị đặc biệt được sử dụng để đại diện cho "không có giá trị" hoặc "giá trị không xác định". Tuy có một số điểm tương đồng, nhưng cũng có một số sự khác biệt quan trọng giữa chúng:

1. Khác về kiểu dữ liệu: null là một giá trị thuộc kiểu dữ liệu Object trong khi undefined là một giá trị thuộc kiểu dữ liệu Undefined.

2. Khác về gán giá trị: null có thể được gán cho một biến, trong khi undefined không thể.

   Ví dụ:

   var x = null; // gán giá trị null cho biến x
   var y; // y sẽ có giá trị undefined

3. Khác trong việc trả về giá trị: khi một hàm không có câu lệnh return hoặc không trả về giá trị, giá trị trả về mặc định là undefined. Trái lại, null không phải là giá trị trả về mặc định của bất kỳ hàm nào.

4. Khác trong việc kiểm tra giá trị: undefined là giá trị khi một biến được khai báo mà chưa được gán giá trị hoặc khi không tìm thấy giá trị của biến trong phạm vi. Null thường được sử dụng khi bạn muốn rõ ràng gán giá trị "không có giá trị" cho một biến.

   Ví dụ:

   var x; // x sẽ có giá trị undefined
   var y = null; // y sẽ có giá trị null

Tóm lại, null và undefined đều đại diện cho "không có giá trị", nhưng có những điểm khác nhau quan trọng về kiểu dữ liệu, cách gán giá trị và cách kiểm tra giá trị.

Trong JavaScript, event là một hành động hoặc sự kiện mà trình duyệt web điều khiển và phản ứng lại. Có nhiều loại event khác nhau mà JavaScript có thể xử lý, bao gồm các sự kiện như nhấp chuột, gõ phím, kéo thả, di chuyển con trỏ chuột và nhiều hơn nữa.

Cách hoạt động của event trong JavaScript bao gồm các bước sau:

1. Trình duyệt web tạo ra và hiển thị trên màn hình một giao diện người dùng để người dùng tương tác.
2. Người dùng thực hiện một hành động như nhấp chuột, gõ phím hoặc kéo thả.
3. Trình duyệt web sẽ phát hiện và nhận biết các hành động mà người dùng thực hiện.
4. Mỗi hành động sẽ kích hoạt một event tương ứng được gửi tới JavaScript để xử lý.
5. JavaScript có thể đăng ký các hàm xử lý sự kiện cho các event cụ thể.
6. Khi event xảy ra, JavaScript sẽ chạy các hàm xử lý được đăng ký cho sự kiện đó.
7. Hàm xử lý sự kiện có thể thực hiện các hành động như thay đổi nội dung của trang web, thay đổi các thuộc tính CSS, gọi các hàm khác và tương tác với máy chủ thông qua AJAX.
8. Sau khi các hành động xử lý sự kiện được thực hiện, trình duyệt có thể cập nhật lại giao diện người dùng để phản ánh các thay đổi.

Việc sử dụng event trong JavaScript cho phép xử lý và phản ứng lại với sự tương tác của người dùng để làm cho trang web trở nên tương tác và đáp ứng tốt hơn.

Trong JavaScript, bạn có thể sử dụng toán tử typeof để kiểm tra kiểu dữ liệu của một biến. Dưới đây là ví dụ minh họa:

var x = "Hello World";
console.log(typeof x); // kết quả: "string"

var y = 10;
console.log(typeof y); // kết quả: "number"

var z = true;
console.log(typeof z); // kết quả: "boolean"

Bạn cũng có thể sử dụng phương thức Object.prototype.toString.call() để kiểm tra chính xác kiểu dữ liệu của một biến, bao gồm cả các đối tượng.

var obj = {};
console.log(Object.prototype.toString.call(obj)); // kết quả: "[object Object]"

var arr = [];
console.log(Object.prototype.toString.call(arr)); // kết quả: "[object Array]"

var func = function() {};
console.log(Object.prototype.toString.call(func)); // kết quả: "[object Function]"

Trong các trường hợp đặc biệt như kiểm tra null và undefined, bạn cần lưu ý rằng typeof trả về "object" cho cả hai giá trị này. Để kiểm tra đầy đủ, bạn có thể so sánh trực tiếp với giá trị mong muốn:

var a = null;
if (a === null) {
  console.log("a is null");
}

var b;
if (typeof b === "undefined") {
  console.log("b is undefined");
}

'Strict mode' là một chế độ trong JavaScript giúp bạn viết mã chương trình theo một tập hợp nguyên tắc nghiêm ngặt hơn. Dưới đây là một số lợi ích khi sử dụng 'strict mode' trong JavaScript:

1. Lỗi nghiêm trọng sẽ gây ra exception: Khi 'strict mode' được bật, một số hành vi không an toàn hoặc lỗi sẽ gây ra exception thay vì chỉ tạo ra một lỗi silent. Điều này giúp bạn khắc phục các lỗi tiềm ẩn một cách nhanh chóng và chính xác hơn.

2. Tạo ra các cảnh báo cho các hành vi không an toàn: 'Strict mode' sẽ tạo ra các cảnh báo cho các hành vi không an toàn như sử dụng biến chưa khai báo, gán giá trị cho các thuộc tính chỉ đọc, sử dụng các từ khóa không được phép như "eval" hoặc "with". Điều này sẽ giúp bạn xử lý các vấn đề an toàn ngay từ khi bạn phát triển ứng dụng.

3. Ngăn chặn sử dụng các tính năng cũ: 'Strict mode' không cho phép sử dụng các tính năng cũ và không an toàn của JavaScript. Điều này giúp bạn viết mã mới hơn, sạch hơn và dễ dàng bảo trì hơn.

4. Tính năng làm việc với "this" trong các hàm: Trong 'strict mode', giá trị "this" trong một hàm không được ràng buộc tới đối tượng toàn cục mà thay vào đó là undefined. Điều này giúp tránh nhầm lẫn và lỗi trong việc sử dụng "this".

5. Thực thi một vài quy tắc lập trình nghiêm ngặt hơn: 'Strict mode' áp dụng một số quy tắc lập trình nghiêm ngặt hơn, như không cho phép khai báo biến mà không cần từ khóa "var" hoặc không cho phép lặp lại các tham số của hàm.

Tóm lại, 'Strict mode' giúp bạn viết mã JavaScript tốt hơn, an toàn hơn và dễ bảo trì hơn bằng cách kiểm tra và cảnh báo các lỗi tiềm ẩn trong quá trình phát triển.

Trong JavaScript, bạn có thể sử dụng phương thức Array.isArray() để kiểm tra xem một biến có phải là một mảng hay không. Phương thức này trả về true nếu biến đó là một mảng, và ngược lại trả về false. Dưới đây là một ví dụ minh họa:

let arr = [1, 2, 3];

console.log(Array.isArray(arr)); // true

let str = "Hello";

console.log(Array.isArray(str)); // false

Trong ví dụ trên, biến arr là một mảng, nên Array.isArray(arr) trả về true. Trong khi đó, biến str không phải là một mảng, nên Array.isArray(str) trả về false.

Closure là một khái niệm quan trọng trong JavaScript, nó xảy ra khi một hàm được tạo ra trong một hàm khác và hàm con có thể truy cập vào biến cục bộ ở phạm vi của hàm bên ngoài. Nói cách khác, closure cho phép một hàm "gắn kết" các biến và tham số từ phạm vi bên ngoài của nó.

Khi một hàm được gọi trong JavaScript, một execution context mới được tạo ra. Execution context là một bộ nhớ tạm để lưu trữ các biến và giá trị khi một hàm được thực thi. Mỗi execution context có một phạm vi hoạt động, bao gồm các biến cục bộ và các tham số của hàm.

Trong trường hợp của closure, khi một hàm được tạo ra trong một hàm khác, execution context của hàm bên ngoài vẫn được giữ lại và không được hủy đi khi hoàn thành. Do đó, hàm con có thể truy cập các biến và tham số của hàm ngoài đó.

Dưới đây là một ví dụ minh họa về closure trong JavaScript:

function outerFunction() {
  var outerVariable = "Hello";

  function innerFunction() {
    console.log(outerVariable); // Inner function can access outer variable
  }

  return innerFunction;
}

var inner = outerFunction(); // Call outer function and assign the returned inner function to inner variable
inner(); // This will print "Hello" because inner function has access to outerVariable through closure

Trong ví dụ trên, innerFunction được tạo bên trong outerFunction và truy cập vào biến outerVariable trong outerFunction thông qua closure. Khi gọi inner(), nó sẽ in ra giá trị "Hello" vì innerFunction có thể truy cập vào outerVariable thông qua closure.

Closure rất hữu ích trong việc tạo ra các biến "ẩn" hoặc tạo ra các hàm "hàng đợi". Bằng cách sử dụng closure, chúng ta có thể giữ các giá trị trong phạm vi bên ngoài của hàm và truy cập chúng sau này khi cần thiết.

Trong JavaScript, từ khóa "this" được sử dụng để tham chiếu đến đối tượng hiện tại, nơi mà mã được thực thi. Cách sử dụng "this" trong JavaScript phụ thuộc vào ngữ cảnh mà nó được sử dụng. Dưới đây là một số cách thường gặp:

1. Trong một phương thức của một đối tượng: Khi sử dụng "this" trong một phương thức của đối tượng, nó sẽ tham chiếu đến chính đối tượng đó.

   
   var obj = {
   message: "Hello",
   printMessage: function() {
   console.log(this.message);
   }
   };

obj.printMessage(); // Kết quả: "Hello"

2. Trong một hàm: Khi sử dụng "this" trong một hàm độc lập, nó sẽ tham chiếu đến đối tượng global (trình duyệt là window).

function printMessage() { console.log(this); }

printMessage(); // Kết quả: window (trình duyệt)

3. Sử dụng bind(), call() hoặc apply(): Các phương thức này cho phép bạn gán giá trị mới cho "this" trong một hàm hoặc phương thức.

function printMessage(message1, message2) { console.log(this.message + message1 + message2); }

var obj = { message: "Hello" };

var boundPrint = printMessage.bind(obj); // ràng buộc "this" với đối tượng obj boundPrint(" World", "!"); // Kết quả: "Hello World!"

printMessage.call(obj, " World", "!"); // Sử dụng call để chuyển đối tượng và tham số printMessage.apply(obj, [" World", "!"]); // Sử dụng apply để chuyển đối tượng và một mảng tham số

4. Arrow function: Trong arrow function, "this" được ràng buộc vào ngữ cảnh của hàm và không thể thay đổi.

var obj = { message: "Hello", printMessage: () => { console.log(this.message); } };

obj.printMessage(); // Kết quả: undefined (không thể truy cập đến message)

Trên đây chỉ là một số ví dụ cơ bản về cách sử dụng "this" trong JavaScript. Có thể có các trường hợp sử dụng "this" phức tạp hơn, nhưng đây là những ví dụ phổ biến nhất.

Để tạo một object trong JavaScript, bạn có thể sử dụng một trong ba phương pháp sau:

1. Sử dụng cú pháp đối tượng:

   var myObject = { key1: value1, key2: value2 };

   Ví dụ:

   var person = { name: "John", age: 30, city: "New York" };

2. Sử dụng hàm khởi tạo (constructor function):

   
   function MyObject(key1, key2) {
   this.key1 = key1;
   this.key2 = key2;
   }

var myObject = new MyObject(value1, value2);

Ví dụ:
```javascript
function Person(name, age, city) {
  this.name = name;
  this.age = age;
  this.city = city;
}

var person = new Person("John", 30, "New York");

3. Sử dụng class (kể từ phiên bản JavaScript ES6):

   
   class MyObject {
   constructor(key1, key2) {
   this.key1 = key1;
   this.key2 = key2;
   }
   }

var myObject = new MyObject(value1, value2);

Ví dụ:
```javascript
class Person {
  constructor(name, age, city) {
    this.name = name;
    this.age = age;
    this.city = city;
  }
}

var person = new Person("John", 30, "New York");

Cả ba phương pháp trên đều tạo một đối tượng mới với các thành phần (key-value pairs) tương ứng. Bạn có thể truy cập và sử dụng các thuộc tính và phương thức của đối tượng bằng cách sử dụng dấu chấm. Ví dụ: myObject.key1 hoặc person.name.

Trong Javascript, synchronous được hiểu là các tác vụ được thực hiện theo thứ tự từ trên xuống dưới, trong khi đó asynchronous là các tác vụ được thực hiện một cách đồng thời và không phụ thuộc vào thứ tự của chúng.

Synchronous JavaScript:

• Tác vụ được thực hiện theo thứ tự từ trên xuống dưới, một tác vụ kết thúc mới thực hiện tác vụ tiếp theo.
• Khi có một tác vụ mất nhiều thời gian để hoàn thành (như việc tải dữ liệu từ server), quá trình thực thi của toàn bộ trang sẽ bị chặn lại cho đến khi tác vụ đó hoàn thành.
• Ví dụ:

console.log("Start");
setTimeout(function(){
  console.log("Delayed task");
}, 2000);
console.log("End");

Kết quả:

Start
End
Delayed task

Trong ví dụ trên, "Start" và "End" sẽ được in ra trước "Delayed task" dù có set timeout 2 giây, bởi vì chúng được thực hiện một cách đồng bộ theo thứ tự.

Asynchronous JavaScript:

• Tác vụ được thực hiện theo cách đồng thời và không phụ thuộc vào thứ tự.
• Khi có một tác vụ mất nhiều thời gian để hoàn thành, quá trình thực thi của toàn bộ trang không bị chặn và tiếp tục thực hiện các tác vụ khác trong khi tác vụ đang chờ hoàn thành.
• Ví dụ:

console.log("Start");
setTimeout(function(){
  console.log("Delayed task");
}, 2000);
console.log("End");

Kết quả:

Start
End
Delayed task

Trong ví dụ trên, "Start" và "End" được in ra đầu tiên, sau đó "Delayed task" được in ra sau 2 giây. Điều này cho thấy rằng "Delayed task" không chặn quá trình thực hiện của các tác vụ khác.