1. pop() 删除数组的最后一个元素并返回删除的元素。
    2. push() 向数组的末尾添加一个或更多元素，并返回新的长度。
    3. shift() 删除并返回数组的第一个元素。
    4. unshift() 向数组的开头添加一个或更多元素，并返回新的长度。
    5. map()。对原来成员改头换面
    6. filter() 检测数值元素，并返回符合条件所有元素的数组。
    7. forEach() 遍历数组。
    8. isArray() 判断对象是否为数组。
    9. find() 返回符合传入测试（函数）条件的数组元素。 // 只返回符合条件的第一个成员, 没有符合条件就返回 undefined
    10. findIndex() 返回符合传入测试（函数）条件的数组元素索引。
    11. indexOf() 搜索数组中的元素，并返回它所在的位置。
    12. lastIndexOf() 搜索数组中的元素，并返回它最后出现的位置。
    13. some() 检测数组元素中是否有元素符合指定条件。 // 用来判断数组是否包含符合条件的成员, 包含返回 true, 不包含返回 false
    14. includes() 判断一个数组是否包含一个指定的值。 // 成员只能是基本数据类型
    15. join() 把数组的所有元素放入一个字符串。
    16. slice() 选取数组的一部分，并返回一个新数组。
    17. splice() 从数组中添加或删除元素。
    18. sort() 对数组的元素进行排序。
    19. reverse() 反转数组的元素顺序。
    1. <script>
    2.     // 1. Array.isArray() 判断对象是否为数组。
    3.     var arr1 = [12, 3, 4, 5];
    4.     // var arr1 = new Array();
    5.     console.log(typeof arr1); // object
    6.     var boo1 = Array.isArray(arr1);
    7.     console.log('boo1', boo1);
    9.     // 2. includes() 判断一个数组是否包含一个指定的值。 // 成员只能是基本数据类型
    10.     var arr2 = ['a', 'b', 'c', 'd'];
    11.     var boo2 = arr2.includes('a'); // 
    12.     console.log('boo2', boo2);
    14.     // 3. join() 把数组的所有元素放入一个字符串
    15.     var arr3 = ['a', 'b', 'c', 'd'];
    16.     var str3 = arr3.join('-'); // -是分隔符, 默认是逗号,也可以上是其他
    17.     console.log('str3=', str3);
    19.     // 4. reverse() 反转数组的元素顺序。
    20.     var arr4 = ['a', 'b', 'c', 'd'];
    21.     var newArr4 = arr4.reverse();
    22.     console.log('newArr4', newArr4);
    24.     // 5. slice() 选取数组的一部分，并返回一个新数组。类似字符串的slice方法
    25.     var arr5 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    26.     var newArr5 = arr5.slice(2, 5);
    27.     console.log('newArr5=', newArr5);
    29.     // 6. pop() 删除数组的最后一个元素并返回删除元素之后的原数组。
    30.     var arr6 = [1, 2, 3];
    31.     arr6.pop();
    32.     console.log('pop', arr6);
    33.     // 7. push() 向数组的末尾添加一个或更多元素，并返回新的长度。
    34.     var arr7 = [1, 2, 3];
    35.     arr7.push(4);
    36.     console.log('push', arr7);
    38.     // 8. shift() 删除并返回数组的删除第一个元素的原数组。
    39.     var arr6 = [1, 2, 3];
    40.     arr6.shift();
    41.     console.log('pop', arr6); // [2, 3]
    42.     // 9. unshift() 向数组的开头添加一个或更多元素，并返回新的长度。
    43.     var arr7 = [1, 2, 3];
    44.     arr7.unshift(4);
    45.     console.log('push', arr7)
    47.     // 10. map()。对原来成员改头换面,传入一个函数, 返回一个新的数组
    48.     var arr10 = [{
    49.         name: 'zs',
    50.         age: 10
    51.     }, {
    52.         name: 'ls',
    53.         age: 20
    54.     }, {
    55.         name: 'ww',
    56.         age: 30
    57.     }];
    58.     var newArr10 = arr10.map(function(item, index) {
    59.         // 对名字进行处理
    60.         var name = item.name.toUpperCase();
    62.         return {
    63.             name: name,
    64.             age: item.age - 10
    65.         };
    66.     });
    67.     console.log('newArr10=', newArr10);
    69.     console.log('----------11. filter()----------------')
    71.     // 11. filter() 检测数组元素，并返回符合条件所有元素的数组。
    72.     var arr11 = [{
    73.         name: 'zs',
    74.         age: 10
    75.     }, {
    76.         name: 'ls',
    77.         age: 20
    78.     }, {
    79.         name: 'ww',
    80.         age: 30
    81.     }];
    82.     var newArr11 = arr11.filter(function(item, index) {
    83.         return item.age >= 20;
    84.     });
    85.     console.log('newArr11=', newArr11);
    87.     console.log('----------12. forEach() ----------------')
    88.         // 12. forEach() 遍历数组。
    89.     var arr12 = [{
    90.         name: 'zs',
    91.         age: 10
    92.     }, {
    93.         name: 'ls',
    94.         age: 20
    95.     }, {
    96.         name: 'ww',
    97.         age: 30
    98.     }];
    99.     arr12.forEach(function(item, index) {
    100.         console.log(index, item);
    101.     });
    102.     console.log(str);
    104.     // for循环
    105.     var filmList = [{
    106.         filmName: '电影1',
    107.         time: 120
    108.     }, {
    109.         filmName: '电影2',
    110.         time: 120
    111.     }, {
    112.         filmName: '电影3',
    113.         time: 120
    114.     }, {
    115.         filmName: '电影4',
    116.         time: 130
    117.     }]
    118.     var str = '';
    119.     for (var i = 0; i < filmList.length; i++) {
    120.         var item = filmList[i];
    121.         str += `
    122.         <li><span>${item.filmName}</span> <span>${item}</span></li> 
    123.         `;
    124.     }
    125.     // document.querySelector('#list').innerHTML = str;
    127.     // forEach循环
    128.     var str = '';
    129.     filmList.forEach(function(item, index) {
    130.             str += `
    131.         <li><span>${item.filmName}</span> <span>${item}</span></li> 
    132.         `;
    133.         })
    134.         // document.querySelector('#list').innerHTML = str;
    137.     console.log('----------13. find() ----------------')
    138.         // 13. find() 返回符合条件的数组元素。 // 只返回符合条件的第一个成员, 没有符合条件就返回 undefined
    139.     var arr13 = [{
    140.         name: 'zs',
    141.         age: 10
    142.     }, {
    143.         name: 'ls',
    144.         age: 20
    145.     }, {
    146.         name: 'ww',
    147.         age: 30
    148.     }];
    149.     var newArr13 = arr13.find(function(item, index) {
    150.         // return item.name === 'zs';
    151.         return item.age > 10; // 只返回符合条件的第一个成员
    152.     });
    153.     console.log('newArr13=', newArr13);
    155.     console.log('----------14. findIndex() ----------------')
    156.         // 14. findIndex() 返回符合传入测试（函数）条件的数组元素索引。如果瞒住的条件多个只返回第一个满足条件的索引值；
    157.     var arr14 = [{
    158.         name: 'zs',
    159.         age: 10
    160.     }, {
    161.         name: 'ls',
    162.         age: 20
    163.     }, {
    164.         name: 'ww',
    165.         age: 30
    166.     }];
    167.     var index14 = arr14.findIndex(function(item, index) {
    168.         return item.age === 30;
    169.     });
    170.     console.log('index14=', index14);
    172.     // 15. indexOf() 搜索数组中的元素，并返回它所在的位置。
    173.     // 16. lastIndexOf() 搜索数组中的元素，并返回它最后出现的位置。
    175.     console.log('----------17. some()  ----------------')
    176.         // 17. some() 检测数组元素中是否有元素符合指定条件。 // 用来判断数组是否包含符合条件的成员, 包含返回 true, 不包含返回 false
    177.     var arr17 = [{
    178.         name: 'zs',
    179.         age: 10
    180.     }, {
    181.         name: 'ls',
    182.         age: 20
    183.     }, {
    184.         name: 'ww',
    185.         age: 30
    186.     }];
    187.     var boo17 = arr17.some(function(item, index) {
    188.         return item.age > 10;
    189.     })
    190.     console.log('boo17=', boo17);
    192.     console.log('----------18. splice() ----------------')
    193.         // 18. splice() 从数组中添加或删除元素。参数可以是2个或者3个
    194.     var arr18 = [{
    195.         name: 'zs',
    196.         age: 10
    197.     }, {
    198.         name: 'ls',
    199.         age: 20
    200.     }, {
    201.         name: 'ww',
    202.         age: 30
    203.     }];
    204.     arr18.splice(1, 1); // 两个参数,第1个参数表示下标,第2个参数,表示删除的成员个数，如果前面的索引值的位置在后面参数位置后面的时候只删除索引值位置的值；
    205.     console.log('arr18', arr18);
    207.     var arr18 = [{
    208.         name: 'zs',
    209.         age: 10
    210.     }, {
    211.         name: 'ls',
    212.         age: 20
    213.     }, {
    214.         name: 'ww',
    215.         age: 30
    216.     }];
    218.     var item = {
    219.         name: '张欢',
    220.         age: 18
    221.     };
    222.     arr18.splice(1, 2, item); // 三个参数,第1个参数表示下标,第2个参数,表示删除的成员个数,第3个参数用来替代被删除的成员
    223.     console.log('arr18', arr18);
    225.     console.log('---------- 19. sort() ----------------')
    226.         // 19. sort() 对数组的元素进行排序。
    227.     var arr19 = ['a', 'c', 'x', 'd'];
    228.     var newArr19 = arr19.sort();
    229.     console.log('newArr19=', newArr19); // 按字母的升序排列
    231.     var arr19 = [1, 2, 10, 20, 8];
    232.     var newArr19 = arr19.sort();
    233.     console.log('newArr19=', newArr19);
    235.     // 传入一个函数参数,a-b升序排列,b-a降序排序（仅限于数字）
    236.     console.log('---------- 19. sort(),传入函数 ----------------')
    237.     var newArr19 = arr19.sort(function(a, b) {
    238.         return b - a;
    239.     });
    240.     console.log('newArr19=', newArr19);
    242.     console.log('---------- 19. sort(),成员是对象 ----------------')
    243.         // 成员是对象时也是如此
    244.     var arr19 = [{
    245.         name: 'zs',
    246.         age: 10
    247.     }, {
    248.         name: 'ls',
    249.         age: 20
    250.     }, {
    251.         name: 'ww',
    252.         age: 30
    253.     }, {
    254.         name: 'zh',
    255.         age: 18
    256.     }];
    257.     var newArr19 = arr19.sort(function(a, b) {
    258.         return b.age - a.age;
    259.     })
    260.     console.log('newArr19=',
    261.                 newArr19);(4) [{…}, {…}, {…}, {…}]
    262.                            0: {name: "ww", age: 30}
    263.                            1: {name: "ls", age: 20}
    264.                            2: {name: "zh", age: 18}
    265.                            3: {name: "zs", age: 10}
    266.                            length:
    267.                             __proto__: Array(0)
    268. </script>