01.函数

1.定义函数

声明式

函数声明是通过使用function关键字来定义函数的方式。它的语法如下：

function functionName(parameters) {
  // 函数体
}

例如：

function greet(name) {
  console.log("Hello, " + name + "!");
}

函数声明可以在任何地方进行，并且在代码执行之前就可以调用。

赋值式

函数表达式是将函数赋值给变量的方式来定义函数。它的语法如下：

var functionName = function(parameters) {
  // 函数体
}

例如：

var greet = function(name) {
  console.log("Hello, " + name + "!");
}

函数表达式必须在赋值之后才能被调用，因为它们实际上是赋值给变量的一个匿名函数。

2.九九乘法表

function multiplicationTable() {
  for (let i = 1; i <= 9; i++) {
    let row = '';
    for (let j = 1; j <= i; j++) {
      row += `${j} * ${i} = ${j * i}\t`;
    }
    console.log(row);
  }
}

multiplicationTable();

运行上述代码，将会输出以下九九乘法表：

1 * 1 = 1
1 * 2 = 2    2 * 2 = 4
1 * 3 = 3    2 * 3 = 6    3 * 3 = 9
1 * 4 = 4    2 * 4 = 8    3 * 4 = 12    4 * 4 = 16
1 * 5 = 5    2 * 5 = 10    3 * 5 = 15    4 * 5 = 20    5 * 5 = 25
1 * 6 = 6    2 * 6 = 12    3 * 6 = 18    4 * 6 = 24    5 * 6 = 30    6 * 6 = 36
1 * 7 = 7    2 * 7 = 14    3 * 7 = 21    4 * 7 = 28    5 * 7 = 35    6 * 7 = 42    7 * 7 = 49
1 * 8 = 8    2 * 8 = 16    3 * 8 = 24    4 * 8 = 32    5 * 8 = 40    6 * 8 = 48    7 * 8 = 56    8 * 8 = 64
1 * 9 = 9    2 * 9 = 18    3 * 9 = 27    4 * 9 = 36    5 * 9 = 45    6 * 9 = 54    7 * 9 = 63    8 * 9 = 72    9 * 9 = 81

3.函数的参数

形式参数

在函数定义时声明的参数，用于接收函数调用时传递的实际参数的值。形式参数位于函数的括号内，多个形参之间用逗号分隔。

示例：

function add(x, y) {
  console.log(x + y);
}

add(2, 3); // 输出：5

在上述示例中，add函数定义了两个形参 x 和 y，当我们调用 add 函数并传递两个实际参数 2 和 3 时，实际参数的值会被分别赋给 x 和 y 形参，从而在函数体内进行操作。

实际参数

在函数调用时传递给函数的值。实际参数可以是常量、变量、表达式或其他函数调用的返回值。

示例：

function greet(name) {
  console.log(`Hello, ${name}!`);
}

let person = "Alice";
greet(person); // 输出：Hello, Alice!

在上述示例中，greet 函数的形参是 name，我们在函数调用时将变量 person 作为实际参数传递给 greet 函数，从而在函数体内使用该值进行操作。

4.函数的返回值

1. 返回基本数据类型： 函数可以返回基本数据类型，如数字、字符串、布尔值等。例如：

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

console.log(add(2, 3)); // 输出: 5

2. 返回复杂数据类型：函数还可以返回复杂数据类型，如数组、对象等。例如：

function getPerson() {
  return { name: "John", age: 30 };
}

console.log(getPerson()); // 输出: { name: "John", age: 30 }

3. 返回undefined：如果函数没有明确的return语句，或者return后面没有值，那么函数将返回undefined。例如：

function doSomething() {
  // 没有return语句
}

console.log(doSomething()); // 输出: undefined

4. 返回函数：JavaScript中的函数也可以作为值返回，这样的函数称为“返回函数”或“高阶函数”。例如：

function greet() {
  return function(name) {
    console.log("Hello, " + name + "!");
  };
}

var greeting = greet();
greeting("John"); // 输出: Hello, John!

总之，函数的返回值是通过使用return语句来指定的。它可以是基本数据类型、复杂数据类型、undefined，甚至是函数本身。返回值允许我们在函数中计算结果并将其传递给调用函数的地方。

5.函数-预解析

1. 函数声明提升：JavaScript中的函数声明（function declaration）会被提升到当前作用域的顶部。这意味着可以在函数声明之前调用函数。例如：

console.log(add(2, 3)); // 输出: 5

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

