精华内容
参与话题
问答
  • js数组

    万次阅读 2015-06-03 16:47:58
    js数组: var workData = []; // 添加元素 workData.push({'pk':'1','name':'1x'}); workData.push({'pk':'2','name':'2x'}); workData.push({'pk':'3','name':'3x'}); workData.push({'pk':'4','

    js数组:

        var workData = [];
        // 添加元素
        workData.push({'pk':'1','name':'1x'});
        workData.push({'pk':'2','name':'2x'});
        workData.push({'pk':'3','name':'3x'});
        workData.push({'pk':'4','name':'4x'});
        // 删除第一个元素
        workData.shift();
        // 删除最后一个元素
        workData.pop();


    展开全文
  • JS数组

    2016-09-18 13:43:29
    来源《JavaScript权威指南》 ... ...(1)JS数组是无类型的:数组元素可以是任意类型,并且同一个数组中的不同元素也可能有不同的类型。...(2)JS数组的索引是基于0 的32位数值。...(4)JS数组可能是稀疏

    来源《JavaScript权威指南》




    (1)JS数组是无类型的:数组元素可以是任意类型,并且同一个数组中的不同元素也可能有不同的类型。
    (2)JS数组的索引是基于0 的32位数值。
    (3)JS数组是动态的,长度会根据需要动态增长或缩减。
    (4)JS数组可能是稀疏的:数组元素的索引不一定要连续,他们之间可以有空缺。
    (5)JS数组是JS对象的特殊形式。
    (6)JS数组继承自 Array.prototype中的属性,它定义了一套丰富的数组操作方法。

    一、创建数组
    (1)数组直接量[ ]
    如果省略数组直接量中的某个值,省略的元素将被赋予undefined值。
    允许有可选的结尾的逗号,故[ , , ]只有两个元素而非三个。

    (2)构造函数创建数组
    var a = new Array(); //空数组
    var a = new Array(10); //指定长度为10
    var a = new Array(5, 4, 3, 2, 1, "testing, testing"); //指定元素

    二、数组元素的读和写
    使用[ ]
    注意:可以使用负数或者非整数来索引数组。这时候,数值转换成字符串,字符串作为属性名来用。


    三、稀疏数组
    四、数组长度length
    (1)数组长度会自动增加。
    (2)设置length属性为一个小于当前长度的非负整数n时,当前数组中的那些索引值大于或者等于n的元素将从中删除。
    (3)可以使用Object.defineProperty()设置数组的length属性为只读。

    五、数组元素的添加和删除
    Array 对象方法
    方法 描述
    concat() 连接两个或更多的数组,并返回结果。
    join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
    pop() 删除并返回数组的最后一个元素
    push() 向数组的末尾添加一个或更多元素,并返回新的长度。
    reverse() 颠倒数组中元素的顺序。
    shift() 删除并返回数组的第一个元素
    slice() 从某个已有的数组返回选定的元素
    sort() 对数组的元素进行排序
    splice() 删除元素,并向数组添加新元素。
    toSource() 返回该对象的源代码。
    toString() 把数组转换为字符串,并返回结果。
    toLocaleString() 把数组转换为本地数组,并返回结果。
    unshift() 向数组的开头添加一个或更多元素,并返回新的长度。
    valueOf() 返回数组对象的原始值

    六、数组遍历
    (1)使用优化的for循环
    for(var i = 0, len = arr.length; i < len; i++) {
    //操作
    }
    for(var i = 0, len = arr.length; i < len; i++) {
    if( !arr[i] ) continue; //跳过null、(undefined和不存在的元素)
    //循环体
    }
    for(var i = 0, len = arr.length; i < len; i++) {
    if( arr[i] == undefined ) continue; //跳过(undefined和不存在的元素)
    //循环体
    }
    for(var i = 0, len = arr.length; i < len; i++) {
    if( ! (i in arr) ) continue; //跳过 不存在的元素
    //循环体
    }

    (2)使用for/in循环处理稀疏数组。
    for(var index in sparseArray) {
    var value = sparseArray[index];
    //此处可以使用索引和值做事情
    }
    注意:使用for/in循环能够枚举继承的属性名。‘
    过滤方法:
    for (var i in a) {
    if( !a.hasOwnProperty(i)) continue; //跳过继承的属性
    //循环体
    }

    (3)使用forEach()
    var data = [1,2,3,4,5];
    var sum = 0;
    data.forEach(function(x) {
    sum += x;
    });
    console.log(sum);

    七、多维数组 matrix[x][y]
    八、数组方法
    在Array.prototype中定义了一些操作数组的方法,他们可以被任何数组使用。

    九、ECMAScript 5中的数组方法
    写在前面:每个方法的第一个参数都是一个函数,函数中最多有三个参数:s数组元素、元素的索引、数组本身。
    (1)forEach( )
    从头至尾遍历数组,为每个数组元素调用指定的函数。

    (2)map()
    将调用的数组的每个元素传递给指定的函数,并返回一个数组,它包含该函数的返回值。

    (3)filter()
    该方法返回的数组元素是调用的数组的一个子集。

    (4)every()和some()
    用来数组的逻辑判定:他们对数组元素应用指定的函数进行判定,返回true或者false。



    (5)reduce()和reduceRight()
    使用指定的函数将数组元素进行组合,生成单个值。 使用例子??

    (6)indexOf()和lastIndexOf()
    搜索整个数组中具有给定值的元素,返回找到的第一个元素的索引,如果没有找到返回-1。
    indexOf()正向,lastIndexOf()反向。


    十、数组类型
    判断是不是数组的方法:
    ECMAScript 5 中使用Array.isArray( )判断。
    例子:






    展开全文
  • js 数组

    千次阅读 2011-10-11 00:56:59
    数组声明方式: var empty=[]; var primes=[2,3]; var misc=[1.1,true,'a']; 一个数组的直接量中 的值不一定要求是个静态量,它可以是任意表达式: var base=1; var table=[base,base+1]

    数组声明方式:

    var empty=[];

    var primes=[2,3];

    var misc=[1.1,true,'a'];

    一个数组的直接量中 的值不一定要求是个静态量,它可以是任意表达式:

    var base=1;

    var table=[base,base+1];

    也可以声明内容是undefined的数组

    var undefs=[,,];

    数组也可以用构造函数来创建:

    var a = new Array();  //效果等同于[],空数组

    var b = new Array(9);//长度为9的数组

    var c = new Array(5,4,3,'test',true);


    访问数组元素a[0]。注意数组的下标必须是0到2G之间的正整数,否则这个下标会自动转换成字符串,成为关联数组访问属性。说到这里,数组其实是一种特殊的对象,所以呢数组也有属性。假设a是个数组,那么a['hello']访问的是a中的hello属性。这个特点很有意思。


    给数组添加新元素

    js的数组可以具有任意个数的元素,即可以在任何时刻改变元素的个数。比如我要添加一个新元素,只要a[8]=10;这样就加上去了。在js中数组是稀疏的,意味着数组的下标不必是连续的,只有那些真正存储在数组中的元素才能够由js实现分配到内存。假设a中只有下标为1和1000两个元素,那么js解释器就只给1和1000两个元素分配内存。

    还有一个比较怪异的用法,我称之为使用数组下标的语法来给一个对象属性赋值,汉译本原文是数组元素也可以被添加到对象中:

    var c = new Cirle(1,2,3);

    c[0]="hello";

    这样的效果只不过是给C对象又定义了一个新的名字叫"0"的属性,c并不会成为数组。


    删除数组元素:

    delete运算符把一个数组元素设置为undefined,但是元素本身还是继续存在的。要真正的删除该元素,以使下标位置高于它的所有元素都向下迁移到较低的下标位置,那么必须使用一个数组方法。Array.shift()方法删除数组的第一个元素,Array.pop()方法删除掉最后一个元素,Array.splice()从一个数组中删除一个连续范围内的元素。详细使用以后再说。

    数组的长度:

    数组长度存储在数组的length属性中。它用来说明这个数组包含的元素个数。但是!之前说过js的数组是稀疏的,也就是下标不一定是连续的。比如:

    var a = new Array(1,2);

    a[10]=3;

    alert(a.length);

    结果是11 。但是在内存中这个数组只存储了3个元素。所以唯一影响length的值的因素就是数组的最大下标,length是数组的最大下标+1。


    遍历数组:

    通常:

    var a=[1,2];

    for(var i=0;i<a.length;i++){
            alert(a[i]);    
        }

    但是如果这个数组的元素不是连续的,比如在a声明之后又有一句a[5]=0;那么循环会执行6次,有三个undefined。如果只想给那些定义过的元素循环,只需要在for中增加一个判断条件if(a[i])


    截断或增长数组

    数组的length既可以读也可以写。如果给length设置了一个比它当前值小的值,那么数组将会被截断。这个长度之外的元素都会被抛弃,它们的值也就丢失了。

    如果给length设的值比当前值大,那么新的、未定义的元素会被加到数组末尾。  尽管可以使用数组下标的语法来给一个对象属性赋值(汉译原文是尽管可以将对象赋给数组元素,牛头不对马嘴),但是对象没有length属性。因此length属性成了数组最重要的特性,这使得它有别于其他对象的特性。


    多维数组

    因为js数组的元素可以是数组,这样也就成了多维数组。访问多维数组语法跟java是一样的。比如a[i][j];

    展开全文
  • js数组去重的10种方法

    万次阅读 多人点赞 2018-08-07 20:23:34
    Methods 1: 思路:定义一个新数组,并存放原数组的第一个元素,然后将元素组一一和新数组的元素对比,若不同则存放在新数组中。 function unique(arr) { let newArr = [arr[0]]; for (let i = 1; i &lt; ...

    Methods 1: 思路:定义一个新数组,并存放原数组的第一个元素,然后将元素组一一和新数组的元素对比,若不同则存放在新数组中。

            function unique(arr) {
                let newArr = [arr[0]];
                for (let i = 1; i < arr.length; i++) {
                    let repeat = false;
                    for (let j = 0; j < newArr.length; j++) {
                        if (arr[i] === newArr[j]) {
                            repeat = true;
                            break;
                        }else{
                            
                        }
                    }
                    if (!repeat) {
                        newArr.push(arr[i]);
                    }
                }
                return newArr;
            }
    
            console.log(unique([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]
    

    Methods 2: 思路:先将原数组排序,在与相邻的进行比较,如果不同则存入新数组。

            function unique2(arr) {
                var formArr = arr.sort()
                var newArr=[formArr[0]]
                for (let i = 1; i < formArr.length; i++) {
                    if (formArr[i]!==formArr[i-1]) {
                        newArr.push(formArr[i])
                    }
                }
                return newArr
            }
            console.log(unique2([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3,  4,5, 6, 7]

     Methods 3: 利用对象属性存在的特性,如果没有该属性则存入新数组。

            function unique3(arr) {
                var obj={}
                var newArr=[]
                for (let i = 0; i < arr.length; i++) {
                    if (!obj[arr[i]]) {
                        obj[arr[i]] = 1
                        newArr.push(arr[i])
                    }   
                }
                return newArr
            }
            console.log(unique2([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]

    Methods 4: 利用数组的indexOf下标属性来查询。

            function unique4(arr) {
                var newArr = []
                for (var i = 0; i < arr.length; i++) {
                    if (newArr.indexOf(arr[i])===-1) {
                        newArr.push(arr[i])
                    }
                }
                return newArr
            }
            console.log(unique4([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]

    Methods 5: 利用数组原型对象上的includes方法。

            function unique5(arr) {
                var newArr = []
                for (var i = 0; i < arr.length; i++) {
                    if (!newArr.includes(arr[i])) {
                        newArr.push(arr[i])
                    }
                }
                return newArr
            }
            console.log(unique5([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]

    Methods 6: 利用数组原型对象上的 filter 和 includes方法。

            function unique6(arr) {
                var newArr = []
                newArr = arr.filter(function (item) {
                    return newArr.includes(item) ? '' : newArr.push(item)
                })
                return newArr
            }
            console.log(unique6([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]

    Methods 7: 利用数组原型对象上的 forEach 和 includes方法。

              function unique7(arr) {
                let newArr = [];
                arr.forEach(item => {
                    return newArr.includes(item) ? '' : newArr.push(item);
                });
                return newArr;
            }
            console.log(unique7([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 4, 5, 6, 7]

    Methods 8: 利用数组原型对象上的 splice 方法。

            function unique8(arr) {
                var i,j,len = arr.length;
                for (i = 0; i < len; i++) {
                    for (j = i + 1; j < len; j++) {
                        if (arr[i] == arr[j]) {
                            arr.splice(j, 1);
                            len--;
                            j--;
                        }
                    }
                }
                return arr;
            }
            console.log(unique8([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));

    Methods 9: 利用数组原型对象上的 lastIndexOf 方法。

            function unique9(arr) {
                var res = [];
                for (var i = 0; i < arr.length; i++) {
                    res.lastIndexOf(arr[i]) !== -1 ? '' : res.push(arr[i]);
                }
                return res;
            }
            console.log(unique9([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]

    Methods 10: 利用 ES6的set 方法。

            function unique10(arr) {
                //Set数据结构,它类似于数组,其成员的值都是唯一的
                return Array.from(new Set(arr)); // 利用Array.from将Set结构转换成数组
            }
            console.log(unique10([1, 1, 2, 3, 5, 3, 1, 5, 6, 7, 4]));
            // 结果是[1, 2, 3, 5, 6, 7, 4]

     

    展开全文
  • JS数组遍历的几种方法

    万次阅读 多人点赞 2019-04-27 08:51:25
    for     最简单的一种循环遍历方法,也是使用频率最高的一种,可优化 var arr = [1, 2, 3, 4, ...    优化:使用临时变量,将长度缓存起来,避免重复获取数组长度,当数组较大时优化效果才会比较明显 var...
  • 当用到.net 时,很多新手都为如何解决.cs文件里数组赋值给.aspx中js数组的问题。我也是百度了N久,结果没有特别明确的答案,然后问了专业人士,又自己实践了一下,才搞出来的。现在给大家一个详细的例子来说明下这个...
  • js数组简单去重,js数组根据对象中的元素去重
  • js数组删除(splice和delete)

    万次阅读 多人点赞 2018-01-17 22:34:57
    今天用到了数组的删除,分别使用了splice和delete方法,记录一下,方便下次查找。原数组是一个关联数组,如var test=[];test[1]={name:'1',age:1};test[2]={name:'2',age:2};test[4]={name:'3',age:3};console.log...
  • 1、js数组往队尾添加数据可以用数组API Array.prototype.push 可以往数组尾部添加元素 2、js数组往队尾添加数据可以用数组API  Array.prototype.pop 可以把数组尾部的元素 弹出 3、有时候,我们需要从队头...
  • ``` var arrName=new Array( String[] name=(String[])request.getAttribute("arrName"); out.print(name[0]); System.out.println(name[0]);...java数组name[]中确认有值,但js数组arrName[]里没有
  • 深入理解js数组自定义排序sort

    万次阅读 2020-07-23 11:40:02
    定义和用法 sort() 方法用于对数组的元素进行排序。 语法 arrayObject.sort(function(nextValue,currentValue){ // code … }); 案例 var arr = [5,4,3,2,1,6,7,8,9];...// 可以看到第一次赋值结果是a = 4,b = 5 ...
  • 微信小程序开发交流qq群 173683895 承接微信小程序开发。...js数组简单去重 var arr1 = [1, 2, 3, 4, 5, 6, 3, 4, 3]; function arrayUnique1(arr) { var arr1 = [], obj = {}; fo...
  • js数组 合并内部数组

    2016-11-17 09:29:18
    var arr=[[7,3],[8,4],[9,6]]; console.log( [].concat.apply([],arr) );
  • 全国城市js数组

    热门讨论 2007-07-06 13:07:13
    全国城市省份 js 下拉列表框.
  • JS 数组数组对象的合并去重方法

    万次阅读 2018-09-03 11:31:08
    这次对数组的操作,我们使用es6的新语法来完成,所以在看下边代码之前,我们要了解我们下边要用到的es6中的set集合,和for...of 方法: 首先介绍set集合: ES6提供了新的数据结构Set,它类似于数组,但是成员的值都...
  • js数组合并

    万次阅读 2018-07-12 15:14:46
    var a = [1,2,3]; var b=[4,5] a = a.concat(b); console.log(a); //此处输出为 [1, 2, 3 ,4 ,5]
  • Js 数组筛选重复项

    万次阅读 2018-04-09 14:37:16
    js数组去重复:Array.prototype.distinct = function () { var arr = this, result = [], i, j, len = arr.length; for (i = 0; i &lt; len; i++) { for (j = i + 1; j &...
  • js数组转为json数组

    万次阅读 2018-05-24 22:40:56
    function agree(){ var ids = []; var rows = $('#signAgainReq').datagrid('getSelections'); for(var i=0,len=rows.length; i&lt;len; i++){ var signAgai...
  • var arrName=new Array( String[] name=(String[])request.getAttribute("arrName"); out.print(name[0]); System.out.println(name[0]);... 已确认数组name[]中有值,但js数组arrName中没有值
  • js数组常用方法

    万次阅读 多人点赞 2018-12-26 15:04:25
    1.join() (数组转字符串) 数组转字符串,方法只接收一个参数:即默认为逗号分隔符()。 &lt;script&gt; var arr=[1,2,3,4]; console.log(arr.join()); //1,2,3,4 console.log(arr.join(":&...
  • Js 数组转JSON格式

    万次阅读 2019-07-01 10:01:30
    //JSON.stringify() 不能转下标非1,2,3这种数字的数组, //所以采用新建对象的方式添加数据 var products={}; products['productid']='32'; products['name']='手机'; arrays.push(products); products['...
  • 下面总结几种js数组和对象深浅拷贝的几种方式: 一、es5实现数组和对象的浅拷贝与深拷贝 1.数组和对象浅拷贝: function shallowCopy(source){ if (typeof source !== 'object') { throw TypeError('the ...
  • js数组转类数组

    2019-05-11 09:14:44
    let arr4=[false,true,false]; console.log(Object.assign({},arr4))
  • js数组方法大全

    万次阅读 多人点赞 2018-10-18 16:09:31
    很早之前就想整明白JS到底有多少操作数组的方法,是怎么使用的,今天正好找到了个比较好的总结,分享给大家 原文地址:https://www.cnblogs.com/obel/p/7016414.html JavaScript中创建数组有两种方式 (一)使用 ...
  • js数组去重,能用几种方法实现?

    万次阅读 2019-11-03 22:03:37
    1.使用es6 set方法 […new Set(arr)] let arr = [1,2,3,4,3,2,3,4,6,7,6]; let unique = (arr)=>...2.利用新数组indexOf查找 indexOf() 方法可返回某个指定的元素在数组中首次出现的位置。如果没有就返回-1。...
  • js 数组深度拷贝详解

    万次阅读 2019-08-23 10:29:09
    js 数组深度拷贝详解 1.我们已经知道的深拷贝和浅拷贝的区别,在于,深拷贝是拷贝值的同时拥有一个新的存储地址,而浅拷贝只是拷贝了值,而存储地址不变;这样会导致的问题是修改拷贝的值,会同时修改原数组; 但是...
  • php数组转js数组

    千次阅读 2018-03-09 10:04:13
    var min_arr = &lt;?php echo json_encode($examination['user_minday']) ?&gt;;var max_arr = &lt;?php echo json_encode($examination['user_maxday']) ?&gt;;简单粗暴
  • ViewBag 数组js 数组

    千次阅读 2017-01-17 12:00:18
    后端代码: 前端页面代码:

空空如也

1 2 3 4 5 ... 20
收藏数 59,979
精华内容 23,991
关键字:

js数组