数组

2019-07-28

数组的概念

所谓数组，是有序的元素序列。（一组有序数据）
JavaScript 的 Array 可以包含任意数据类型。注：一般来说数组中元素的类型相同

数组的创建方式

字面量

var arr = [1, 2]; //数组中有两个元素
arr.length; //获取数组的长度
arr[i]; //获取数组中的第i个元素，i称为数组的下标或者索引，下标从0开始
arr[0]; //获取数组中的第一个元素
arr[0] = 100; //修改数组中第一个元素的值为100

构造函数方式创建数组
Array 是一个构造函数，可以用它生成新的数组

1
2
3

var arr = new Array(2);
arr.length; // 2
arr[0]; //undefined

上面代码中，Array 构造函数的参数 2，表示生成一个两个成员的数组。

Array 构造函数有一个很大的缺陷，就是不同的参数，会导致它的行为不一致。

// 单个非数值（比如字符串、布尔值、对象等）作为参数，
// 则该参数是返回的新数组的成员
new Array("abc"); // ['abc']
// 多参数时，所有参数都是返回的新数组的成员
new Array(1, 2); // [1, 2]
new Array("a", "b", "c"); // ['a', 'b', 'c']

可以看到，Array 作为构造函数，行为很不一致。因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法。

数组的操作

push/pop/unshift/shift

push方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组

var arr = [];
arr.push(1); // 1
arr.push("a"); // 2
arr.push(true, {}); // 4
arr; // [1, 'a', true, {}]

pop方法用于删除数组的最后一个元素，并返回该元素。注意，该方法会改变原数组。

1
2
3

var arr = ["a", "b", "c"];
arr.pop(); // 'c'
arr; // ['a', 'b']

对空数组使用 pop 方法，不会报错，而是返回 undefined。

push 和 pop 结合使用，就构成了“后进先出”的栈结构（stack）。

var arr = [];
arr.push(1, 2);
arr.push(3); //1,2,3
arr.pop();
arr; // [1, 2]

上面代码中，3 是最后进入数组的，但是最早离开数组。
concat 合并数组

shift方法用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。

1
2
3

var a = ["a", "b", "c"];
a.shift(); // 'a'
a; // ['b', 'c']

push 和 shift 结合使用，就构成了“先进先出”的队列结构（queue）。

unshift方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。

1
2
3

var a = ["a", "b", "c"];
a.unshift("x"); // 4
a; // ['x', 'a', 'b', 'c']

slice/splice

slice方法用于复制目标数组的一部分，返回一个新数组，原数组不变。
arr.slice(start, end);
它的第一个参数为起始位置（从 0 开始），第二个参数为终止位置（但该位置的元素本身不包括在内）。如果省略第二个参数，则一直返回到原数组的最后一个成员。

var a = ["a", "b", "c"];
a.slice(0); // ["a", "b", "c"]
a.slice(1); // ["b", "c"]
a.slice(1, 2); // ["b"]
a.slice(2, 6); // ["c"]
a.slice(); // ["a", "b", "c"]

上面代码中，最后一个例子 slice 没有参数，实际上等于返回一个原数组的拷贝。

如果 slice 方法的参数是负数，则表示倒数计算的位置。

1
2
3

var a = ["a", "b", "c"];
a.slice(-2); // ["b", "c"]
a.slice(-2, -1); // ["b"]

上面代码中，-2 表示倒数计算的第二个位置，-1 表示倒数计算的第一个位置。

如果第一个参数大于等于数组长度，或者第二个参数小于第一个参数，则返回空数组。

1
2
3

var a = ["a", "b", "c"];
a.slice(4); // []
a.slice(2, 1); // []

splice方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。
arr.splice(start, count, addElement1, addElement2, ...);
splice 的第一个参数是删除的起始位置（从 0 开始），第二个参数是被删除的元素个数。如果后面还有更多的参数，则表示这些就是要被插入数组的新元素。

1
2
3

var a = ["a", "b", "c", "d", "e", "f"];
a.splice(4, 2); // ["e", "f"]
a; // ["a", "b", "c", "d"]

上面代码从原数组 4 号位置，删除了两个数组成员。

1
2
3

var a = ["a", "b", "c", "d", "e", "f"];
a.splice(4, 2, 1, 2); // ["e", "f"]
a; // ["a", "b", "c", "d", 1, 2]

