数组的笔记

一.数组：

1.数组的定义：计算机内存中一块连续的存储单元，这些存储单元有共同的名称，不同的索引（下标）

     a: 数组的声明：

（1）使用数组字面量[ ]

（2）使用Array对象声明数组  

     b：数组的属性：length 表示数组元素的个数（数组的单元个数）

           语法：数组名 . length

     c：数组元素的下标：从0开始到数组元素个数减1 

     d：数组元素的访问：数组名[ 下标 ]

     e：数组的遍历：

1. 使用for循环遍历：
2. 使用for…in循环遍历：

语法：for（index  in  数组名）{

          循环体语句

}

index：表示数组元素的索引

1. 使用for…of 循环遍历：

语法：for（value  of  数组名）{

          循环体语句

}

value：表示数组的元素

作用：依次将数组中的元素赋给value

1. 使用forEach 循环遍历：

语法：数组名 . forEach （function（value , index）{

                 函数体语句

}）

value：表示数组元素

index：表示元素的下标

1. 使用map函数遍历数组

语法：let 新数组名称 = 原数组名 . map（function（item）{

  函数体语句

}）

Item：表示数组元素

二.排序：

1. 冒泡排序：数据两两比较，如果发现存在大小关系，就进行交换

例如：var arr = [87,11,8,56,38,22,65]

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

                  for （let j = i ; j < arr.length-1; j++）{

                         if (arr[ i ] > arr[ j+1] ){

                          let temp = arr[ j ]

                          arr[ j ] = arr[ j+1 ]

                          arr[ j+1 ] = temp

                         }

             }

}

      console.log(“排序后的数组为” + arr)

三．数组的常用方法：内置方法，直接使用

1.join（连接字符）：作用是将数组中的元素通过给定的连接字符连城一个字符串

   例如： var a1 = [11,22,33]

          var a2 = a1.join（’-’）

          var a3 = a1.join （）

          console.log(a1) // 11-22-33

          console.log(a1) // 11,22,33

2.push (值/变量)：数组末尾添加元素

   例如： var a1 = [1,2,3]

               a1.push(‘貂蝉’)

               console.log(a1)//1,2,3,’貂蝉’

3.pop：末尾删除元素

   例如：var a1 = [1,2,3]

              var a2 = a1.pop（）

              console.log(a1)// 1,2

              console.log(a2)//3

4.shift(值/变量)：数组首部删除元素

 例如：var a1 = [1,2,3]

            var a2 = a1.shift（）

            console.log(a1)// 2,3

            console.log(a2)//1

5.unshift()：数组的首部插入元素

 例如：var a1 = [1,2,3]

            var a2 = a1.unshift（0）

            console.log(a1)// 0,1,2,3

6.sort()：排序函数，默认从小到大排序

 例如：var a1 = [2,3,1]

            var a2 = a1.sort（）

            console.log(a2)// 1,2,3

7.reverse()：数组元素颠倒顺序

例如： var a1 = [1,2,3]

            var a2 = a1.reverse（）

            console.log(a2)  // 3，2，1

8.concat()：连接两个或多个数组

例如： var a1 = [1,2,3]

            var a2 = [11,12,13,]

            var a3 =a1.concat(a2)

            console.log(a3)//1,2,3,11,12,13

9.slice()：贴片函数，原数组中截取部分元素构成新的数组，截取时指定开始位置和结束位置

例如：var a1 = [1,2,3,4,5]

           var a2 = a1.slice(1,3)

           console.log(a2)// 2,3

10.splice()：可实现对数组元素的插入，替换，删除

      （1）删除元素：

 例如 ：  var a1 = [1,2,3,4,5]

               var a2 = a1.splice(0,3)

               console.log(a2)// 1, 2,3

    (2) 替换和插入

例如 ：   var a1 = [1,2,3,4,5]

               a1.splice (1,0,66)   // 插入

               console.log(a1)// 1,66,2,3,4,5

              var a1 = [1,2,3,4,5]

              a1.splice (1,1,66)   // 替换

              console.log(a1)// 1,66,3,4,5

11.indexOf（元素）：从左往右查找元素的位置，返回元素在数组中的下标，返回-1表示没有找到

例如：   var a1 = [1,2,3,4,5]

              var a2 = a1.indexOf (2)  

              console.log(a2)// 1

12.lastIndexOf(元素)：从右往左找元素的位置

13.filter（function（value,index）{

        函数体语句

}）

         可以实现对数组元素的“过滤“，返回的元素可构成一个新的数组

         value：表示数组元素

         index：表示数组元素的下标

            例如：var arr = [1,2,3,4,5,6,7,8,9,10]

                  var temp = arr.filter(function (value,index){

                          reture  index % 3 ==0

                    })

                  console.log(temp) // 1,4,7,10

     14.fill（值/变量）：用给定的值或变量填充一个数组

            例如：var arr = new Array（5）

                       arr.fill(1)

                       console.log(arr) // [1,1,1,1,1]

     15.every(function (value){

                       函数体语句

             })

            判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true，否则返回false

          例如：var arr = [1,2,3,4,5,6,7,8,9,10]

                     var temp = arr.every(function (value){

                     reture  value <= 10

                     })

                    console.log(temp) // true

  16.includes()：判断一个数组中是否含一个指定的值

           例如：var arr = [12,23,34,45,56]

                      var a1 = arr.includes（45）

                      console.log(a1) // true

四．二维数组

1．一维数组：数组中只有一个下标

2．二维数组：数组中的每个元素都有两个下标（由行和列组成）

   （1）定义：

        a：通过字面量[ ]

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

        b：使用Array对象声明

           var arr = new Array（new Array（1，2，3），new Array（4，5，6），new Array（7，8，9））

   （2）二维数组的访问：数组名[下标1][下标2]

          下标1：代表行下标

          下标2：代表列下标

   （3）输出：采用循环嵌套

          例如：var arr = [ [1,2,3],[4,5,6],[7,8,9] ]

                var str = ‘’

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

                      for (let j = 0 ; j < arr[ i ].length ; j++){

                            str += arr[ i ][ j ] + ‘\t‘

                           }

                      str += ‘\n’

                      }

                     console.log(str) // 1 2 3

                                                  4 5 6

                                                  7 8 9