nolebase
Search K

Appearance

10 作业 03 ​

主观题 ​

练习题 1 ​

年龄统计 (codepen.io)

写一个程序，要求如下（★★）

  • 需求 1: 让用户输入五个有效年龄（0-100 之间），放入数组中

    • 必须输入五个有效年龄年龄，如果是无效年龄，则不能放入数组中

  • 需求 2: 打印出所有成年人的年龄 (数组筛选)

  • 需求 3: 打印出所有人总年龄（累加）

  • 需求 4: 打印出所有人的平均年龄（累加）

  • 需求 5: 打印出最大年龄和最小年龄（最大值）

html
<div class="data-container">
  <h1>年龄统计</h1>
  <label for="q1"
    >第 1 个有效年龄（0-100 之间）
    <input type="number" id="q1" placeholder="请输入第1个有效年龄" min="0" max="100" />
  </label>
  <label for="q2"
    >第 2 个有效年龄（0-100 之间）
    <input type="number" id="q2" placeholder="请输入第2个有效年龄" min="0" max="100" />
  </label>
  <label for="q3"
    >第 3 个有效年龄（0-100 之间）
    <input type="number" id="q3" placeholder="请输入第3个有效年龄" min="0" max="100" />
  </label>
  <label for="q4"
    >第 4 个有效年龄（0-100 之间）
    <input type="number" id="q4" placeholder="请输入第4个有效年龄" min="0" max="100" />
  </label>
  <label for="q5"
    >第 5 个有效年龄（0-100 之间）
    <input type="number" id="q5" placeholder="请输入第5个有效年龄" min="0" max="100" />
  </label>
  <button onclick="generate()">计算</button>
</div>
<div id="result-container"></div>
css
.data-container {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  margin: 20px 0;
}

.data-container label,
.data-container button {
  margin-top: 10px;
}

.data-container input {
  padding-left: 10px;
  width: 180px;
  outline: none;
  line-height: 22px;
}

.data-container button {
  padding: 5px 10px;
  border: none;
  border-radius: 5px;
  background-color: #ccc;
  cursor: pointer;
}

.data-container button:hover {
  background-color: #aaa;
}

#result-container {
  display: flex;
  justify-content: space-evenly;
  align-items: flex-end;
  width: 750px;
  margin: 20px auto;
  background-color: #ccc;
}
js
function generate() {
  const ageArr = [];

  const resultContainer = document.getElementById("result-container");
  resultContainer.innerHTML = ""; // 清空容器

  const result = document.createElement("ul");
  result.classList.add("result");

  //  validate 让用户输入五个有效年龄（0-100 之间），**放入数组中**
  for (let i = 1; i <= 5; i++) {
    const input = document.getElementById(`q${i}`);
    // if (input.value >0 && input.value < 100) {
    //   ageArr.push(input.value);
    // }
    ageArr.push(parseInt(input.value) || Math.floor(Math.random() * 99) + 1);
  }

  // 打印出所有人的年龄（数组）
  // let output = ageArr.map((item) => `${item}, `).join("");
  let output = ageArr.join(", ");
  result.innerHTML = `<li>所有人的年龄：${output}</li>`;

  // printAdultAge  打印出所有成年人的年龄 (数组筛选)
  const adultAge = ageArr.filter((age) => age >= 18);
  output = adultAge.join(", ");
  result.innerHTML += `<li>所有成年人的年龄：${output}</li>`;

  // printTotalAge 打印出所有人总年龄（累加）
  // let totalAge = 0;
  // for (let i = 0; i < ageArr.length; i++) {
  //   totalAge += ageArr[i];
  // }
  const totalAge = ageArr.reduce((total, age) => total + age, 0);
  result.innerHTML += `<li>所有人总年龄：${totalAge}</li>`;

  // printAverageAge 打印出所有人的平均年龄（累加）
  result.innerHTML += `<li>所有人平均年龄：${(totalAge / ageArr.length).toFixed(2)}</li>`;

  // printMaxAge/printMinAge 打印出最大年龄和最小年龄
  // const maxAge = Math.max(...ageArr);
  // const minAge = Math.min(...ageArr);
  // resultContainer.innerHTML += `<br>最大年龄：${maxAge}，最小年龄：${minAge}`;
  ageArr.sort((a, b) => a - b);
  result.innerHTML += `<li>最大年龄：${ageArr[ageArr.length - 1]}，最小年龄：${ageArr[0]}</li>`;

  resultContainer.appendChild(result);
}

