Live Coding

如何检查一个 JavaScript 对象是否为空？

解释： 如果一个对象没有任何自身可枚举的属性，则该对象为空。我们可以使用 Object.keys(obj)，它返回给定对象自身可枚举属性名称的数组。如果这个数组的长度为0，则该对象为空。

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

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

编写一个函数来反转给定的字符串。

解释： 最简单的方法是将字符串转换为字符数组，使用数组内置的 reverse() 方法，然后将字符重新连接成一个字符串。

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

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

编写一个函数来检查给定的字符串是否是回文。

解释： 回文是一个正读反读都一样的单词或短语。我们可以通过反转字符串（为进行更健壮的检查，可以忽略大小写和非字母数字字符，但这里我们只做简单检查）并与原字符串进行比较来检查这一点。

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

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

编写一个函数来查找数字数组中的最大值。

解释： 您可以遍历数组，跟踪迄今为止找到的最大值。或者，您可以使用 Math.max() 函数以及展开语法（...）将数组元素作为参数传递。

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // 或者抛出错误
  return Math.max(...arr);
}

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

编写一个程序，打印从 1 到 n 的数字。但对于三的倍数，打印 'Fizz' 而不是数字；对于五的倍数，打印 'Buzz'。对于既是三的倍数又是五的倍数的数字，打印 'FizzBuzz'。

解释： 这个经典问题测试基本的循环和条件逻辑。您需要从 1 迭代到 n，并使用模运算符（%）检查是否可被 3 和 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);

编写一个函数，从数组中删除重复元素。

解释： 一种现代且简洁的实现方法是使用 Set。Set 只存储唯一值。您可以将数组转换为 Set，然后再转换回数组。

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

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

编写一个函数，检查两个字符串是否是彼此的变位词。

解释： 变位词是通过重新排列另一个单词的字母形成的单词。要检查，我们可以清理、排序和比较字符串。清理包括删除非字母数字字符并转换为一致的大小写。

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

编写一个函数来计算非负整数的阶乘。

解释： 数字的阶乘（n!）是所有小于或等于 n 的正整数的乘积。我们可以通过将从 1 到 n 的数字相乘来迭代计算。

function factorial(n) {
  if (n < 0) return undefined; // 阶乘对负数没有定义
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

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

编写一个函数，返回数组中所有数字的和。

解释： 您可以使用 reduce 方法，它非常适合从数组中累积单个值。它接受一个回调函数和一个初始值（求和时为 0）。

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

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

编写一个函数来扁平化嵌套数组。为简单起见，假设只有一层嵌套。

解释： 对于单层嵌套，您可以使用 Array.prototype.concat() 和展开运算符，或者 flat() 方法（ES2019）。

function flattenArray(arr) {
  // 使用 flat()（如果 ES2019+ 可以，则更简单）
  // return arr.flat();

  // 使用 reduce 和 concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

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

编写一个函数，计算给定字符串中元音字母（a, e, i, o, u）的数量。

解释： 遍历字符串（不区分大小写），并检查每个字符是否是元音字母。维护一个计数器。

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

编写一个函数，将句子转换为首字母大写（每个单词的首字母大写）。

解释： 将句子拆分成单词，然后遍历每个单词，将首字母大写，其余部分小写。最后，将单词重新连接起来。

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'

给定一个整数数组 nums 和一个整数 target，返回两个数字的索引，使它们相加等于 target。

解释： 一种常见的方法是使用哈希映射（或 JavaScript 对象）在迭代时存储数字及其索引。对于每个数字，检查 target - current_number 是否存在于映射中。

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 []; // 或者 null，如果无解则抛出错误
}

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

创建一个函数，该函数返回一个计数器函数。每次调用返回的函数时，它都应该递增并返回一个计数。

解释： 这演示了闭包。内部函数可以访问外部函数作用域的 count 变量，即使外部函数已经执行完毕。

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

编写一个函数，查找字符串中第一个不重复的字符。

解释： 您可以使用哈希映射来计算字符频率。首先，遍历字符串以构建频率映射。然后，再次遍历字符串并返回计数为 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; // 或者某种指示，如果所有字符都重复
}

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

