JavaScript内置对象汇总

常用内置对象

Math对象

它是一个全局对象，是一个系统已经定义好的对象，不需要我们通过new关键字来创建就可以直接使用，它主要用于我们的数学运算

因这个数学对象里面它主要包含了两个东西，一个是常数，另一个就是方法

常数

常数就是数学或自然界里面一些固定的数，如π它就是一个常数

• Math.PI圆周率，约等于3.14
• Math.E自然对数的底数，约等于2.718
• Math.LN1010的自然对数值，约等于2.302
• Math.LN22的自然对数值，约等于0.693
• Math.SQRT22的平方根，约等于1.414
• Math.SQRT1_20.5的平方根，约等于0.707

方法

方法才是Math内置对象的重要点

1. 绝对值Math.abs()方法

   Math.abs(10);       //10
   Math.abs(-5);       //5

2. 四舍五入Math.round()方法

   Math.round(3.4);        //保留整数四舍五入，3
   Math.round(4.7);        //保留整数四舍五入，5

   注意 ：上面的代码Math.round都是我们以整数为单位再进行四舍五入,如果我们想保留多位小数，怎么办呢？

   var a = 3.1415926;
   //希望保留3位小数，四舍五入，怎么办呢？
   var b = Math.round(a * 1000) / 1000;
   console.log(b);

3. Math.floor()向下取整，返回小于或等于这个数的最大整数

   Math.floor(99.2);           //99
   Math.floor(15.7);           //15
   Math.floor(11);             //11
   Math.floor(-12.4);          //-13

4. Math.ceil()向上取整，返回大于或等于这个数的最小整数

   Math.ceil(99.2);            //100
   Math.ceil(15.7);            //16
   Math.ceil(11);              //11
   Math.ceil(-12.4);           //-12

   到目前为止，我们处理数据就有很多种方法了，是parseInt(),Math.round(),Math.floor(),Math.ceil(),现在我们来将这些东西进行一些对比

   在对比上面这个操作的时候，我们发现其它的方法在操作的时候都很正常，但是Math.round()在执行负数的操作的时候会让很人头疼，它其实执行的是"五舍六入"的操作

5. Math.pow(x,n)函数，取x的n次方的结果

   如果我们现在想取100的3次的结果 ，怎么办呢？

   Math.pow(100,3);

6. Math.max()方法用于求一系列数中的最大值

   Math.max(100,20,302);       //302

   之前在讲跨对象调用方法的时候，我们已经讲到过，可以通过这个方法来求出数组中的最大值

   var arr = [100,200,87,54,203,22];
   var max = Math.max.apply(Math,arr);         //203

7. Math.min()求一系列数中的最小值

   Math.min(100,20,302);       //20
   ​
   var arr = [100,200,87,54,203,22];
   var min = Math.min.apply(Math,arr);         //22

8. Math.sqrt(n)取n的平方根

   Math.sqrt(9);           //3

9. Math.random()获取0~1之间的一个随机数

   Math.random();      //0.4864583107356837

   小技巧：如果要产生某一个范围之内的随机整数，我们可以参照下面的公式

    function getRandomInt(min, max) {
       min = Math.ceil(min);
       max = Math.floor(max);
       return Math.floor(Math.random() * (max - min)) + min;
    }

10. Math.sin()方法，求一个弧数的正弦值

    这个地方请注意，是弧度rad，不是角度。

    弧度与角度有一个计算公式，不要弄混了，这个与我们这前所学习的数学里面的角度不一样

    1°=π/180°，1rad=180°/π。

    度	0°	30°	45°	60°	90°	120°	135°	150°	180°	270°	360°
    弧度	0	π/6	π/4	π/3	π/2	2π/3	3π/4	5π/6	π	3π/2	2π

    如匀们想求出90度的弧度正弦值，应该先将90度转换成弧度

    var x = Math.sin(90 * Math.PI / 180);       //1

11. Math.cos()方法， 求一个弧度的余弦值

12. Math.tan()方法，求一个弧度的正切值

---

Date对象

在JavaScript里面用Date对象是用于表述日期的对象，它可以获取系统当前的日期与时间，也可以手动的设置日期与时间，每次通过Date去创建日期对象默认都是系统当前时间

