JavaScript数组

数组

数组的定义

1. new Array(length/content);

var arr = new Array();

var arr = new Array(10);
// 长度为十的稀松数组 : arr = [undefined * 10];
var arr = new Array(1,2,3,4,5);
// arr = [1,2,3,4,5];

2. 字面量

var arr = [];

console.log(Array());
–> []

数组的读和写

1. arr[num] //不可以溢出读 结果为undefined

var arr = Array(10);
console.log(arr[10]);
// undefined

2. arr[num] = xxx;//可以溢出写

var arr = Array(10);
arr[10] = "abc";
console.log(arr.length);
// 11

数组常用的方法 (es3.0)

1. 改变原数组 (在原数组基础上)

push,pop,shift,unshift,sort,reverse,splice

• push 将新数据写入数组最后一位, 返回写入后数组的长度

var arr = [];
arr.push(11);
// arr = [11];
arr.push(10,9);
// arr = [11,10,9];

• pop 删除数组最后一位, 返回删除前数组的长度 (忽略传参)

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

• shift 删除数组第一位, 返回删除前数组的长度

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

• unshift 将新数据写入数组第一项, 返回写入后数组的长度

var arr = [1,2,3];
arr.unshift(0);
// arr.length = 4;
// arr = [0,1,2,3];
arr.unshift(-2,-1);
// arr.length = 6;
// arr = [-2,-1,0,1,2,3];

• reverse 将原数组逆转, 返回逆转后的数组

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

• splice 从第几位开始, 截取多少的长度, 在切口处添加新的数据, 返回被切掉的数组数据

var arr = [1,2,3,4,5,6];
arr.splice(1,2);
// arr = [1,4,5,6];
arr.splice(1,1,0,0,0);
// arr = [1,0,0,0,5,6];
arr.splice(4,0,4);
// arr = [1,0,0,0,4,5,6];
arr.splice(-1,1);
// arr = [1,0,0,0,4,5];

• sort 将数组进行排序 (按照ASCII码)

var arr = [5,2,3,1,4];
arr.sort();
// arr = [1,2,3,4,5];
var arr1 = [1,4,3,10,2];
arr1.sort();
// arr1 = [1,10,2,3,4];

按照升 / 降序进行排序:

// 符合冒泡排序:
// 1. 必须写俩形参
// 2. 看返回值  1) 当返回值为负数时, 那么前面的数放在前面
//             2) 为正数, 那么后面的数在前
//             3) 为0, 不动
var arr = [1,4,3,10,2];
arr.sort(function(a,b) {
    // if(a > b) {
    //     return 1;
    // }else {
    //     return -1;
    // }
    return a - b; // 升序
    // return b - a; 降序
});

给一个有序的数组乱序:

var arr = [1,2,3,4,5,6,7];
arr.sort(function() {
    return Math.random() - 0.5;
});

2. 不改变原数组

concat, join, toString, slice

• concat 将两个数组拼接, 返回拼接后的数组

var arr = [1,2,3,4,5,6];
var arr1 = [7,8,9];
arr.concat(arr1);
// [1,2,3,4,5,6,7,8,9]

• toString 将数组以字符串形式展现出来, 返回字符串形式的数组

var arr = [1,2,3,4,5];
arr.toString();
// "1,2,3,4,5"

• slice(从该位开始截取, 截取到该位(不包括该位)), 返回截取的数据

var arr = [1,2,3,4,5,6];
var newArr = arr.slice(1,3);
// newArr = [2,3];
var newArr1 = arr.slice(1);
// newArr1 = [2,3,4,5,6];
var newArr2 = arr.slice(-4);
// newArr2 = [3,4,5,6];
var newArr3 = arr.slice();
// newArr3 = [1,2,3,4,5,6];

• join(字符串方法: split) 在数组每两个数据一直加入一个符号并以字符串形式返回

var arr = [1,2,3,4,5,6];
arr.join("-");
// "1-2-3-4-5-6"
var str = arr.join("-");
str.split("-");
// ["1", "2", "3", "4", "5", "6"]
// str.split("4");
// ["1-2-3-", "-5-6"]

将字符串连接到一起:

