Live Coding

Làm thế nào để kiểm tra xem một đối tượng JavaScript có rỗng không?

Giải thích: Một đối tượng được coi là rỗng nếu nó không có bất kỳ thuộc tính nào của riêng nó có thể liệt kê được. Chúng ta có thể sử dụng Object.keys(obj) để trả về một mảng chứa tên các thuộc tính riêng có thể liệt kê được của đối tượng đã cho. Nếu độ dài của mảng này là 0, thì đối tượng đó rỗng.

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

Viết một hàm để đảo ngược một chuỗi đã cho.

Giải thích: Cách đơn giản nhất là chuyển chuỗi thành một mảng các ký tự, sử dụng phương thức reverse() có sẵn cho mảng, sau đó nối các ký tự lại thành một chuỗi.

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

Viết một hàm kiểm tra xem một chuỗi đã cho có phải là chuỗi palindrome không.

Giải thích: Một chuỗi palindrome là một từ hoặc cụm từ đọc xuôi và ngược đều như nhau. Chúng ta có thể kiểm tra điều này bằng cách đảo ngược chuỗi (bỏ qua chữ hoa/thường và các ký tự không phải chữ-số để kiểm tra mạnh mẽ hơn, nhưng ở đây chúng ta thực hiện kiểm tra đơn giản) và so sánh nó với chuỗi gốc.

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

Viết một hàm để tìm số lớn nhất trong một mảng các số.

Giải thích: Bạn có thể lặp qua mảng, theo dõi số lớn nhất tìm được cho đến nay. Hoặc, bạn có thể sử dụng hàm Math.max() cùng với cú pháp spread (...) để truyền các phần tử mảng làm đối số.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Hoặc ném lỗi
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

Viết một chương trình in các số từ 1 đến n. Nhưng đối với bội số của ba, in 'Fizz' thay vì số và đối với bội số của năm, in 'Buzz'. Đối với các số là bội số của cả ba và năm, in 'FizzBuzz'.

Giải thích: Bài toán cổ điển này kiểm tra logic vòng lặp và điều kiện cơ bản. Bạn cần lặp từ 1 đến n và sử dụng toán tử modulo (%) để kiểm tra khả năng chia hết cho 3 và 5.

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log('FizzBuzz');
    } else if (i % 3 === 0) {
      console.log('Fizz');
    } else if (i % 5 === 0) {
      console.log('Buzz');
    } else {
      console.log(i);
    }
  }
}

fizzBuzz(15);

Viết một hàm xóa các phần tử trùng lặp khỏi một mảng.

Giải thích: Một cách hiện đại và súc tích để đạt được điều này là sử dụng Set. Set chỉ lưu trữ các giá trị duy nhất. Bạn có thể chuyển đổi mảng thành một Set và sau đó trở lại thành một mảng.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

Viết một hàm để kiểm tra xem hai chuỗi có phải là anagram của nhau không.

Giải thích: Anagram là những từ được tạo thành bằng cách sắp xếp lại các chữ cái của một từ khác. Để kiểm tra, chúng ta có thể làm sạch, sắp xếp và so sánh các chuỗi. Làm sạch bao gồm loại bỏ các ký tự không phải chữ-số và chuyển đổi thành một trường hợp nhất quán.

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

Viết một hàm để tính giai thừa của một số nguyên không âm.

Giải thích: Giai thừa (n!) của một số là tích của tất cả các số nguyên dương nhỏ hơn hoặc bằng n. Chúng ta có thể tính toán điều này một cách lặp đi lặp lại bằng cách nhân các số từ 1 đến n.

