Javascript笔试题目（四）

1.如何使用JS实现数组的乱序输出?请写出具体代码

在JavaScript中，可以通过多种方法实现数组的乱序输出。其中，最常用的方法之一是使用Fisher-Yates洗牌算法（也称为Knuth洗牌算法）。该算法可以高效地打乱数组的顺序。以下是具体的代码实现：

// Fisher-Yates 洗牌算法实现数组的乱序  
function shuffleArray(array) {  for (let i = array.length - 1; i > 0; i--) {  // 生成一个0到i之间的随机整数  const j = Math.floor(Math.random() * (i + 1));  // 交换元素 array[i] 和 array[j]  [array[i], array[j]] = [array[j], array[i]];  }  return array;  
}  // 示例数组  
const originalArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];  // 打乱数组顺序  
const shuffledArray = shuffleArray(originalArray);  // 输出乱序后的数组  
console.log(shuffledArray);

代码解释：

1. 函数定义：
   • shuffleArray(array)：接收一个数组作为参数。
2. 循环遍历：
   • 从数组的最后一个元素开始向前遍历（i 从 array.length - 1 到 1）。
3. 生成随机索引：
   • const j = Math.floor(Math.random() * (i + 1));：生成一个0到i之间的随机整数。
4. 交换元素：
   • [array[i], array[j]] = [array[j], array[i]];：使用ES6的解构赋值语法交换当前索引i和随机索引j处的元素。
5. 返回打乱后的数组：
   • 函数返回打乱后的数组。
6. 示例使用：
   • 定义一个示例数组originalArray。
   • 调用shuffleArray函数打乱数组顺序，并将结果存储在shuffledArray中。
   • 使用console.log输出打乱后的数组。

这个算法的时间复杂度是O(n)，因为它只需要遍历数组一次，并且在每次迭代中执行一个常数时间的交换操作。此外，这个算法保证了每个排列的概率是相等的，即每个排列的出现概率是1/n!。

2.如何使用JS实现数组元素的求和?请写出具体代码

在JavaScript中，实现数组元素求和是一个相对简单的任务。你可以使用多种方法来完成这一操作，包括使用for循环、forEach方法、reduce方法以及ES6的箭头函数和let声明等。下面是几种具体的实现方式：

使用 reduce 方法

reduce 方法是数组的一个高阶函数，它接收一个回调函数和一个可选的初始值作为参数，并返回数组元素经过处理后的累计值。

const numbers = [1, 2, 3, 4, 5];  const sum = numbers.reduce((accumulator, currentValue) => {  return accumulator + currentValue;  
}, 0); // 第二个参数是初始值，这里设为0  console.log(sum); // 输出: 15--------------------------------------------------------------
const numbers = [1, 2, 3, 4, 5];  const sum = numbers.reduce((acc, curr) => acc + curr, 0);  console.log(sum); // 输出: 15

3.如何使用JS实现数组的扁平化?请写出具体代码

在JavaScript中，数组扁平化是指将一个多维数组转换为一个一维数组。这通常涉及将嵌套数组中的元素“展平”到单个数组中。以下是几种实现数组扁平化的方法：

1. 使用递归

递归是一种常见且直观的方法来处理嵌套结构。你可以编写一个递归函数来遍历数组，如果遇到一个数组，则递归地调用该函数来处理它。

function flattenArray(arr) {  let result = [];  arr.forEach(item => {  if (Array.isArray(item)) {  result = result.concat(flattenArray(item));  } else {  result.push(item);  }  });  return result;  
}  // 示例  
const nestedArray = [1, [2, [3, [4, 5]]], 6];  
const flatArray = flattenArray(nestedArray);  
console.log(flatArray); // 输出: [1, 2, 3, 4, 5, 6]

2. 使用 Array.prototype.reduce 和 Array.prototype.concat

reduce 方法可以累积地处理数组中的每个元素，并返回单个结果。在这里，我们可以使用它来构建一个扁平化的数组。

