数组：一组数(一般用于存放一组相同类型的数据)，数组中的每一个数据叫做该数组的元素

如何创建数组：

(1) 字面量/直接量创建 => 快捷创建
var arr = []; // 空数组
var arr = ["张三", "李四", "王五"];
console.log(arr);

(2) 通过构造函数创建 (官方提供的方法)
var arr = new Array();
var arr = new Array("张三", "李四", "王五");
console.log(arr);

数组 一组数(一般用于存放一组相同类型的数据) 可不可以存不同类型的(可以 js是弱类型的语言,但是一般不这么用)
var arr = [1, "100", true, null, undefined, [5, 6], function () { }]
console.log(arr);

数组的特性

1. 有lenth属性,表长度(数组中元素的个数)

2. 可以通过下标取值和赋值 下标的最大值 = length - 1

3. 可以被循环遍历

冒泡排序(从小到大)

原理:相邻的两个值作比较大值放后面

原数组: [21, 63, 39, 43, 94, 77, 55]
21 63 [21, 63, 39, 43, 94, 77, 55]
63 39 [21, 39, 63, 43, 94, 77, 55]
63 43 [21, 39, 43, 63, 94, 77, 55]
63 94 [21, 39, 43, 63, 94, 77, 55]
94 77 [21, 39, 43, 63, 77, 94, 55]
94 55 [21, 39, 43, 63, 77, 55, 94]
=> 得到最大的放在最后面

for (var i = 0; i < arr.length - 1; i++) {//外层循环 => 控制总次数(层数)
  // j < arr.length - 1 , 最后一个数没有必要和后面比,排除
  for (var j = 0; j < arr.length - 1 - i; j++) { // 控制每层 做的详细操作
    // arr[j]; // 循环的当前值
    // arr[j + 1]; // 后一个值
    if (arr[j] > arr[j + 1]) { // 如果当前值 大于 后一个 交换位置
      var temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
 console.log(arr);
}

选择排序 (从小到大)

拿第一个值和后面所有的的值做比较,如果存在比第一个值还要小的数交换两个数的位置 => 得到最小的值放在第一个位置

var arr = [24, 1, 38, 74, 12, 57, 26];
console.log("原数组", arr);
//i<arr.length-1 最后一个没有必要和后面所有的比较
for (var i = 0; i < arr.length - 1; i++) {
// arr[i] 第几个
// i+1 -> arr.length 后面所有的
  for (var j = i + 1; j < arr.length; j++) {
    if (arr[i] > arr[j]) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }
}
console.log(arr);
}

sort排序

数组交换排序：

返回值:排序后的原数组

是否影响原数组:影响

a. 字符排序 (默认)
// var arr = [2, 8, 4, 11, "a", 6, "A", 5, 24, 7, 35, 9, 3, 1];
// arr.sort();
// console.log(arr);

b.纯数字排序 => sort中接收一个函数,用于指定排序的方式
// 怎么指定? 函数中有两个形式参数 分别代表比较的两个元素
var arr = [2, 8, 4, 11, 6, 5, 24, 7, 35, 9, 3, 1];
arr.sort(function (a, b) {
// return a - b; // a-b>0 => a>b 前一个大于后一个时交换位置 (从小到大)
  return b - a; // b-a>0 => a<b 前一个小于后一个时交换位置 (从大到小)
 })
 console.log(arr);

浅复制：

对于引用类型来说,直接通过=赋值,会使两个变量引用同一片内存空间 (=== 全等)

缺点:只要有一个改动,另一个也会受到影响

var arr = [1, 2, 3];
// arr = [1, 2, 3];
var brr = arr;
// brr = [1, 2, 3];
brr.push(4); arr.push(5)
; console.log(arr, brr);
// [1, 2, 3, 4]; [1, 2, 3, 4];
console.log(arr === brr);
// [1, 2, 3, 4]; [1, 2, 3, 4];

深复制（拷贝）：

得到一个与原数组元素相同的新数组

(1) 新建数组,遍历原数组,将原数组中的每个元素放到新数组中

(2) 借助数组的拓展方法 slice() concat()

var arr = [1, 2, 3];
// var brr = []; //
for (var i = 0; i < arr.length; i++) {
// var item = arr[i];
// brr.push(item); //
}
// console.log(arr, brr, arr === brr);
var brr = arr.slice();
var brr = arr.concat();
console.log(arr, brr, arr === brr);

数组去重

数组去重之删除去重

var arr = [1, 3, 2, 1, 2, 3, 3, 1, 2, 2, 3, 1]; // [1,2,3]
// 0 1 2 3 4 5
// var arr = [1,1,1,1,1,1,1,1,1,1]
//1 [1, 3, 2, 2, 3, 3, 2, 2, 3]
//3 [1, 3, 2, 2, 2, 2]
//2 [1, 3, 2]
// for (var i = 0; i < arr.length; i++) {
  // // list[i] 第几个
  // for (var j = i + 1; j < arr.length; j++) { // j=1
  // if (arr[i] === arr[j]) {
  // arr.splice(j, 1);
  // j--;
  // }
//  }
// }
// console.log(arr);

数组去重之新建数组去重

var arr = [1, 3, 2, 1, 2, 3, 3, 1, 2, 2, 3, 1]; // [1,2,3]
var list = [];
for (var i = 0; i < arr.length; i++) {
  var item = arr[i];
  if (list.indexOf(item) == -1) {
  list.push(item);
 }
}
console.log(list);

数组坍塌：

数组中的元素被删除后,后续的元素会批量前移,占据前面的位置

var arr = ["a", "b", "c", "d"];
arr.splice(1, 1);
arr; // ["a","c","d"]

元素统计次数：

var arr = [1, 3, 2, 1, 2, 3, 3, 1, 2, 2, 3, 1]; // [1,2,3] var list = arr.concat(); for (var i = 0; i < list.length; i++) { // list[i] 第几个 for (var j = list.length - 1; j >= i + 1; j--) { // j=1 if (list[i] === list[j]) { list.splice(j, 1); } } } console.log(list); console.log(arr); for (var i = 0; i < list.length; i++) { // 遍历去重后的数组 // list[i] //去重后的值 1 3 2 var count = 0; for (var j = 0; j < arr.length; j++) { if (list[i] === arr[j]) { count++; } } console.log(list[i], count); }

#### 后续会专门写一篇数组的扩展方法介绍数组的一些常用方法 juejin.cn/post/718833…

js数组