数组-day06 - 《JavaScript 免费课程》

1.自执行函数(匿名函数的一种)
2.数组的增删查改
3.数组的方法

1.自执行函数(匿名函数的一种)

+function(){}();
-function(){}();
~function(){}();
!function(){}();

示例代码如下:

  // 自执行函数,自己执行自己
        let res = (function (n){
              console.log(n);
              return 1;
              console.log(666);
          })(123);
          console.log(res);
          // (function (){})();
          (function(){}());
          +function(){}();
          -function(){}();
          ~function(){}();
          !function(){}();

2.数组的增删查改

是一个特殊的对象
数组的索引从0开始,依次递增,代表了每个元素的索引位置
数组有一个长度属性值,可以控制数据的长度、

push，可以往数组内添加元素,返回数组的长度

   // - 1、push：
      // + 含义：给数组末尾增加内容
      // + 参数：多个
      // + 返回值：是新增后数组的长度
      // + 原数组是否变化：变化
      let ary = [100,200,300,400];
      // 只有血统纯正的数组才可以用数组的方法
     console.log(ary.push(500,600)); // 6
     console.log(ary); // [100,200,300,400,500,600]
  //    ary[ary.length] = 'xxxx'

unshift,给数组头部增加内容,可增加多个参数,返回数组的长度

// - 2、unshift
  //  + 含义：给数组开头增加内容
  //  + 参数：多个
  //  + 返回值：是新增之后数组的长度
  //  + 原数组是否变化：变化
   let ary = [100,200,300,400];
  //  console.log(ary.unshift(200,200));
   let res = ary.unshift(200,[900]);
   console.log(res); // 6
   console.log(ary); // [200,[900],100,200,300,400]

pop,删除数组末尾最后一项内容,返回删除的那一项元素,无参数直接使用
shift删除数组开头的第一项内容,返回删除的那一项元素,无参数直接使用
splice,实现数组的指定删除元素 ```javascript // - 5、splice: // + 含义：实现数组的增删改 // + 参数：不固定 // + 返回值：是一个新的数组，数组里边存储的是删除的那几项 // + 原数组是否变化：变化

let ary = [100,200,300,400]; // 传参数量0个：什么都不干

// console.log(ary.splice()); // [] // console.log(ary); // [100,200,300,400]

// 传参数量1个：n:从索引n开始，删除到数组末尾

// console.log(ary.splice(2)); // [300,400]
// console.log(ary); // [100,200]

// 传参数量2个：n,m:从索引n开始，删除m个 (可以删除任意位置的那一项) console.log( ary.splice(1,1)); // [200] console.log(ary); // [100,300,400]

// ary.splice(2,10); // console.log(ary); // [100,200]

// ary.splice(4,10)
// console.log(ary); // [100,200,300,400]

// 传参数量3个：n,m,x:从索引n开始，删除m个,用x进行替换(从第三个参数开始都是替换的内容)

    // console.log(ary.splice(2,1,900)); // [300]
    // console.log(ary); // [100,200,900,400]
    // ary.splice(2,2,900,1000,2000) // 从索引2开始删除2个，用900,1000和2000进行替换
    // console.log(ary); // [100, 200, 900, 1000, 2000]
    // 传参：n,0,x:从索引n开始，删除0个，把x放到索引n对应值的前面
    // let ary = [100,200,300,400];
    // //              n
    // // 往数组开头新增800
    // ary.splice(0,0,800); // 数组开头新增
    // ary.splice(ary.length,0,800) // 数组末尾新增
    // 把10放到索引n的后面
    // splice(n+1,0,10)


- slice 数组的截取,返回值是一个数组,数组是被截取的内容
```javascript
 // - 6、slice:
        // + 含义：数组的截取
        // + 参数：不固定
        // + 返回值：是一个新的数组，数组里存储的是截取的内容
        // + 原数组是否变化：不变化
            let ary = [100,200,300,400];
            // 不传参:克隆原数组
            // console.log(ary.slice()); // [100,200,300,400]
            // console.log(ary); // [100,200,300,400];
            // 传一个参数n：从索引n开始，截取到末尾
            // console.log(ary.slice(2)); // [300,400]
            // console.log(ary); // [100,200,300,400];
            // 传两个参数n,m：从索引n开始，截取到索引m(不包含m对应的那一项)
            // console.log(ary.slice(1,3)); // [200,300]
            console.log(ary.slice(2,100)); // [300,400]