Date它只是一个构造函数（它与我们上面的Math是不一样的，Math直接就是一个对象），我们如果需要得到日期对象，我产要通过new的方式来创建

var d = new Date();         //得到当前的日期与时间对象
// Fri Aug 27 2023 10:50:42 GMT+0800 (中国标准时间)

当我们在创建日期对象的时候，默认是以当前日期时间为准，如果我们需要手动的去设置一个时间，是可以向构造函数Date里面去传递参数

var d1 = new Date("2023-7-3 12:00:00");
//Sat Jul 03 2023 12:00:00 GMT+0800 (中国标准时间)
​
var d2 = new Date(2023, 7, 10, 11, 20, 40);
//Tue Aug 10 2023 11:20:40 GMT+0800 (中国标准时间)

方法

1. Date.now()方法，返回当前的时间戳。请注意，它返回的是一串数字，这个数字代表从1970-1-1到现在的毫秒数

   var d1 = Date.now();            //1703563167320

   通过这个时间戳，我们可以知道它的具体时间

   var currentDate = new Date(1703563167320);
   //这样就得到了这个时间戳的具体时间

2. getFullYear()获取年份方法

   var d = new Date();
   d.getFullYear();            //2023

3. getMonth()获取月份的方法

   一年有12个月，但是月份是从0开始的

   d.getMonth();       //现在是8月，得到的结果应该是7

4. getDate()获取当前的天数

   d.getDate();        //今天是8月27，所以结果是27

5. getDay()获取星期几

   星期是从0开始的，但是一个星期的第一天是星期天

   d.getDay();     //今天星期五     得到结果5

6. getHours()获取小时数

   d.getHours();           //获取小时数 11

7. getMinutes()获取分钟

   d.getMinutes();         //获取分钟数 16

8. getSeconds()获取秒钟

   d.getSeconds();         //获取秒钟数 

9. getMilliseconds()获取毫秒数

   d.getMillseconds();     //获取毫秒

   上面的几个方法我们是可以通过get来获取到日期与时间的相关信息，与之相对应的我们还有set相关的赋值方法

   如果我们想某一个日期对象进行赋值，则可以按下面的方式进行操作

   var d = new Date();         //当前时间2023-8-27
   //我现在希望改变它的年份
   d.setFullYear(1999);
   //改变月份,我现在希望设置10月
   d.setMonth(9);              //注意月份是从0开始的

10. toString()方法

    日期对象可以调用这个方法将日期转换成字符串，但是在转换的过程当中，我们要注意一些事项

    • toString()
    • toDateString()
    • toTimeString()

    d.toString();
    //Fri Aug 27 2023 11:24:30 GMT+0800 (中国标准时间);
    ​
    d.toDateString();           //Fri Aug 27 2023
    ​
    d.toTimeString();           //11:25:19 GMT+0800 (中国标准时间)

    我们一般情况下，会很少使用这一个toString()的方法

11. toLocaleString()转换成本地时间，也就是你电脑右下角格式的时间

    • toLocaleString()
    • toLocaleDateString()
    • toLocaleTimeString()

    d.toLocaleString();             //2023/8/27 上午11:27:49
    d.toLocaleDateString();         //2023/8/27
    d.toLocaleTimeString();         //上午11:28:42

    所以我们一般将时间对象转换成字符串的时候，我们都是使用这一个方法再进行（或单独编写一个方法）

12. toGMTString()将当前时间以GMT格式去显示为字符串

    GMT时间就是0时区的时间

    var d = new Date();     //Fri Aug 27 2023 11:30:29 GMT+0800 (中国标准时间)
    //这个时候得到时间是一个东8区  GMT+8 的这个时间， 我们要转换成0时间的标准时间
    d.toGMTString();        //Fri, 27 Aug 2023 03:31:14 GMT

上面的12个方法就是我们处理时间对象的时候经常会使用到的方法，但是还有一个方法比较特殊，我们单独讲一下

扩展：如果现在有2个时间，我们需要将这2个时间进行比较，或相减，针对这一种业务逻辑场景，我们怎么处理呢？

• 第一种场景 ：我想看两个时间相隔多久
• 第二种场景：我想看哪一个时间在前面，哪一个时间在后面（比较大小）