2. 函数表达式不会被提升：与函数声明不同，函数表达式（function expression）不会被提升。函数表达式是将函数赋值给一个变量。例如：

console.log(add(2, 3)); // 报错: add is not a function

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

3. 变量提升：除了函数声明，JavaScript还会将变量声明（var、let、const）提升到当前作用域的顶部。但是，只有声明会被提升，赋值不会被提升。例如：

console.log(a); // 输出: undefined
var a = 10;

console.log(b); // 报错: b is not defined
let b = 20;

总之，函数预解析是JavaScript引擎在代码执行之前将函数声明提升到当前作用域顶部的机制。这意味着可以在函数声明之前调用函数。但是，函数表达式不会被提升，变量的赋值也不会被提升。了解函数预解析可以帮助我们理解JavaScript中的作用域和变量声明的行为。

6.函数-重名问题

在全局作用域中，如果多次使用var关键字来定义同一个变量，后面的定义将会覆盖前面的定义。例如：

var x = 10;
var x = 20;
console.log(x); // 输出20

在函数作用域中，如果在同一个函数中多次使用var关键字或函数声明来定义同一个变量或函数，后面的定义也将会覆盖前面的定义。例如：

function foo() {
   var x = 10;
   var x = 20;
   console.log(x); // 输出20
}

foo();

为了避免重名问题，可以采取以下几种方法：

1. 使用不同的变量或函数名称。
2. 使用不同的作用域，例如使用闭包或立即执行函数表达式。
3. 使用对象或命名空间来组织变量或函数，以避免全局命名冲突。

例如，可以使用对象来组织变量：

var obj = {
   x: 10,
   y: 20
};

console.log(obj.x); // 输出10
console.log(obj.y); // 输出20

或者使用立即执行函数表达式来创建一个新的作用域：

(function() {
   var x = 10;
   console.log(x); // 输出10
})();

(function() {
   var x = 20;
   console.log(x); // 输出20
})();

7.作用域

全局作用域

全局作用域是指在任何函数内部都可以访问的作用域。它是整个JavaScript程序的最外层作用域，包含了所有的全局变量和函数。

在全局作用域中定义的变量和函数可以在任何地方被访问，包括其他函数内部。全局作用域中的变量和函数可以被称为全局变量和全局函数。

在浏览器环境中，全局作用域是指在浏览器窗口或标签页中加载的JavaScript代码的作用域。在Node.js环境中，全局作用域是指在Node.js进程中执行的JavaScript代码的作用域。

在全局作用域中定义变量时，可以使用var关键字或不使用任何关键字。使用var关键字定义的变量是局部变量，只在全局作用域中可见。不使用任何关键字定义的变量是全局变量，可以在全局作用域以及任何其他作用域中访问。

例如，在全局作用域中定义一个全局变量：

var x = 10;

function foo() {
   console.log(x); // 输出10
}

foo();

全局作用域中的变量可以被其他函数内部访问和修改：

var x = 10;

function foo() {
   x = 20;
}

foo();

console.log(x); // 输出20

需要注意的是，在全局作用域中定义的变量可能会被其他函数内部的同名变量覆盖。为了避免命名冲突，可以使用命名空间或模块化的方法来组织代码。

局部作用域

局部作用域是指在函数内部定义的作用域。它包含了函数内部的变量和函数，这些变量和函数只能在函数内部被访问。

在函数内部定义的变量和函数可以被称为局部变量和局部函数。这些变量和函数只在函数内部可见，外部的代码无法直接访问它们。

使用函数可以创建一个新的局部作用域。当函数被调用时，会创建一个新的局部作用域，当函数执行完毕后，局部作用域会被销毁。

在局部作用域中定义的变量会在函数执行过程中被创建，并在函数执行完毕后被销毁。这意味着局部变量的生命周期只存在于函数的执行期间。

例如，在函数内部定义一个局部变量：

function foo() {
   var x = 10;
   console.log(x); // 输出10
}

foo();

console.log(x); // 报错，x未定义

在函数内部可以访问外部作用域中的变量，但外部作用域无法访问函数内部的变量。

var x = 10;

function foo() {
   var y = 20;
   console.log(x); // 输出10
   console.log(y); // 输出20
}

foo();

console.log(y); // 报错，y未定义

需要注意的是，在函数内部可以访问外部作用域中的变量，但如果在函数内部定义了同名的变量，则会覆盖外部作用域中的同名变量。

var x = 10;

