26 数组、创建数组、数组的方法

26 数组、创建数组、数组的方法

数组

概念

数组: 是一个用来存放不定数量不定数据类型的数据的容器

索引: 下标

元素: 值

创建数组

字面量

字面量创建: var 变量 = [值, 值, 值,...];

// 字面量
var arr = [1,2,3,4];

new关键字创建

new创建: var 变量 = new Array(长度/每一个值);

如果Array后面的()中，放置1个以上的内容 表示是数组的每一个值

如果放置一个内容并且还是数字，这个值表示数组的长度, 写几在数组中就有几个empty

// new
var arr1 = new Array(2,3);
console.log(arr1);
​
var arr2 = new Array(3);
console.log(arr2);

长度 length

长度: 数组.length

数组的长度可以通过设置length属性改变

索引：通过索引获取到具体的值

console.log(arr2.length);
console.log(arr2[1]); // undefined
​
// 了解 数组的长度可以通过设置length属性改变
arr2.length = 1;
console.log(arr2);
arr1.length = 0;
console.log(arr1);
​
arr1[2] = 100; // 将arr1的第三项设置成100  
console.log(arr1);

栈方法

push

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

数组.push(项, 项, ...);

var arr = ['a', 'b', 'c'];
console.log(arr);
var len = arr.push(1, 2, 3);
console.log(arr, len); // ["a", "b", "c", 1, 2, 3] 6

pop

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

数组.pop();

var del = arr.pop();
console.log(arr, del); // ["a", "b", "c", 1, 2]  3

unshift

unshift: 在数组的开头添加一项或者是多项, 返回新数组的长度

数组.unshift(项, 项, ...);

var len1 = arr.unshift('d', 'e');
console.log(arr, len1); // ["d", "e", "a", "b", "c", 1, 2]  7

shift

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

数组.shift();

var del1 = arr.shift();
console.log(arr, del1); // ["e", "a", "b", "c", 1, 2]   d

splice

语法

splice: 数组.splice(起始下标[, 删除个数[, 添加的项, 添加的项,....]]);

起始下标：从当前这个下标开始操作

返回被删除的项组成的新数组

添加: 删除个数为0

数组.splice(起始下标, 0, 添加的项, ....);

删除:

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

只传起始下标, 从起始下标开始到数组末尾都被删除

替换: 既删除又添加

数组.splice(起始下标[, 删除个数[, 添加的项, 添加的项,....]]);

var arr = ['亚索', '女枪', '蔡文姬', '盖伦', '盲僧', '迪迦'];
// 蔡文姬后面添加一个瑶
var a = arr.splice(3, 0, '瑶');
console.log(arr); // ["亚索", "女枪", "蔡文姬", "瑶", "盖伦", "盲僧", "迪迦"]
console.log(a); // []
​
var b = arr.splice(4);
console.log(arr);
console.log(b);
​
arr.splice(0, 1);
console.log(arr); // ["女枪", "蔡文姬", "瑶"]
​
var c = arr.splice(1, 1, '明世隐');
console.log(arr, c);

去重

数组去重:

拿数组的每一项 和 当前项后面的每一项进行对比 如果相同 删除后面的

当删除之后 数组的下标开始动态改变 新进的项 还没有与 项做对比

需要在本轮循环在多做一次对比

i = 0 j = 1 2 3 4

i = 1 j = 2 3 4 5

i = 2 j = 3 4 5 6

var arr = [1, 2, 3, 4, 1, 3, 2, 3, 41, 21, 43, 1, 23, 43];
// for(var i = 0; i < arr.length; i++){
//     // console.log(arr[i]);
//     for(var j = i+1; j < arr.length; j++){ // 2 + 1 -1
//         // console.log('j', arr[j]);
//         if(arr[i] == arr[j]){
//             // 删除后面的
//             arr.splice(j, 1);
//             j--;
//         }
//     }
// }