function factorial(n) {
  if (n < 0) return undefined; // Giai thừa không được định nghĩa cho số âm
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

Viết một hàm trả về tổng của tất cả các số trong một mảng.

Giải thích: Bạn có thể sử dụng phương thức reduce, rất lý tưởng để tích lũy một giá trị duy nhất từ một mảng. Nó nhận một hàm callback và một giá trị khởi tạo (0 để tính tổng).

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

Viết một hàm để làm phẳng một mảng lồng nhau. Để đơn giản, giả sử chỉ có một cấp độ lồng nhau.

Giải thích: Đối với một cấp độ lồng nhau, bạn có thể sử dụng Array.prototype.concat() với toán tử spread hoặc phương thức flat() (ES2019).

function flattenArray(arr) {
  // Sử dụng flat() (đơn giản hơn nếu ES2019+ ổn)
  // return arr.flat();

  // Sử dụng reduce và concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

Viết một hàm đếm số nguyên âm (a, e, i, o, u) trong một chuỗi đã cho.

Giải thích: Lặp qua chuỗi (không phân biệt chữ hoa/thường) và kiểm tra xem mỗi ký tự có phải là nguyên âm không. Duy trì một bộ đếm.

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

Viết một hàm chuyển đổi một câu thành dạng viết hoa chữ cái đầu (chữ cái đầu tiên của mỗi từ được viết hoa).

Giải thích: Chia câu thành các từ, sau đó lặp qua từng từ, viết hoa chữ cái đầu tiên và viết thường phần còn lại. Cuối cùng, nối các từ lại với nhau.

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

Cho một mảng các số nguyên nums và một số nguyên target, trả về chỉ số của hai số sao cho tổng của chúng bằng target.

Giải thích: Một cách tiếp cận phổ biến là sử dụng một hash map (hoặc một đối tượng JavaScript) để lưu trữ các số và chỉ số của chúng khi bạn lặp. Đối với mỗi số, hãy kiểm tra xem target - số_hiện_tại có tồn tại trong map không.

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // Hoặc null, hoặc ném lỗi nếu không có giải pháp
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

Tạo một hàm trả về một hàm bộ đếm. Mỗi khi hàm được trả về được gọi, nó sẽ tăng lên và trả về một số đếm.

Giải thích: Điều này thể hiện closure. Hàm bên trong có quyền truy cập vào biến count trong phạm vi của hàm bên ngoài, ngay cả sau khi hàm bên ngoài đã hoàn thành thực thi.

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

Viết một hàm tìm ký tự không lặp lại đầu tiên trong một chuỗi.

Giải thích: Bạn có thể sử dụng một hash map để đếm tần suất ký tự. Đầu tiên, lặp qua chuỗi để xây dựng bản đồ tần suất. Sau đó, lặp lại qua chuỗi và trả về ký tự đầu tiên có số lần xuất hiện là 1.

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // Hoặc một chỉ báo nào đó nếu tất cả đều lặp lại
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

Viết một hàm chia một mảng thành các nhóm có kích thước đã chỉ định.

Giải thích: Lặp qua mảng, lấy các lát cắt có kích thước đã chỉ định và đẩy chúng vào một mảng mới. Xử lý trường hợp phân đoạn cuối cùng có thể nhỏ hơn.

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

Viết một hàm để xác định xem một số đã cho có phải là số nguyên tố không.

Giải thích: Một số nguyên tố là một số tự nhiên lớn hơn 1 không có ước số dương nào khác ngoài 1 và chính nó. Lặp từ 2 đến căn bậc hai của số, kiểm tra khả năng chia hết. Xử lý các trường hợp đặc biệt như 1 và 2.

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

Viết một hàm tìm từ dài nhất trong một câu.

Giải thích: Chia chuỗi thành một mảng các từ. Sau đó, lặp qua mảng, theo dõi từ dài nhất tìm được cho đến nay (hoặc độ dài của nó).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Làm sạch từ nếu cần (ví dụ: loại bỏ dấu câu)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Thực hiện phiên bản của riêng bạn của hàm Array.prototype.map.

Giải thích: Hàm map nhận một callback và tạo một mảng mới bằng cách áp dụng callback cho mỗi phần tử của mảng gốc. Hàm của bạn nên lặp qua mảng và xây dựng mảng mới.

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Thực hiện phiên bản của riêng bạn của hàm Array.prototype.filter.

Giải thích: Hàm filter nhận một callback và tạo một mảng mới với tất cả các phần tử vượt qua kiểm tra được thực hiện bởi hàm callback được cung cấp.

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Thực hiện phiên bản của riêng bạn của hàm Array.prototype.reduce.

Giải thích: Hàm reduce thực thi một hàm callback 'reducer' do người dùng cung cấp trên mỗi phần tử của mảng, chuyển giá trị trả về từ phép tính trên phần tử trước đó. Kết quả cuối cùng của việc chạy reducer trên tất cả các phần tử của mảng là một giá trị duy nhất. Xử lý đối số giá trị khởi tạo.

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce of empty array with no initial value');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

Thực hiện một hàm Fibonacci bằng cách sử dụng memoization để tối ưu hóa hiệu suất.

Giải thích: Dãy Fibonacci liên quan đến các phép tính lặp đi lặp lại. Memoization lưu trữ kết quả của các lệnh gọi hàm tốn kém và trả về kết quả đã lưu trong bộ nhớ cache khi cùng một đầu vào xảy ra lần nữa.

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (nhanh hơn nhiều so với không có memoized)

Viết một hàm để kiểm tra xem một chuỗi chứa các dấu ngoặc {}[]() có cân bằng không.

Giải thích: Sử dụng một stack. Khi bạn gặp dấu ngoặc mở, đẩy nó vào stack. Khi bạn gặp dấu ngoặc đóng, kiểm tra xem stack có rỗng không hoặc nếu phần tử trên cùng là dấu ngoặc mở khớp. Nếu khớp, pop stack. Nếu không, hoặc nếu stack rỗng, nó không cân bằng. Cuối cùng, một stack rỗng có nghĩa là cân bằng.

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

Thực hiện cấu trúc dữ liệu Queue với các phương thức enqueue (thêm vào cuối) và dequeue (xóa khỏi đầu).

Giải thích: Một hàng đợi tuân theo nguyên tắc Nhập trước, Xuất trước (FIFO). Một mảng có thể được sử dụng, với push cho enqueue và shift cho dequeue.

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

Thực hiện cấu trúc dữ liệu Stack với các phương thức push (thêm vào trên cùng) và pop (xóa khỏi trên cùng).

Giải thích: Một stack tuân theo nguyên tắc Nhập sau, Xuất trước (LIFO). Một mảng có thể được sử dụng, với các phương thức push và pop.

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

Cho một mảng chứa n số phân biệt lấy từ 0, 1, 2, ..., n, tìm số bị thiếu trong mảng.

Giải thích: Tổng các số từ 0 đến n có thể được tính bằng công thức n*(n+1)/2. Tổng thực tế của các phần tử mảng có thể được tính. Sự khác biệt giữa hai tổng này sẽ là số bị thiếu.

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

Thực hiện một hàm debounce. Debouncing đảm bảo rằng một hàm không được gọi lại cho đến khi một khoảng thời gian nhất định đã trôi qua mà không bị gọi.

Giải thích: Sử dụng setTimeout và clearTimeout. Mỗi khi hàm debounced được gọi, xóa timeout trước đó và đặt một cái mới. Lệnh gọi hàm thực tế chỉ xảy ra khi timeout hoàn thành.

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Ví dụ sử dụng:
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Được gọi sau 1 giây (nếu không được gọi lại)
debouncedHello(); // Đặt lại bộ hẹn giờ
debouncedHello(); // Đặt lại bộ hẹn giờ, sẽ thực sự chạy 1 giây sau lệnh gọi này.

Thực hiện một hàm throttle. Throttling đảm bảo rằng một hàm được gọi tối đa một lần trong một khoảng thời gian được chỉ định.

Giải thích: Sử dụng một cờ để cho biết liệu một lệnh gọi có được phép hay không. Khi được gọi, nếu được phép, thực thi hàm, đặt cờ thành false và sử dụng setTimeout để đặt lại cờ sau khoảng thời gian.

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Ví dụ sử dụng:
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Sẽ ghi nhật ký tối đa một lần mỗi giây.

Viết một hàm nhận một hàm với hai đối số và trả về phiên bản curried của nó.

Giải thích: Currying biến đổi một hàm với nhiều đối số thành một chuỗi các hàm, mỗi hàm nhận một đối số duy nhất. f(a, b) trở thành f(a)(b).

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

Viết một hàm để thực hiện deep clone một đối tượng JavaScript.

Giải thích: Một shallow clone chỉ sao chép các thuộc tính cấp cao nhất. Một deep clone sao chép đệ quy tất cả các thuộc tính, bao gồm các đối tượng và mảng lồng nhau. Một cách đơn giản (với những hạn chế, ví dụ: không xử lý tốt các hàm, ngày tháng, biểu thức chính quy) là sử dụng JSON.parse(JSON.stringify(obj)). Một cách tiếp cận đệ quy mạnh mẽ hơn.

function deepClone(obj) {
  // Phiên bản đơn giản (có những hạn chế)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Cloning failed:", e);
      return null;
  }
  
  // Đệ quy mạnh mẽ hơn (ví dụ cơ bản):
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (chứng minh nó là deep clone)
console.log(cloned.b.c); // 3

Làm thế nào để lấy một mảng các khóa từ một đối tượng?

Giải thích: Sử dụng Object.keys(obj).

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

Làm thế nào để lấy một mảng các giá trị từ một đối tượng?

Giải thích: Sử dụng Object.values(obj).

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

Làm thế nào để kiểm tra xem một mảng có chứa một giá trị cụ thể không?

Giải thích: Sử dụng Array.prototype.includes(value).

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

Làm thế nào để hợp nhất hai mảng thành một?

Giải thích: Sử dụng cú pháp spread (...) hoặc Array.prototype.concat().

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

this đề cập đến điều gì trong phạm vi toàn cục trong trình duyệt?

Giải thích: Trong ngữ cảnh thực thi toàn cục (ngoài bất kỳ hàm nào), this đề cập đến đối tượng toàn cục, đó là window trong các trình duyệt web.

console.log(this === window); // true (trong môi trường trình duyệt)

this đề cập đến điều gì khi được sử dụng bên trong một phương thức đối tượng?

Giải thích: Khi một hàm được gọi như một phương thức của một đối tượng, this đề cập đến đối tượng mà phương thức đó được gọi trên.

const myObject = {
  prop: 'Hello',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Hello'

Các hàm mũi tên xử lý this như thế nào?

Giải thích: Các hàm mũi tên không có ngữ cảnh this của riêng chúng. Thay vào đó, chúng kế thừa this từ phạm vi (từ vựng) xung quanh nơi chúng được định nghĩa.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Ghi 42 vì 'this' được kế thừa
  }, 100);
}
new MyClass();