练习题 2 ​

找出数组中 元素为 10 的下标 (codepen.io)

找出数组中 元素为 10 的下标，有则打印该下标，没有则打印 -1

  • 例如：[88,20,10,100,50] 打印 2
  • 例如：[88,20,30,100,50] 打印 -1
js
// 找出数组中 元素为 10 的下标，有则打印该下标，没有则打印 -1

// const arr = [88, 20, 10, 100, 50];
const arr = Array.from({length: 10000}, () => Math.floor(Math.random() * 100));

let output = "";

// 打印数组
output = arr.join(", ");
document.write("数组元素为：" + output + "<br>");

// 方法一：使用 indexOf
console.time("indexOf");
document.write("使用 indexOf 方法：" + arr.indexOf(10) + "<br>");
console.timeEnd("indexOf");

// 方法二：使用 findIndex
console.time("findIndex");
document.write("使用 findIndex 方法：" + arr.findIndex((item) => item === 10) + "<br>");
console.timeEnd("findIndex");

// 方法三：使用 find，findIndex 与 find 的区别是 findIndex 返回的是下标，find 返回的是元素
// document.write("使用 find 方法：" + arr.find((item) => item === 10) + '<br>');

// 方法四：使用 for 循环
document.write("使用 for 循环：");
console.time("for loop");
for (let i = 0; i < arr.length; i++) {
  if (arr[i] === 10) {
    document.write(i + "<br>");
    break;
  }
}
console.timeEnd("for loop");

// 方法五：使用 forEach
document.write("使用 forEach 循环：");
console.time("forEach");
arr.forEach((item, index) => {
  if (item === 10) {
    document.write(index + "<br>");
  }
});
console.timeEnd("forEach");

练习题 3 ​

使用 for 循环 - 求出数组元素的和 (codepen.io)

使用 for 循环 - 求出数组元素的和 [5, 8, 9, 2, 1, 5]

js
// 使用 for 循环 - 求出数组元素的和 [5, 8, 9, 2, 1, 5]

const numbers = [5, 8, 9, 2, 1, 5];
let output = "";

output = numbers.join(" + ");
output += " = ";
// let sum = 0;
// for (let i = 0; i < numbers.length; i++) {
//   sum += numbers[i];
// }
// output += sum;
output += numbers.reduce((a, b) => a + b, 0);

document.write(output);

练习题 4 ​

使用 for 循环 - 求出数组里大于 5 的 i 的数的和 [4, 9, 5, 20, 3, 11]

js
const numbers = [4, 9, 5, 20, 3, 11];
let result = "";
let sum = 0;
for (let i = 0; i < numbers.length; i++) {
  if (numbers[i] > 5) {
    sum += numbers[i];
    result += numbers[i] + "[" + i + "]" + " ";
  }
}

document.write(result + "的和为：" + sum);
js
const numbers = [4, 9, 5, 20, 3, 11];
let result = "";
let sum = 0;
numbers.reduce((prev, curr, i) => {
  if (curr > 5) {
    result += curr + "[" + i + "]" + " ";
    sum += curr;
  }
}, 0);
document.write(result + "的和为：" + sum);

练习题 5 ​

使用 for 循环 - 求出班级里同学们平均年龄 [15, 19, 21, 33, 18, 24]

js
const ages = [15, 19, 21, 33, 18, 24];
let sum = 0;
for (let i = 0; i < ages.length; i++) {
  sum += ages[i];
}

