1. pop() 删除数组的最后一个元素并返回删除的元素。

      1. // 6. pop() 删除数组的最后一个元素并返回删除的元素。
      2.  var arr6 = [1, 2, 3];
      3.  arr6.pop();
      4.  console.log('pop', arr6);

    2. push() 向数组的末尾添加一个或更多元素，并返回新的长度。

      1. // 7. push() 向数组的末尾添加一个或更多元素，并返回新的长度。
      2.  var arr7 = [1, 2, 3];
      3.  arr7.push(4);
      4.  console.log('push', arr7);

    3. shift() 删除并返回数组的第一个元素。

    4. unshift() 向数组的开头添加一个或更多元素，并返回新的长度。
    5. map()。对原来成员改头换面 ```javascript

    // 10. map()。对原来成员改头换面,传入一个函数, 返回一个新的数组 var arr10 = [{ name: ‘zs’, age: 10 }, { name: ‘ls’, age: 20 }, { name: ‘ww’, age: 30 }]; var newArr10 = arr10.map(function(item, index) { // 对名字进行处理 var name = item.name.toUpperCase();

    1.     return {
    2.         name: name,
    3.         age: item.age - 10
    4.     };
    5. });
    6. console.log('newArr10=', newArr10);
    2. 6. **filter() 检测数值元素，并返回符合条件所有元素的数组。**
    3. ```javascript
    4.  // 11. filter() 检测数组元素，并返回符合条件所有元素的数组。
    5.     var arr11 = [{
    6.         name: 'zs',
    7.         age: 10
    8.     }, {
    9.         name: 'ls',
    10.         age: 20
    11.     }, {
    12.         name: 'ww',
    13.         age: 30
    14.     }];
    15.     var newArr11 = arr11.filter(function(item, index) {
    16.         return item.age >= 20;
    17.     });
    18.     console.log('newArr11=', newArr11);

    1. forEach() 遍历数组。

      1. // 12. forEach() 遍历数组。
      2.  var arr12 = [{
      3.      name: 'zs',
      4.      age: 10
      5.  }, {
      6.      name: 'ls',
      7.      age: 20
      8.  }, {
      9.      name: 'ww',
      10.      age: 30
      11.  }];
      12.  arr12.forEach(function(item, index) {
      13.      console.log(index, item);
      14.  });
      15.  console.log(str);
      17.  // for循环
      18.  var filmList = [{
      19.      filmName: '电影1',
      20.      time: 120
      21.  }, {
      22.      filmName: '电影2',
      23.      time: 120
      24.  }, {
      25.      filmName: '电影3',
      26.      time: 120
      27.  }, {
      28.      filmName: '电影4',
      29.      time: 130
      30.  }]
      31.  var str = '';
      32.  for (var i = 0; i < filmList.length; i++) {
      33.      var item = filmList[i];
      34.      str += `
      35.      <li><span>${item.filmName}</span> <span>${item}</span></li> 
      36.      `;
      37.  }
      38.  // document.querySelector('#list').innerHTML = str;
      40.  // forEach循环
      41.  var str = '';
      42.  filmList.forEach(function(item, index) {
      43.          str += `
      44.      <li><span>${item.filmName}</span> <span>${item}</span></li> 
      45.      `;
      46.      })
      47.      // document.querySelector('#list').innerHTML = str;

    2. isArray() 判断对象是否为数组。

      1. // 1. Array.isArray() 判断对象是否为数组。
      2.  var arr1 = [12, 3, 4, 5];
      3.  // var arr1 = new Array();
      4.  console.log(typeof arr1); // object
      5.  var boo1 = Array.isArray(arr1);
      6.  console.log('boo1', boo1);

    3. find() 返回符合传入测试（函数）条件的数组元素。 // 只返回符合条件的第一个成员, 没有符合条件就返回 undefined

      1. // 13. find() 返回符合条件的数组元素。 // 只返回符合条件的第一个成员, 没有符合条件就返回 undefined
      2.  var arr13 = [{
      3.      name: 'zs',
      4.      age: 10
      5.  }, {
      6.      name: 'ls',
      7.      age: 20
      8.  }, {
      9.      name: 'ww',
      10.      age: 30
      11.  }];
      12.  var newArr13 = arr13.find(function(item, index) {
      13.      // return item.name === 'zs';
      14.      return item.age > 10; // 只返回符合条件的第一个成员
      15.  });
      16.  console.log('newArr13=', newArr13);

    4. findIndex() 返回符合传入测试（函数）条件的数组元素索引。 ```javascript

    // 14. findIndex() 返回符合传入测试（函数）条件的数组元素索引。 var arr14 = [{ name: ‘zs’, age: 10 }, { name: ‘ls’, age: 20 }, { name: ‘ww’, age: 30 }]; var index14 = arr14.findIndex(function(item, index) { return item.age === 30; }); console.log(‘index14=’, index14);

    2. 11. **indexOf() 搜索数组中的元素，并返回它所在的位置。**
    3. 12. **lastIndexOf() 搜索数组中的元素，并返回它最后出现的位置。**
    4. 13. **some() 检测数组元素中是否有元素符合指定条件。 // 用来判断数组是否包含符合条件的成员, 包含返回 true, 不包含返回 false**
    5. ```javascript
    10. // 17. some() 检测数组元素中是否有元素符合指定条件。 // 用来判断数组是否包含符合条件的成员, 包含返回 true, 不包含返回 false
    11.     var arr17 = [{
    12.         name: 'zs',
    13.         age: 10
    14.     }, {
    15.         name: 'ls',
    16.         age: 20
    17.     }, {
    18.         name: 'ww',
    19.         age: 30
    20.     }];
    21.     var boo17 = arr17.some(function(item, index) {
    22.         return item.age > 10;
    23.     })
    24.     console.log('boo17=', boo17);
    1. includes() 判断一个数组是否包含一个指定的值。 // 成员只能是基本数据类型 ```javascript

    // 2. includes() 判断一个数组是否包含一个指定的值。 // 成员只能是基本数据类型 var arr2 = [‘a’, ‘b’, ‘c’, ‘d’]; var boo2 = arr2.includes(‘a’); // console.log(‘boo2’, boo2);

    2. 15. **join() 把数组的所有元素放入一个字符串。**
    3. ```javascript
    4. // 3. join() 把数组的所有元素放入一个字符串。
    5.     var arr3 = ['a', 'b', 'c', 'd'];
    6.     var str3 = arr3.join('-'); // -是分隔符, 默认是逗号,也可以上是其他
    7.     console.log('str3=', str3);

    1. slice() 选取数组的一部分，并返回一个新数组。

      1. // 5. slice() 选取数组的一部分，并返回一个新数组。类似字符串的slice方法
      2. var arr5 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
      3. var newArr5 = arr5.slice(2, 5);
      4. console.log('newArr5=', newArr5);

    2. splice() 从数组中添加或删除元素。 ```javascript // 18. splice() 从数组中添加或删除元素。参数可以是2个或者3个 var arr18 = [{

      1. name: 'zs',
      2. age: 10

      }, {

      1. name: 'ls',
      2. age: 20

      }, {

      1. name: 'ww',
      2. age: 30

      }]; arr18.splice(1, 1); // 两个参数,第1个参数表示下标,第2个参数,表示删除的成员个数 console.log(‘arr18’, arr18);

      var arr18 = [{

      1. name: 'zs',
      2. age: 10

      }, {

      1. name: 'ls',
      2. age: 20

      }, {

      1. name: 'ww',
      2. age: 30

      }];

      var item = {

      1. name: '张欢',
      2. age: 18

      }; arr18.splice(1, 2, item); // 三个参数,第1个参数表示下标,第2个参数,表示删除的成员个数,第3个参数用来替代被删除的成员 console.log(‘arr18’, arr18);

    2. 18. **sort() 对数组的元素进行排序。**
    3. ```javascript
    7.  // 19. sort() 对数组的元素进行排序。
    8.     var arr19 = ['a', 'c', 'x', 'd'];
    9.     var newArr19 = arr19.sort();
    10.     console.log('newArr19=', newArr19); // 按字母的升序排列
    12.     var arr19 = [1, 2, 10, 20, 8];
    13.     var newArr19 = arr19.sort();
    14.     console.log('newArr19=', newArr19);
    16.     // 传入一个函数参数,a-b升序排列,b-a降序排序
    17.     console.log('---------- 19. sort(),传入函数 ----------------')
    18.     var newArr19 = arr19.sort(function(a, b) {
    19.         return b - a;
    20.     });
    21.     console.log('newArr19=', newArr19);
    23.     console.log('---------- 19. sort(),成员是对象 ----------------')
    24.         // 成员是对象时也是如此
    25.     var arr19 = [{
    26.         name: 'zs',
    27.         age: 10
    28.     }, {
    29.         name: 'ls',
    30.         age: 20
    31.     }, {
    32.         name: 'ww',
    33.         age: 30
    34.     }, {
    35.         name: 'zh',
    36.         age: 18
    37.     }];
    38.     var newArr19 = arr19.sort(function(a, b) {
    39.         return b.age - a.age;
    40.     })
    41.     console.log('newArr19=', newArr19);
    1. reverse() 反转数组的元素顺序。 ```javascript

    // 4. reverse() 反转数组的元素顺序。 var arr4 = [‘a’, ‘b’, ‘c’, ‘d’]; var newArr4 = arr4.reverse(); console.log(‘newArr4’, newArr4); ```