Sự khác biệt chính giữa let, const và var là gì?

Giải thích: var có phạm vi hàm và được hoisted. let và const có phạm vi khối và được hoisted nhưng nằm trong 'vùng chết tạm thời' cho đến khi khai báo. const phải được khởi tạo và không thể gán lại.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Khai báo lại và ảnh hưởng đến 'a' bên ngoài
    let b = 20; // 'b' mới trong khối
    // const c = 30; // Sẽ là một 'c' mới
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Giải thích Promise trong JavaScript là gì.

Giải thích: Promise là một đối tượng đại diện cho việc hoàn thành (hoặc thất bại) cuối cùng của một thao tác bất đồng bộ và giá trị kết quả của nó. Nó có thể ở một trong ba trạng thái: đang chờ xử lý, đã hoàn thành hoặc đã từ chối.

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Thành công!');
    // reject('Lỗi!');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

async và await đơn giản hóa việc làm việc với Promise như thế nào?

Giải thích: async/await cung cấp cú pháp đơn giản hóa cho Promise, làm cho mã bất đồng bộ trông và hoạt động giống mã đồng bộ hơn một chút. Một hàm async luôn trả về một Promise và await tạm dừng thực thi cho đến khi một Promise giải quyết.

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('Đang bắt đầu...');
  await delay(1000);
  console.log('Đã đợi 1 giây.');
  await delay(500);
  console.log('Đã đợi thêm 0,5 giây.');
  return 'Đã hoàn thành!';
}