var d1 = new Date("2021-12-31");
var d2 = new Date("2021-8-27");

• 现在我如果想看两个时间谁在前面，谁在后面怎么办呢？
• 如果我想看一下两个时间相隔多少天，怎么办呢？

如果在日期对象上面要做业务逻辑操作的时候，一定不能直接操作，要将时间转换成时间戳以后再操作。

一个日期对象如果想获取时间戳，可以调用getTime()这个方法

var d1Time = d1.getTime();          //1640908800000
var d2Time = d2.getTime();          //1629993600000

现有有了这个具体的数值以后，我们就可以进行判断与操作了

if(d1Time > d2Time){
    console.log("第1个时间在第2个时间后面");
}
else{
    console.log("第2个时间在第1个时间的后面");
}

同样的通过上面的时间戳，我们也可以计算出两个数的时间天数间隔

//两个时间相隔多少天
var totalDay = parseInt((d1Time - d2Time) / 1000 / 60 / 60 / 24);
console.log("距离2024年元旦还有" + totalDay + "天");

d1.valueOf();       //1640908800000
d2.valueOf();       //1629993600000

我们发现Date对象在valueOf方法其实就是getTime()的方法，所以我们可以直接将两个对象相减，或判断大小

var d1 = new Date("2024-12-31");
var d2 = new Date("2024-8-27");
if(d1<d2){
    //这么判断也是可以的，因为内部的valueOf方法与getTime方法一样，都返回时间戳
}
var times = d1 - d2;

String对象

String字符串对象是我们JavaScript当中最常见的一种包装对象，它个包装对象对象的就是基本数据类型当中的string类型

字符串其实是可以把它理解为一个字符数组，它具备数组里面的大部分方法与属性

现在我们以下面的字符串为例子，来学习

var str = "hello-world";

1. length属性

   返回当前字符串的字符个数，也就是字符串的长度

   str.length;     //11

2. 索引取值

   之前讲数组的时候说过数组的元素是通过索引取值的，字符串是一个特殊的字符数组，所以也可能通过索引取值

   str[0];     //h
   str[4];     //o

   注意：字符串只能通过索引取值 ，不能通过索引赋值

3. concat()拼接字符串

   这个方法在数组里面也是拼接的意思，在字符串里面，它会拼接一个字符串，返回新字符串，原字符串不变

   var str = "hello";
   var userName = "world";
   var result = str.concat(userName);      //helloworld
   ​
   //其实这个方法基本上不会用，因为我们可以直接使用加法操作符
   var result2 = str + userName;

4. slice(start?,end?)方法

   这个方法在数组里面也是存在的，它是用于截取数组的元素。在字符串里面的用法也是一样的，它会从起始位置开始，截到end的位置 ，但不包含end，原字符串不变

   var str='hello-world'
   str.slice(0,4);         //"hell"
   str.slice(3,-1);        //"lo-worl"
   str.slice(-4,-1);       //"orl"
   str.slice(1);           //"ello-world"
   str.slice();            //"hello-world"

5. substring(start,end?)截取字符串，返回新字符串，原字符串不变

   str.substring(0,4);     //"hell"
   str.substring(1);       //"ello-world"

   注意：

   • substring()开始位置不能省略，结果位置可以省略，slice()开始与结束都可以省略
   • substring()不建议使用负数做为参数，slice可以使用负数做为参数
   • substring与slice有个共同点，在截取的时候，都不包含end

6. substr(start,length?)截取字符串，从start位置开始，截取length长度，原字符串不变

   这点与上面的两个方法都不一样，这个方法的第2个参数是截取的长度

   str.substr(1,4);            //"ello"
   str.substr(3);              //"lo-world",从索引为3的位置开始，一直截取到最后

7. indexOf/lastIndexOf查找匹配的字符串，与数组里面的方法保持一致，找到以后返回索引 ，找不到返回-1

   var str1 = "我爱北京天安门，天安门上太阳升";
   str1.indexOf("北");          //2
   str1.indexOf("天");          //4
   str1.indexOf("哈");          //-1
   str1.indexOf("天",5);        //8