var str = "alibaba";
var str1 = "baidu";
var str2 = "tencent";
var str3 = "toutiao";
var str4 = "wangyi";
// 散列
var arr = [str,str1,str2,str3,str4];
arr.join("");

类数组

将数组和对象的功能 (不是全部) 合为一体

组成: 属性要为索引 (数字) 属性, 必须有length属性, 最好加上push

var obj = {
    "0" : 'a',
    "1" : 'b',
    "2" : 'c',
    "name" : 'abc',
    "length" : 3,
    "push" : Array.prototype.push,
    "splice" : Array.prototype.splice
}
obj.push('d');
// obj = {
//     "0" : 'a',
//     "1" : 'b',
//     "2" : 'c',
//     "3" : 'd',
//     "length" : 4
// }
console.log(obj);
// ['a', 'b', 'c']

push的原理:

Array.prototype.push = function (target) {
    obj[obj.length] = target;
    obj.length ++;
}

var obj = {
    "2" : 'a',
    "3" : 'b',
    "length" : 2,
    "push" : Array.prototype.push
}
obj.push('c');
obj.push('d');
// obj = {
//     "2" : 'c',
//     "3" : 'd',
//     "length" : 4
// }

特点:

1. 可以利用属性名模拟数组的特性

2. 可以动态的增长length属性

3. 如果强行让类数组调用push方法, 则会根据length属性值的位置进行属性的扩充.

封装type

1. 分两类: 原始值 引用值
2. 区分引用值

function type(target) {
    var ret = typeof(target);
    var template = {
        "[object Array]" : "array",
        "[object Object]" : "object",
        "[object Number]" : "number - object",
        "[object Boolean]" : "boolean - object",
        "[object String]" : "string - object"
    }
    if(target === null) {
        return "null";
    }
    if(ret == "object") {
        var str = Object.prototype.toString.call(target);
        return template[str];
    }else{
        return ret;
    }
}

数组去重

将数组中相同的数据删掉只留下一个 (hash: 将数组的属性值添加到对象的属性名里面去, 因对象的属性名不能重复, 因此可将数组重复的属性值删掉)

var arr = [1,1,1,1,1,2,2,2,2,2,1,1,1,1];
Array.prototype.unique = function () {
    var temp = {},
        arr = [],
        len = this.length;
    for(var i = 0; i < len; i ++) {
        if(!temp[this[i]]) {
            temp[this[i]] = "abc";
            arr.push(this[i]);
        }
    }
    return arr;
}

try…catch

在try里面出现错误时不会执行错误后try里面的代码,且后续代码可继续执行, 在catch内捕捉错误 (catch只执行一次)

try{
    console.log('a');
    console.log(b);
    console.log(c);
}catch(e) {
    console,log(e.name + " : " + e.message);
}
console,log('d');
// a
// ReferenceError : b is not defined
// d

Error.name的六种值对应的信息:

1. EvalError: eval()的使用与定义不一致

2. RangeError: 数值越界

3. ReferenceError: 非法或不能识别的引用数值

4. SyntaxError: 发生语法解析错误

5. TypeError: 操作数类型错误

6. URIError: URI处理函数使用不当

es5严格模式

现在所用的是基于es3.0 + es5.0的新增方法使用的

es3.0 和 es5.0产生冲突的部分: 若启用es5.0的严格模式, es3.0和es5.0产生冲突的部分就使用es5.0,否则使用es3.0

es5.0严格模式的启动: 在 (全局 / 局部) 逻辑最顶端写"use strict";, 就是一行字符串, 不会对不兼容严格模式的浏览器产生影响.

不再兼容es3的一些不规则语法. 使用全新的es5规范

两种用法:

1. 全局严格模式

2. 局部函数内严格模式 (推荐)

不支持with, arguments, callee, func, caller, 变量赋值前必须声明, 局部this必须被赋值 (Person.call(null/undefined)赋值什么就是什么), 拒绝重复属性和参数

• with

将with里面的对象放在执行期上下文的最顶端首先访问

var obj = {
    name : "obj"
}
var name = 'window';
function test() {
    var name = 'scope';
    with(obj) {
        console.log(name);
    }
}
test();
// obj