let average = sum / ages.length;
console.log(average.toFixed(2));
js
const ages = [15, 19, 21, 33, 18, 24];
let totalAge = ages.reduce((total, age) => total + age, 0);
let averageAge = totalAge / ages.length;
console.log(averageAge.toFixed(2));

练习题 6 ​

计算 [2, 6, 18, 15, 40] 中能被 3 整除的偶数的和

js
const numbers = [2, 6, 18, 15, 40];
let sum = numbers.reduce((prev, curr) => {
  if (curr % 3 === 0 && curr % 2 === 0) {
    return prev + curr;
  } else {
    return prev;
  }
}, 0);
console.log(sum);
js
const numbers = [2, 6, 18, 15, 40];
let sum = numbers.reduce((total, num) => (num % 3 === 0 && num % 2 === 0 ? total + num : total), 0);
console.log(sum);

练习题 7 ​

计算 [2, 6, 18, 15, 40] 中能被 3 整除的偶数的个数

js
const numbers = [2, 6, 18, 15, 40];
console.log(numbers.filter((item) => item % 3 === 0 && item % 2 === 0).length);

练习题 8 ​

给一个数字数组，该数组中有很多数字 0，将不为 0 的数据存入到一个新的数组中

js
const numbers = Array.from({length: 10000}, () => Math.floor(Math.random() * 100));
// console.log(numbers);
console.log(numbers.filter((item) => item !== 0));

核心练习题 ​

需求：根据用户输入的个数，页面可以渲染对应王者荣耀永雄的个数

效果如下：渲染图片案例 (codepen.io)

思路分析：

  1. 渲染图片比较多，我们可以把图片地址放入数组中，
  2. 图片名称是有序号排列的，比如 1.webp 2.webp 此处可以使用循环方式重复渲染图片
  3. 渲染位置？可以考虑放到 box 盒子里写 script 即可
html
<div class="data-container">
  <h1>渲染图片案例</h1>
  <label for="q1"
    >请输入显示的英雄个数 1~20 之间：
    <input type="number" id="q1" placeholder="请输入显示的英雄个数" min="1" max="20" />
  </label>
  <button onclick="generate()">计算</button>
</div>
<div id="result-container"></div>
css
.data-container {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  margin: 20px 0;
}

.data-container label,
.data-container button {
  margin-top: 10px;
}

.data-container input {
  padding-left: 10px;
  width: 180px;
  outline: none;
  line-height: 22px;
}

.data-container button {
  padding: 5px 10px;
  border: none;
  border-radius: 5px;
  background-color: #ccc;
  cursor: pointer;
}

.data-container button:hover {
  background-color: #aaa;
}

#result-container {
  display: flex;
  flex-wrap: wrap;
  justify-content: space-between;
  align-items: center;
  width: 540px;
  margin: 20px auto;
}

#result-container img {
  width: 100px;
  height: 100px;
  margin-bottom: 10px;
  border: 2px solid #258df2;
  border-radius: 10px 0 10px 0;
}

#result-container img.empty {
  height: 0;
  visibility: hidden;
}
js
function generate() {
  const colors = [
    "#69d2e7",
    "#a7dbd8",
    "#e0e4cc",
    "#f38630",
    "#fa6900",
    "#fe4365",
    "#fc9d9a",
    "#f9cdad",
    "#c8c8a9",
    "#83af9b",
  ];
  const q1 = document.getElementById("q1").value;
  const resultContainer = document.getElementById("result-container");
  resultContainer.innerHTML = "";
  for (let i = 0; i < q1; i++) {
    const img = document.createElement("img");
    img.src = `https://source.unsplash.com/random/100x100`;
    img.referrerPolicy = "no-referrer";
    img.style.backgroundColor = colors[Math.floor(Math.random() * colors.length)];
    resultContainer.appendChild(img);
  }

  for (let i = 0; i < 5; i++) {
    const empty = document.createElement("img");
    empty.classList.add("empty");
    resultContainer.appendChild(empty);
  }
}

排错题 ​

拍错题 1 ​

js
// 请问以下代码会出现什么问题，如何解决？