8. split()方法，将字符串以指定的字符隔开，变成数组

   var str = "hello-world";
   str.split("-");         //["hello", "world"]
   //如果我们以一个空字符串去隔开，结果如下
   str.split("");          //["h", "e", "l", "l", "o", "-", "w", "o", "r", "l", "d"]

   这一个方法其实就是数组join()方法的反向操作

   var arr1 = ["hello","world"];
   arr1.join("-");         //"hello-world";
   var arr2 = ["h", "e", "l", "l", "o", "-", "w", "o", "r", "l", "d"];
   arr2.join("");          //"hello-world"

   后期我们在工作过程当中经常会将这2个方法联合起来一起使用

9. charAt(index)通过索引来获取字符串里面的某个字符

   str.charAt(0);
   //相当于
   str[0];

10. charCodeAt(index)通过索引来获取字符串里面某一个字符串unicode编码，如果是英文就会返回ascii码

    var str = "我爱你";
    str.charCodeAt(0);          //字符"我"的unicode编码       25105
    str.charCodeAt(2);          //字符"你"的unicode编码       20320
    "我" > "你";                 //true  中文字符串在比较的的时候，得到的unicode编码 
    ​
    var str2 = "abc";
    str2.charCodeAt(0);         //"97"  得到ascii码

11. String.fromCharCode()通过某珍上编码反向的得到字符串

    var str1 = String.fromCharCode(97);         //得到结果"a";
    var str2 = String.fromCharCode(65);         //得到结果"A";
    var str3 = String.fromCharCode(25015);      //得到结果"我"

12. startsWith()判断某个字符串是以什么开始的

    var str = "我爱北京天安门";
    str.startsWith("我");                //true
    str.startsWith("我爱");               //true
    str.startsWith("你");                //false
    ​
    var url1 = "http://www.softeem.xin";
    url.startsWith("http");             //true

13. endsWith()判断某个字符串是以什么结束

    var str = "我爱北京天安门";
    str.endsWith("天安门");                    //true
    ​
    var url1 = "http://www.softeem.xin";
    url1.endsWith("com");                     //false

14. includes()判断某个字符串是否包含

    var str = "我爱北京天安门";
    str.includes("北京");             //true

    这个功能点的实现其实通过indexOf/lastIndexOf也是可以的

    str.indexOf("北京");              //2   

    只要结果不是-1就包含

15. trim()/trimLeft()/trimRight()去除字符串左边、右边或左右两边的空格

    • trim()去除两边的空格
    • trimLeft()只去除左边的空格
    • trimRight()只去除右边的空格

    var str = "   我爱北京天安门   ";
    str.trim();                     //"我爱北京天安门"
    str.trimLeft();                 //"我爱北京天安门   "
    str.trimRight();                //"   我爱北京天安门"

    现在如果是有下面的字符串需要去掉空格呢

    var str = " 我 爱 北 京 天 安 门 ";

    如果这个空格在中间，怎么办呢？后面要用到正则表达式+替换去完成

16. replace()方法，将字符串中间字符替换成指定的字符

    var str = "我爱你";
    //我要把"爱"替换成"恨"
    var str1 = str.replace("爱","恨");            //"我恨你"
    ​
    var str2 = "我爱你，你爱我吗";
    //将上面字符串当中的"爱"换成"恨"
    var str3 = str2.replace("爱","恨");           //"我恨你，你爱我吗"

    这个时候我们就发现一个问题，replace只替换了第一次找到的值，后面没有替换，如果希望全局替换，则要结合正则表达式使用

    var str4 = str2.replace(/爱/g,"恨");

Array对象

JavaScript中的数组对象可以使用new Array或者字面量"[ ]"来创建，在创建之后，就可以调用数组对象提供的一些方法来实现对数组的操作，如添加或删除数组元素，数组排序，数组索引。

数组的常用属性及方法

属性：用于描述对象的事物的特征的我们叫属性

方法：在面向对象的概念里面， 方法也叫函数。所以就去可以理解为我们之前所学习的函数

属性是用来描述的，方法是用于来使用的。学习数组里面的属性与方法能够让我们更方便的了解数组，操作数组

