1. 神乎其技的 + 号
//使用 `+` 运算符可以快速将一个字符串数值转化为数字
console.log(typeof '1'); //string
console.log(typeof +'1'); //number
//Date类型会转化为number类型的时间戳，精确到ms
console.log(+new Date()) //1484219585488
//相比这种方式转换时间戳简便，Date.parse()只精确到s，ms的位置都为0
console.log(Date.parse(new Date())) //'1484219585000'
//无法转换为有效的数字一般会得到NaN
console.log(+'abc') //NaN
console.log(+function(){}) //NaN
//数组有点奇特
console.log(+[1,2,3]); //NaN
console.log(+[]); //0
console.log(+[5]); //5
//这还就导致了
console.log(++[[]][+[]]+[+[]]) //10
//为什么呢？一脸懵逼的你一定愿意看看推导
+[] = 0
=> ++[[]][+[]]+[+[]] = ++[[]][0]+[0]
[[]][0] = []
=> ++[[]][0] = ++[] = [] + 1 = '' + '1' = '1'
//++运算符得到的结果一定是number，所以有必要用 + 号再一次转换类型
++[] = +( [] + 1 ) = +'1' = 1
=> 1 + [0] = '1' + '0' = '10'
2. 妙用数组length属性
var a = [1, 2, 3, 4];
console.log(a.length) //4
//清空数组
a.length = 0; //a = []
//截取数组
a.length = 2; //a = [1, 2]
//扩张数组，用undefined填充
a.length = 5; //a = [1, 2, 3, 4, undefined]
3. 两个数花式交换
//方案一
var a = 1, b =2;
a = [b, b = a][0];
console.log(a, b); //2 1
//方案二
var a = 1, b =2;
a = a ^ b;
b = a ^ b;
a = a ^ b;
console.log(a,b) //2 1
4. 在读取length的循环中缓存length
var a = [1, 2, 3];
for(var i = 0; i < a.length; i++){
console.log(a[i])
}
尽管上面的做法没有异议，但每次循环都会额外做一个计算数组length的操作，数组足够小的时候这当然没有任何问题，但当它足够大，它就会成为拖垮性能的一个元凶。假如你尝试过在java中处理一个超大文件的每一个字节时使用上面的做法，你可能会懂得它对性能的破坏力有多大。
必要的时候采用下面这种做法吧：
var a = [1, 2, 3];
for(var i = 0, len = a.length; i < len; i++){
console.log(a[i]);
}
5. 可动态指定地访问Object属性
var o = {
name : 'cmx',
age : 24
}
//可以这么访问一个key
console.log(o.name);
//还可以这么访问一个key
console.log(a['name']);
//再直白一点
var key = 'name';
console.log(a[key]);
看完你能知道应用场景吗？
6. 妙用And和Or
//设置变量的初始默认值
function(a){
a = a || '默认值';
}
//代替if语句，利用短路特性，如果a变量是有效值（非undefined、null、""、false、0等），执行方法dosomething
a && dosomething(a);
//同理，a为无效值时执行dosomething函数
a || dosomething();
7. 数组拼接
存在两种方式去拼接两个数组：
var a = [1,2];
var b = [3];
//生成一个新的数组，不破坏原数组
a = a.concat(b) //a=[1,2,3]
//以第一个参数数组作为this，第二个参数数组作为遍历参数，push进第一个数组，最终第一个数组为两个数组的拼接，第二个数组不改变
Array.prototype.push.apply(a, b) //a=[1,2,3] b=[3]
//相当于
a.push(b[0], b[1], b[2]..)
什么时候用哪种呢？concat由于生成新的数组，必然是占内存的，但它不限制合并数组大小。而第二种方法存在合并数组个数限制（实际上是函数的形参个数限制，不超过65536），内存则相对于concat减少了一个合并后数组的大小。性能上相差不多。
8. 两个操作符typeof跟instanceof
-
typeof判断变量的类型，为一元运算符 -
instanceof判断变量的实例（原型链），为二元运算符
用法上，
console.log(typeof {name:'chenmuxin'}) //'object'
console.log({name:'chenmuxin'} instanceof Object) //true
typeof返回的是一个全小写字符串，依据变量的类型可能会返回：
'object'、'number'、'string'、'undefined'、'function'、'boolean'、'symbol'
如你所见，不存在数组类型。数组返回的是'object'，不仅数组，所有诸如Date、RegExp都被作为object看待
'number'类型：
typeof 1
typeof(1) //也可以这样使用，类似java
typeof 3.1415 //js的number类型统一了整型浮点型等
typeof NaN //Not a number表示的是无穷和非数值，它是一个number类型
typeof Number(1) //Number类直接返回的类型也是number
'undefined'类型：
typeof undefined
typeof i_am_undeclared //一个未声明变量
var i_am_declared_but_undefined_value; //一个已声明但未赋值变量
typeof i_am_declared_but_undefined_value
最容易迷惑情形：
typeof new Number(1) //返回'object'，使用new操作符时，诸如String、Boolean等引用类返回的是object
typeof Number(1) //'number'
typeof null //返回'object'，js诞生之时起，null就是跟object同类型，这显然不合适。但es6的提案typeof null == 'null'被否决，所以目前都还只能这么认识它
typeof /a/ //正则在不同浏览器上可能有不同类型，可能是function，也可能是object，标准是object。判断正则应使用instanceof
使用instanceof时，首先要保证对象可以new，只有允许new才会存在所谓实例。所以想使用instanceof判断一个基本变量的类型是不可行的。
console.log(1 instanceof Number) //false
数组无法使用typeof来判断，但可以使用instanceof（一定场景下会失败，例如多重iframe）
console.log([1] instanceof Array) //true
当然也可以使用更稳妥的数组的方法：
console.log(Array.isArray([1])) //true
总结：像数组、正则等继承自Object但具体的对象（首先可以new），我们一般都可以用instanceof去判断。像很多基本变量以及它们的引用类型，我们就用typeof去判断。
9. in和for遍历
var a = [10,20,30];
var b = {name : 'cmx'}
//基本数组遍历
for(var i=0,length = a.length; i < length; i++){
console.log(a[i]);
}
//of运算符每次循环直接得到数组值
for(var i of a){
console.log(i);
}
//in运算符每次循环得到当前下标
for(var i in a){
console.log(a[i]);
}
//in运算符遍历对象时，每次得到对象的key
for(var i in b){
console.log(i);
console.log(b[i]);
}
存在一些特殊情况，in遍历时，不仅会把数组（或对象）的每一个下标（key）遍历出来，一旦像下面这样定义了原型属性或方法
Array.prototype.what = function(){ }
in遍历还会把它们一起遍历出来，这里得到一个what。如果没有作必要的判断往往会导致如下：
for(var i in a){
//打印a[what]出错
console.log(a[i]);
}
要么不使用原型直接添加的方式，而使用Object.defineProperty并设置可枚举属性为false。要么就in遍历数组时，都判断当前i是否为number类型：
var a = [1, 2, 3];
Array.prototype.cmx = 5;
for(var i in a){
//+i是因为i遍历出来的都是字符串形式。至于为什么不使用 i != NaN ，因为任意两个NaN不相等啊
if(!Number.isNaN(+i)){
console.log(i)
}
}
因为原型扩展是不允许添加一个number类型的，所以上面的做法成立。
Array.prototype.1 = 1 //error
或者使用通用的方法（同时适合数组和对象）
for(var i in a){
if(a.hasOwnProperty(i)){
console.log(a[i])
}
}
Object.prototype.hasOwnProperty()会忽略对象原型链上的属性和方法。
10. call和apply
我们先来看段代码：
function Chen(){
this.name = '老陈';
this.sayHello = function(hello){
console.log('我是老陈的方法');
console.log(hello + '， I am ' + this.name);
}
}
function Huang(){
this.name = '老黄';
this.sayHello = function(hello){
console.log('我是老黄的方法');
console.log(hello + '， I am ' + this.name);
}
}
var chen = new Chen();
chen.sayHello('你好'); //我是老陈的方法 你好， I am 老陈
var huang = new Huang();
chen.sayHello.call(huang,'Hello'); //我是老陈的方法 Hello， I am 老黄
chen.sayHello.apply(huang,['Hi']) //我是老陈的方法 Hi， I am 老黄
call和apply非常像，都是为一个函数指定上下文，并传入参数。唯一的区别在于参数参入的形式。
Function.prototype.call(thisObj, ...args)
Function.prototype.apply(thisObj[, argArray])
call()以thisObj作为上下文带上若干个指定的参数值调用某个函数或方法，参数必须展开。
apply()以thisObj作为上下文带上一个数组或累数组参数调用某个函数或方法，参数必须组合成一个数组。
由于只是形式不同，故以其中一个作为示例说明：
chen.sayHello.call(huang, 'Hello')
以huang作为上下文，调用chen的sayHello方法，由于chen.sayHello()调用的this.name已经被更改为huang.name，所以得到上面的执行结果。
用call或者apply来模拟一下继承：
function Boy(name, love){
this.name = name;
this.lova = love;
this.say = function(){
console.log('I am '+ name +'，I like '+ love +'，what about you?');
}
}
function BadBoy(name, love){
Boy.call(this, name, love);
this.do = function(){
console.log('I made a mistake!');
}
}
var badBoy = new BadBoy('张三','打架');
badBoy.say(); //I am 张三，I like 打架，what about you?
badBoy.do(); //I made a mistake!
var boy = new Boy('李四','学习');
boy.say(); //I am 李四，I like 学习，what about you?
boy.do(); //boy.do is not a function
（转载请注明出处，简书-沐心chen）
