学习Javascript数据结构与算法（第2版）笔记（2）

第 2 章数组

1. 创建和初始化数组

var arr = new Array();
var arr = new Array(7);
var arr = new Array('aa','bb');
或：
var arr = [];
var arr = ['aa','bb'];

arr.length  //数组长度

访问元素和迭代数组

for(var i=0;i<arr.length;i++){
    console.log(arr[i]);
}

2. 添加元素

var arr = [1,2,3];
arr[arr.length] = 4;

2.1 使用 push 方法（添加到数组末尾）

arr.push(5);
arr.push(6,7);

2.2 使用 unshift 方法（插入元素到数组首位）

arr.unshift(0);
arr.unshift(-2,-1);

原理：
for (var i=arr.length; i>=0; i--){
    arr[i] = arr[i-1];
}
arr[0] = 0;

3. 删除元素

3.1 使用 pop 方法（删除数组里最靠后的元素）

arr.pop();

3.2 使用 shift 方法（从数组首位删除元素）

arr.shift();
原理：
for (var i = 0; i < arr.length; i++){
    arr[i] = arr[i+1];
}

4. 在任意位置添加或删除元素

使用 splice 方法（通过指定位置/索引添加或删除相应位置和数量的元素）

arr.splice(1,2); // 从数组索引1开始删除2个元素
arr.splice(1,0,7,8,9); // 从数组索引1开始添加3个元素
arr.splice(1,2,7,8,9);//从数组索引1开始删除2个元素，并从索引1开始添加3个元素

5. 二维和多维数组

function printArr(matrix){
    for(var i=0;i<matrix.length;i++){
        for(var j=0;j<matrix[i].length;j++){
            console.log(matrix[i][j])
        }
    }
}

3×3×3：
for (var i=0; i<arr.length; i++){
    for (var j=0; j<arr[i].length; j++){
        for (var z=0; z<arr[i][j].length; z++){
            console.log(arr[i][j][z]);
        }
    }
}

6. Javascript 数组方法参考

方法名	描述
concat	连接2个或更多数组，并返回结果
every	对数组中的每一项运行给定函数，如果该函数对每一项都返回 true ，则返回 true
filter	对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组
forEach	对数组中的每一项运行给定函数。这个方法没有返回值
join	将所有的数组元素连接成一个字符串
indexOf	返回第一个与给定参数相等的数组元素的索引，没有找到则返回-1
lastIndexOf	返回在数组中搜索到的与给定参数相等的元素的索引里最大的值
map	对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组
reverse	颠倒数组中元素的顺序，原先第一个元素现在变成最后一个，同样原先的最后一个元素变成了现在的第一个
slice	传入索引值，将数组里对应索引范围内的元素作为新数组返回
some	对数组中的每一项运行给定函数，如果任一项返回 true ，则返回 true
sort	按照字母顺序对数组排序，支持传入指定排序方法的函数作为参数
toString	将数组作为字符串返回
valueOf	和 toString 类似，将数组作为字符串返回

6.1 数组合并（concat）

var num = 0;
var arr1 = [1,2,3];
var arr2 = [-3,-2,-1];
var nums = arr2.concat(num,arr2);//[-3,-2,-1,0,1,2,3]

6.2 迭代器函数

var isEven = function(x){
    console.log(x)
    return (x % 2 == 0);
};
var nums = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];

1. 用 every 方法迭代（ every 方法会迭代数组中的每个元素，直到返回 false ）
nums.every(isEven); //1

2. 用 some 方法迭代（ some 方法会迭代数组的每个元素，直到函数返回 true）
nums.some(isEven);//1,2

3. 用 forEach 方法迭代（迭代整个数组，与for循环相同）
nums.forEach(isEven);

4. 使用 map 和 filter 方法
var myMap = nums.map(isEven);// [false, true, false, true, false, true, false, true,false, true, false, true, false, true, false]

var myFilter = nums.filter(isEven);//[2, 4, 6, 8, 10, 12, 14]

5. 使用 reduce 方法
nums.reduce(function(preVal,currVal,index,arr){
    return preVal + currVal;
});//120

6.3 ECMAScript 6 和数组的新功能

ES6和ES7新增的数组方法。

方法	描述
@@iterator	返回一个包含数组键值对的迭代器对象，可以通过同步调用得到数组元素的键值对
copyWithin	复制数组中一系列元素到同一数组指定的起始位置
entries	返回包含数组所有键值对的 @@iterator
includes	如果数组中存在某个元素则返回 true ，否则返回 false 。ES7新增
find	根据回调函数给定的条件从数组中查找元素，如果找到则返回该元素
findIndex	根据回调函数给定的条件从数组中查找元素，如果找到则返回该元素在数组中的索引
fill	用静态值填充数组
from	根据已有数组创建一个新数组
keys	返回包含数组所有索引的 @@iterator
of	根据传入的参数创建一个新数组
values	返回包含数组中所有值的 @@iterator

6.3.1 使用 forEach 和箭头函数迭

nums.forEach(function(x){
   console.log(x%2==0); 
});

num.forEach(x => {console.log(x%2==0)})

6.3.2 使用 for...of 循环迭代

for(let n of nums){ //n 代表数组中每一项
    console.log((n%2==0)?'even':'odd');
}

6.3.3 使用ES6新的迭代器（ @@iterator ）

ES6还为 Array 类增加了一个 @@iterator 属性，需要通过 Symbol.iterator 来访问。

