js小节其六

数组

        定义数组

                索引下标从0开始，到数组的长度减1

                        每个数组有一个默认的属性length，代表的是数组的长度

                length的用法，数组名.length

        使用Array的方法：Array是数组类

                let arr1 = new Array（5）

                let arr = new Array（）

                let arr = new Array（‘’，‘’，‘’）

        数组元素的访问

                数组名[下标]

                方法一：使用for循环遍历数组，将数组中的每个元素拼接到字符串中。

        数组的变量：不重复的访问数据元素

                1、普通的for循环

                2、for...in        可以用于循环遍历集合

                        for（let 变量名 in  数组名和对象名）{

                        }

                3、for...of循环

                        for（let 变量名 of 数组名）{

                        }

                        const和let区别

                        const  局部变量，变量的值不能改变，实际上是常量，const声明的变量必须初始化

                        let        局部变量           

                         let arr = new Array(10,20,30,40,50);

                        let str = ''

                        for(const num of arr){

                            str += num +'\t';

                        }

                        console.log(str);

                4、foreach循环  只能用于遍历数组

                        数组名：foreach（function（val，index）{

                        }）

                        val表示当前的元素，index表示当前元素的索引

                        第一个参数，就是当前正在遍历的元素

                        第二个参数，就是当前正在遍历的元素的索引

                        第三个参数，就是正在遍历的数组                         

                         let arr = new Array(10,20,30,40,50);

                        arr.forEach(function(val,index){

                            console.log(index + ':' + val)

                5、使用map函数遍历

                        返回一个新的数组，返回结果不会影响到原数组                    

                        let arr = new Array(1,2,3,4,5);

                        let temp = arr.map(function(item)){

                            let num = item * 2;

                            return num;

                        }

                        console.log("原数组：" + arr);

                        console.log("新数组：" + temp);

        2、数组元素的排序

                1、排序：使数组元素有序（升序，降序）

                2、排序的步骤：比较、交换（Number类型可以通过加减快速排序）

                3、排序算法：

                        （1）冒泡法排序：数据两两比较，若存在大小关系，则进行交换

                                需要通过循环嵌套来实现（两层循环）

                                外层循环：控制排序的次数

                                内层循环：进行数据的比较

                        （2）选择法排序：每次从当前无序的序列中找出最小数并记录其下标，然后让最

                        小数与当前无序序列的第一个数进行交换，如此循环，知道数组有序。                   

                            let arr3 = new Array(3,1,4,7,5);

                            for(let i = 0; i< arr3.length - 1; i++){

                                let min = arr3[i];//假设当前无序序列的第一个元素是最小的

                                let k = i;//记录当前无序序列的第一个元素的下标

                                for(let j = i + 1; j < arr3.length; j++){//内循环，找当前无序序列的最小值，然后

                                用K记录最小值的下标

                                    if(min > arr3[j]){

                                        min = arr3[j];

                                        k = j;

                                    }

                                }

                                if(k != i){

                                    let temp = arr3[i];

                                    arr3[i] = arr3[k];

                                    arr3[k] = temp;

                                        }

                                    }  

                            console.log("排序后的数组：" + arr3);

                       （3）插入法排序：定义新函数，将原数组的每一项放入新数组中进行比较，插入

                        之后比较结束，进行下一次比较                 

                        let arr = [2, 1, 5, 4, 8, 6];

                          function insert(arr) {

                            //定义一个新数组，用来存储抓在手里的牌，开始先抓一张牌进来。

                            let handle = [];

                            handle.push(arr[0]); //将原数组的第一项放进来，当做是手里的牌

                            //从第二项开始依次抓牌，一直把台面上的牌抓光

                            for (let i = 1; i < arr.length; i++) {

                              //A是新抓的牌

                              let A = arr[i];

                              //用新抓的牌和手里的牌依次比较（从后往前比较）

                              for (let j = handle.length - 1; j >= 0; j--) {

                                //B是手里的牌

                                let B = handle[j];

                                //如果新牌比旧牌大，就放在旧牌的后面，停止循环

                                if (A > B) {

                                  handle.splice(j + 1, 0, A);

                                  break;  //插入之后，比较结束，进行下一次比较

                                }

                                //如果已经比到第一项，就直接把手里的牌放到最前面

                                if (j == 0) {

                                  handle.unshift(A);

                                }

                              }

                            }

                            return handle;

                          }

                          arr = insert(arr);

                          console.log(arr);

          3、数组中常用的函数

                1、join（）：将数组元素转换成字符串

                                        变量.split拆分成为数组

                2、push（）：将追加的元素添加到数组末尾

                3、pop（）：从数组的末尾删除一个元素，函数有返回值

                4、shift（）：从数组的开头删除一个元素，函数有返回值

                5、unshift（）：在数组的首部插入一个或多个元素

                6、slice（start，end）切片函数，会接收一个或两个参数，从数组中截取部分数据，函

                数的返回值是数组

                        （1）slice（索引）：截取数组中从给定索引到末尾的所有元素

                        （2）slice（索引1，索引2）：截取数组中索引1到索引2之间的元素，（包含索

                                引1，但不包含索引2）

                                索引可以为负数，如果是负数表示从后往前找元素。

                7、fill（）填充函数，用给定的值去填充数组

                8、filter（）函数，对数组元素进行过滤，参数是一个函数，返回值是一个数组。

                        返回值为真则保留，返回值为假则删除。

                       

                        let arr = [1,3,5,7,9,11,13,15]

                        let t = arr.filter(function(val,index){//按要求过滤出满足条件的元素,val表示数组的元

                        素，index表示元素的索引

                            if(index % 3 == 0 || val > 8 )//返回index是3的倍数，或val大于8的元素

                            return(index % 3 == 0 || val > 8 )

                        })

                        console.log(t)

                9、concat 两个数组的拼接

                        concat 方法不改变原有数组，而是返回拼接后的新数组        

                        let arr = [1,2,3,4]

                        let arr2 = [5,6,7]

                        arr.concat[arr2]

                10、splice（起始位置，删除几个，内容）  插入法

                11、every

                        const arr = [1,2,3,4,5]

                        数组.every(function(item,index)){

                            return item > 0;

                        }

                        every返回布尔值，用来判断数组内的每个项目是否都符合条件

                        函数参数返回值是否都为true

                12、some（）类似every，条件是假，所有都是假，条件是真，所有都是真

                13、find（函数）返回符合条件的（返回值为真的首个内容）

                14、findIndex（函数）返回符合条件的（返回值为真的首个内容）首个索引值

                15、includes（内容）判断数组中书否包含（===  全等判断类型）某个内容，返回值为

                布尔值。

                16、indexof        lastIndexOf（从后往前找）搜索数组中的元素，并返回他最后出现的位

                置。

                17、reduce  将数组结算一个值 

                    reduceRight

                        const arr = [1,2,3,4,5]

                        let total = 0

                        console.log(arr.reduce(function(total,n){

                            return total + n

                        })

                18、sort排序

                        const arr = [ 7,8,9,5,3,2,4,1,6,10]

                        console.log(

                            arr.sort(function(a,b){

                                //将数组中任意两个内容用函数参数处理，

                                结果为负值，则保持不变，结果为正值，则调换位置。

                                if(a % 2 == 0){

                                    a *= 1000

                                }

                                if(b % 2 == 0){

                                    b *= 1000

                                }

                                return a - b

                            })

                        )

                        )

                19、reverse 反转数组的顺序

        

        二维数组

                定义方式：

                        1、通过数组字面量[]定义

                                let arr = [[1,2,3],[4,5,6],[7,8,9]];

                        2、通过array定义

                                let arr = new Array（new Array（1,2,3），new Array（4,5,6））；

                二维数组元素的访问

                        （1）按行优先

                                数组名[行下标][列下标]；

                                

                            let arr = [[1,2,3,],[4,5,6,],[7,8,9]]//arr是一个二维数组

                            let str = '';

                            for(let i = 0; i  < arr.length; i++){//外循环：i行下标，arr.length表示数组的行数

                                for(let j = 0; j < arr[i].length; j++){//内循环，j列下标,arr[i].length表示1行的列数

                                    str += arr[i][j]+'\t';

                                }

                                str += '\n';//换行，每行结束后换行

                            }

                            console.log(str)

                        （2）按列优先

                                数组名[列下标][行下标]

                js中数组的特点

                        1、可以存放混合数据

                        2、数组的length属性的值是随数组元素的增减自动增减的。