Javascript集合

对不起，没问题。请您解释一下，以下两者的区别是什么：

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

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

---

我在互联网上找不到这么写的文章。

一组物品？使用此表示法（JavaScript数组）：

要将新元素放入集合，请执行以下操作：

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

---

在JavaScript中，所有对象都是。在第一种情况下，您创建了一个数组；在第二种情况下，您创建了一个也是数组的空对象：）

因此，在JS中，您可以像处理数组一样处理任何对象：

var a = {};
a["temp"] = "test";

作为目的：

var a = {};
a.temp = "test";

---

我将使用一组对象：

collection = [ 
    { "key":"first key", "value":"first value" }, 
    { "key":"second key", "value":"second value" } 
];

---

等

文字

[]

和

{}

分别称为数组和对象文本

var x=[]

是

var x=new Array（）的缩写

而
vary={}
是
vary=newobject（）的缩写

阵列

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

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.

这会无缘无故地降低性能。拯救内部缓存：

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

可以使用阵列定义的测试用例

3。避免使用Array.prototype.push（arr.push）

如果您处理的是大型集合，那么直接赋值比使用
Array.prototype.push（）更快方法

myArray[i]=0
比myArray.push（0）快，根据jsPerf.com

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

// 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.

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;
  };
};

它工作的唯一原因是
Array
扩展了JS语言核心中的
Object
类。您也可以使用
Date（）或
RegEx（）对象。这不会有什么不同。
x['property']=someValue
必须始终与对象一起使用

数组应该只有数字索引。请参阅，谷歌JS开发指南！避免（arr中的x）
循环或
arr['key']=5

这很容易备份，请查看示例

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

将输出：
[对象数组]

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

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

将输出
[对象字符串]

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

// 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.

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;
  };
};

一个鲜为人知但真正强大的技巧：

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

，分别为：

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

对象

对于对象，您只能执行以下操作：

vary={}
或
vary=newobject（）

y['first']='firstValue'
与
y.first='firstValue'
相同，这是数组无法实现的。对象设计用于与
字符串
键进行关联访问

迭代是这样的：

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

表演技巧和陷阱

1。检查对象是否具有属性。

// 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.

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;
  };
};

大多数人使用
Object.prototype.hasOwnProperty
。不幸的是，这常常会产生错误的结果，导致意外的错误

下面是一个很好的方法：

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

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.

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;
  };
};

一个简单但有效的JS技巧是
switch
replacement

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

在大多数JS引擎中，上面提到的速度非常慢。当你考虑三种可能的结果时，这并没有什么区别，但如果你有几十个或几百个呢

上述内容可以很容易地替换为对象。不要添加尾随的
（）
，这不是执行函数，而是简单地存储对它们的引用：

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

代替
开关
：

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

3。深度克隆变得容易。

// 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.

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;
  };
};

它们做同样的事情，您可以调用
s
和
s2
上的所有字符串方法。
然而：

在JS中，您可能会听到一切都是
对象
。这并不完全正确，尽管这是一个很容易犯的错误

实际上有两种类型，原语和对象，当您调用
s.indexOf（“c”）
时，JS引擎将自动将
s
转换为其非原语包装类型，在本例中是
对象字符串
，其中所有方法都在
字符串.prototype
上定义

这称为
自动装箱
。
Object.prototype.valueOf（obj）
方法是强制将强制转换从基本体转换为非基本体的一种方法。这与Java等语言为其自身的许多原语引入的行为相同，特别是对：
int
-Integer、
double
-double、
float
-float等

你为什么要在乎

简单：

function isString(obj) {
   return typeof obj === "string";
}
isString(s); // true
isString(s2); // false

因此，如果
s2
是使用
var s2=new String（“test”）
创建的，那么即使对于一个简单的类型检查，您也会得到一个假阴性。更复杂的对象本身也会带来严重的性能损失

正如一些人所说，这是一个微观优化，但结果确实非常显著，即使对于字符串初始化这样非常简单的事情也是如此。让我们从性能方面比较以下两种：

var s1 = "this_is_a_test" 

及

您可能会期望获得全面的匹配性能，但令人惊讶的是，使用
newstring
的后一个语句比第一个语句慢92%，这已被证明

功能

1。默认参数

|
操作符是最简单的默认方法。它为什么有效？因为真实和虚假的价值观

在逻辑条件下求值时，
未定义
和
空
值将自动转换为
假

一个简单的示例（代码）：

2。OO JS

要理解的最重要的事情是JavaScript
这个
对象不是不可变的。它只是一个可以很容易地更改的引用<
Size.prototype.area = function() {
   return this.width * this.height;
};

function Size2(width, height) {
   this.width = width;
   this.height = height;
   this.area = function() {
      return this.width * this.height;
   }
}

var s = new Size(5, 10);
var s2 = new Size2(5, 10);



var s3 = new Size2(5, 10);
var s4 = new Size(5, 10);
 // Looks identical, but lets use the reference equality operator to test things:
s2.area === s3.area // false
s.area === s4.area // true

Size.prototype.settings = {};

Size.prototype.x = 5; // won't be shared, because it's a primitive.
// see auto-boxing above for primitive vs non-primitive
// if you come from the Java world, it's the same as int and Integer.

var x = {
    doStuff: function(x) {
    },
    doMoreStuff: 5,
    someConstant: 10
}

var x = {
   width: 10,
   height: 5
}
var y = {
   width: 15,
   height: 10
}

   function() {
      // some computation
      var x = 10 / 2;
      var y = 5;
      return {
         width: x,
         height: y
      }
    }

function() {
    var x = 10 / 2;
    var y = 5;
    return new Size(10, 5);
};

function Thing(someParam) {
   this.someFn = function() {
     return someParam;
   }
}

function bindSomething(param) {
   someDomElement.addEventListener("click", function() {
     if (param) //do something
     else // do something else
   }, false);
}

/**
 * Adds a {@code getInstance} static method that always return the same instance
 * object.
 * @param {!Function} ctor The constructor for the class to add the static
 *     method to.
 */
function addSingletonGetter(ctor) {
  ctor.getInstance = function() {
    if (ctor.instance_) {
      return ctor.instance_;
    }
    return ctor.instance_ = new ctor;
  };
};

project.some.namespace.StateManager = function() {
   this.x_ = 5;
};
project.some.namespace.prototype.getX = function() { return x; }
addSingletonGetter(project.some.namespace.StateManager);

function Thing() {
   this.someMethod = function() {..}
}
// and then use it like this:
Thing.someMethod();

// This is the top of a JavaScript file.
var a = 5;
var b = 20;
var x = {};//blabla

// more code
function someFn() {..}

function test(someArgs) {
   var someMoreStuf = // a very big complex object;
}
test();

var x = 5;
var y = {..}; //etc;

var myProject = {};
myProject.settings = {};
myProject.controllers = {};
myProject.controlls.MainController = function() {
    // some class definition here
}

    function some(f){
var Object = {name: "Boo", age: "foo"}, key;
if(f == true){
   key = "name";
}else{
   key = "age";
}
 return Object[key];
}