run().then(console.log);

Làm thế nào để chuyển đổi một chuỗi thành một số?

Giải thích: Sử dụng parseInt(), parseFloat() hoặc toán tử cộng một ngôi (+).

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

Làm thế nào để chuyển đổi một số thành một chuỗi?

Giải thích: Sử dụng String(), number.toString() hoặc nối chuỗi.

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

JSON.stringify làm gì?

Giải thích: Nó chuyển đổi một đối tượng JavaScript hoặc giá trị thành một chuỗi JSON.

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

JSON.parse làm gì?

Giải thích: Nó phân tích một chuỗi JSON, xây dựng giá trị hoặc đối tượng JavaScript được mô tả bởi chuỗi.

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

Toán tử spread được sử dụng với mảng như thế nào?

Giải thích: Nó cho phép một iterable (như một mảng) được mở rộng ở những nơi mong đợi không hoặc nhiều đối số hoặc phần tử. Hữu ích cho việc sao chép, hợp nhất và thêm các phần tử.

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

Toán tử spread được sử dụng với đối tượng như thế nào?

Giải thích: Nó cho phép sao chép và hợp nhất các thuộc tính đối tượng.

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

Giải thích giải cấu trúc mảng bằng một ví dụ.

Giải thích: Đó là một cú pháp cho phép giải nén các giá trị từ mảng thành các biến riêng biệt.

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

