JavaScript数组

数组

1. 数组的基本概念

1.1 数组的基本概念

1)

数组通常用来保存一组相同类型的值 ( 如 : 咱班所有同学的姓名 )

对象通常是用来保存某个具体的物体的相关属性和方法 ( 如 : 咱班某个同学的信息 )

2)

数组是有序的值的集合,对象是无序的值的集合

1.2 数组的创建

1) 字面量

var arr = [ ] ;

2) 构造函数

var arr2 = new Array ( 10 ) ;
 var arr3 = new Array("a");
           console.log(arr3);
           var arr4 = new Array(10, 20);
           console.log(arr4);

3) 新增元素

var arr5 = [];
      arr5[0] = "a";
      arr5[1] = "b";
      arr5[2] = "c";
      arr5[10] = "d";
      console.log(arr5); //长度为11

4) 取值

 arr5[0] = "a";
      arr5[1] = "b";
      arr5[2] = "c";
      arr5[10] = "d";
      console.log(arr5);
console.log(arr5[0]);
console.log(arr5[3]); 
console.log(arr5[20]);//越界,取到undefined

5) 改值

 arr5[0] = "a";
      arr5[1] = "b";
      arr5[2] = "c";
      arr5[10] = "d";
      console.log(arr5);
console.log(arr5[0]);
console.log(arr5[3]); 
console.log(arr5[20]);//越界,取到undefined
arr5[0] = "aa";
console.log(arr5);

6) 遍历

 var arr6 = [10, 20, 30, 40, 50];
      for (var i = 0; i < arr6.length; i++) {
        console.log(arr6[i]);
      }

2. 数组中一些常用方法

2.1 push( )

向数组尾部添加元素 , 元素填括号内做参数 , 返回新增元素后的数组的长度,原数组发生变化

2.2 pop( )

从数组尾部删除一个元素

2.3 unshift( )

向数组头部添加元素

2.4 shift

从数组头部删除一个元素

2.5 sort( )

对数组进行排序 , 1. 针对相同位数的数值进行排序 2. 如果不是相同的位数或者不是数值类型将平等的排在一起

//真正的实现数值排序 是以一个函数作为参数
      /*  var arr = [23, 17, 5, 66, 9];
      arr.sort(function (a, b) {
        //从小到大
        //return a - b;
        //从大到小
        return b - a;
      });
      console.log(arr); */

2.6 reverse( )

数组翻转

2.7 join( )

将数组中所有的元素以指定的连字符拼接成为字符串

2.8 slice( m,n )

如果是1个参数，就从该参数表示的索引位开始往后截取数组，直至结束，返回截取的数组，原数组不变 ; 如果是2个参数，第1个参数表示截取的起始索引，第2个表示截取的结束索引，不包含结束索引位上的元素，返回截取的数组，原数组不变

2.9 splice( )

如果是1个参数，就从该参数表示的索引位开始往后截取数组，直至结束，返回截取的数组，原数组改变，变成剩余元素的一个数组

如果是2个参数，第1个参数表示截取的起始索引，第2个表示截取的元素个数，不包含结束索引位上的元素，返回截取的数组，原数组改变，变成剩余元素的一个数组

如果是3个及以上的参数，，第1个参数表示截取的起始索引，第2个表示截取的元素个数，第3个及后续的参数会从截取的起始索引位添加原数组中

2.10 concat( )

合并数组

var arr = [1, 2];
      var brr = arr.concat([3, 4], 5); //如果参数是一个数组，将数组中的元素提取出来扔到原数组中，并返回，如果不是一个数组，直接扔到原数组里，并返回
      console.log(brr); //[1,2,3,4,5]

2.11 indexOf( )

返回参数在数组中的索引，如果数组中没有参数表示的值，返回 -1 从前往后找

2.12 lastIndexOf( )

返回参数在数组中的索引，如果数组中没有参数表示的值，返回 -1 从后往前找

2.13 includes( )

判断一个数组中是否含有某个元素，含了，返回true，不含，返回false

2.14 forEach( )

遍历

2.15 map( )

遍历

2.16 filter( )

过略出符合条件的数组元素,返回一个新数组

//var arr = [10, 20, 30, 40, 50];
      //var brr = arr.filter((v) => v > 20 && v < 50);
      /* var brr = arr.filter(function (v) {
        return v > 20 && v < 50;
      });
      console.log(brr); */

2.17 some( )

判断数组中是否有元素满足指定的条件,如果有就返回true

 /*  var arr = [10, 20, 30, 40, 50];
      var flag = arr.some((v) => v > 20);
      console.log(flag); */

2.18 every( )

判断数组中是否所有元素满足指定的条件,如果有返回true ( 同上 )

2.19 reduce( )

累计效果的

/*  var arr = [10, 20, 30, 40, 50];
      var result = arr.reduce((a, b) => {
        //第一个参数第1次表示的是数组中的第1个元素，第二个参数表示数组中的第2个元素，取出之后进行操作，这个操作一般会放到return后面
        //第一个参数第2次表示的是return后面的结果，第二个参数表示数组中的第3个元素，再次进行操作
        //以此类推，直至元素全部取完，将最终结果作为返回值给到result
        //console.log(a, b);
        //累计求和
        return a + b;
      });

      console.log(result); */

2.20 find( )

找到符合条件的第一个元素

2.21 findIndex( )

找到符合条件的第一个元素的索引

2.22 Array.from( )

将一个伪数组转为一个数组

3. 数组 : 冒泡排序

冒泡排序：数组中的元素两两比较，如果前一个比后一个大，交换值，一轮结束后，这些元素中的最大值排到了最后

​ 1. 轮数 轮数为length-1

​ 2. 每轮比较的次数 length-1-i i表示轮数

var arr1 = [78, 23, 65, 9, 17];
      function bubblesort(arr) {
        for (var i = 0; i < arr.length ; i++) {
          for (var j = 0; j < arr.length ; j++) {
            if (arr[j] > arr[j + 1]) {
              var t = arr[j];
              arr[j] = arr[j + 1];
              arr[j + 1] = t;
            }
          }
        }
        return arr;
      }
      console.log(bubblesort(arr1));

4. 数组 : 选择排序

假设第一个值为最小值，minIndex指向最小值的索引，让minIndex指向的这个值和后面所有的值进行比较，后边有比minIndex指向的这个值小的，改变minIndex的值（重复赋值），再让minIndex指向的这个继续和后面的值进行比较，一轮结束后，minIndex存的是最小值的索引。假设第二个值是最小值，以此类推

var arr1 = [78, 23, 65, 9, 17];

      function selectSort(arr) {
        for (var i = 0; i < arr.length - 1; i++) {
          var minIndex = i;
          for (var j = i + 1; j < arr.length; j++) {
            if (arr[minIndex] > arr[j]) {
              minIndex = j;
            }
          }
          //内层循环走完，minIndex指向的就是最小值索引
          var t = arr[minIndex];
          arr[minIndex] = arr[i];
          arr[i] = t;
        }
        return arr;
      }
      console.log(selectSort(arr1));