// 如果两项没有重复 不需要删除的时候  j++  否则 不能加
for(var i = 0; i < arr.length; i++){
    // console.log(arr[i]);
    for(var j = i+1; j < arr.length;){ 
        // console.log('j', arr[j]);
        if(arr[i] == arr[j]){
            // 删除后面的
            arr.splice(j, 1);
        } else {
            j++;
        }
    }
}
console.log(arr);

排序

选择排序

选择排序：

用数组的每一项 和 后面的每一项区进行对比

如果后面的项比前面的项 小 互换位置

i = 0 j = 1 2 3 4

i = 1 j = 2 3 4 5

i = 2 j = 3 4 5 6

for (var i = 0; i < arr.length; i++) {
    // console.log(arr[i]);
    for (var j = i + 1; j < arr.length; j++) {
        // console.log('j', arr[j]);
        if(arr[j] < arr[i]){
            // 互换位置
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}
console.log(arr);

冒泡排序

冒泡排序：

两两相邻的值进行比较 如果后面的比前面的小 互换位置

i = 0 0 1

i = 1 1 2

i = 2 2 3

for (var j = 0; j < arr.length; j++) {
    // j = 0  1
    // j = 1  2
    // j = 2  3
    for (var i = 0; i < arr.length - j; i++) {
        // console.log(arr[i], arr[i + 1]);
        if (arr[i] > arr[i + 1]) {
            var temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
    }
}
console.log(arr);

sort

数组.sort([函数]);

即改变原数组 也会返回一个排序好的数组

不传参的时候 默认按照字符串的比较规则来排序

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

var arr = [31, 11, 422, 22, 112, 51];
arr.sort();
console.log(arr);

数组.sort(function(x, y){ 形参名字自定义

return x - y; 从小到大

return y - x; 从大到小

});

arr.sort(function(x, y){
    console.log(x, y);
    // return x - y;
    return y - x;
});
console.log(arr);

数组方法

join

join: 拼接 返回字符串

数组.join([拼接符])

如果不传拼接符 默认,拼接

var arr = [1, 2, 3, 4];
console.log(arr.join()); // 1,2,3,4
console.log(arr.join('')); // 1234

slice

slice: 截取

slice(): 表示返回整个数组

slice(起始下标): 返回从起始下标到数组的结束为止

slice(起始下标, 结束下标): 返回从起始下标到结束下标的项 包含起始下标 但是不包含结束下标

起始下标>结束下标: 返回空数组

结束下标是负数: 从起始下标开始截取, 从右往左数有几个不要

var arr = ['亚索', '盖伦', '阿狸', '马里奥', '猴子', '东皇', '123'];
console.log(arr.slice());
console.log(arr.slice(3)); //  '马里奥', '猴子', '东皇'
console.log(arr.slice(3, 5)); //  '马里奥', '猴子'
console.log(arr.slice(5, 3)); //  
console.log(arr.slice(1, -3)); //   '盖伦', '阿狸'

indexOf/lastIndexOf

indexOf/lastIndexOf: 使用的语法与字符串完全一致的

lastIndexOf/indexOf(内容, 起始下标)

如果找到匹配的项 返回匹配项的下标

如果找不到 返回-1

查找的内容与项必须全等 ===

console.log(arr.indexOf('瑶'));
console.log(arr.indexOf('盖伦')); // 1
console.log(arr.indexOf(123)); // -1
console.log(arr.indexOf('123')); // 6

reverse

reverse: 翻转数组

数组.reverse();

arr.reverse();
console.log(arr);

concat

concat: 拼接数组或项

数组.concat(项/数组, 项,....)

原数组不变 会将拼接好的数组作为返回值返回回来

var barr = ['蔡文姬', '后裔'];
var newArr = arr.concat(barr, '墨子');
console.log(arr);
console.log(newArr);

迭代方法

every

every: 对数组中的每一项去做一些判断 如果每一项返回都是true 最后返回结果就是true

如果有一个返回是false 直接返回false

全真为真 一假为假

数组.every(函数)

var arr = [4, 5, 6, 7, 8];
var end = arr.every(function (value, index, array) {
    console.log(index, value, array);
    // return true;
    // return value > 5;  // 执行一次
    return value > 3; // 执行5次
});
console.log(end);

some

some: 对数组中的每一项去做一些判断 如果每一项返回都是false 最后返回结果就是false

如果有一个返回是true 直接返回true

全假为假 一真为真

数组.some(函数);

var end = arr.some(function (value, index, array) {
    console.log(index, value, array);
    // return true; // 执行 1 次
    // return value > 5; // 执行 3 次
    return value > 9; // 执行 5 次
});
console.log(end);

filter

filter: 对数组的每一项做一些判断，将符合判断条件(判断结果为true)组成一个新数组之后再返回

数组.filter(函数);

var arr = [4, 5, 6, 7, 8];
var result = arr.filter(function (value, index) {
    console.log(index, value);
    // return true; // [4, 5, 6, 7, 8]
    return value > 5; // 6, 7, 8
});
console.log(result); 

map

map: 对数组进行一些遍历 将数组的返回值组成一个新的数组返回

数组.map(函数);

var rel = arr.map(function(v, i){ // 固定位置 不固定名称  第一个形参: 数组中的项  第二个形参: 下标
    console.log(v);
    return v * v;
});
console.log(rel);

forEach

forEach: 对数组进行一些遍历

数组.forEach(函数)

var rel = arr.forEach(function(v, i){ // 固定位置 不固定名称  第一个形参: 数组中的项  第二个形参: 下标
    console.log(v);
    return v * v;
});
console.log(rel); // undefined

中文排序

localeCompare: 中文.localeCompare(中文1)

网页中 模拟表格排序

0--一样

1--str在str1的后面 返回1

-1--str在str1的前面 返回-1

var arr = [
    { name: '武丽昕', num: 78 },
    { name: '汤文博', num: 38 },
    { name: '卢文博', num: 58 },
    { name: '邓钧键', num: 97 },
    { name: '刘继昂', num: 56 },
    { name: '栗军安', num: 78 },
    { name: '屈晓月', num: 98 },
    { name: '付秋萍', num: 79 }
];

arr.sort(function(a, b){
    // console.log(a, b); // 相邻的两个对象
    console.log(a.name, b.name); // 相邻的两个对象的名字  a---z
    return a.name.localeCompare(b.name); // 
});
console.log(arr);

快速排序

1. 求出中间下标

2. 获取中间值

3. 将中间值从原数组中删除

4. 创建两个空数组 用来存储左右数据

5. 遍历数组中的每一项 如果比中间值小的放左边 如果比中间值大放右边

6. 封装函数

7. 设置结束条件 return

var arr = [21, 2, 5, 9, 31, 1];
var na = qs(arr);
console.log(na);


function qs(array) {
    // 7. 设置结束条件  return
    // 如果array  长度 是 0 1的时候 需要直接结束代码 
    if(array.length <= 1){
        return array;
    }
    // 1. 求出中间下标
    var num = Math.floor(array.length / 2);
    // console.log(num);
    // 2. 获取中间值
    var val = array[num];
    // console.log(val);
    // 3. 将中间值从原数组中删除
    array.splice(num, 1);
    // console.log(array);
    // 4. 创建两个空数组 用来存储左右数据
    var left = [], right = [];
    // 5. 遍历数组中的每一项 如果比中间值小的放左边 如果比中间值大放右边
    for (var i = 0; i < array.length; i++) {
        if (array[i] < val) {
            left.push(array[i]);
        } else {
            right.push(array[i]);
        }
    }
    console.log(left, right);
    var end = qs(left).concat(val, qs(right));
    return end;
}

递归函数:

\1. 函数里面调用自己

\2. 必须有让函数结束的条件 否则形成死循环