Giải thích giải cấu trúc đối tượng bằng một ví dụ.

Giải thích: Nó cho phép giải nén các thuộc tính từ đối tượng thành các biến riêng biệt.

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

Làm thế nào bạn có thể thực hiện một phiên bản cơ bản của Function.prototype.call?

Giải thích: call gọi một hàm với giá trị this được chỉ định và các đối số được cung cấp riêng lẻ. Bạn có thể đính kèm hàm vào ngữ cảnh this, gọi nó, sau đó xóa nó.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Sử dụng một khóa duy nhất
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Hi', '!'); // Hi, Charlie!

Làm thế nào bạn có thể thực hiện một phiên bản cơ bản của Function.prototype.apply?

Giải thích: apply tương tự như call, nhưng nó chấp nhận các đối số dưới dạng một mảng.

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Hello', '.']); // Hello, David.

Giải thích ngắn gọn Event Loop của JavaScript.

Giải thích: JavaScript là đơn luồng, nhưng nó đạt được tính đồng thời bằng cách sử dụng một vòng lặp sự kiện (event loop). Ngăn xếp cuộc gọi (call stack) xử lý mã đồng bộ. Các Web API xử lý các thao tác bất đồng bộ (như setTimeout, fetch). Khi một thao tác bất đồng bộ hoàn tất, hàm callback của nó sẽ chuyển vào hàng đợi callback (hoặc hàng đợi microtask cho Promise). Vòng lặp sự kiện liên tục kiểm tra xem ngăn xếp cuộc gọi có trống không; nếu có, nó sẽ di chuyển hàm callback tiếp theo từ hàng đợi vào ngăn xếp để thực thi.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Goes to Callback Queue
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Goes to Microtask Queue
});

console.log('End');

// Output Order: Start, End, Promise Resolved, Timeout Callback
// (Microtasks run before Macrotasks/Callbacks)

Triển khai một hàm tìm kiếm nhị phân cho một mảng đã sắp xếp.

Giải thích: Tìm kiếm nhị phân tìm một mục trong một mảng đã sắp xếp một cách hiệu quả bằng cách liên tục chia đôi khoảng tìm kiếm. Nếu giá trị của khóa tìm kiếm nhỏ hơn mục ở giữa khoảng, thu hẹp khoảng về nửa dưới. Ngược lại, thu hẹp nó về nửa trên. Bạn thực hiện điều này cho đến khi tìm thấy giá trị hoặc khoảng trống.

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // Found
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Search right half
    } else {
      end = middle - 1; // Search left half
    }
  }
  return -1; // Not found
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

Triển khai thuật toán Merge Sort.

Giải thích: Merge Sort là một thuật toán chia để trị. Nó chia mảng đầu vào thành hai nửa, gọi đệ quy cho hai nửa, và sau đó gộp hai nửa đã sắp xếp lại. Hàm gộp (merge) rất quan trọng; nó kết hợp hai mảng con đã sắp xếp thành một mảng đã sắp xếp duy nhất.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

Triển khai thuật toán Quick Sort.

Giải thích: Quick Sort cũng là một thuật toán chia để trị. Nó chọn một phần tử làm trục (pivot) và phân chia mảng đã cho xung quanh trục đã chọn. Các phần tử nhỏ hơn trục sẽ đi sang trái, và các phần tử lớn hơn sẽ đi sang phải. Sau đó nó sắp xếp đệ quy các mảng con.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Triển khai thuật toán Bubble Sort.

Giải thích: Bubble Sort là một thuật toán sắp xếp đơn giản lặp đi lặp lại trong danh sách, so sánh các phần tử liền kề và hoán đổi chúng nếu chúng không đúng thứ tự. Việc duyệt qua danh sách được lặp lại cho đến khi danh sách được sắp xếp.

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // Swap
        swapped = true;
      }
    }
    n--; // Optimization: last element is already in place
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

Cho một chuỗi, tìm độ dài của xâu con dài nhất không có ký tự lặp lại.

