精华内容
下载资源
问答
  • var person={name:"wang"}; var people=[{name:"wang"}]; var morepeople=[person]; console.log(morepeople==people) //false 为什么people和morepeople的值不想等
  • 数组和数组

    千次阅读 2018-06-10 15:04:00
    数组和数组的转化类数组和数组的区别

    什么是类数组对象 ArrayLike

    • 拥有length属性,其它属性(索引)为非负整数(对象中的索引会被当做字符串来处理,这里你可以当做是个非负整数串来理解)
    • 不具有数组所具有的方法
    //类数组示例
    var a = {'1':'gg','2':'love','4':'meimei',length:5};
    Array.prototype.join.call(a,'+');//'+gg+love++meimei'
    
    //非类数组示例
    var c = {'1':2};   //没有length属性就不是类数组

    javascript中常见的类数组有 arguments对象和 DOM方法的返回结果。比如 document.getElementsByTagName()


    判断一个对象是否属于类数组

    function isArrayLike(o) {
        if (o &&                                // o is not null, undefined, etc.
            typeof o === 'object' &&            // o is an object
            isFinite(o.length) &&               // o.length is a finite number
            o.length >= 0 &&                    // o.length is non-negative
            o.length===Math.floor(o.length) &&  // o.length is an integer
            o.length < 4294967296)              // o.length < 2^32
            return true;                        // Then o is array-like
        else
            return false;                       // Otherwise it is not
    }


    区别 数组和类数组对象

    ① instanceof

    ② constructor

    ③ toString()

    ④ ES 提供的方法 isArray()

    <!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    </head>
    <body>
    	<ul id="list">
    		<li>1</li>
    		<li>2</li>
    		<li>3</li>
    		<li>4</li>
    		<li>5</li>
    		<li>6</li>
    	</ul>
    	<script type="text/javascript">
    	// 获取所有li
    	var lis = document.getElementsByTagName("li");
    	// 定义数组
    	var arr = [];
    	// 请问有几种方式来区别类数组和数组?
    	
    	// typeof 用来判断类型 (是值类型还是引用类型) 返回的是一个字符串
    
    	// 第一种方式 instanceof
    	console.log(arr instanceof Array);
    	console.log(lis instanceof Array);
    
    	// 第二种方式
    	console.log(arr.constructor === Array)
    	console.log(lis.constructor === Array)
    
    	// 第三种方式
    	console.log(Object.prototype.toString.call(arr) === "[object Array]")
    	console.log(Object.prototype.toString.call(lis) === "[object Array]")
    
    	// 使用ES5提供的方法
    	console.log(Array.isArray(arr))
    	console.log(Array.isArray(lis))
    	</script>
    </body>
    </html>

    类数组转换成数组之后进行操作有什么优势

        由于类数组不具有数组所具有的操作数组的方法,讲类数组转换为数组之后就能调用如shift,unshift,splice,slice,concat,reverse,sort等这些强大的方法,方便快捷。

    类数组转换为数组方法

    Array.prototype.slice.call(arrayLike)

    首先Array.prototype.slice.call(arrayLike)的结果是将arrayLike对象转换成一个Array对象。所以其后面可以直接调用数组具有的方法

    Array.prototype.slice.call(arrayLike).forEach(function(element,index){  //可以随意操作每一个element了 })
    (1)Array.prototype.slice表示数组的原型中的slice方法。注意这个slice方法返回的是一个Array类型的对象。
    //slice的内部实现
    Array.prototype.slice = function(start,end){  
          var result = new Array();  
          start = start || 0;  
          end = end || this.length; //this指向调用的对象,当用了call后,能够改变this的指向,也就是指向传进来的对象,这是关键  
          for(var i = start; i < end; i++){  
               result.push(this[i]);  
          }  
          return result;  
     } 

    (2)能调用call的只有方法,所以不能用[].call这种形式,得用[].slice。而call的第一个参数表示真正调用slice的环境变为了arrayLike对象。所以就好像arrayLike也具有了数组的方法。

    将数组转换为参数列表(类数组)

    调用apply方法的时候,第一个参数是对象(this), 第二个参数是一个数组集合,   这里就说明apply的一个巧妙用法,可以将一个数组默认的转换为一个参数列表([param1,param2,param3] 转换为 param1,param2,param3), 这个如果让我们用程序来实现将数组的每一个项,来转换为参数的列表,可能都得费一会功夫,借助apply的这点特性,所以就有了以下高效率的方法。

    (1)Math.max 实现得到数组中最大的一项  

    因为Math.max 参数里面不支持Math.max([param1,param2]) 也就是数组 ,但是它支持Math.max(param1,param2,param3…),所以

    可以根据刚才apply的那个特点来解决 var max=Math.max.apply(null,array),这样轻易的可以得到一个数组中最大的一项  (apply会将一个数组装换为一个参数接一个参数的传递给方法)  

             这块在调用的时候第一个参数给了一个null,这个是因为没有对象去调用这个方法,我只需要用这个方法帮我运算,得到返回的结果就行,.所以直接传递了一个null。

     var arr = new Array(1,2,3,4,5);
     var max = Math.max.apply(null,arr);    //5

    (2)Array.prototype.push 可以实现两个数组合并

      同样push方法没有提供push一个数组,但是它提供了push(param1,param,…paramN);

    var arr1=new Array("1","2","3");   
    var arr2=new Array("4","5","6");

    如果我们要把 arr2展开,然后一个一个追加到arr1中去,最后让arr1=[“1”,“2”,“3”,“4”,“5”,“6”]
    arr1.push(arr2)显然是不行的,因为这样做会得到[“1”,“2”,“3”,[“4”,“5”,“6”]]

    我们只能用一个循环去一个一个的push(当然也可以用arr1.concat(arr2),但是concat方法并不改变arr1本身)

    var arrLen=arr2.length;
    for(var i=0;i<arrLen;i++){
        arr1.push(arr2[i]);
    }

    所以同样也可以通过apply来转换一下这个数组,即: 

    var arr1=new Array("1","2","3");   
    var arr2=new Array("4","5","6");   
    Array.prototype.push.apply(arr1,arr2);

    也可以这样理解,arr1调用了push方法,参数是通过apply将数组装换为参数列表的集合.。

    展开全文
  • lodash库数组和数组对象去重

    千次阅读 2021-01-08 18:06:26
    lodash库数组和数组对象去重 ###uniq(array) 创建一个去重后的array数组副本。使用了 SameValueZero 做等值比较。只有第一次出现的元素才会被保留。 参数 array (Array): 要检查的数组。 返回 (Array): 返回新的...

    lodash库数组和数组对象去重

    import { isEqual, uniqWith, uniqBy } from 'lodash'
    let arr = [
          {id: 1, name: 'sli', year: 2012},
          {id: 2, name: 'ap', year: 2015},
          {id: 1, name: 'alslion', year: 2012},
          {id: 3, name: 'pose', year: 2012},
          {id: 3, name: 'pose', year: 2012},
        ]
    console.log('原数组:', arr);
    console.log('根据id去掉相同的元素:', uniqBy(arr, 'id'));
    console.log('深检查数组每一项进行去重:', uniqWith(arr, isEqual));
    

    在这里插入图片描述

    展开全文
  • JavaScript伪数组和数组

    千次阅读 2021-05-04 12:07:46
    文章目录伪数组和数组对象与数组的关系什么是数组什么是伪数组二者区别小结 伪数组和数组 在JavaScript中,除了5种原始数据类型之外,其他所有的都是对象,包括函数(Function)。 对象与数组的关系 在说区别之前,...

    伪数组和数组

    在JavaScript中,除了5种原始数据类型之外,其他所有的都是对象,包括函数(Function)。

    对象与数组的关系

    在说区别之前,需要先提到另外一个知识,就是 JavaScript 的原型继承。
    所有 JavaScript 的内置构造函数都是继承自 Object.prototype
    在这个前提下,可以理解为使用 new Array()[] 创建出来的数组对象,都会拥有 Object.prototype 的属性值。

    var obj = {};// 拥有 Object.prototype 的属性值
    var arr = [];
    //使用数组直接量创建的数组,由于 Array.prototype 的属性继承自 Object.prototype,
    //那么,它将同时拥有 Array.prototype 和 Object.prototype 的属性值
    

    可以得到对象和数组的第一个区别:对象没有数组 Array.prototype 的属性值。

    什么是数组

    数组具有一个最基本特征:索引,这是对象所没有的,下面来看一段代码:

    var obj = {};
    var arr = [];
     
    obj[2] = 'a';
    arr[2] = 'a';
     
    console.log(obj[2]); // => a
    console.log(arr[2]); // => a
    console.log(obj.length); // => undefined
    console.log(arr.length); // => 3
    
    • obj[2]输出’a’,是因为对象就是普通的键值对存取数据
    • 而arr[2]输出’a’ 则不同,数组是通过索引来存取数据,arr[2]之所以输出’a’,是因为数组arr索引2的位置已经存储了数据
    • obj.length并不具有数组的特性,并且obj没有保存属性length,那么自然就会输出undefined
    • 而对于数组来说,length是数组的一个内置属性,数组会根据索引长度来更改length的值
    • 为什么arr.length输出3,而不是1
      • 在给数组添加元素时,并没有按照连续的索引添加,所以导致数组的索引不连续,那么就导致索引长度大于元素个数

    什么是伪数组

    1. 拥有 length 属性,其它属性(索引)为非负整数(对象中的索引会被当做字符串来处理,这里你可以当做是个非负整数串来理解)
    2. 不具有数组所具有的方法

    伪数组,就是像数组一样有 length 属性,也有 0、1、2、3 等属性的对象,看起来就像数组一样,但不是数组,比如:

    var fakeArray = {
      "0": "first",
      "1": "second",
      "2": "third",
      length: 3
    };
     
    for (var i = 0; i < fakeArray.length; i++) {
      console.log(fakeArray[i]);
    }
     
    Array.prototype.join.call(fakeArray,'+');
    

    常见的伪数组有:

    • 函数内部的 arguments
    • DOM 对象列表(比如通过 document.getElementsByTags 得到的列表)
    • jQuery 对象(比如 $("div")

    伪数组是一个 Object,而真实的数组是一个 Array。

    伪数组存在的意义,是可以让普通的对象也能正常使用数组的很多方法,比如:

    var arr = Array.prototype.slice.call(arguments);
     
    Array.prototype.forEach.call(arguments, function(v) {
      // 循环arguments对象
    });
    
    // push
    // some
    // every
    // filter
    // map
    // ...
    

    以上在借用数组的原型方法的时候都可以通过数组直接量来简化使用:

    var obj = {
      0: 'a',
      1: 'b',
      2: 'c',
      length: 3
    }
    
    ;[].push.call(obj, 'd')
    
    console.log([].slice.call(obj))
    
    ;[].forEach.call(obj, function (num, index) {
      console.log(num)
    })
    

    二者区别

    1.长度:

    • 真数组的长度是可变的
    • 伪数组的长度不可变

    2.方法的使用:

    • 真数组可以使用数组中的方法
    • 伪数组不可以使用数组中的方法

    小结

    • 对象没有数组 Array.prototype 的属性值,类型是 Object ,而数组类型是 Array
    • 数组是基于索引的实现, length 会自动更新,而对象是键值对
    • 使用对象可以创建伪数组,伪数组可以正常使用数组的大部分方法
    展开全文
  • 前后端数据交互无可避免处理数组,数组去重也是一个常用的方法,总结了两个方法: export default { /* 数组对象去重,例如 [ { id: 1, name: 'a' }, { id: 1, name: 'a' ...

    前后端数据交互无可避免处理数组,数组去重也是一个常用的方法,总结了两个方法:

    export default {
        /*
        数组对象去重,例如
        [
            {
                id: 1,
                name: 'a'
            },
            {
                id: 1,
                name: 'a'
            }
        ]
        */
        deteleObject(obj) {
            var uniques = [];
            var stringify = {};
            for (var i = 0; i < obj.length; i++) {
                var keys = Object.keys(obj[i]);
                keys.sort(function(a, b) {
                    return (Number(a) - Number(b));
                });
                var str = '';
                for (var j = 0; j < keys.length; j++) {
                    str += JSON.stringify(keys[j]);
                    str += JSON.stringify(obj[i][keys[j]]);
                }
                if (!stringify.hasOwnProperty(str)) {
                    uniques.push(obj[i]);
                    stringify[str] = true;
                }
            }
            uniques = uniques;
            return uniques;
        },
        /*
        数组去重 例如[1,2,3,1,2,5,6,7,8]
        */ 
        arrayDeduplication(list){
            let newArray = [...new Set(list)];
            return newArray
        }
    }

    这里要注意就是处理完会返回一个新数组,然后定义一个新的数组接收一下

    demo演示:

    作为一个走向成熟的前端工程师,后面会慢慢的封装一些方法方便使用

    展开全文
  • JavaScript中伪数组和数组以及转化 之前看到过一个经典的面试题 说如何将伪数组转成数 当时一脸懵逼 如今学会了高级JS然后再次看这个问题 好像没有想象中那么难。 伪数组和数组 在JavaScript中,除了5种原始数据...
  • 在JavaScript中,类数组和数组是两个不同的概念,同时也是需要区分清楚的。 数组我们都了解,是JavaScript中的一个引用类型,那类数组是什么呢? 类数组和数组之间的区别 类数组拥有length属性和索引,是object; ...
  • JavaScript中的伪数组和数组

    万次阅读 多人点赞 2018-12-04 14:37:34
    数组和数组 在JavaScript中,除了5种原始数据类型之外,其他所有的都是对象,包括函数(Function)。 对象与数组的关系 在说区别之前,需要先提到另外一个知识,就是 JavaScript 的原型继承。 所有 JavaScript 的...
  • 类数组定义 任何可迭代的结构,或者拥有length属性,其他属性(索引)为非负整数 ...类数组和数组的区别和联系 相同点: 都可用下标索引访问每个元素 都有length属性 不同点: 数组对象类型为Array,遍历数组可以用
  • 指针数组和数组指针

    2012-03-06 21:42:10
    指针数组和数组指针   这个问题大家应该都碰到过,指针数组和数组指针,刚开始看时觉得还是能看懂,但是过些时又搞混了,最后发现还是没有真正理解。 下面就简单说说这两个概念: 一:指针数组,...
  • // 转数 int nSize = array.size(); for (int i = 0; i ; ++i) { qDebug() (i).toObject().value("num").toString(); qDebug() (i).toObject().value("id").toString(); qDebug() (i).to...
  • 一文读懂JS伪数组和数组的区别

    千次阅读 2019-10-21 16:44:37
    数组和数组的区别伪数组常见的伪数组伪数组转换为真数组 伪数组 1、拥有length属性,其它属性(索引)为非负整数(对象中的索引会被当做字符串来处理,这里你可以当做是个非负整数串来理解) 2、不具有数组所具有的...
  • 数组和数组转换

    2019-11-29 17:22:53
    数组定义:简而言之就是一有序的数据集合,其索引为从0开始且自然增长的整数,其元素值可以是任何js数据!并且包含一个名为length的属性,该属性表示数组元素的个数! 类数组对象:1)它拥有length属性,其它属性...
  • 数组和数组的区别

    千次阅读 2019-04-10 15:46:09
    数组 拥有length属性,其它属性(索引)为非负整数(对象中的索引会被当做字符串来处理); 不具有数组所具有的方法; 类数组是一个普通对象,而真实的数组是Array类型。...类数组可以转换为数: /...
  • go语言跟c语言一样,指针数组和数组指针概念容易搞混,其实只要看后面的两字就行。 指针数组就是一个数组,数组里每一个元素是一个指针。 数组指针呢,则是一个指针,它是指向一个数组的地址。 package main ...
  • 指针数组和数组指针、动态数组

    千次阅读 2018-09-07 09:47:13
    普通的数组定义不允许提供未知长度,也就是说n必须是个常量,在程序运算中的来的n是不能用的,所以你无法用普通的静态方法来定义任意大小的数组,也就是数组的大小永远是一样的。动态的方法不一样,因为内存分配不...
  • JAVA数组和数组队列。

    2018-08-26 13:29:08
    1.数组 数组是一个容器,可以存储同一类型的N个数据。 数组是一种数据结构,是数据结构中访问速度最快的一种。 数组是直接通过下标进行定位的。 数组是属于引用数据类型(数组名中存储的是内存首地址)。 ...
  • 指针数组和数组指针的简单理解

    千次阅读 多人点赞 2019-06-04 16:48:29
    指针数组,重点在数组 数组指针,重点在指针 例子: include <iostream> using namespace std; int main() { int c[2][4]={1,2,3,4, 5,6,7,8}; int *a[4]; //指针数组 int (*b)[4]; //数组指针 b=c...
  • C++:引用的数组和数组的引用之间的区别?

    千次阅读 多人点赞 2019-03-02 17:13:14
    一、声明、定义和初始化 ...三、引用的数组和数组的引用之间的区别 首先,需要明确引用的概念,引用是对某个目标对象取了一个别名,对该引用的操作与对变量直接 操作的效果是一样的。 1、引用的数组:字面意思...
  • 数组是一个普通对象,而真实的数组是Array类型。 常见的类数组有: 函数的参数 arguments, DOM 对象列表(比如通过 document.querySelectorAll 得到的列表), jQuery 对象 (比如 $(“div”)). 类数组...
  • Js中的索引数组,关联数组,类数组对象 对象和数组 1.创建数组 1.1.数组字面量创建 var arr1=[1,2,3]; 1.2.调用构造函数创建(有3种调用方法) i.调用时没有参数 var arr=new Array(); 该方法创建一个没有任何元素...
  • Javascript不支持多维数组,但是因为数组里面可以包含对象数组也是一个对象),所以数组可以通过相互嵌套实现类似多维数组的功能 1.1 定义数组 声明有10个元素的数组 复制代码 代码如下: var a

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,958
精华内容 31,183
关键字:

对象数组和数组对象