JavaScript集合的问题

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (11)

关于noobie问题。你们能解释一下吗,有什么区别:

1. var a = [];
   a['b'] = 1;

2. var a = {};
   a['b'] = 1;

提问于
用户回答回答于

字面

[]{}分别被称为阵列和对象文字。

var x = [] 是简短的 var x = new Array();

并且var y = {}是简短的var y = new Object();

数组

数组是具有长度属性的结构。您可以通过数字索引访问值。

var x = [] or var x = new Array();
x[0] = 'b';
x[1] = 'c';

如果你想列出你所做的所有属性:

for(var i = 0; i < x.length; i++)
console.log(x[i]);// numeric index based access.

性能技巧和陷阱

1.内部缓存长度属性

标准数组迭代:

for (var i = 0; i < arr.length; i++) {
    // do stuff
};

鲜为人知的事实:在上述场景中,该arr.length属性在for循环的每一步都被读取。就像您在那里致电的任何功能一样:

for (var i = 0; i < getStopIndex(); i++) {
     // do stuff
};

这无缘无故地降低了性能。缓存内部缓存:

for (var i = 0, len = arr.length; i < len; i++) {
     // enter code here
};

2.不要在构造函数中指定数组长度。

// doing this:
var a = new Array(100);
// is very pointless in JS. It will result in an array with 100 undefined values.

// not even this:
var a = new Array();
// is the best way.

var a = [];
// using the array literal is the fastest and easiest way to do things.

数组定义的测试用例可以在这里找到

3.避免使用Array.prototype.push(arr.push)

如果你正在处理大型集合,则直接分配比使用该Array.prototype.push();方法要快。

myArray[i] = 0;myArray.push(0);根据jsPerf.com 测试用例,速度比它快。

4.将数组用于关联赋值是错误的。

它工作的唯一原因是因为Array扩展Object了JS语言核心内部的类。例如,您可以使用a Date();RegEx();object。它不会有所作为。 x['property'] = someValue 必须始终与对象一起使用。

var x = [];
console.log(x.prototype.toString.call);

会输出: [object Array]

这揭示了核心语言的“类”继承模式。

var x = new String();
console.log(x.prototype.toString.call);

会输出[object String]

5.从数组中获取最小值和最大值。

一个鲜为人知的但非常强大的技巧:

function arrayMax(arr) {
    return Math.max.apply(Math, arr);
};

, 分别:

function arrayMin(arr) {
    return Math.min.apply(Math, arr);
};

对象

对于一个对象,你只能这样做:

var y = {} 要么 var y = new Object();

y['first'] = 'firstValue'y.first = 'firstValue'你无法用数组做同样的事情。对象设计用于通过String键进行关联访问。

迭代就是这样的:

for (var property in y) {
    if (y.hasOwnProperty(property)) {
        console.log(y.property);
    };
};

性能技巧和陷阱

1.检查一个对象是否有属性。

大多数人使用Object.prototype.hasOwnProperty。不幸的是,这往往会导致错误的结果,导致意想不到的错误。

这是一个很好的方法来做到这一点:

function containsKey(obj, key) {
    return typeof obj[key] !== 'undefined';
};

2.更换开关语句。

其中一个简单但有效的JS技巧是switch替换。

switch (someVar) {
    case 'a':
        doSomething();
        break;
    case 'b':
        doSomethingElse();
        break;
    default:
        doMagic();
        break;
};

在大多数JS引擎中,上述过程非常缓慢。当你看到三种可能的结果时,它没有什么区别,但如果你有几十或几百个呢?

以上可以很容易地用一个物体代替。不要添加尾随(),这不是执行函数,而是简单地存储对它们的引用:

var cases = {
    'a': doSomething,
    'b': doSomethingElse,
    'c': doMagic
};

而不是switch

var x = ???;
if (containsKey(cases, x)) {
    c(x);
} else {
    console.log("I don't know what to do!");
};

3.深入克隆变得容易。

function cloneObject(obj) {
   var tmp = {};
   for (var key in obj) {
       tmp[key] = fastDeepClone(obj[key];
   };
   return tmp;
}

function cloneArr(arr) {
   var tmp = [];
   for (var i = 0, len = arr.length; i < len; i++) {
     tmp[i] = fastDeepClone(arr[i]);
   }
   return tmp;
}


function deepClone(obj) {
   return JSON.parse(JSON.stringify(obj));
};

function isArray(obj) {
   return obj instanceof Array;
}

function isObject(obj) {
  var type = typeof obj;
  return type === 'object' && obj !== null || type === 'function';
}

function fastDeepClone(obj) {
  if (isArray(obj)) {
    return cloneArr(obj);
  } else if (isObject(obj)) {
    return cloneObject(obj);
  } else {
    return obj;
  };

用户回答回答于

一组对象?使用这个符号(JavaScript数组):

var collection = [ {name:"object 1"} , {name:"object 2"} , {name:"object 3"} ];

为你的收藏放入新元素:

collection.push( {name:"object 4"} );

扫码关注云+社区