【前端口试】随机、布局赋值、博弈题

解构赋值（Destructuring Assignment）是 JavaScript ES6 引入的一项非常有用的特性，它允许我们快速地从数组或对象中提取值，并将它们赋给变量。这种方式使得代码更加简便、易读，并且可以或许淘汰重复的访问和赋值操纵。
1. 数组解构赋值

通过解构赋值，我们可以直接从数组中提取值并赋给变量。比方：

1. // 基本的数组解构赋值
2. const arr = [1, 2, 3];
3. const [a, b, c] = arr;
5. console.log(a); // 1
6. console.log(b); // 2
7. console.log(c); // 3

复制代码

说明：

• a、b 和 c 分别从数组 arr 中提取了值。
  
• 解构赋值次序是按数组的索引次序进行的。
  

跳过元素：
假如我们只需要数组中的部分元素，可以跳过不需要的元素：

1. const arr = [1, 2, 3];
2. const [a, , c] = arr;  // 跳过第二个元素
4. console.log(a); // 1
5. console.log(c); // 3

复制代码

默认值：
解构时，假如数组的某个位置没有值，可以为该变量提供默认值：

1. const arr = [1];
2. const [a, b = 2] = arr;
4. console.log(a); // 1
5. console.log(b); // 2

复制代码

2. 对象解构赋值

对象解构赋值允许我们从对象中提取特定的属性并赋给变量。

1. const person = { name: 'Alice', age: 25 };
2. const { name, age } = person;
4. console.log(name); // Alice
5. console.log(age);  // 25

复制代码

说明：

• 变量名需要与对象属性的名称雷同。假如变量名与对象属性名不同，可以通过 : 来重命名：
  

1. const person = { name: 'Alice', age: 25 };
2. const { name: personName, age: personAge } = person;
4. console.log(personName); // Alice
5. console.log(personAge);  // 25

复制代码

默认值：
假如某个属性在对象中不存在，可以为该属性设置默认值：

1. const person = { name: 'Alice' };
2. const { name, age = 30 } = person;
4. console.log(name); // Alice
5. console.log(age);  // 30

复制代码

嵌套解构：
你还可以对对象进行嵌套解构，从嵌套的对象中提取值：

1. const person = { name: 'Alice', address: { city: 'Wonderland', zip: '12345' } };
2. const { name, address: { city, zip } } = person;
4. console.log(name); // Alice
5. console.log(city); // Wonderland
6. console.log(zip);  // 12345

复制代码

3. 解构赋值与剩余操纵符

假如你需要从数组或对象中提取出剩余的元素或属性，可以利用剩余操纵符 ...。
数组的剩余解构：

1. const arr = [1, 2, 3, 4, 5];
2. const [first, second, ...rest] = arr;
4. console.log(first);  // 1
5. console.log(second); // 2
6. console.log(rest);   // [3, 4, 5]

复制代码

对象的剩余解构：

1. const person = { name: 'Alice', age: 25, city: 'Wonderland' };
2. const { name, ...otherInfo } = person;
4. console.log(name);     // Alice
5. console.log(otherInfo); // { age: 25, city: 'Wonderland' }

复制代码

4. 函数参数中的解构赋值

解构赋值可以与函数参数联合利用，直接从传入的对象或数组中提取值：
数组解构作为函数参数：

1. function sum([a, b]) {
2.   return a + b;
3. }
5. console.log(sum([3, 5])); // 8

复制代码

对象解构作为函数参数：

1. function greet({ name, age }) {
2.   console.log(`Hello, ${name}! You are ${age} years old.`);
3. }
5. greet({ name: 'Alice', age: 25 }); // Hello, Alice! You are 25 years old.

复制代码

带默认值的函数参数解构：

1. function greet({ name = 'Guest', age = 18 } = {}) {
2.   console.log(`Hello, ${name}! You are ${age} years old.`);
3. }
5. greet({ name: 'Alice' }); // Hello, Alice! You are 18 years old.
6. greet(); // Hello, Guest! You are 18 years old.

复制代码

这段代码 [arr, arr[j]] = [arr[j], arr]; 是数组元素互换的语法，属于一种解构赋值的用法。它通常用于互换数组中两个元素的位置。
表明

• 解构赋值：这是 JavaScript ES6 中引入的一个特性，允许我们利用数组或对象的布局来进行赋值。
  
• 数组元素互换：在没有解构赋值的语法时，我们通常利用临时变量来互换两个元素，好比：
  
  1. let temp = arr[i];
  2. arr[i] = arr[j];
  3. arr[j] = temp;

  复制代码
  而利用解构赋值的方式可以淘汰临时变量的利用，使代码更简便。通过这种方式，arr 和 arr[j] 两个元素的值会互换。
  

利用场景

这个代码片断在Fisher-Yates 洗牌算法中非常常见，它用于随机打乱数组中的元素次序。通过不断互换数组中的元素，从最后一个元素开始，渐渐将每个元素与之前的元素互换，确保每个元素都有相等的概率出如今数组的任何位置。
示例：Fisher-Yates 洗牌算法实现

1. function shuffleArray(arr) {
2.   for (let i = arr.length - 1; i > 0; i--) {
3.     // 随机选择一个索引 j，其中 0 <= j <= i
4.     const j = Math.floor(Math.random() * (i + 1));
5.     // 交换 arr[i] 和 arr[j]
6.     [arr[i], arr[j]] = [arr[j], arr[i]];
7.   }
8. }
10. const arr = [1, 2, 3, 4, 5];
11. shuffleArray(arr);
12. console.log(arr); // 打乱顺序后的数组

复制代码

这段代码的关键点：

• Fisher-Yates 洗牌算法：这个算法的核心头脑是从数组的最后一个元素开始，随机选择一个元素并与当前元素互换位置，直到整个数组都经过处置惩罚。这确保了数组中每个元素出现的次序是随机的。
  
• 解构赋值：通过 [arr, arr[j]] = [arr[j], arr]; 来简便地互换元素，无需利用额外的临时变量。
  

以下是将上述题目改成先输后赢情况的题目及对应答案，也就是目标变为让对方拿到最后一颗石子、最后一枚硬币等情况来取得胜利，供你参考：