Giải thích: Sử dụng kỹ thuật cửa sổ trượt (sliding window). Duy trì một cửa sổ (xâu con) và một tập hợp các ký tự trong cửa sổ đó. Mở rộng cửa sổ bằng cách di chuyển con trỏ phải. Nếu tìm thấy một ký tự lặp lại, thu hẹp cửa sổ từ bên trái cho đến khi ký tự lặp lại được loại bỏ.

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

Triển khai một Danh sách liên kết đơn (Singly Linked List) với các phương thức add và print.

Giải thích: Một danh sách liên kết là một cấu trúc dữ liệu tuyến tính trong đó các phần tử không được lưu trữ ở các vị trí bộ nhớ liền kề. Mỗi phần tử (nút) trỏ đến phần tử tiếp theo. Bạn cần một lớp Node và một lớp LinkedList để quản lý đầu (head) và thêm các nút mới.

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

Triển khai một Cây tìm kiếm nhị phân (Binary Search Tree) với các phương thức insert và find.

Giải thích: Một BST là một cấu trúc dữ liệu cây nhị phân dựa trên nút có các thuộc tính sau: Cây con bên trái của một nút chỉ chứa các nút có khóa nhỏ hơn khóa của nút đó. Cây con bên phải của một nút chỉ chứa các nút có khóa lớn hơn khóa của nút đó. Cả hai cây con cũng phải là cây tìm kiếm nhị phân.

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

Viết một hàm để xoay một mảng sang phải k bước.

Giải thích: Xoay một mảng có nghĩa là di chuyển các phần tử của nó. Đối với xoay phải, phần tử cuối cùng trở thành phần tử đầu tiên. Lặp lại điều này k lần thì được nhưng không hiệu quả. Một cách tốt hơn là sử dụng thao tác mảng hoặc tính toán các vị trí mới.

function rotateArray(nums, k) {
  k = k % nums.length; // Handle cases where k > length
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

Cho hai mảng, viết một hàm để tính giao của chúng (các phần tử chung của cả hai).

Giải thích: Một cách tiếp cận tốt là chuyển đổi một mảng thành một Set để tra cứu thời gian trung bình O(1). Sau đó, lặp qua mảng thứ hai và kiểm tra xem mỗi phần tử có tồn tại trong tập hợp không. Thu thập các kết quả khớp.

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

Cho một mảng các chuỗi, nhóm các từ đảo chữ lại với nhau.

Giải thích: Điều quan trọng là tìm một chữ ký duy nhất cho mỗi nhóm từ đảo chữ. Một cách phổ biến là sắp xếp mỗi từ theo thứ tự bảng chữ cái. Các từ có cùng chuỗi đã sắp xếp là các từ đảo chữ. Sử dụng một bản đồ băm (hash map) trong đó các khóa là các từ đã sắp xếp và các giá trị là các mảng các từ gốc.

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// Output: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Cho một mảng nums, viết một hàm để di chuyển tất cả các số 0 về cuối trong khi vẫn giữ nguyên thứ tự tương đối của các phần tử khác 0.

Giải thích: Sử dụng phương pháp hai con trỏ hoặc quả cầu tuyết (snowball). Một con trỏ theo dõi vị trí mà phần tử khác 0 tiếp theo sẽ được đặt. Lặp qua mảng; nếu một phần tử khác 0, đặt nó vào vị trí của con trỏ và tăng con trỏ. Cuối cùng, điền phần còn lại bằng số 0.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Move all non-zero elements to the front
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Fill the rest with zeros
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]

Cho một mảng số nguyên nums, tìm mảng con liên tục (chứa ít nhất một số) có tổng lớn nhất và trả về tổng của nó.

Giải thích: Thuật toán Kadane là một cách hiệu quả để giải quyết vấn đề này. Lặp qua mảng, theo dõi tổng currentMax kết thúc ở vị trí hiện tại và tổng globalMax tìm thấy cho đến nay. Nếu currentMax trở nên âm, đặt lại nó về 0 (hoặc đúng hơn là phần tử hiện tại).

function maxSubArray(nums) {
  let globalMax = -Infinity;
  let currentMax = 0;

  for (let i = 0; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    if (currentMax > globalMax) {
      globalMax = currentMax;
    }
  }
  return globalMax;
}

console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])); // 6 (from [4, -1, 2, 1])