// 需求：求 1~100 之间的累加和
// 注意：此处有 3 个错误，找出并且修正
let sum
for (let i = 1; i < 100; i++;) {
  sum += i
}
console.log(sum)

// 答案
1. 变量 sum 没有初始化，应该赋初值为 0。
2. for 循环语句中，分号应该是两个，而不是三个。
3. 循环条件中应该是 i <= 100，而不是 i < 100，否则会漏掉 100。

// 解决方案
let sum = 0;
for (let i = 1; i <= 100; i++) {
  sum += i;
}
console.log(sum);

排错题 2 ​

js
// bug:请你找到下面代码的 bug，把数字 1 打印出来

let sum = 0;
let arr = [1, 2, 3, 4, 5];
for (let i = 1; i < arr.length; i++) {
  console.log(arr[i]);
}

// 答案
// 1. 循环起始条件设置为 let i = 1，这时打印的是数组中的第二个元素，而不是第一个元素。
// 2. 循环体中没有 break，会一直循环下去，打印出所有的元素。

// 解决办法
let sum = 0;
let arr = [1, 2, 3, 4, 5];
for (let i = 0; i < arr.length; i++) {
  if (arr[i] === 1) {
    console.log(arr[i]);
    break;
  }
}

排错题 3 ​

js
// bug:找到下面代码死循环的原因，并修改为正确的代码

for (let i = 1; i <= 5; i++) {
  for (let j = 1; j <= 5; i++) {
    console.log(`这是双重 for 循环`);
  }
}

// 答案
// 内层循环的计数器是 let j = 1，但是在循环体内却执行了 i++ 而不是 j++，导致内层循环的计数器一直保持为 1，无法正常跳出内层循环。

// 解决办法
for (let i = 1; i <= 5; i++) {
  for (let j = 1; j <= 5; j++) {
    console.log(`这是双重 for 循环`);
  }
}

客观题 ​

JavaScript 基础第三天测试题-pink 老师 (wjx.top)

  1. 关于数组的常用方法，下列描述正确的是（）

    js
    A: 数组能在本长度内任意位置删除元素;
B: 数组只能在头部追加或删除元素;
C: 数组只能在头部或尾部追加或删除元素;
D: 上述描述都是错误的;

    答案是 C: 数组只能在头部或尾部追加或删除元素。

    JavaScript 中，数组提供了许多常用的方法，其中包括向数组末尾添加元素、从数组末尾删除元素、从数组头部添加元素、从数组头部删除元素等操作。但是无论是使用 push、pop 方法还是 shift、unshift 方法，都是在数组的末尾或头部进行操作的。在本长度内任意位置删除元素不是数组的内置方法，但是可以通过 splice 方法来实现。

  2. 关于 javascript 中数组的说法中，不正确的是（）

    js
    A: 数组的长度必须是创建时给定，之后便不能改变
B: 数组里面可以存放多个数据
C: 数组中元素的类型可以不同
D: 数组可以在声明的同时进行初始化

    答案是 A: 数组的长度必须是创建时给定，之后便不能改变。

    在 JavaScript 中，数组的长度是可以动态改变的。可以通过添加或删除元素来改变数组的长度。例如使用 push、pop、shift 和 unshift 等方法可以改变数组的长度。而且，在使用数组字面量声明数组时也不需要指定数组的长度，数组会根据初始化的个数来动态分配空间。

    因此，A 选项中的描述是不正确的。正确的应该是：数组的长度可以动态改变，可以通过增加或删除元素来改变数组的长度。

  3. let arr = [] 声明数组未给值，请问里面的值是什么？ （）

    js
    A: true;
B: false;
C: null;
D: undefine;

    答案是 D: undefined。let arr = [] 声明数组未给值时，数组里面没有任何元素，它的长度为 0。

    在 JavaScript 中，如果一个变量没有被赋值，则会默认被赋值为 undefined。因此，这个空数组中没有任何元素，其值为 undefined。

  4. 下面关于 for 循环说法正确的是（）

    js
    A: for(;;) 这种写法会出现语法错误