function foo() {
   var x = 20;
   console.log(x); // 输出20
}

foo();

console.log(x); // 输出10

局部作用域的存在可以帮助我们避免命名冲突和变量污染，同时也提供了更好的封装性和代码可维护性。

访问规则

1. 访问全局变量：

var x = 10;

function foo() {
   console.log(x); // 输出10
}

foo();

在函数foo内部访问全局变量x，由于全局变量在整个作用域链中可见，所以可以正确地访问并输出其值。

2. 访问局部变量：

function foo() {
   var x = 10;
   console.log(x); // 输出10
}

foo();
console.log(x); // 报错，x未定义

在函数foo内部定义了一个局部变量x，该变量只在函数内部可见。在函数外部访问x会导致报错。

3. 变量提升：

console.log(x); // 输出undefined
var x = 10;
console.log(x); // 输出10

在第一个console.log语句中，变量x被声明但尚未赋值，所以输出undefined。在第二个console.log语句中，变量x已经被赋值为10，所以输出10。

4. 块级作用域：

if (true) {
   var x = 10;
   let y = 20;
   const z = 30;
}

console.log(x); // 输出10
console.log(y); // 报错，y未定义
console.log(z); // 报错，z未定义

在if语句的代码块中，使用var关键字定义的变量x具有函数作用域，所以在if语句外部仍然可见。而使用let和const关键字定义的变量y和z具有块级作用域，只在if语句内部可见，所以在if语句外部访问会导致报错。

02.对象

创建对象

字面量

内置构造函数

对象的基本操作

增

查

改

删

对象的遍历

for...in循环：使用for...in循环可以遍历对象的所有可枚举属性（包括继承的属性）。例如：

const obj = {a: 1, b: 2, c: 3};

for(let key in obj) {
  console.log(key, obj[key]);
}

输出结果：

a 1
b 2
c 3

03.不同数据类型的存储

基本数据类型

1. 数字（Number）：

   • 存储方式：数值直接存储在栈内存中。

   • 示例：

     let num = 10;
     

2. 字符串（String）：

   • 存储方式：字符串的字符序列存储在栈内存中。

   • 示例：

     let str = "Hello";
     

3. 布尔值（Boolean）：

   • 存储方式：布尔值（true或false）存储在栈内存中。

   • 示例：

     let isTrue = true;
     

4. null和undefined：

   • 存储方式：null和undefined值都存储在栈内存中。

   • 示例：

     let nullValue = null;
     let undefinedValue;
     

基本数据类型的值在栈内存中被直接存储和访问，而不需要通过引用地址。当一个变量赋值给另一个变量时，会创建一个新的值并复制给新变量。因此，两个变量拥有独立的值，互不影响。

复杂数据类型

04.数组

创建数组

字面量

数组字面量使用方括号（[]）表示，并包含一个或多个以逗号分隔的元素。以下是使用数组字面量创建数组的示例：

1. 创建一个空数组：

   let emptyArray = [];
   

2. 创建一个包含多个元素的数组：

   let numbers = [1, 2, 3, 4, 5];
   let fruits = ["apple", "banana", "orange"];
   

3. 创建一个混合类型的数组：

   let mixedArray = [1, "hello", true, null, undefined];
   

4. 创建一个嵌套数组：

   let nestedArray = [[1, 2], [3, 4], [5, 6]];
   

5. 创建一个包含表达式的数组：

   let expressionArray = [1 + 2, "Hello" + "World", true && false];
   

在数组字面量中，你可以直接指定数组的元素，并使用逗号将它们分隔开。数组的元素可以是任何数据类型，包括数字、字符串、布尔值、null、undefined等。你还可以创建嵌套数组，将一个数组作为另一个数组的元素。使用数组字面量可以方便地创建和初始化数组。

Array

var arr = new Array(element1, element2, ..., elementN);

其中，element1, element2, ..., elementN是数组中的元素。可以传入任意类型的元素，也可以不传入任何元素创建一个空数组。

以下是一些示例：

1. 创建一个空数组：

var arr = new Array();

2. 创建一个包含元素的数组：

var arr = new Array(1, 2, 3);

3. 创建一个包含不同类型元素的数组：

var arr = new Array("apple", 123, { name: "John" });

需要注意的是，当传入一个数字作为参数时，Array构造函数会创建指定长度的数组，并且数组的每个元素都是undefined。例如：

var arr = new Array(5);
console.log(arr); // 输出: [undefined, undefined, undefined, undefined, undefined]