编写一个函数，将数组分成指定大小的组。

解释： 遍历数组，截取指定大小的片段并将其推入新数组。处理最后一个块可能更小的情况。

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]]

编写一个函数来确定给定数字是否为素数。

解释： 素数是大于 1 的自然数，除了 1 和它本身之外没有其他正约数。从 2 迭代到数字的平方根，检查可除性。处理 1 和 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

编写一个函数，查找句子中最长的单词。

解释： 将字符串拆分为单词数组。然后，遍历数组，跟踪迄今为止找到的最长单词（或其长度）。

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // 如果需要，清理单词（例如，删除标点符号）
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

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

实现您自己的 Array.prototype.map 函数版本。

解释： map 函数接受一个回调函数，并通过将回调函数应用于原始数组的每个元素来创建新数组。您的函数应该遍历数组并构建新数组。

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]

实现您自己的 Array.prototype.filter 函数版本。

解释： filter 函数接受一个回调函数，并创建一个新数组，其中包含通过所提供的回调函数实现的测试的所有元素。

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']

实现您自己的 Array.prototype.reduce 函数版本。

解释： reduce 函数对数组的每个元素执行用户提供的“reducer”回调函数，传入上一个元素计算的返回值。对数组所有元素运行 reducer 的最终结果是一个单一值。处理初始值参数。

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

使用记忆化实现斐波那契函数以优化性能。

解释： 斐波那契数列涉及重复计算。记忆化存储昂贵函数调用的结果，并在再次出现相同输入时返回缓存结果。

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 (比非记忆化快得多)

编写一个函数来检查包含括号 {}[]() 的字符串是否平衡。

解释： 使用栈。当您遇到一个开括号时，将其推入栈中。当您遇到一个闭括号时，检查栈是否为空，或者栈顶元素是否是匹配的开括号。如果匹配，则弹出栈。如果不匹配，或者栈为空，则不平衡。最后，空栈表示平衡。

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

实现一个具有 enqueue（添加到尾部）和 dequeue（从头部删除）方法的队列数据结构。

解释： 队列遵循先进先出（FIFO）原则。可以使用数组，push 用于 enqueue，shift 用于 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

实现一个具有 push（添加到顶部）和 pop（从顶部删除）方法的栈数据结构。

解释： 栈遵循后进先出（LIFO）原则。可以使用数组，并使用 push 和 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

给定一个包含从 0, 1, 2, ..., n 中取出的 n 个不同数字的数组，找出数组中缺失的那个数字。

解释： 从 0 到 n 的数字和可以使用公式 n*(n+1)/2 计算。可以计算数组元素的实际和。这两个和之间的差值就是缺失的数字。

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

实现一个防抖函数。防抖确保在函数被调用后，在一定时间没有再次调用它之前，该函数不会再次被调用。

解释： 使用 setTimeout 和 clearTimeout。每次调用防抖函数时，清除之前的超时并设置新的超时。实际的函数调用只在超时完成时发生。

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

// 示例用法：
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // 1 秒后调用（如果没有再次调用）
debouncedHello(); // 重置计时器
debouncedHello(); // 重置计时器，将在本次调用 1 秒后实际运行。

实现一个节流函数。节流确保一个函数在指定的时间间隔内最多被调用一次。

解释： 使用一个标志来指示是否允许调用。当被调用时，如果允许，则执行函数，将标志设置为 false，并使用 setTimeout 在间隔后重置标志。

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

// 示例用法：
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // 最多每秒记录一次。

编写一个函数，它接受一个有两个参数的函数并返回它的柯里化版本。

解释： 柯里化将一个多参数函数转换为一系列函数，每个函数接受一个参数。f(a, b) 变为 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

编写一个函数来执行 JavaScript 对象的深克隆。

解释： 浅克隆只复制顶层属性。深克隆递归复制所有属性，包括嵌套对象和数组。一种简单的方法（有局限性，例如，不能很好地处理函数、日期、正则表达式）是使用 JSON.parse(JSON.stringify(obj))。递归方法更健壮。