3.数组的方法

join方法,把当前数组以特定的分隔符转换成字符串,如果不传入字符串,则默认以逗号分开

eval可以把字符串变成JS运算式

// - 8、join
      //     + 含义：把当前的数组以特定的分隔符转化为字符串
      //     + 参数：字符串的分隔符
      //     + 返回值：是转化后的字符串
      //     + 不发生变化
      let ary = [100, 200, 300, 400];
      // console.log(ary.join('$')); // '100$200$300$400'
      // console.log(ary.join()); // '100,200,300,400'
      // console.log(ary.join('')); // '100200300400'
      // 把数组的里的内容进行求和
      // console.log(ary.join('+')); // '100+200+300+400'
      // console.log(eval('100+200+300+400')); // 可以把字符串变成js表达式
      // console.log('1+2'); //'1+2'
      // let res = eval(ary.join('+')); // 给数组内容进行求和
      // console.log(res);
      // function fn() {
      //     console.log(100);
      // }
      // eval('fn()')

reverse,讲数组倒转进行排列.无参数

sort,排序,讲数组按照特定规律进行排序.默认是正序排列。可传函数参数,默认比较的是

// + 含义：把数组按照规律进行排序
      // + 参数：不传或者传函数
      // + 返回值：排序之后的数组
      // + 发生变化
      // let ary = [1, 8, 5, 4];
      // console.log(ary.sort()); // 默认升序 [1,4,5,8]
      // console.log(ary); // [1,4,5,8]
      // console.log(ary.sort() == ary); // true
      // 如果数组的内容都是个位数，那就直接不用传参，默认是升序
      let ary = [156, 99, 101, 100];
      console.log(ary.sort(function(a, b) {
          // return a - b; // 升序
          return b - a; // 降序
      }));

indexof,检测一个数组元素的在数组中第一次出现的位置 ```javascript // + 含义：检测某个值在数组中第一次出现的位置

  // + 参数：被检测的值
  // + 返回值：被检测的值第一次出现的位置，如果被检测的值在数组中没有，那就返回-1
  // + 不发生变化
  // let ary = [100, 200, 300, 200, 400];
  // // console.log(ary.indexOf(200)); // 1
  // // console.log(ary.indexOf(800)); // -1
  // // 传两个参n, m: n表示被检测值， m是检测开始的位置索引
  // console.log(ary.indexOf(200, 2)); // 3
  // console.log(ary.indexOf(200, 4)); // -1
  //----------------------------------------------------------------------
  // // lastIndexOf
  // let ary = [100, 200, 300, 200, 400];
  // console.log(ary.lastIndexOf(200)); // 3
  // console.log(ary.lastIndexOf(800)); // -1
  // // 传两个参n, m: n表示被检测值,m就是表示检测结束的位置
  // console.log(ary.lastIndexOf(200, 2)); //  1


- includes,检测某个元素在该数组存不存在
- 数组的去重
```javascript
        // 数组的去重
        let ary = [100, 200, 300, 200, 400, 200]; // af0
        // function fn(ss) { // af0
        //     ss[0] = true;
        // }
        // fn(ary); // af0
        // console.log(ary); // af0
        // 循环 for循环
        // for in 循环
        let obj = {
            name: 1,
            age: 2,
            3: 100
        }
        for (var key in obj) {
            console.log(key);
            // continue; // 可以
            // break; // 可以
            // 对象有几个键值对，此循环就会执行几次
            // key代表每一个键值对的属性名
            // 我想输出每一个键值对的属性值
            console.log(obj[key]);
        }