let iterator = nums[Symbol.iterator]();
console.log(iterator.next().value); // 1
console.log(iterator.next().value); // 2
console.log(iterator.next().value); // 3
console.log(iterator.next().value); // 4
console.log(iterator.next().value); // 5

数组的 entries 、 keys 和 values 方法

1. entries 方法返回包含键值对的 @@iterator 
let aEntries = nums.entries(); // 得到键值对的迭代器
console.log(aEntries.next().value); // [0, 1] - 位置0的值为1
console.log(aEntries.next().value); // [1, 2] - 位置1的值为2
console.log(aEntries.next().value); // [2, 3] - 位置2的值为3

2. keys 方法返回包含数组索引的 @@iterator
let aKeys = nums.keys(); // 得到数组索引的迭代器
console.log(aKeys.next()); // {value: 0, done: false }
console.log(aKeys.next()); // {value: 1, done: false }
console.log(aKeys.next()); // {value: 2, done: false }

3. values 方法返回的 @@iterator 则包含数组的值
let aValues = nums.values();
console.log(aValues.next()); // {value: 1, done: false }
console.log(aValues.next()); // {value: 2, done: false }
console.log(aValues.next()); // {value: 3, done: false }

6.3.4 使用 from 方法（根据已有的数组创建一个新数组）

let nums2 = Array.from(nums);

let evens = Array.from(nums,x => {x%2==0});

6.3.5 使用 Array.of 方法（根据传入的参数创建一个新数组）

let num3 = Array.of(1);
let num4 = Array.of(1, 2, 3, 4, 5, 6);
等价于：
let num3 = [1];
let num4 = [1, 2, 3, 4, 5, 6];

复制已有数组：
let numCopy = Array.of(...num4);

6.3.6 使用 fill 方法（用静态值填充数组。参数：填充数、开始索引、结束索引）

let numCopy = Array.of(1, 2, 3, 4, 5, 6);

numCopy.fill(0); // [0,0,0,0,0,0]
numCopy.fill(2, 1); // [0,2,2,2,2,2]
numCopy.fill(1, 3, 5); // [0,2,2,1,1,2]
let ones = Array(6).fill(1);// [1,1,1,1,1,1]

6.3.7 使用 copyWithin 方法（复制数组中的一系列元素到同一数组指定的起始位置）

let copyArray = [1, 2, 3, 4, 5, 6];
copyArray.copyWithin(0, 3); // [4, 5, 6, 4, 5, 6]

copyArray = [1, 2, 3, 4, 5, 6];
copyArray.copyWithin(1, 3, 5);// [1, 4, 5, 4, 5, 6]

6.4 排序元素

nums = [1,2,3,4,5,6,7,8,9,10]
nums.reverse();//[10,9,8,7,6,5,4,3,2,1]
nums.sort(function(a, b){
    return a-b;
});
等价于：
function compare(a, b) {
    if (a < b) {
        return -1;
    }
    if (a > b) {
        return 1;
    }
    return 0;
}
nums.sort(compare);

6.4.1 自定义排序

var friends = [
    {name:'张三',age:18},
    {name:'李四',age:25},
    {name:'王五',age:21}
]
function comparePerson(a, b){
    if (a.age < b.age){
        return -1
    }
    if (a.age > b.age){
        return 1
    }
    return 0;
}
console.log(friends.sort(comparePerson));//从小到大

6.4.2 字符串排序

var names =['Ana', 'ana', 'john', 'John'];
names.sort(function(a, b){
    if (a.toLowerCase() < b.toLowerCase()){
        return -1
    }
    if (a.toLowerCase() > b.toLowerCase()){
        return 1
    }
    return 0;
});

对带有重音符号的字符做排序
var names2 = ['Maève', 'Maeve'];
console.log(names2.sort(function(a, b){
    return a.localCompare(b);
}));

6.5 搜索

indexOf 方法返回与参数匹配的第一个元素的索引， lastIndexOf 返回与参数匹配的最后一个元素的索引

6.5.1 ECMAScript 6—— find 和 findIndex 方法

let nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
function multipleOf13(element, index, array) {
    return (element % 13 == 0) ? true : false;
}
console.log(nums.find(multipleOf13)); //找到返回13，找不到返回undefined
console.log(nums.findIndex(multipleOf13)); //找到返回索引，找不到返回-1

6.5.2 ECMAScript 7——使用 includes 方法

数组里存在某个元素， includes 方法会返回 true ，否则返回 false 。
console.log(nums.includes(15));
console.log(nums.includes(20));

let nums2 = [7, 6, 5, 4, 3, 2, 1];
console.log(nums2.includes(4, 5));//从索引5开始查找

6.6 输出数组为字符串

把数组里所有元素输出为一个字符串，可以用 toString 方法
console.log(nums.toString());

用一个不同的分隔符（比如 - ）把元素隔开，可以用 join 方法
var numsString = nums.join('-');
console.log(numsString);

6.7 类型数组

类型数组则用于存储单一类型的数据

类型数组	数据类型
Int8Array	8位二进制补码整数
Uint8Array	8位无符号整数
Uint8ClampedArray	8位无符号整数
Int16Array	16位二进制补码整数
Uint16Array	16位无符号整数
Int32Array	32位二进制补码整数
Uint32Array	32位无符号整数
Float32Array	32位IEEE浮点数
Float64Array	64位IEEE浮点数

let length = 5;
let int16 = new Int16Array(length);
let array16 = [];
array16.length = length;
for (let i=0; i<length; i++){
    int16[i] = i+1;
}
console.log(int16);