function flattenArray(arr) {  return arr.reduce((acc, val) =>   Array.isArray(val) ? acc.concat(flattenArray(val)) : acc.concat(val), []);  
}  // 示例  
const nestedArray = [1, [2, [3, [4, 5]]], 6];  
const flatArray = flattenArray(nestedArray);  
console.log(flatArray); // 输出: [1, 2, 3, 4, 5, 6]

3. 使用堆栈（Stack）模拟递归

如果你不想使用递归，可以使用一个堆栈来模拟递归过程。这种方法在处理深度未知的嵌套数组时特别有用。

function flattenArray(arr) {  let stack = [...arr];  let result = [];  while (stack.length) {  const next = stack.pop();  if (Array.isArray(next)) {  stack.push(...next);  } else {  result.push(next);  }  }  // 因为我们是从数组末尾开始处理的，所以结果需要反转  return result.reverse();  
}  // 或者，为了避免反转，你可以从数组头部开始处理并收集到另一个数组  
function flattenArrayWithoutReverse(arr) {  let stack = [...arr].reverse(); // 反转输入数组以从尾部开始处理  let result = [];  while (stack.length) {  const next = stack.pop();  if (!Array.isArray(next)) {  result.unshift(next); // 使用unshift将元素添加到结果数组的开头  } else {  stack.push(...next.reverse()); // 反转子数组以保持元素顺序  }  }  return result;  
}  // 示例  
const nestedArray = [1, [2, [3, [4, 5]]], 6];  
const flatArray = flattenArray(nestedArray);  
console.log(flatArray); // 输出: [1, 2, 3, 4, 5, 6]

注意：上面的 flattenArrayWithoutReverse 函数虽然避免了最终的结果反转，但它需要在处理每个子数组时都进行反转，这可能会增加一些不必要的复杂性。通常，第一种使用堆栈的方法（之后反转结果）在实践中更为常见。

4. 使用 ES6 的 Array.prototype.flat（最简洁）

从ECMAScript 2019（ES10）开始，JavaScript 提供了一个内置的 flat 方法来直接扁平化数组。你可以指定一个深度参数来控制扁平化的层级。

const nestedArray = [1, [2, [3, [4, 5]]], 6];  
const flatArray = nestedArray.flat(Infinity); // Infinity 表示无限深度扁平化  
console.log(flatArray); // 输出: [1, 2, 3, 4, 5, 6]

如果你知道数组的最大嵌套深度，也可以提供一个具体的数字作为深度参数。例如，flat(2) 会扁平化两层深度的嵌套数组。

5.如何使用JS实现数组去重?请写出具体代码

在JavaScript中，实现数组去重（即移除数组中的重复元素）有多种方法。以下是几种常见的实现方式，包括使用Set对象、filter方法和indexOf方法，以及使用reduce方法。

1. 使用 Set 对象

Set 是 ES6 引入的一个新的数据结构，它类似于数组，但是成员的值都是唯一的，没有重复的值。利用这个特性，我们可以很容易地实现数组去重。

const array = [1, 2, 2, 3, 4, 4, 5];  
const uniqueArray = [...new Set(array)];  
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

2. 使用 filter 方法和 indexOf 方法

filter 方法创建一个新数组，其包含通过所提供函数实现的测试的所有元素。indexOf 方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。结合这两个方法，我们可以实现数组去重。

const array = [1, 2, 2, 3, 4, 4, 5];  
const uniqueArray = array.filter((item, index) => array.indexOf(item) === index);  
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

3. 使用 reduce 方法

reduce 方法对数组中的每个元素执行一个由您提供的 reducer 函数（升序执行），将其结果汇总为单个返回值。利用这个方法，我们也可以实现数组去重。

const array = [1, 2, 2, 3, 4, 4, 5];  
const uniqueArray = array.reduce((acc, curr) => {  if (!acc.includes(curr)) {  acc.push(curr);  }  return acc;  
}, []);  
console.log(uniqueArray); // 输出: [1, 2, 3, 4, 5]

注意事项