B: 在 for 循环中，不能用 break 语句跳出循环体
C: for 循环是先执行循环体语句，后判断表达式（终止条件）
D: for 循环的循环体语句中，可以包含多条语句，但必须用花括号括起来

    答案是 D: for 循环的循环体语句中，可以包含多条语句，但必须用花括号括起来。

    A 选项，for(;;) 是一个合法的无限循环写法，相当于 while(true)。

    B 选项 break 语句是用来跳出循环的，可以在循环中使用。

    C 选项 for 循环首先会判断表达式是否成立，如果成立才会执行循环体语句。

  5. 以下代码，依次输出的结果为（）

    js
    let i;
for (i = 0; i < 5; i++) {
  console.log(i);
}
console.log(i);
    js
    A: 0 1 2 3 4 4
B: 5 5 5 5 5 5
C: 0 1 2 3 4 5
D: 0 1 2 3 4

    答案是 C: 0 1 2 3 4 5。

    使用了 for 循环来迭代输出变量 i 的值，循环中先将 i 初始化为 0，每次循环将 i 加一，并且在循环体内打印 i 的值。当 i 的值达到 5 时跳出循环，最后在循环外部再次打印 i 的值。

    因此，循环内共执行了 5 次，分别打印了 0、1、2、3、4，然后在循环外部又打印了一次 i 的值，其值为 5。

  6. 下列语句中 helloworld 打印的次数是（）

    js
    for (var i = 0; i <= 3; i++) {
  for (var j = 1; j <= 3; j++) {
    console.log("helloworld");
  }
}
    js
    A: 3 次
B: 4 次
C: 9 次
D: 12 次

    答案是 C: 12 次。

    外层循环执行了 4 次（i 的取值为 0、1、2、3），内层循环每次执行 3 次（j 的取值为 1、2、3），所以 "helloworld" 这个字符串在内层循环中共打印了 4*3=12 次。

  7. 关于数组的说法错误的是（）

    js
    A: 可以按照索引号查找数组元素;
B: 能存储多个数据;
C: 按照索引遍历数组方便;
D: 数组只能存储一种类型的数据;

    答案是 D: 数组只能存储一种类型的数据。

    在 JavaScript 中，数组可以存储多种类型的数据。也就是说，一个数组中既可以存储字符串，也可以存储数字或者布尔值等不同类型的数据。这是 JavaScript 动态类型语言的特性之一，与静态类型语言（如 Java）不同。

    因此，D 选项描述是错误的，数组可以存储多种类型的数据。

  8. 关于数组的描述错误的是（）

    js
    A: 数组的创建方式是 let arr = [1, 2, 3, 4, 5]
B: 数组的长度可以使用 arr.length 来得到
C: 数组的每一项值都有索引，索引默认从 1 开始
D: 数组里面的元素可以增加和删除等操作

    答案是 C: 数组的每一项值都有索引，索引默认从 1 开始。

    在 JavaScript 中，数组的索引是从 0 开始的，而不是从 1 开始。这意味着第一个元素的索引为 0，第二个元素的索引为 1，以此类推。因此，C 选项中的描述是错误的，数组的索引是从 0 开始计数的。

    正确的说法是：

    A 选项描述了创建数组的常见方式，使用方括号 [] 来声明并初始化数组。

    B 选项描述了获取数组长度的常见方式，可以使用 arr.length 来获取数组的长度值。

    D 选项描述了数组的基本操作，可以通过增加或删除元素等操作改变数组的内容。

  9. 请问以下代码执行的结果是什么？

    js
    let sum = 0;
let arr = [10, 20, 30, 40];
for (let i = 0; i < arr.length; i++) {
  if (i === 2) {
    continue;
  }
  sum += arr[i];
}
console.log(sum);
    js
    A: 0;