如果只传入一个参数，且该参数是一个非负整数，则Array构造函数会创建指定长度的数组。但如果传入的参数是一个负整数或者其他非数字类型的值，则会创建包含该参数作为唯一元素的数组。例如：

var arr1 = new Array(-1); // 创建一个包含-1作为唯一元素的数组
console.log(arr1); // 输出: [-1]

var arr2 = new Array("hello"); // 创建一个包含"hello"作为唯一元素的数组
console.log(arr2); // 输出: ["hello"]

因此，推荐使用数组字面量（[]）来创建数组，因为它更简洁、直观。例如：

var arr = [];

数组的基本操作

长度

获取数组长度：使用length属性可以获取数组的长度。例如：

var arr = [1, 2, 3];
console.log(arr.length); // 输出: 3

索引

数组的索引是从 0 开始的整数，用于访问数组中的元素。可以使用方括号（[]）来访问数组的特定索引位置的元素。

下面是一些关于数组索引的示例：

1. 访问数组元素：

var arr = [1, 2, 3];
console.log(arr[0]); // 输出: 1
console.log(arr[1]); // 输出: 2
console.log(arr[2]); // 输出: 3

2. 修改数组元素：

var arr = [1, 2, 3];
arr[1] = 4;
console.log(arr); // 输出: [1, 4, 3]

3. 添加新元素：

var arr = [1, 2, 3];
arr[3] = 4;
console.log(arr); // 输出: [1, 2, 3, 4]

需要注意的是，如果访问的索引超出了数组的长度，将返回 undefined。例如：

var arr = [1, 2, 3];
console.log(arr[4]); // 输出: undefined

此外，还可以使用负数索引来访问数组中的元素。负数索引表示从数组末尾开始计数，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。例如：

var arr = [1, 2, 3];
console.log(arr[-1]); // 输出: undefined
console.log(arr[-2]); // 输出: undefined
console.log(arr[-3]); // 输出: 1

总之，要使用正确的索引来访问和修改数组中的元素，确保不超出数组的长度范围。

遍历

以下是使用 for 循环遍历数组的示例：

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

在上述示例中，i 是循环的计数器，初始值为 0，每次循环递增 1，直到 i 小于数组的长度 arr.length。在循环的每一次迭代中，通过 arr[i] 访问数组中的元素，并将其输出到控制台。

需要注意的是，使用 for 循环遍历数组时，需要注意索引的范围。确保索引从 0 开始，并小于数组的长度，以避免访问超出数组边界的元素。

此外，还可以在循环中进行其他操作，如条件判断、累加、过滤等，以满足具体的需求。

排序法sort

冒泡排序法（Bubble sort）

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历数组，比较相邻的元素，并根据需要交换它们的位置，直到整个数组排序完成。下面是使用冒泡排序法对数组进行排序的示例：

function bubbleSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len - 1; i++) {
    for (var j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        // 交换相邻元素的位置
        var temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

// 示例用法
var arr = [5, 3, 8, 2, 1, 4];
console.log(bubbleSort(arr)); // 输出: [1, 2, 3, 4, 5, 8]

在上述示例中，bubbleSort 函数接受一个数组作为参数，并使用两层嵌套的循环遍历数组。外层循环控制需要比较的轮数，内层循环用于比较相邻元素并进行交换。如果前一个元素大于后一个元素，则交换它们的位置。

通过多次遍历和比较，最大的元素会逐渐“冒泡”到数组的末尾，而最小的元素会逐渐“沉底”，从而实现排序。

冒泡排序的时间复杂度是 O(n^2)，其中 n 是数组的长度。因此，在处理大型数组时，冒泡排序可能不是最优的选择。

选择排序法（Selection Sort）

选择排序（Selection Sort）是一种简单的排序算法，它每次从未排序部分选择最小（或最大）的元素，并将其放置在已排序部分的末尾。下面是使用选择排序法对数组进行排序的示例：

function selectionSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len - 1; i++) {
    var minIndex = i;
    for (var j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    // 交换最小元素和当前位置元素的位置
    var temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

// 示例用法
var arr = [5, 3, 8, 2, 1, 4];
console.log(selectionSort(arr)); // 输出: [1, 2, 3, 4, 5, 8]

在上述示例中，selectionSort 函数接受一个数组作为参数，并使用两层嵌套的循环遍历数组。外层循环控制已排序部分的末尾位置，内层循环用于在未排序部分中找到最小元素的索引。

在内层循环中，使用 minIndex 变量记录当前找到的最小元素的索引。如果找到比当前最小元素更小的元素，则更新 minIndex。

在内层循环结束后，将最小元素与当前位置的元素进行交换，将最小元素放置在已排序部分的末尾。

通过多次选择最小元素并交换位置，数组逐渐变得有序。

选择排序的时间复杂度是 O(n^2)，其中 n 是数组的长度。与冒泡排序类似，选择排序也不适用于处理大型数组。

数组常用方法

push后追加元素

在 JavaScript 中，可以使用 push() 方法向数组的末尾追加一个或多个元素。push() 方法会修改原始数组，将新元素添加到数组的末尾。下面是使用 push() 方法追加元素的示例：

var arr = [1, 2, 3];
arr.push(4);
console.log(arr); // 输出: [1, 2, 3, 4]

arr.push(5, 6);
console.log(arr); // 输出: [1, 2, 3, 4, 5, 6]

在上述示例中，首先创建了一个数组 arr，包含了一些初始元素 [1, 2, 3]。然后使用 push() 方法追加元素到数组的末尾，分别追加了单个元素 `4

---

pop后删除元素

---

unshift前追加元素

可以使用Array的unshift()方法在数组的开头添加一个或多个元素。

以下是一个示例代码：

let arr = [2, 3, 4, 5];

// 在数组的开头添加元素
arr.unshift(1);

console.log(arr); // 输出：[1, 2, 3, 4, 5]

在上面的代码中，使用unshift()方法在数组arr的开头添加了元素1。最后输出添加元素之后的数组arr。

---

shift前删除元素

可以使用Array的shift()方法删除数组的第一个元素，并返回被删除的元素。

以下是一个示例代码：

let arr = [1, 2, 3, 4, 5];

// 删除数组的第一个元素
let deletedElement = arr.shift();

console.log(deletedElement); // 输出：1
console.log(arr); // 输出：[2, 3, 4, 5]

在上面的代码中，使用shift()方法删除了数组arr的第一个元素，并将被删除的元素赋值给deletedElement变量。最后输出删除元素之后的数组arr。

---

splice

splice() 方法用于删除或替换数组的元素，并返回被删除的元素。

splice() 方法的语法如下：

array.splice(start, deleteCount, item1, item2, ...)

• start：要删除或替换元素的起始索引位置。
• deleteCount：要删除的元素个数。如果为 0，则不删除任何元素。
• item1, item2, ...：要插入到数组中的新元素（可选）。

以下是一些示例用法：

1. 删除数组中的元素：

var arr = [1, 2, 3, 4, 5];
arr.splice(2, 1); // 从索引为 2 的位置开始删除 1 个元素
console.log(arr); // 输出: [1, 2, 4, 5]

2. 替换数组中的元素：

var arr = [1, 2, 3, 4, 5];
arr.splice(2, 1, "a", "b"); // 从索引为 2 的位置开始删除 1 个元素，并在该位置插入新元素 "a" 和 "b"
console.log(arr); // 输出: [1, 2, "a", "b", 4, 5]

3. 在数组中插入新元素：

var arr = [1, 2, 3, 4, 5];
arr.splice(2, 0, "a", "b"); // 从索引为 2 的位置开始，不删除任何元素，只在该位置插入新元素 "a" 和 "b"
console.log(arr); // 输出: [1, 2, "a", "b", 3, 4, 5]

需要注意的是，splice() 方法会修改原始数组。如果不想修改原始数组，可以先复制一份再进行操作。

---

resver 倒序

reverse() 方法会修改原始数组，将数组中的元素顺序颠倒过来。

以下是使用 reverse() 方法倒序数组的示例：

var arr = [1, 2, 3, 4, 5];
arr.reverse();
console.log(arr); // 输出: [5, 4, 3, 2, 1]

在上面的示例中，arr.reverse() 会将数组 [1, 2, 3, 4, 5] 的元素顺序颠倒，得到 [5, 4, 3, 2, 1]。

---

sort排序

sort() 方法默认将数组元素转换为字符串，然后按照 UTF-16 编码顺序进行排序。这意味着默认情况下，sort() 方法会将数组元素作为字符串进行排序，而不是按照数值大小进行排序。

以下是使用 sort() 方法对数组进行排序的示例：

var arr = [3, 1, 5, 2, 4];
arr.sort();
console.log(arr); // 输出: [1, 2, 3, 4, 5]

在上面的示例中，arr.sort() 会将数组 [3, 1, 5, 2, 4] 中的元素转换为字符串，然后按照字符串的 UTF-16 编码顺序进行排序，得到 [1, 2, 3, 4, 5]。

如果要按照数值大小进行排序，可以使用一个比较函数作为 sort() 方法的参数。比较函数接受两个参数，通常被称为 a 和 b，表示数组中的两个元素。比较函数需要返回一个负数、零或正数，来表示 a 和 b 的相对顺序。

以下是使用比较函数对数组进行数值排序的示例：

var arr = [3, 1, 5, 2, 4];
arr.sort(function(a, b) {
  return a - b;
});
console.log(arr); // 输出: [1, 2, 3, 4, 5]

在上面的示例中，比较函数 function(a, b) { return a - b; } 会将数组元素按照数值大小进行排序。返回负数表示 a 应该排在 b 前面，返回零表示 a 和 b 相等，返回正数表示 a 应该排在 b 后面。这样就可以得到按照数值大小排序的结果 [1, 2, 3, 4, 5]。

---

concat拼接

concat() 方法不会修改原始数组，而是返回一个新的数组，其中包含原始数组和要拼接的数组或值的合并结果。

以下是使用 concat() 方法拼接数组的示例：

var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
var arr3 = arr1.concat(arr2);
console.log(arr3); // 输出: [1, 2, 3, 4, 5, 6]

在上面的示例中，arr1.concat(arr2) 会将数组 arr2 拼接到数组 arr1 的后面，得到一个新的数组 [1, 2, 3, 4, 5, 6]。

除了数组，concat() 方法还可以接受其他值作为参数，这些值会被添加到新数组的末尾。

以下是使用 concat() 方法拼接值的示例：

var arr1 = [1, 2, 3];
var value = 4;
var arr2 = arr1.concat(value);
console.log(arr2); // 输出: [1, 2, 3, 4]

在上面的示例中，arr1.concat(value) 会将值 value 添加到数组 arr1 的末尾，得到一个新的数组 [1, 2, 3, 4]。

需要注意的是，concat() 方法不会改变原始数组，而是返回一个新的数组。如果想要修改原始数组，可以将拼接结果赋值给原始数组变量。例如：arr1 = arr1.concat(arr2);

---

join 数组转字符串

join() 方法将数组中的所有元素转换为字符串，并使用指定的分隔符将它们连接起来。返回的结果是一个字符串。

以下是使用 join() 方法将数组转换为字符串的示例：

var arr = [1, 2, 3, 4, 5];
var str = arr.join(",");
console.log(str); // 输出: "1,2,3,4,5"

在上面的示例中，arr.join(",") 将数组 [1, 2, 3, 4, 5] 中的元素转换为字符串，并使用逗号 , 作为分隔符将它们连接起来，得到字符串 "1,2,3,4,5"。

join() 方法的参数是可选的，默认情况下使用逗号作为分隔符。如果不提供参数，或者参数为 undefined，则使用逗号作为分隔符。可以使用其他字符作为分隔符，将其作为参数传递给 join() 方法。

以下是使用不同分隔符的示例：

var arr = [1, 2, 3, 4, 5];
var str1 = arr.join("-"); // 使用横线作为分隔符
console.log(str1); // 输出: "1-2-3-4-5"

var str2 = arr.join(""); // 不使用分隔符
console.log(str2); // 输出: "12345"

var str3 = arr.join(" and "); // 使用 " and " 作为分隔符
console.log(str3); // 输出: "1 and 2 and 3 and 4 and 5"

需要注意的是，join() 方法不会修改原始数组，而是返回一个新的字符串。如果想要修改原始数组，可以将转换结果赋值给原始数组变量。例如：arr = arr.join(",");

---

slice 截取

slice() 方法接受两个参数，即截取的起始索引和截取的结束索引（不包括结束索引对应的元素）。如果只提供起始索引，则 slice() 方法会从该索引开始截取到数组末尾的所有元素。

以下是使用 slice() 方法截取数组的示例：

var arr = [1, 2, 3, 4, 5];
var slicedArr = arr.slice(1, 4);
console.log(slicedArr); // 输出: [2, 3, 4]

在上面的示例中，arr.slice(1, 4) 会从索引 1 开始截取到索引 4 的前一个位置的所有元素，得到一个新的数组 [2, 3, 4]。

如果只提供起始索引，例如 arr.slice(2)，则会截取从索引 2 开始到数组末尾的所有元素。

以下是只提供起始索引的示例：

var arr = [1, 2, 3, 4, 5];
var slicedArr = arr.slice(2);
console.log(slicedArr); // 输出: [3, 4, 5]

在上面的示例中，arr.slice(2) 会从索引 2 开始截取到数组末尾的所有元素，得到一个新的数组 [3, 4, 5]。

需要注意的是，slice() 方法不会修改原始数组，而是返回一个新的数组。如果想要修改原始数组，可以将截取结果赋值给原始数组变量。例如：arr = arr.slice(1, 4);

---

indexOf

indexOf() 方法接受一个参数，即要查找的元素。它会在数组中从头到尾进行搜索，返回第一个匹配的元素的索引位置。如果找不到匹配的元素，则返回 -1。

以下是使用 indexOf() 方法查找数组中元素的索引位置的示例：

var arr = [1, 2, 3, 4, 5];
var index = arr.indexOf(3);
console.log(index); // 输出: 2

在上面的示例中，arr.indexOf(3) 会在数组 [1, 2, 3, 4, 5] 中查找元素 3，并返回它的索引位置 2。

如果要查找的元素在数组中有多个匹配，indexOf() 方法只会返回第一个匹配的索引位置。

如果要查找的元素不存在于数组中，indexOf() 方法会返回 -1。

以下是查找不存在元素和多个匹配元素的示例：

var arr = [1, 2, 3, 4, 5];
var index1 = arr.indexOf(6);
console.log(index1); // 输出: -1

var arr2 = [1, 2, 3, 4, 2];
var index2 = arr2.indexOf(2);
console.log(index2); // 输出: 1

在上面的示例中，arr.indexOf(6) 返回 -1，因为元素 6 不存在于数组 [1, 2, 3, 4, 5] 中。而 arr2.indexOf(2) 返回 1，因为元素 2 在数组 [1, 2, 3, 4, 2] 中有多个匹配，但 indexOf() 方法只返回第一个匹配的索引位置。

需要注意的是，indexOf() 方法仅返回第一个匹配的索引位置。如果要查找所有匹配的索引位置，可以使用循环结合 indexOf() 方法来实现。

---

案例-数组去重

if和indexOf

function removeDuplicates(arr) {
  var result = [];
  for (var i = 0; i < arr.length; i++) {
    if (result.indexOf(arr[i]) === -1) {
      result.push(arr[i]);
    }
  }
  return result;
}

var arr = [1, 2, 3, 2, 4, 5, 1, 6, 3];
var uniqueArr = removeDuplicates(arr);
console.log(uniqueArr);  // [1, 2, 3, 4, 5, 6]

在上述代码中，通过遍历数组arr，判断每个元素在result数组中第一次出现的位置是否等于当前遍历的位置，如果等于-1，则说明该元素是第一次出现，可以将其添加到result数组中。最终返回的result数组就是去重后的数组。

---

利用对象

function removeDuplicates(arr) {
  var obj = {};
  var result = [];
  
  for (var i = 0; i < arr.length; i++) {
    if (!obj[arr[i]]) {
      obj[arr[i]] = true;
      result.push(arr[i]);
    }
  }
  
  return result;
}

var arr = [1, 2, 3, 2, 4, 5, 1, 6, 3];
var uniqueArr = removeDuplicates(arr);
console.log(uniqueArr);  // [1, 2, 3, 4, 5, 6]

在上述代码中，通过遍历数组arr，判断每个元素是否存在于对象obj中，如果不存在则将该元素作为对象的属性，并将其添加到结果数组result中。最终返回的result数组就是去重后的数组。

---

new Set

function removeDuplicates(arr) {
  return Array.from(new Set(arr));
}

var arr = [1, 2, 3, 2, 4, 5, 1, 6, 3];
var uniqueArr = removeDuplicates(arr);
console.log(uniqueArr);  // [1, 2, 3, 4, 5, 6]

在上述代码中，通过将数组arr转换为Set对象，然后再通过Array.from方法将Set对象转换为数组，就可以得到去重后的数组。

需要注意的是，Set对象是ES6中的新特性，如果在较低版本的浏览器或环境中使用，可能需要进行兼容处理。可以使用babel等工具进行转换，或者使用其他方法进行数组去重。

---

forEach遍历

var arr = [1, 2, 3, 4, 5];

arr.forEach(function(element, index, array) {
  console.log(element);  // 打印当前元素
  console.log(index);    // 打印当前元素的索引
  console.log(array);    // 打印原始数组
});

在上述代码中，我们定义了一个数组arr，然后调用arr.forEach方法。回调函数接受三个参数：当前元素（element）、当前元素的索引（index）和原始数组（array）。在回调函数中，我们可以对每个元素进行操作，或者打印出相关信息。

需要注意的是，forEach方法没有返回值，它只是用于遍历数组。如果需要对数组进行操作并返回新的数组，可以使用map方法。如果需要在遍历过程中中断循环，可以使用for循环或者其他方法。

---

map映射

var arr = [1, 2, 3, 4, 5];

var mappedArr = arr.map(function(element, index, array) {
  return element * 2;  // 将每个元素乘以2
});

console.log(mappedArr);  // [2, 4, 6, 8, 10]

在上述代码中，我们定义了一个数组arr，然后调用arr.map方法。回调函数接受三个参数：当前元素（element）、当前元素的索引（index）和原始数组（array）。在回调函数中，我们对每个元素进行了乘以2的操作，并将结果返回。

map方法会遍历原数组的每个元素，并将每个元素传递给回调函数进行操作，然后将操作的结果收集到一个新的数组中并返回。最终返回的新数组的长度和原数组相同。

---

filter 过滤

在JavaScript中，可以使用filter()方法来实现数组的过滤。filter()方法接受一个回调函数作为参数，该回调函数会对数组中的每个元素进行判断，如果返回值为true，则该元素会被保留在新的数组中，否则会被过滤掉。

以下是一个示例代码，展示如何使用filter()方法进行数组过滤：

const numbers = [1, 2, 3, 4, 5, 6];

// 过滤出所有大于3的元素
const filteredNumbers = numbers.filter(num => num > 3);

console.log(filteredNumbers); // 输出 [4, 5, 6]

在上述代码中，回调函数(num => num > 3)判断元素是否大于3，如果是，则返回true，否则返回false。filter()方法会根据这个返回值来决定是否保留该元素。

---

every 每一个

数组every()方法是用于判断数组中的所有元素是否满足指定条件的方法。它会遍历数组中的每个元素，并对每个元素应用一个回调函数，如果所有元素都满足回调函数的条件，则返回true，否则返回false。

以下是一个示例代码，展示如何使用every()方法：

const numbers = [1, 2, 3, 4, 5];

// 判断数组中的所有元素是否都大于0
const allPositive = numbers.every(num => num > 0);

console.log(allPositive); // 输出 true

在上述代码中，回调函数(num => num > 0)判断每个元素是否大于0。every()方法会对数组中的每个元素应用这个回调函数，如果所有元素都满足条件，则返回true，否则返回false。

需要注意的是，如果数组为空，则every()方法会返回true。

---

some

JavaScript中的数组some()方法用于检查数组中是否至少有一个元素满足指定的测试函数。该方法返回一个布尔值，如果至少有一个元素满足测试函数，则返回true，否则返回false。

---

find

find是Array类型的一个方法，用于查找数组中满足指定条件的第一个元素，并返回该元素。find方法接受一个回调函数作为参数，该回调函数用于定义查找的条件。

find方法的语法如下：

array.find(callback[, thisArg])

---

reduce 叠加

1. 将数组中的所有元素相加：

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue);
console.log(sum); // 输出15

2. 将数组中的所有元素相乘：

const numbers = [1, 2, 3, 4, 5];
const product = numbers.reduce((accumulator, currentValue) => accumulator * currentValue);
console.log(product); // 输出120

3. 将数组中的所有字符串连接成一个字符串：

const strings = ["Hello", " ", "World", "!"];
const concatenatedString = strings.reduce((accumulator, currentValue) => accumulator + currentValue);
console.log(concatenatedString); // 输出 "Hello World!"

4. 计算数组中的最大值：

const numbers = [3, 7, 2, 9, 1];
const max = numbers.reduce((accumulator, currentValue) => Math.max(accumulator, currentValue));
console.log(max); // 输出9

5. 将数组中的对象的某个属性值相加：

const products = [
  { name: "Apple", price: 1.5 },
  { name: "Banana", price: 0.75 },
  { name: "Orange", price: 2.25 }
];
const totalPrice = products.reduce((accumulator, currentValue) => accumulator + currentValue.price, 0);
console.log(totalPrice); // 输出4.5

---

总结

累！！！！！！！！！！！！！！！！！！！！