JavaScript数组的一些方法、数学对象、定时器

<script>

        // sort()方法会按照字符串的先后顺序对数组的每一个数组项目的字符顺序来进行排序的

        // 如果数组的某个项目不是字符串, 那么会先把数组项目转换为字符串,再来按照字符串的比较方式来排序

        // 该方法会改变原始的数组

        // let array = [10,5,8,6,9];

        // array.sort();

        // console.log("sort",array); //[10, 5, 6, 8, 9]

        // let aa = [1,10,2,20,6,8];

        // aa.sort(function(value1,value2){

        //     if(value1 < value2){

        //         return -1;  //-1前的值比-1后的值小

        //     }else if(value1 > value2){

        //         return 1;  //返回1，value1在数组后  value2在数组前 -1前的值比-1后的值大

        //     }else{

        //         return 0;

        //     }

        // });

        // console.log(aa);

        

        // reverse()方法会反转数组项的顺序

        // 直接在原始的数组上排序, 只是单纯的调转数字的数组项目的整体顺序而已

        // 该方法会改变原始的数组

        // array.reverse();

        // console.log("reverse",array); //[9, 6, 8, 5, 10]

        // 数组的队列操作方法 先进先出

        // Array.push(数组项目5)

        // 往数组末尾增加一个数组项目

        // 与此同时,数组的length自动加1

        // Array.shift()

        // 删除数组的第一个数组项目

        // 与此同时,数组的length自动减1

        // 反向队列操作方法

        // Array.unshift(数组项目0)

        // 往数组开始位置增加一个数组项目

        // 与此同时,数组的length自动加1

        // Array.pop()

        // 删除数组的最后一个数组项目

        // 与此同时,数组的length自动减1

        // 栈操作方法  先进后出

        // Array.pop()

        // 删除数组的最后一个数组项目

        // 与此同时,数组的length自动减1

        // Array.pop()

        // 删除数组的最后一个数组项目

        // 与此同时,数组的length自动减1

        // array.push("111");

        // console.log("push",array);  //push (6) [10, 5, 8, 6, 9, "111"]

        // array.pop();

        // console.log("pop",array);  //pop (5) [10, 5, 8, 6, 9]

        // array.shift();

        // console.log("shift",array);  //shift (4) [5, 8, 6, 9]

        // array.unshift("123");

        // console.log("unshift",array);  //unshift (5) ["123", 5, 8, 6, 9]

       

        // concat()方法可以基于当前数组中的所有项创建一个新数组。

        // concat()方法不会改变原数组

        // 如果传递给concat()方法的是一或多个数组，则该方法会将这些数组中的每一项都添加到结果数组中。

        // let a1 = [1,2,5],

        //     a2 = [4,8,9],

        //     a3 = a1.concat(a2);

        // console.log(a1);  //[1,2,5]

        // console.log(a3);  //[1, 2, 5, 4, 8, 9]

        // slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。

        // 情况1:如果不传入参数的情况下, silce()方法返回完整的数组

        // 情况2:在只有一个参数的情况下，slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。

        // 情况3:如果有两个参数，该方法返回起始和结束位置之间的项——但不包括结束位置的项。

        // slice()方法不会影响原始数组

        // splice()方法会影响原始数组

        // 删除：可以删除任意数量的项，只需指定2 个参数：要删除的第一项的位置和要删除的项数。

        // 插入：可以向指定位置插入任意数量的项，只需提供3 个参数：起始位置、0（要删除的项数）

        // 和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项

        // 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定3 个参数：起

        // 始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。

        

        // console.log("a3",a3);  //[1, 2, 5, 4, 8, 9]

        // console.log("slice:原来",a3.slice());  //[1, 2, 5, 4, 8, 9]

        

        // console.log("a3",a3);     //[1, 2, 5, 4, 8, 9]

        // console.log("原来的：",a3.splice());  //[]

        // console.log(a3);          //[1, 2, 5, 4, 8, 9]

        

        // console.log("slice:yi",a3.slice(4));  //[8, 9]

        // console.log("slice:a3",a3);           //[1, 2, 5, 4, 8, 9]

        

        // console.log("加一",a3.splice(4));     //[8, 9]

        // console.log(a3);                      //[1, 2, 5, 4]

        // console.log("slice:yi",a3.slice(1,4));   //[2, 5, 4]

        // console.log("slice:a3",a3);              //[1, 2, 5, 4, 8, 9]

        

        // console.log("两个值",a3.splice(1,4));    //[2, 5, 4, 8]

        // console.log("a3",a3);                    //[1, 9]

        // console.log("三个值",a3.splice(0,1,3,4,5));   //[1]

        // console.log(a3);                              //[3, 4, 5, 2, 5, 4, 8, 9]          

        

        // 位置方法:indexOf()和lastIndexOf()

        // 接收两个参数：要查找的项和（可选的）表示查找起点位置的索引

        // indexOf()方法从数组的开头（位置0）开始向后查找，

        // lastIndexOf()方法则从数组的末尾开始向前查找。

        // 在没找到的情况下返回-1

        // console.log(a3.indexOf(4));  //3

        // ecm5提供五个迭代方法，每个方法都接收两个参数：要在每一项上

        // 运行的函数和（可选的）运行该函数的作用域对象————影响this的值

        // 接收运行的函数传入三个参数：数组项的值、该项在数组中的位置（下标）和数组对象本身

        // 1、every():对数组中的每一项运行给定函数，如果该函数对每一项都返回true，则返回true。

        // 即传入的函数必须对每一项都返回true，这个方法才返回true，否则false

        // let arra = [1,2,3,6,4,8];

        // let re = arra.every(function(item ,index, arr){

        //     return item >2;

        // });

        // console.log(re);  //false

        // 2、some():对数组中的每一项运行给定函数，如果该函数对任一项返回true，则返回true。

        // 即传入的函数对数组中的任一项返回true，这个方法就返回true，否则false

    

        // let arra = [1,2,3,6,4,8];

        // let re = arra.some(function(item ,index, arr){

        //     return item >2;

        // });

        // console.log(re);   //true

        //3、filter():对数组中的每一项运行给定函数，返回该函数会返回true 的项组成的数组

        // 它利用指定的函数中return语句的条件, 把所有符合该条件的数组项目组合成一个新的数组返回

        // 该方法不会修改原来的数组

        // let arra = [1,2,3,6,4,8];

        // let re = arra.some(function(item ,index, arr){

        //     return item >2;

        // });

        // console.log(re); //符合大于2的取出来放在re中 

        // let arra = [1,2,2,undefined,4,6,7,undefined,undefined,"w"];

        // let result1 = arra.filter(function(item,index,arr){

        //     return !isNaN(item);  //是数值返回false再非,所以就是true

        // });

        // console.log(result1);//[1, 2, 2, 4, 6, 7]

        

        // let result2 = arra.filter(function(item,index,arr){

        //     return !isNaN(item) || item;

        // });

        // console.log(result2); //返回非空的值  [1, 2, 2, 4, 6, 7, "w"]

        // 4、map():对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

        // map() 返回一个新数组，这个新数组的每一项都是在原始数组中的对应的数组项目传入函数经过一系列处理的结果

        // let arrb = [1,2,2,5,6,7];

        // 值，下标，数组的本身

        // let result3 = arrb.map(function(item,index,arr){

        //     return item*2;

        // });

        // // 等价的for循环的使用

        // // for(let i=0; i<arrb.length;i++){

        // //     arrb[i] = arrb[i]*2;

        // // }

        // console.log(result3);  //[2, 4, 4, 10, 12, 14]

        // 5、forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。

        // foreach(one,two)第二个参数改变 函数的this的作用域 this指向谁 

        // 没有返回值

        // let arrb = [1,2,2,5,6,7];

        // let result3 = arrb.forEach(function(item,index,arr){

        //     arr[index] *= 2;

        // })

        // console.log(arrb);  //[2, 4, 4, 10, 12, 14]

        // // 请使用计数遍历

        // for(let i=0;i<arr.lengeh;i++)

        // 非计数遍历

        // forEach

        

        // 归并数组方法：reduce()和reduceRight()

        // 可以迭代数组所有项，然后狗邮件一个最终的值。

        // reduce()从数组的第一项开始，逐个遍历到最后。

        // 而reduceRight()则从数组的最后一项开始，向前遍历到第一项。

        // 这两个方法都接收两个参数：一个函数和（可选的）作为归并基础的初始值。

        // 传入的函数接收4 个参数：前一个值、当前值、项的索引和数组对象。

        // let values = [1,2,2,4,5,6];

        // let sum = values.reduce(function(prev,cur,index,array){

        //     return prev + cur;

        // });

        // console.log(sum);  //20

        // 数学对象MATH（常用）

        // π的值  ：Math.PI

        // 取最大数，最小数 Math.max Math.min

        // let max = Math.max(2,5,35,65);

        // console.log(max);  //65

        // let min = Math.min(2,5,35,65);

        // console.log(min);   //2

        // 取整

        // Math.ceil()执行向上舍入，即它总是将数值向上舍入为最接近的整数；

        // Math.floor()执行向下舍入，即它总是将数值向下舍入为最接近的整数；

        // Math.round()执行标准舍入，即它总是将数值四舍五入为最接近的整数;

        // console.log(Math.ceil(25.6));  //26

        // console.log(Math.ceil(25.1));  //26

        // console.log(Math.ceil(-2.5));   //-2

        // console.log(Math.floor(25.6));  //25

        // console.log(Math.floor(25.1));  //25

        // console.log(Math.floor(-2.5));  //-3

        // console.log(Math.round(25.6));  //26

        // console.log(Math.round(25.1));  //25

        // 随机数

        // Math.random()方法返回大于等于0 小于1 的一个随机数

        // 取的数不大于一，都是小数

        // 改造，取整，向下取整,0-10的数

        // console.log(Math.floor(Math.random()*10 ) );

        

        // 计时器

        // setInterval(function(){},t)  1000=1s

        // 每隔t ms执行一次函数function(){};

        // clearInterval(定时器名称) ：删除之前设定的定时器

        // let i = 0;

        // function a(){

        //     console.log(++i);

            

        // }

        // let time;

        // // 计时器

        // time = window.setInterval(function(){

        //     if(i == 10){

        //         window.clearInterval(time);  //关闭计时器

        //     }else{

        //         a();

        //     }

        // },1000);