Javascript权威指南之数组总结笔记

最新推荐文章于 2024-04-16 09:39:43 发布

lamzzz

最新推荐文章于 2024-04-16 09:39:43 发布

阅读量377

点赞数

分类专栏： Javascript

本文链接：https://blog.csdn.net/qq_39103338/article/details/109953399

版权

Javascript 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

数组

数组定义
创建数组
读和写
稀疏数组
数组长度
数组元素的添加和删除
数组遍历
多维数组
数组方法
ECMAScript5中的数组方法.
数组类型
类数组对象
作为数组的字符串

数组定义

数组是无类型的 数组元素可以是任意类型的
索引长度：0-2^32-2
JS数组是动态的，空间会随着需要增长或者缩减
创建数组时无需声明一个固定大小或者在数组大小变化时时无需重新分配空间
JS数组可能是稀疏的 即数组元素索引不一定要连续,它们之间可以有空缺
稀疏数组 length比所有元素的索引大
数组继承Array.prototype中的属性

创建数组

	var count = [1,,3]; //可以看到结果是3
    console.log(count.length);
    var undefs = [,,];
    console.log(undefs.length); //可以看到结果是2 并不是3
    //以上可以总结出 如果逗号出现在最后面 则略去

    //new Array() 不建议使用此方法 因为没有数组字面量方便
    var a = new Array(); //相当于 var a = [];

    //指定长度
    var a = new Array(10);
    console.log(a.length); //output:10

读和写

    //数组也是对象 
    var o = {};
    o[1] = "one";
    o[2] = "two";
    o[3] = "three";
    console.log(o); //还是对象 并不会变成数组
    console.log(o.length); //undefined 要想知道对象元素的个数需要自己写函数统计

    var a = [];
    a["name"] = "Yoona"
    a["age"] = "23";
    console.log(a.length); //output:0 使用小于2^32的非负数整数为索引 才会自动维护length

    //js不会出现对象越界的情况
    var b = [];
    b[4999999999] = 666;
    console.log(b.length); //output:0 超出数组上限

    var c = [];
    c[4294967294] = "y";
    console.log(c.length); //output:4294967294 数组上限

稀疏数组

	//稀疏数组就是宝行从0开始的不连续索引的数组
    var d = [];
    d[0] = 0;
    d[2] = 2;
    console.log(d.length); //3
    console.log(d[1]); //undefined

    //delete也会造成稀疏数组
    d[1] = 1; //此时d已经是一个完整的数组
    d[3] = 3;
    delete d[2];
    console.log(d.length); //4
    console.log(d[2]); //undefined
    console.log(d); 

    //足够稀疏的数组通常在实现上比稠密的数组更慢、内存利用率更高；查找元素的时间与常规对象一样

    var a1 = [1,,3]; 
    var a2 = new Array(3);
    console.log(a1); //索引2处为empty ECMAScript6
    //false javascript权威指南第六版第147页说此处应该会有一个元素 undefined,但实际运行结果为flase 可能ECMAScript6与5不同
    console.log(0 in a1); 
    console.log(0 in a2); //false

数组长度

	//在非稀疏数组中 数组长度就是数组元素的个数

    //设置数组长度
    var e = [1,2,3,4,5];
    e.length = 3; // 会直接截取索引0-3的元素 删除4,5两个元素
    console.log(e); //输出 [1,2,3]

    e.length = 5;
    console.log(e); //会在尾部直接添加2个空间 没有元素

    //设置length只读
    var f = [0,1,2,3];
    Object.defineProperty(f, "length", {writable:false});
    f.length = 0;
    console.log(f); //output:[0, 1, 2, 3] 数组没有被清空

数组元素的添加和删除

	var g = ["culprit"];
    g.push("zero", "one"); //添加多个元素
    console.log(g); 
    g.unshift("minus"); //添加元素到首部

    //删除元素 数组将会变成一个稀疏数组 length不会被改变
    var iArr = [1, 2, 3];
    delete iArr[1];
    console.log(1 in iArr);  //fasle 
    console.log(iArr.length); //3
    console.log(iArr[1]); //undefined 无此元素

    //pop出栈 从数组尾部删除一个元素
    //shift从数组头部删除一个元素

数组遍历

	//for循环 length应该只查询一次 即 循环体应该写成 for (var i = 0,len=iArr.length;i++);
    for (var i = 0; i < iArr.length; i++) {
        console.log(iArr[i]);
    }

    //循环跳过null和undefined不赘述 下述跳过不存在的元素
    for (var i = 0, len; i < len; i++) {
       if (!(i in iArr)) continue;
    }

    //for in 不会遍历不存在的索引
    var jarr = [1,,3];
    for (var index in jarr) { //index是索引
        console.log(index); //打印出 0 2
    }

    //函数里的局部变量的声明都会被提到顶部所以for定义的idnex在for外仍可以使用
    console.log("index " + index); 
    //建议不要使用for in 因为不只会遍历自有属性 还会遍历继承的可枚举的属性
    var kArr = ["name","zhy"];
    var oArr = Object.create(kArr);
    console.log(oArr); //此时应该为空 继承的值为kArr(可以查看原型)
    for (var index in oArr) {
        console.log(index + " " + oArr[index]); //输出0 name 1 zhy
    }

    //推荐使用数组的forEach遍历方法

多维数组

	var person = [["name"],["zhy"]];
    console.log(person[1][0]);

    //也可以用 new Array();创建二维数组
    var table = new Array(2);
    table[0] = new Array(1);
    table[0][0] = 666;
    table[1] = new Array(1);
    table[1][0] = 777;
    console.log(table);