上面代码除了删除成员，还插入了两个新成员。
起始位置如果是负数，就表示从倒数位置开始删除。

1 2	var a = ["a", "b", "c", "d", "e", "f"]; a.splice(-4, 2); // ["c", "d"]

上面代码表示，从倒数第四个位置 c 开始删除两个成员。

如果只是单纯地插入元素，splice 方法的第二个参数可以设为 0。

1
2
3

var a = [1, 1, 1];
a.splice(1, 0, 2); // []  在 删除位置的前面添加了
a; // [1, 2, 1, 1]

如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组。

1
2
3

var a = [1, 2, 3, 4];
a.splice(2); // [3, 4]
a; // [1, 2]

reverse/sort

reverse方法用于颠倒排列数组元素，返回改变后的数组(还是原数组)。注意，该方法将改变原数组。

1
2
3

var a = ["a", "b", "c"];
a.reverse(); // ["c", "b", "a"]
a; // ["c", "b", "a"]

sort方法对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。

["d", "c", "b", "a"]
  .sort()
  [
    // ['a', 'b', 'c', 'd']
    (4, 3, 2, 1)
  ].sort()
  [
    // [1, 2, 3, 4]
    (11, 101)
  ].sort()
  [
    // [101, 11]
    (10111, 1101, 111)
  ].sort();
// [10111, 1101, 111]

上面代码的最后两个例子，需要特殊注意。sort 方法不是按照大小排序，而是按照字典顺序。也就是说，数值会被先转成字符串，再按照字典顺序进行比较，所以 101 排在 11 的前面。

如果想让 sort 方法按照自定义方式排序，可以传入一个函数作为参数。

[10111, 1101, 111].sort(function (a, b) {
  return a - b; //升序
});
// [111, 1101, 10111]

上面代码中，sort 的参数函数本身接受两个参数，表示进行比较的两个数组成员。如果该函数的返回值大于 0，表示第一个成员排在第二个成员后面；其他情况下，都是第一个元素排在第二个元素前面

join

join 方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回。如果不提供参数，默认用逗号分隔。

var a = [1, 2, 3, 4];
a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
//如果数组成员是undefined或null或空位，会被转成空字符串。
[undefined, null].join('#')
// '#'
['a',, 'b'].join('-')
// 'a--b'

数组的遍历（for）
整数数组/字符串数组/对象数组/二维数组
for-in循环 for(var i in arr)i 是下标
for(var i in obj) i 是属性名
函数的值传递和引用传递
堆和栈及索引思维
JSON 表示对象的方法
随机点名程序
数组的排序（冒泡，选择）

数组的冒泡排序

冒泡排序的视频

思路分析：在要排序的一组数中，对当前还未排好的序列，从前往后对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。

即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

var arr = [5, 1, 3, 2, 4];
//1,5,3,2,4
//1 , 3,5,2,4
//1,3   2,5,4
//1,3,2    4,      5
//外层循环 执行4 次，每次找到一个最大的数字放在 尾部
for (var i = 0; i < 5 - 1; i++) {
  console.log(i);
  for (var j = 0; j < 5 - i - 1; j++) {
    if (arr[j] > arr[j + 1]) {
      //交换数组两个元素的值
      var t = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = t;
    }
  }
}

选择排序

思路分析：选择排序和冒泡排序类似，跟冒泡不同之处在于，它不是每比较一次就调换位置，
而是一轮比较完毕，找到最大值(或者最小值)之后，将其放在正确的位置，其他数的位置不变。

//选择排序 ，每次选择一个最小值 ，放特定位置上
//外层控制比较轮数，每轮找到最小值 跟i位置上的元素进行交换
for (var i = 0; i < array.length - 1; i++) {
  var minIndex = i;
  var min = array[i];
  for (var j = i + 1; j < array.length; j++) {
    //当循环出来的元素 比最小值 小的时候，最小值发生变化，最小值索引也变化
    if (min > array[j]) {
      min = array[j];
      minIndex = j;
    }
  }
  //确定了最小值以后需要给  i位置上的元素进行交换
  if (minIndex != i) {
    var tmp = array[i];
    array[i] = array[minIndex];
    array[minIndex] = tmp;
  }
}

本文作者：人模人样的搬砖老段
本文链接：数组
如有错误，请及时评论或者知乎私信或者 B 站私信哦~

最后更新于:2020/04/20