js-day08 数组

数组

数组: 用来存储不定数量不定类型的数据的容器;

创建数组

1. 字面量创建

2. new关键字创建

// 1. 字面量创建
var arr = [12, 43, 64];
console.log(arr);
console.log(typeof arr); // object
​
// 2. new关键字创建
// var 变量 = new Array(...data);
// 注意: 当参数只有一个且是数字, 表示数组的长度
var arr1 = new Array(1, 2, 3, 4);
console.log(arr1);
​
var arr2 = new Array(7);
console.log(arr2);
console.log(arr2[0]);

length

获取数组长度 数组.length

console.log(arr2.length);

设置数组长度 数组.length = 值; 长度加长 填充undefined 长度减小 多余的项会被删除 永远都找不到

var arr3 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(arr3.length); // 9
arr3.length = 4;
console.log(arr3);
arr3.length = 100;
console.log(arr3);

为什么要划分成基础数据类型和复杂数据类型:

基础: 数据比较单一, 声明和存储都在栈

复杂: 数据比较复杂, 声明和地址存储在栈, 具体数据存储在堆

深浅拷贝

深浅出现在引用数据类型

浅拷贝: 地址的赋值

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

判断引用数据类型是否是同一个地址的数据 用 == 判断

console.log(arr == brr); // true

深拷贝: 在堆中在划一块, 重新存储对应位置的每一个数据

var crr = [];
// 将arr的每一个数据 存到 crr中   对应位置: 下标一致
for(var i = 0; i < arr.length; i++){
    crr[i] = arr[i];
}
console.log(crr);
console.log(crr == arr); // false

添加删除

数组的方法大部分都是在原来数组上进行直接操作, 会改变原数组

栈方法:

push: 在数组的末尾添加一项或者多项, 返回添加数据后的数组的新长度

数组.push(...data);

pop: 在数组的末尾删除一项, 返回被删除的项

数组.pop();

unshift: 在数组的首位添加一项或者多项, 返回添加数据后的数组的新长度

数组.unshift(...data);

shift: 在数组的首位删除一项, 返回被删除的项

数组.shift();

// push
var arr = [1, 2, 3, 4];
var a = arr.push('a', 'b', 'c');
console.log(arr, a);
​
// pop
var b = arr.pop();
console.log(arr, b);
​
// unshift:
var c = arr.unshift('小乔', '大乔', '周瑜');
console.log(arr, c);
​
// shift
var d = arr.shift();
console.log(arr, d);

splice

splice: 增删改, 返回被删除的项组成的新数组

语法: 数组.splice(起始下标, 删除的个数, [....data]);

增:

数组.splice(起始下标, 删除个数, ...data);

删除:

数组.splice(起始下标, 删除个数);

替换:

数组.splice(起始下标, 删除个数, ...data);

var arr = ['小乔', '大乔', '貂蝉', '王昭君', '西施'];
// 小乔后面添加 周瑜
var a = arr.splice(1, 0, '周瑜');
console.log(arr); // ['小乔', '周瑜', '大乔', '貂蝉', '王昭君', '西施']
console.log(a, 'a----');
// 貂蝉 删除
var b = arr.splice(3, 1);
console.log(arr); // ['小乔', '周瑜', '大乔', '王昭君', '西施']
console.log(b, 'b----');
// 替换
var c = arr.splice(3, 2, '潘金莲', '西门庆');
console.log(arr);
console.log(c, 'c----');

数组方法

concat

concat: 拼接数组和项, 返回新数组

数组.concat(...data);

var arr = [1, 2, 3];
var brr = [6, 7, 8];
var crr = arr.concat(4, 5, brr);
console.log(arr, brr);
console.log(crr); // [1, 2, 3, 4, 5, 6, 7, 8]

slice

slice: 截取 用法与字符串一模一样, 返回截取出来的新数组

数组.slice([起始下标], [结束下标]);

console.log(crr.slice()); // [1, 2, 3, 4, 5, 6, 7, 8]
console.log(crr.slice(2)); // [3, 4, 5, 6, 7, 8]
console.log(crr.slice(2, 5)); // [3, 4, 5]

reverse

reverse: 数组翻转, 改变原数组, 具有返回值, 返回翻转以后的数组

数组.reverse();

var arr = [1, 2, 3, 4];
var a = arr.reverse();
console.log(arr, a);

join

join: 将数组按照拼接符连接起来, 返回字符串

数组.join(连接符)

连接符可以是一切字符, 默认以,作为连接符

var arr = ['小乔', '吕布', '貂蝉'];
console.log(arr.join('和')); // 小乔和吕布和貂蝉
console.log(arr.join('<b>+++</b>')); // 小乔<b>+++</b>吕布<b>+++</b>貂蝉
console.log(arr.join()); // 小乔,吕布,貂蝉
console.log(arr.join('')); // 小乔吕布貂蝉

indexOf/lastIndexOf

indexOf/lastIndexOf: 查找对应的项在数组中出现的位置，如果有返回下标，如果没有返回-1

与字符串一致

注意: 查找的项必须和数组的项 全等 才能被找到

var arr = [1, '1', 2];
console.log(arr.indexOf('1')); // 1
console.log(arr.indexOf(1)); // 0

sort

数组.sort([函数]); 默认按照字符串的排序规则进行排序

有2个形参(假设叫a, b):

return a - b; 从小到大

return b - a; 从大到小

var arr = [4, 2, 4, 1, 3, 31, 4, 15, 81, 11];
arr.sort();
console.log(arr);

console.log(arr.sort);

arr.sort(function (a, b) {
    console.log(a, b); // 相邻的两项
    // return a - b; // 从小到大
    return b - a; // 从大到小
});
console.log(arr);

中文比较

localeCompare: 比较字符是否在另一个字符之前或者之后

字符a.localeCompare(字符b);

字符a 在 字符b 之前 返回 -1

字符a 和 字符b 完全一致 返回 0

字符a 在 字符b 之后 返回 1

var a = '张三';
var b = '李四';
console.log(b.localeCompare(a));
console.log(a.localeCompare(b));
console.log(a.localeCompare(a));

// 用姓名升序排序 a---z
arr.sort(function (x, y) {
    console.log(x.name, y.name);
    return x.name.localeCompare(y.name);
});
console.log(arr);