B: 60;
C: 70;
D: 100;

    答案是 C: 70。

    使用 if 语句判断当前遍历到的元素是否为第三个元素（即索引值等于 2 的元素），如果是，则使用 continue 跳过本次循环，不进行累加操作；否则将当前遍历到的元素的值加入到变量 sum 中。

    因此，在循环结束后，变量 sum 中存储的是数组中除了第三个元素以外所有元素的和，即 10 + 20 + 40 = 70。最后通过 console.log 方法输出变量 sum 的值。

  10. 下面代码输出的结果是（）

    js
    let sum = 0;
let arr = [11, 22, 33];
for (let i = 0; i <= arr.length; i++) {
  sum += arr[i];
}
console.log(sum);
    js
    A: 66;
B: 0112233;
C: NaN;
D: undefined;

    答案是 C: NaN。

    在循环的判断条件中，使用了小于等于号（<=）来判断 i 是否小于等于数组长度，这会导致循环会多执行一次，当 i 取到等于数组长度时，arr[i] 将返回 undefined，而 undefined 与任何数字相加的结果都是 NaN，所以最终变量 sum 的值也会变成 NaN。

    正确地输出数组中所有元素的累加和（66）的代码：

    js
    let sum = 0;
let arr = [11, 22, 33];
for (let i = 0; i < arr.length; i++) {
  sum += arr[i];
}
console.log(sum);

  11. 今日单词：请问下面那个方法可以删除数组第一个元素？（）

    js
    A: shift();
B: unshift();
C: pop();
D: push();

    答案是 A: shift()。

    shift() 方法用于从数组中删除并返回第一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。因此，使用 shift() 方法可以删除数组的第一个元素。而选项 B、C、D 中的方法分别用于在数组的开头或结尾添加或删除元素，不能单独删除数组的第一个元素。

    A: shift(): 方法用于从数组中删除并返回第一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。

    B: unshift(): 方法将一个或多个元素添加到数组的开头，并将已有元素顺次地移到更高的索引位置，以便为新元素腾出空间。该方法修改原数组，不创建新的副本。

    C: pop(): 方法用于从数组中删除并返回最后一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。

    D: push(): 方法将一个或多个元素添加到数组的末尾，并返回新数组的长度。该方法修改原数组，而不是创建新的副本。

    这四个方法都是 JavaScript 数组常见的操作之一。使用这些方法可以方便地对数组进行增加和删除操作。其中 shift() 和 unshift() 方法用于在数组的开头进行操作，pop() 和 push() 方法用于在数组的末尾进行操作。需要注意的是，这些方法都会改变原数组，所以如果需要保留原数组，可以在操作前先创建一个原数组的拷贝。

  12. 今日单词：请问下面那个方法可以删除数组最后一个元素？（）

    js
    A: shift();
B: unshift();
C: pop();
D: push();
E: splice();

    答案是 C: pop()。

    pop() 方法用于从数组中删除并返回最后一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。因此，使用 pop() 方法可以删除数组的最后一个元素。而选项 A、B、D 中的方法分别用于在数组的开头或结尾添加或删除元素，不能单独删除数组的最后一个元素。选项 E 中的 splice() 方法可以用于删除数组中的指定元素，包括最后一个元素，但它需要传入要删除的元素的索引值，使用起来比较麻烦，不如直接使用 pop() 方法方便。

    A: shift(): 方法用于从数组中删除并返回第一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。

    B: unshift(): 方法将一个或多个元素添加到数组的开头，并将已有元素顺次地移到更高的索引位置，以便为新元素腾出空间。该方法修改原数组，不创建新的副本。

    C: pop(): 方法用于从数组中删除并返回最后一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。

    D: push(): 方法将一个或多个元素添加到数组的末尾，并返回新数组的长度。该方法修改原数组，而不是创建新的副本。

    E: splice(): 方法可以用于在数组的任意位置添加或删除元素。它接受三个参数：要操作的起始索引、要删除的元素个数以及要插入的元素（可选）。使用 splice() 方法可以添加、删除或替换数组中特定位置的元素，但是它会改变原数组，需要谨慎使用。

    这五个方法都是 JavaScript 数组常见的操作之一。使用这些方法可以方便地对数组进行增加和删除操作。其中 shift() 和 unshift() 方法用于在数组的开头进行操作，pop() 和 push() 方法用于在数组的末尾进行操作，splice() 方法用于在任意位置进行操作。需要注意的是，这些方法都会改变原数组，所以如果需要保留原数组，可以在操作前先创建一个原数组的拷贝。

  13. 今日单词：请问下面那个方法可以给数组尾部追加元素？ （）

    js
    A: shift();