• 上述方法都适用于基本数据类型的数组去重（如数字、字符串等）。如果数组中包含对象或其他复杂数据类型，需要根据具体情况实现去重逻辑。
• 在使用 indexOf 方法进行去重时，如果数组元素是对象，由于对象引用的问题，indexOf 方法可能无法正确判断元素是否重复。此时，可以考虑使用其他方法（如深度比较）来实现对象数组的去重。
• Set 对象在内部使用了哈希表来实现元素的唯一性，因此其性能通常优于其他方法（特别是在处理大数据集时）。然而，需要注意的是，Set 对象不支持所有类型的数组元素（如 undefined 和 NaN），在使用时需要特别注意。

Javascript中Object、Array、String_objectarray-CSDN博客

6.如何使用JS实现数组的flat方法?请写出具体代码【与3类似】

在JavaScript中，Array.prototype.flat() 方法用于将嵌套的数组“扁平化”，即递归地将一个多维数组转换为一个一维数组。如果你需要在不支持 flat() 方法的旧版JavaScript环境中实现类似的功能，你可以手动编写一个扁平化数组的函数。

以下是一个使用递归实现数组扁平化的示例代码：

function flatArray(arr, depth = 1) {  // 创建一个空数组用于存储扁平化后的结果  const result = [];  // 遍历数组中的每个元素  for (const item of arr) {  // 如果元素是数组，并且递归深度还未达到限制  if (Array.isArray(item) && depth > 0) {  // 递归调用 flatArray，并将当前元素的扁平化结果合并到 result 中  result.push(...flatArray(item, depth - 1));  } else {  // 如果元素不是数组，或者递归深度已达到限制，则直接将元素添加到 result 中  result.push(item);  }  }  // 返回扁平化后的数组  return result;  
}  // 示例使用  
const nestedArray = [1, [2, [3, [4]], 5]];  
const flattenedArray = flatArray(nestedArray, Infinity); // 使用 Infinity 表示无限深度扁平化  
console.log(flattenedArray); // 输出: [1, 2, 3, 4, 5]

在这个实现中，flatArray 函数接受两个参数：要扁平化的数组 arr 和一个可选的 depth 参数，表示扁平化的深度。如果 depth 设置为 Infinity，则表示无限深度扁平化，即无论嵌套多少层都会扁平化。

注意，这个实现使用了 ES6 的扩展运算符（...）来合并数组。如果你需要在旧版JavaScript环境中运行此代码，你可能需要使用其他方法来合并数组，比如使用 Array.prototype.concat() 方法。

7.如何使用JS实现数组的push方法?请写出具体代码

在JavaScript中，Array.prototype.push() 方法用于将一个或多个元素添加到数组的末尾，并返回新的数组长度。虽然我们可以直接使用JavaScript内置的 push 方法，但如果你想了解如何自己实现一个类似的方法，可以按照以下步骤进行：

以下是一个简单的实现，它模拟了 push 方法的行为：

function myPush(array, ...elements) {  // 遍历要添加的元素  for (const element of elements) {  // 将元素添加到数组的末尾  array[array.length] = element;  }  // 返回新的数组长度  return array.length;  
}  // 示例使用  
const myArray = [1, 2, 3];  
const newLength = myPush(myArray, 4, 5, 6);  
console.log(myArray);       // 输出: [1, 2, 3, 4, 5, 6]  
console.log(newLength);     // 输出: 6

8.如何使用JS实现数组的filter方法?请写出具体代码

在JavaScript中，Array.prototype.filter() 方法用于创建一个新数组，其中包含通过所提供函数实现的测试的所有元素。如果你需要在不支持 filter 方法的旧版JavaScript环境中实现类似的功能，你可以手动编写一个过滤数组的函数。

以下是一个使用高阶函数（即接受函数作为参数或返回函数的函数）来实现数组过滤的示例代码：

function myFilter(array, predicate) {  // 创建一个空数组用于存储过滤后的结果  const result = [];  // 遍历数组中的每个元素  for (const item of array) {  // 如果元素满足谓词函数（predicate）的条件，则将其添加到结果数组中  if (predicate(item)) {  result.push(item);  }  }  // 返回过滤后的数组  return result;  
}  // 示例谓词函数：检查数字是否为偶数  
function isEven(number) {  return number % 2 === 0;  
}  // 示例使用  
const numbers = [1, 2, 3, 4, 5, 6];  
const evenNumbers = myFilter(numbers, isEven);  
console.log(evenNumbers); // 输出: [2, 4, 6]