数组方法

	//join();是 String.split()的逆向操作
    var aJoin = [1,2,3];
    console.log(aJoin.join()); //1,2,3
    console.log(aJoin.join("-")); //可以加入指定分隔符 1-2-3

    //reverse();
    console.log(aJoin.reverse()); //[3,2,1]

    //sort()排序
    var unsortArr = [6,2,3,5,1,4];
    console.log(unsortArr.sort()); //[1,2,3,4,5,6]
    var unsortStrArr = ["bname","dname","aname","cname",1,3,2];
    //字符串按字母排序 数字排序在字母前面 undefined会排在尾部
    console.log(unsortStrArr.sort()); //[1,2,3,"aname","bname","cname"，"dname"]

    //自定义排序
    //比如不分大小写排序
    var selfArr = [ "D","a","c","B"];
    console.log(selfArr.sort()); //["B", "D", "a", "c"]
    console.log(selfArr.sort(function(s, t) {
        var a = s.toLowerCase();
        var b = t.toLowerCase();
        if (a < b) return -1;
        if (a > b) return 1;
        return 0;
    }));

    selfArr.sort(function(s, t) {
        var a = s.toLowerCase();
        var b = t.toLowerCase();
        if (a < b) return -1;
        if (a > b) return 1;
        return 0;
    });

    //concat();
    var aConcatArr = [1,2,3];
    console.log(selfArr.concat(aConcatArr)); //["a", "B", "c", "D", 1, 2, 3]

    //slice(from, to) 返回指定数组的一个片段或者子数组 和go语言的切片有点像
    //from to返回的数组范围[from, to)
    //如果from 或者to出现负数 负数代表相对于数组中的最后一个元素的位置
    var aSplice = [1,2,3,4,5];
    console.log(aSplice.slice(-3,-1));
    console.log(aSplice.slice(3));

    //push pop
    var stack = [];
    stack.push(0,1,2); //添加元素
    console.log(stack); // 0 1 2
    stack.pop(); //移除最后一个元素
    console.log(stack); //0 1

    //unshift对头部元素进行插入 shift对头部元素进行移除

    //toString(); toLocaleString(); valueOf();
    console.log([1,2,3].toString()); //生成1,2,3
    console.log([1,2,3].toLocaleString()); //生成1,2,3
    console.log([1,2,3].valueOf()); //输出数组原值

ECMAScript5中的数组方法.

	//forEach(); 遍历数组
    var eachArr = [1,null,undefined,2];
    eachArr.forEach(function(val) { //function(val,i,a) val是数组的每个值 i是索引 a是数组本身
        console.log(val);
    });//1,null,undefined,2
    //forEach无法像for循环一样使用break终止循环 return类似于for循环的continue;

    //map函数 返回的是一个新数组 不会改动原有的数组
    var mapArr = [1,2,3];
    var testMapArr = mapArr.map(function(x) {
        return x + 1;
    });
    console.log(testMapArr); //[2,3,4]
    console.log(mapArr); //[1,2,3]

    //filter过滤函数
    var filterArr = [1,2,3,4,5,6];
    //只取偶数
    var t2 = filterArr.filter(function(val) {
        return val%2==0; 
    });
    console.log(t2); //[2,3,6]

    //every() some()对数组进行逻辑判定
    //every() 所有数组的元素都应该满足判定才返回true 否则返回false;
    //是否所有元素都小于10
    var everyStatus = filterArr.every(function(val) {
        return val < 10;
    });
    console.log(everyStatus); //true;
    //some 存在元素满足条件就返回true
    var someStatus = filterArr.some(function(val) {
        return val > 5; //6>5
    });
    console.log(someStatus); //true;
    //注意 空数组时 every会返回true some会返回false 使用时最好进行空判断

    //reduce()和reduceRight(); 将数组的值进行组合，生成单个值
    //reduce()
    var reduceArr = [1,2,3,4,5];
    //参数x,y x是上一次相加的和值 y是这次要相加的数组元素 0是数组的初始化值赋值给x；
    var sum = reduceArr.reduce(function(x, y) {
        return x+y;
    }, 0);
    //思考 如果初始值0改为1 输出结果还会是15么？
    console.log(sum); //15

    //以下求最大值没有指定初始值 会使用数组的第一个元素作为初始值
    var maxVal = reduceArr.reduce(function(x, y) {
        return (x>y)?x:y;
    });
    console.log(maxVal); //5
    //注 使用前最好进行空判断 必须赋初始值 否则会报错

    //reduceRight() 操作顺序与reduce相反
    var reduceRightArr = [2,3,4];
    //2^(3^4)乘方
    var big = reduceRightArr.reduceRight(function(accumulator, val) {
        return Math.pow(val, accumulator)
    });

    //indexOf 和 lastIndexOf 搜索数组中指定的元素值 -1就是不存在 1则存在

数组类型

	//判断是否是数组 ECMAScript5
    Array.isArray([]); //true
    Array.isArray({}); //false
    //如果是ECMAScript3 
    var isArray = Function.isArray || function(o) {
        return typeof o === "object" &&
        Object.prototype.toString.call(O) === "[object Array]"
    }

类数组对象

	var asArrObj = {};
    var i = 0;
    while (i < 10) {
        asArrObj[i] = i;
        i++;
    }
    asArrObj.length = 10;
    Array.prototype.forEach.call(asArrObj, function(val) {
        console.log(val + "类数组");
    });
    for (var j = 0; j < asArrObj.length; j++) {
        console.log(asArrObj[j]);
    }

作为数组的字符串

	var s = "test"; //e
    Array.prototype.forEach.call(s, function(val) {
        console.log(val);
    });
    console.log(s[1]);