function deepClone(obj) {
  // 简单版本（有局限性）
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Cloning failed:", e);
      return null;
  }
  
  // 更健壮的递归（基本示例）：
  /*
  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 (证明是深克隆)
console.log(cloned.b.c); // 3

如何从对象中获取键的数组？

解释： 使用 Object.keys(obj)。

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

如何从对象中获取值的数组？

解释： 使用 Object.values(obj)。

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

如何检查数组是否包含特定值？

解释： 使用 Array.prototype.includes(value)。

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

如何将两个数组合并为一个？

解释： 使用展开语法（...）或 Array.prototype.concat()。

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

在浏览器中的全局作用域中，this 指的是什么？

解释： 在全局执行上下文（任何函数之外），this 指的是全局对象，在 Web 浏览器中是 window。

console.log(this === window); // true (在浏览器环境中)

在对象方法中使用 this 时，this 指的是什么？

解释： 当函数作为对象的方法被调用时，this 指的是调用该方法的对象。

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

箭头函数如何处理 this？

解释： 箭头函数没有自己的 this 上下文。相反，它们从定义它们的周围（词法）作用域继承 this。

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // 因为继承了 'this'，所以打印 42
  }, 100);
}
new MyClass();

let、const 和 var 之间有什么主要区别？

解释： var 是函数作用域的，并且会提升。let 和 const 是块作用域的，并且会提升，但直到声明之前都处于“暂时性死区”。const 必须初始化且不能重新赋值。

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // 重新声明并影响外部的 'a'
    let b = 20; // 块内新的 'b'
    // const c = 30; // 将是一个新的 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

解释 JavaScript 中的 Promise 是什么。

解释： Promise 是一个对象，表示异步操作的最终完成（或失败）及其结果值。它有三种状态：待定（pending）、已履行（fulfilled）或已拒绝（rejected）。

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Success!');
    // reject('Error!');
  }, 1000);
});

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

async 和 await 如何简化 Promise 的使用？

解释： async/await 为 Promise 提供了语法糖，使异步代码看起来和行为更像同步代码。async 函数总是返回一个 Promise，而 await 会暂停执行直到 Promise 解决。

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

async function run() {
  console.log('Starting...');
  await delay(1000);
  console.log('Waited 1 second.');
  await delay(500);
  console.log('Waited another 0.5 seconds.');
  return 'Finished!';
}

run().then(console.log);

如何将字符串转换为数字？

解释： 使用 parseInt()、parseFloat() 或一元加号运算符（+）。

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

如何将数字转换为字符串？

解释： 使用 String()、number.toString() 或字符串连接。

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

JSON.stringify 的作用是什么？

解释： 它将 JavaScript 对象或值转换为 JSON 字符串。

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

JSON.parse 的作用是什么？

解释： 它解析 JSON 字符串，根据字符串描述构造 JavaScript 值或对象。

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

展开运算符如何与数组一起使用？

解释： 它允许将可迭代对象（如数组）在预期零个或多个参数或元素的位置展开。用于复制、合并和添加元素很有用。

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

展开运算符如何与对象一起使用？

解释： 它允许复制和合并对象属性。

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 }

用示例解释数组解构。

解释： 是一种语法，可以将数组中的值解包到不同的变量中。

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

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

用示例解释对象解构。

解释： 使得可以将对象中的属性解包到不同的变量中。

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'

您如何实现一个基本版本的 Function.prototype.call？

解释： call 以指定的 this 值和单独提供的参数调用函数。您可以将函数附加到 this 上下文，调用它，然后将其删除。

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // 使用一个唯一键
  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!

您如何实现一个基本版本的 Function.prototype.apply？

解释： apply 类似于 call，但它接受参数作为数组。

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.

简要解释 JavaScript 事件循环。

解释： JavaScript 是单线程的，但它通过事件循环实现并发。调用栈处理同步代码。Web API 处理异步操作（如 setTimeout、fetch）。当异步操作完成时，其回调函数会进入回调队列（Promise 的回调会进入微任务队列）。事件循环不断检查调用栈是否为空；如果为空，它会将回调队列中的下一个回调移动到栈中执行。

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // 进入回调队列
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // 进入微任务队列
});

console.log('End');

// 输出顺序：Start, End, Promise Resolved, Timeout Callback
// (微任务在宏任务/回调之前运行)

为排序数组实现一个二分查找函数。

解释： 二分查找通过重复将搜索区间一分为二来高效地在排序数组中查找项。如果搜索键的值小于区间中间的项，则将区间缩小到下半部分。否则，将其缩小到上半部分。重复此操作直到找到值或区间为空。

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; // 找到
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // 搜索右半部分
    } else {
      end = middle - 1; // 搜索左半部分
    }
  }
  return -1; // 未找到
}

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

实现归并排序算法。

解释： 归并排序是一种分治算法。它将输入数组分成两半，对这两半调用自身，然后合并两个已排序的半部分。合并函数至关重要；它将两个已排序的子数组组合成一个已排序的数组。

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]

实现快速排序算法。

解释： 快速排序也是一种分治算法。它选择一个元素作为枢轴，并围绕所选枢轴对给定数组进行分区。小于枢轴的元素到左侧，大于枢轴的元素到右侧。然后它递归地对子数组进行排序。

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]

实现冒泡排序算法。

解释： 冒泡排序是一种简单的排序算法，它重复地遍历列表，比较相邻元素，并在它们处于错误顺序时交换它们。对列表的遍历重复进行直到列表排序完成。

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]]; // 交换
        swapped = true;
      }
    }
    n--; // 优化：最后一个元素已经就位
  } while (swapped);
  return arr;
}

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

给定一个字符串，找出最长无重复字符的子串的长度。

解释： 使用“滑动窗口”技术。维护一个窗口（子串）和该窗口中字符的集合。通过移动右指针扩展窗口。如果找到重复字符，则从左侧缩小窗口直到重复字符被移除。

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')

实现一个带有 add 和 print 方法的单向链表。

解释： 链表是一种线性数据结构，其中元素不存储在连续的内存位置。每个元素（节点）指向下一个元素。您需要一个 Node 类和一个 LinkedList 类来管理头节点和添加新节点。

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

实现一个带有 insert 和 find 方法的二叉搜索树。

解释： BST 是一种基于节点的二叉树数据结构，具有以下属性：节点的左子树只包含键小于节点键的节点。节点的右子树只包含键大于节点键的节点。两个子树也必须是二叉搜索树。

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

编写一个函数，将数组向右旋转 k 步。

解释： 旋转数组意味着移动其元素。对于右旋转，最后一个元素变为第一个。重复 k 次有效，但效率低下。更好的方法是使用数组操作或计算新位置。

function rotateArray(nums, k) {
  k = k % nums.length; // 处理 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]

给定两个数组，编写一个函数来计算它们的交集（两者共有的元素）。

解释： 一个好的方法是将一个数组转换为 Set 以实现平均 O(1) 的查找时间。然后，遍历第二个数组并检查每个元素是否存在于 Set 中。收集匹配项。

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]

给定一个字符串数组，将字母异位词分组。

解释： 关键是为每组字母异位词找到一个唯一的签名。一种常见的方法是对每个单词进行字母排序。排序后相同的单词就是字母异位词。使用哈希映射，其中键是排序后的单词，值是原始单词的数组。

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'])); 
// 输出: [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

给定一个数组 nums，编写一个函数将所有 0 移动到它的末尾，同时保持非零元素的相对顺序。

解释： 使用“双指针”或“雪球”方法。一个指针跟踪下一个非零元素应该放置的位置。遍历数组；如果元素非零，则将其放置在指针位置并递增指针。最后，用零填充其余部分。

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // 将所有非零元素移到前面
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // 用零填充其余部分
  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]

给定一个整数数组 nums，找出其中和最大的连续子数组（至少包含一个数字），并返回其和。

解释： Kadane 算法是一种高效的解决方案。遍历数组，跟踪当前位置结束的 currentMax 和迄今为止找到的 globalMax 和。如果 currentMax 变为负数，则将其重置为 0（或者，当前元素）。

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 (来自 [4, -1, 2, 1])