1. 1. length属性，该属性用于获取 或 设置数组的长度

      var arr = ["张三","李四","王五","赵六"];
      console.log(arr.length);            //得到长度4
      arr.length = 100;                   //重新设置数组的长度为100

   2. push(...items):number方法， 该方法是向数组的最后面追加新的元素

      var arr = ["张三", "李四", "王五"];
      //希望在数组的最后面追加一个"赵六"
      var x = arr.push("赵六");           //在arr数组最后追加一个"赵六",同时返回新的长度x为4
      ​
      //同时，我们还可以一次性追加多个元素
      var y = arr.push(true, "hello", 3.14);
      //这时候arr同时在后面追加了三个元素，并且返回了数组的新长度y为7

   3. pop()方法，从数组的最后移除一个元素，并返回这个移除的元素

      var arr = ["张三", "李四", "王五"];
      ​
      var x = arr.pop();
      //这一个时候的数组就会变成["张三","李四"];
      //x就是移除的这个元素，是"王五"

   4. unshift(...items):number方法，向当前数组的前面去追加新的元素，并返回数组的新的长度

      var stus = ["张三","李四","王五","赵六"];
      var x = stus.unshift("钱七");
      //这个时候会向前面追加"钱七",并将数组新的长度x,x为5
      ​
      //同样的，它也可以追加多个元素
      var y = stus.unshift(true, 123);
      //[true, 123,"钱七","张三","李四","王五","赵六"];

   5. shift()方法，从当前数组的前面去移除第一个元素，并返回这个移除的元素

      var stus = ["张三","李四","王五","赵六"];
      var x = stus.shift();
      //数组会变为["李四","王五","赵六"],x是移除的元素为"张三"

   6. concat()方法，将多个数组拼接成一个新的数组，返回这个新的数组，原数组不变

      var arr1 = ["张三","李四"];
      var arr2 = ["王五","赵六"];
      var arr3 = arr1.concat(arr2);
      //把arr1与arr2拼接起来，变成arr3  ["张三","李四","王五","赵六"]
      ​
      //其实数组在拼接的时候，还可以同时拼接多个数组
      var arr4 = ["aaa", "bbb"];
      var arr5 = arr1.concat(arr2, arr4);
      //这个时候将arr1,arr2,arr4一起拼接，并成形成arr5
      //["张三","李四","王五","赵六","aaa", "bbb"]

      上面的数组拼接，其实还有另一种写法

      //这种写法叫链式语法
      var result = arr1.concat(arr2).concat(arr3);
      //相当于
      var result1 = arr1.concat(arr2,arr3);

      小技巧 ：我们可以通过concat这个方法来实现数组的复制

      var arr1 = ["张三", "李四"];
      //如果想复制相同的数组，怎么办？
      var arr2 = arr1;

      像上面这种方式的复制数组是有问题的，因为这种复制叫浅拷贝，两个数组会相互影响

      arr1[0]="qqq";
      console.log(arr2[0]);       //"qqq";

      这个时候我们看到2个数组相互影响了。所以我们不能像上面这种方式来复制数组

      可以通过concat来完成

      var arr1 = ["张三", "李四"];
      //如果想复制相同的数组，怎么办？
      var arr2 = arr1.concat();           //这个时候返回了新的数组，两个数组之前互不影响
      //现在再来改变里面的元素值
      arr1[0] = "zzz";
      console.log(arr2); //["张三", "李四"]

   7. slice(start?:number,end?:number):[]方法，该方法是从数组的start位置开始 ，到end位置结束 ，截取里面的元素，形成一个新的数组，原数组不变

      在截取的时候，包含开始，不包含结束

      var arr = ["a", "b", "c", "d", "e", "f", "g"];
      var arr1 = arr.slice(2, 5); 
      //["c","d","e"];
      ​
      var arr2 = arr.slice(1);
      //["b", "c", "d", "e", "f", "g"]
      //这里的"1"代表开始截取的位置，结束的位置省略了，就会一直到数组的最后
      ​
      var arr3 = arr.slice();
      //["a", "b", "c", "d", "e", "f", "g"]
      //这里省略了开始位置，也省略了结束位置，这样就会从开始一直截取到最后
      //我们也可以通过一个像这样的方法来实现数组的复制
      ​
      var arr4 = arr.slice(1, -1);
      //["b", "c", "d", "e", "f"]
      //1代表开始位置，-1代表结束位置，对于负数，我们可以倒着数
      ​
      var arr5 = arr.slice(-3, -1);
      //["e","f"]

      下面有几种特殊情况，大家也了解一下

      var arr6 = arr.slice(3, 1);
      //开始索引位置一定要小于结束索引的位置 ,否则结果会是[]空数组
      ​
      var arr7 = arr.slice(1, "a");
      //本来应该是Number类型，结果给了个"a"
      //通过Number("a")就是NaN
      //arr.slice(1,NaN);    最终会得到空数组[]
      ​
       var arr8 = arr.slice(1,"4");
      //本来应该是Number类型，结果给了个"4"
      //通过Number("4")去转换 得到了4
      //arr.slice(1,4)  得到结果 ["b", "c", "d"]

   8. reverse():Array方法，该方法主要是将数组里面的元素反转，形成一个新的数组组，原数组也会改变

      var arr = ["a", "b", "c", "d", "e"];
      var arr1  = arr.reverse();
      //这个地方的原数组arr与新数组arr1都会变成["e", "d", "c", "b", "a"],
      //新旧数组其实在内在当中是同一个数组,arr改变，arr1也改变

   9. toString()方法，将数组里面的元素使用逗号隔开，然后变成字符串

      var arr = ["张三", "李四", "王五"];
      var str = arr.toString();
      //"张三,李四,王五"

   10. join(separator?:string):string使用指定字符串将数组元素隔开，然后变成字符串

       join方法其实就是toString()方法的高级版

       var arr = ["张三", "李四", "王五"];
       var str1 = arr.join("#");  //"张三#李四#王五"
       var str2 = arr.join("~");  //"张三~李四~王五"
       var str3 = arr.join();     //相当于toString() "张三,李四,王五"

   11. splice(start:number,deleteCount:number,...items):Array方法

       从指定位置开始，删除指定元素的个数，并且添加新的元素，删除的元素会形成一新的数组

       start代表开始删除的位置

       deleteCount代表删除元素的个数

       var arr = ["a", "b", "c", "d", "e", "f", "g"];
       ​
       //这个过程可以理解为删除
       var arr1 = arr.splice(4, 2);
       //arr的结果 ["a", "b", "c", "d", "g"]
       //arr1就是删除元素构成的数组["e","f"]
       ​
       //这个过程可以理解为替代 ，删除2个，添加1个
       var arr3 = arr.splice(4, 2, "aaa");
       //从第索引4开始删，删除2个，再放一个"aaa"进去
       //arr的结果就是 ["a", "b", "c", "d", "aaa", "g"]
       //arr3还是我们的["e","f"];
       ​
       //这个过程可以理解为插入
       var arr4 = arr.splice(4, 0, "aaa","bbb");
       //在索引为4的位置删除0个，再添加一个"aaa","bbb"
       //["a", "b", "c", "d", "aaa", "bbb", "e", "f", "g"]

       这个操作其实就是数据结构的"链"操作。这个方法可以在数组的任何位置插入，删除，替换

       特殊情况

       var arr = ["a", "b", "c", "d", "e", "f", "g"];
       arr.splice(1);      //['b', 'c', 'd', 'e', 'f', 'g']
       ​
       arr.slice(-2);      //['f', 'g']
       ​
       arr.slice(1,-1);    //['b', 'c', 'd', 'e', 'f']
       ​
       arr.splice(1,"a");  //[]
       ​
       arr.splice(1,"1");  //[]

   12. indexOf(searchElement:string|number|boolean,fromIndex?:number):number在数组当中查找某个元素索引值 ，如果找到了就返回穿上索引值，如果没有找到，就返回-1

       indexOf在执行查找的时候是全等操作，强判断===

       searchElement代表我们要查找的元素，只查找string/number/boolean三种类型，返回第一次出现的索引位置

       fromIndex从第几个位置开始找

       var arr = ["a", "b", "c", "11", "true", 11, true, "f"];
       ​
       var x = arr.indexOf("c");       //2
       ​
       var y = arr.indexOf(11);        //5  查询的时候执行全等操作
       ​
       var z = arr.indexOf("z");      //-1  没有找到就是-1

       在查找的时候，如果发现了多个元素，则永远只会找到第一次出现的

       var arr2 = ["a", "b", "a", "c", "b", 11, "true", false];
       ​
       var x1 = arr2.indexOf("b");     //1 只返回第一次找到的值

       特殊情况：正常情况下，查找都是从数组的索引为0的位置开始，但是我们也可以让它从指定的位置开始

       var arr2 = ["a", "b", "a", "c", "b", 11, "true", false];
       var y1 = arr2.indexOf("b", 2);      //4
       //前面的都忽略，从索引为2的这个位置开始找

   13. lastIndexOf(searchElement: string | number | boolean, fromIndex?: number)查找某个元素在数组中的最后一次出现的位置，找到了就返回索引 ，找不到就返回-1

       lastIndexOf与indexOf的用法是非常相似，都是强判断

       lastIndex里面的fromIndex其实是endIndex的意思，到这个地方结束，后面的都忽略

       var arr2 = ["a", "b", "a", "c", "b", 11, "true", false];
       ​
       var x = arr2.lastIndexOf("a"); //2
       //`lastIndex`里面的`fromIndex`其实是`endIndex`的意思，到这个地方结束，后面的都忽略
       var y = arr2.lastIndexOf("b", 3); //1

   ES6数组扩展的方法

   1. Array.of()方法

      它是数组定义的一个方法，解决了之前new Array()所存在的问题

      let arr1 = new Array(4); //这代表这个数组的长度为4
      ​
      let arr2 = Array.of(4); //这个4代表的就是里面的元素
      ​
      let arr3 = [4];         //上面的写法等价于这种写法

      既然等价于[]这种写法，那么，肯定可以同时放多个值

      let arr4 = Array.of(2,3,4,5);

   2. Array.from()方法

      这一个方法可以将类数组转换成数组

      let lis = document.querySelectorAll(".ul1>li");         //NodeList类型
      console.log(lis);
      ​
      let arr1 = Array.prototype.slice.call(lis);
      let arr2 = [...lis];
      let arr3=Array.from(lis);

   3. Array.prototype.fill(value:any,start?:number,end?:number)填充数组的方法

      有时候我们希望将数组的元素填充为统一的个值，这个时候就可以使用这个方法

      vlaue代表要填充的内容，start代表填充的开始位置，end代表填充的结束位置，不包含结束位置

      let arr1 = new Array(100);
      arr1.fill("aaa");
      ​
      let arr2 = new Array(100);
      arr2.fill("张三", 0, 20);
      ​
      let arr3 = new Array(100);
      arr3.fill("李四",10,15);

   4. Array.prototype.flat(steps)拍平一个多维数组

      以前如果需要将多维数组拍平，我们要使用递归遍历 ，现在有了这个方法就很简单了

      let arr1 = [
          "张三",
          ["李四", "王五"],
          ["a", "b", ["c", ["d",["e"]]]]
      ]
      ​
      let arr2 = arr1.flat(Infinity);

      参数steps代表要拍平多少层，如果想把整个多维数组转换成一维数组可以直接传递一个参数Infinity即可

   5. Array.prototype.find()方法

      该方法主要就是为了弥补数组之前的indexOf及lastIndexOf无法查找对象的问题

          let list = [{
                  userName: "张三",
                  sex: "男"
              }, {
                  userName: "李四",
                  sex: "女"
              },
              {
                  userName: "王五",
                  sex: "男"
              }, {
                  userName: "赵六",
                  sex: "男"
              },
              {
                  userName: "王五",
                  sex: "男",
                  hobby: "看书"
              }
          ]
      //要求，查找userName为王五的信息
      /*
          let obj = undefined;
          for (let i = 0; i < list.length; i++) {
              if (list[i].userName == "王五") {
                  obj = list[i];
                  break;
              }
          }
      */
      //迭代方法
      var obj = list.find(function(item, index, _arr) {
          //返回一个条件即可
          return item.userName == "王五";
      });
      console.log(obj);

      找到了就返回第一次找到的这个元素，找不到就返回undefined

   6. Array.prototype.findIndex()查找某一个元素的索引，这个方法上面的方法非常相似

      var index = list.findIndex(function(item, index, _arr) {
          return item.userName == "王五";
      });
      console.log(index);  //2

      找到了就返回 次找到的索引 ，找不到就返回-1