在这个实现中，myFilter 函数接受两个参数：

1. array：要过滤的数组。
2. predicate：一个函数，用于测试数组中的每个元素。该函数应该接受一个参数（即数组中的元素），并返回一个布尔值。如果返回 true，则表示该元素应该包含在结果数组中。

函数内部，我们使用一个 for...of 循环来遍历数组中的每个元素，并使用 predicate 函数来测试每个元素。如果元素满足条件（即 predicate 函数返回 true），则将其添加到 result 数组中。

最后，函数返回过滤后的 result 数组。

9.如何使用JS实现数组的map方法?请写出具体代码

在JavaScript中，Array.prototype.map() 方法用于创建一个新数组，其结果是对原数组中的每个元素调用一次提供的函数后的返回值组成的新数组。如果你想自己实现一个类似 map 方法的功能，你可以按照以下步骤进行：

以下是一个简单的实现，它模拟了 map 方法的行为：

function myMap(array, callback) {  // 创建一个空数组用于存储映射后的结果  const result = [];  // 遍历数组中的每个元素  for (let i = 0; i < array.length; i++) {  // 调用回调函数，并将当前元素、索引和原数组作为参数传递  // 将回调函数的返回值添加到结果数组中  result.push(callback(array[i], i, array));  }  // 返回映射后的数组  return result;  
}  // 示例回调函数：将数字乘以2  
function multiplyByTwo(number, index, array) {  // 注意：这里的index和array参数在回调函数中并未使用，但它们是map方法的标准参数  return number * 2;  
}  // 示例使用  
const numbers = [1, 2, 3, 4, 5];  
const doubledNumbers = myMap(numbers, multiplyByTwo);  
console.log(doubledNumbers); // 输出: [2, 4, 6, 8, 10]

在这个实现中，myMap 函数接受两个参数：

1. array：要映射的数组。
2. callback：一个函数，用于处理数组中的每个元素。该函数应该接受三个参数：当前元素、当前元素的索引和原数组，并返回一个值。这个返回值将被添加到结果数组中。

函数内部，我们使用一个 for 循环来遍历数组中的每个元素，并对每个元素调用 callback 函数。我们将 callback 函数的返回值添加到 result 数组中。

最后，函数返回映射后的 result 数组。

10.如何使用JS实现Object.create方法?请写出具体代码

在JavaScript中，Object.create() 方法用于创建一个新对象，该对象使用现有的对象来提供其 [[Prototype]]（即内部原型）。这意味着新创建的对象将继承现有对象的属性和方法。如果你想自己实现一个类似 Object.create() 的方法，你可以使用一种称为“原型式继承”的技术。

以下是一个简单的实现，它模拟了 Object.create() 方法的行为：

function createObject(proto) {  
  // 创建一个空的函数F，它的原型指向传入的proto对象  
  function F() {}  
    
  // 设置F的原型为proto  
  F.prototype = proto;  
    
  // 根据F创建一个新对象，这个新对象的原型就是F.prototype，即传入的proto对象  
  // 因此，这个新对象会继承proto对象的属性和方法  
  return new F();  
}  

function createObject(proto) {  // 创建一个空的函数F，它的原型指向传入的proto对象  function F() {}  // 设置F的原型为proto  F.prototype = proto;  // 根据F创建一个新对象，这个新对象的原型就是F.prototype，即传入的proto对象  // 因此，这个新对象会继承proto对象的属性和方法  return new F();  
}  // 示例使用  
const person = {  isHuman: false,  printIntroduction: function() {  console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);  }  
};  // 创建一个新对象，其原型是person对象  
const me = createObject(person);  // 为新对象添加属性  
me.name = 'John'; // "name" 是 me 的属性  
me.isHuman = true; // "isHuman" 也是 me 的属性  // 调用继承自原型对象的printIntroduction方法  
me.printIntroduction();  
// 输出: "My name is John. Am I human? true"