B: unshift();
C: pop();
D: push();
E: splice();

    答案是 D: push()。

    push() 方法可以将一个或多个元素添加到数组的末尾，并返回新数组的长度。该方法会修改原数组，而不是创建新的副本。因此，使用 push() 方法可以给数组尾部追加元素。而选项 A、B、C 中的方法分别用于在数组的开头或结尾删除元素，不能单独增加元素。选项 E 中的 splice() 方法可以用于在数组中的任意位置增加或删除元素，但是需要传入要添加或删除的元素的索引值及数量，使用起来比较麻烦，不如直接使用 push() 方法方便。

  14. 今日单词：请问下面那个方法可以给数组头部追加元素？ （）

    js
    A: shift();
B: unshift();
C: pop();
D: push();
E: splice();

    答案是 B: unshift()。

    unshift() 方法可以将一个或多个元素添加到数组的开头，并将已有元素顺次地移到更高的索引位置，以便为新元素腾出空间。该方法会修改原数组，而不是创建新的副本。因此，使用 unshift() 方法可以给数组头部追加元素。而选项 A、C、D 中的方法分别用于在数组的开头或结尾删除元素，不能单独增加元素。选项 E 中的 splice() 方法可以用于在数组中的任意位置增加或删除元素，但是需要传入要添加或删除的元素的索引值及数量，使用起来比较麻烦，不如直接使用 unshift() 方法方便。

  15. 今日单词：请问下面那个方法可以删除数组任意元素？ （）

    js
    A: shift();
B: unshift();
C: pop();
D: push();
E: splice();

    答案是 E: splice()。

    splice() 方法可以用于在数组的任意位置添加或删除元素。它接受三个参数：要操作的起始索引、要删除的元素个数以及要插入的元素（可选）。使用 splice() 方法可以添加、删除或替换数组中特定位置的元素，因此，使用 splice() 方法可以删除数组任意元素。而选项 A、B、C、D 分别用于在数组的开头或结尾删除元素或增加元素，不能单独删除数组中间的元素。

  16. 今日单词：请问下面那个方法可以给数组元素排序？ （）

    js
    A: join();
B: unshift();
C: pop();
D: sort();
E: splice();

    答案是 D: sort()。

    A: join(): 方法将数组中所有元素转化为字符串，并返回一个由这些字符串连接而成的新字符串。该方法不会改变原数组。

    B: unshift(): 方法将一个或多个元素添加到数组的开头，并将已有元素顺次地移到更高的索引位置，以便为新元素腾出空间。该方法修改原数组，不创建新的副本。

    C: pop(): 方法用于从数组中删除并返回最后一个元素。删除后，其他元素会自动移动填补空出来的位置，同时数组的长度减一。

    D: sort(): 方法用于对数组元素进行排序，默认按照字符编码的顺序进行排序。可以传入一个比较函数来指定排序规则。该方法会改变原数组，但不会创建新的副本。

    E: splice(): 方法可以用于在数组的任意位置添加或删除元素。它接受三个参数：要操作的起始索引、要删除的元素个数以及要插入的元素（可选）。使用 splice() 方法可以添加、删除或替换数组中特定位置的元素，但是它会改变原数组，需要谨慎使用。

    这五个方法都是 JavaScript 数组常见的操作之一。其中 join() 方法用于将数组中的元素拼接成字符串，unshift() 和 pop() 方法用于在数组的开头和末尾增加或删除元素，sort() 方法用于对数组元素进行排序，splice() 方法用于在任意位置增加、删除或替换元素。需要注意的是，这些方法都有可能改变原数组（除了 join()），所以如果需要保留原数组，可以在操作前先创建一个原数组的拷贝。