for...of是es6引入的新遍历方式，使用的是迭代器，其原理相当于：

var myObject = {

a: 2,

b: 3

};

Object.defineProperty( myObject, Symbol.iterator, {

enumerable: false,

writable: false,

configurable: true,

value: function() {

var o = this;

var idx = 0;

var ks = Object.keys( o );

return {

next: function() {

return {

value: o[ks[idx++]],

done: (idx > ks.length)

};

}

};

}

} );

// 手动遍历 myObject

var it = myObject[Symbol.iterator]();

var x = it.next();

while(!x.done){

console.log(x.value);;

x = it.next();

}

'use strict';

let obj1 = { a: 0 , b: { c: 0, d:{ee: 323 }}};

let obj2 = Object.assign({}, obj1);

console.log(JSON.stringify(obj2));

// 深拷贝

obj1.a = 1;

console.log(JSON.stringify(obj1));

console.log(JSON.stringify(obj2));

// 深拷贝

obj2.a = 2;

console.log(JSON.stringify(obj1));

console.log(JSON.stringify(obj2));

// 以下两个例子标明除了最外一层，里面的对象都是浅拷贝

obj1.b.c = 3;

console.log(JSON.stringify(obj1));

console.log(JSON.stringify(obj2));

obj2.b.c = 5;

console.log(JSON.stringify(obj1));

console.log(JSON.stringify(obj2));

obj1.b.d.ee = 988;

console.log(JSON.stringify(obj1));

console.log(JSON.stringify(obj2));

obj2.b.d.ee = 123;

console.log(JSON.stringify(obj1));

console.log(JSON.stringify(obj2));

function Person(){

}

Person.prototype = {

name : "Nicholas",

age : 29,

job: "Software Engineer",

sayName : function () {

alert(this.name);

}

};

此时constructor 属性不再指向 Person,而是指向object :

var friend = new Person();

alert(friend instanceof Object); //true

alert(friend instanceof Person); //true

alert(friend.constructor == Person); //false

alert(friend.constructor == Object); //true

若构造函数很重要则可写成 :

( 此时constructor 的 Enumerable 会被设置为true )

Person.prototype = {

constructor : Person,

name : "Nicholas",

age : 29,

job: "Software Engineer",

sayName : function () {

alert(this.name);

}

};

默认情况下，原生的 constructor 属性是不可枚举的，因此如果你使用兼容 ECMAScript 5 的 JavaScript 引擎，可以试一试Object.defineProperty() :

//重设构造函数，只适用于 ECMAScript 5 兼容的浏览器

Object.defineProperty(Person.prototype, "constructor", {

enumerable: false,

value: Person

});

function foo(a) {

var b;

console.log( a + b );

b = a;

}

foo( 2 );

这是一个“未声明”的变量，因为在任何相关的作用域中都无法找到它。在所有嵌套的作用域中遍寻不到所需的变量，引擎就会抛出 ReferenceError 异常

栗子1：

function fn() {

return 20;

}

console.log(fn + 10);

栗子2：

function fn() {

return 20;

}

fn.toString = function() {

return 10;

}

console.log(fn + 10); // 输出结果是多少？

栗子3：

function fn() {

return 20;

}

fn.toString = function() {

return 10;

}

fn.valueOf = function() {

return 5;

}

console.log(fn + 10);

console.log(NaN == NaN); // false

console.log(NaN === NaN); // false

alert(isNaN(true)); //false（可以被转换成数值 1）

1. null 不是空对象指针，而是基本数据类型，故有：

typeof(null) // object

在 JavaScript 中二进制前三位都为 0 的话会被判

断为 object 类型， null 的二进制表示是全 0，自然前三位也是 0，所以执行 typeof 时会返回“object”

2. undefined 派生自 null

console.log(null == undefined); //true

console.log(null === undefined); //false

都是为了改变函数执行上下文

1. 改变this指针，第一个参数都是this要指向的对象，也就是想指定的上下文；

2. 借用其他对象的方法

下面就借用一道面试题，来更深入的去理解下 apply 和 call 。

定义一个 log 方法，让它可以代理 console.log 方法，常见的解决方法是：

function log(msg)　{

console.log(msg);

}

log(1); //1

log(1,2); //1

上面方法可以解决最基本的需求，但是当传入参数的个数是不确定的时候，上面的方法就失效了，这个时候就可以考虑使用 apply 或者 call，注意这里传入多少个参数是不确定的，所以使用apply是最好的，方法如下：

function log(){

console.log.apply(console, arguments);

};

log(1); //1

log(1,2); //1 2

接下来的要求是给每一个 log 消息添加一个"(app)"的前辍，比如：

log("hello world"); //(app)hello world

该怎么做比较优雅呢?这个时候需要想到arguments参数是个伪数组，通过 Array.prototype.slice.call 转化为标准数组，再使用数组方法unshift，像这样：

function log(){

var args = Array.prototype.slice.call(arguments);

args.unshift('(app)');

console.log.apply(console, args);

};

foo();

function foo() {

console.log( a ); // undefined

var a = 2;

}

函数声明会被提升，但是函数表达式却不会被提升。

foo(); // 不是 ReferenceError, 而是 TypeError!

var foo = function bar() {

// ...

};

foo(); // 1

var foo;

function foo() {

console.log( 1 );

}

foo = function() {

console.log( 2 );

};

会输出 1 而不是 2 ！这个代码片段会被引擎理解为如下形式：

function foo() {

console.log( 1 );

}

foo(); // 1

foo = function() {

console.log( 2 );

};

注意， var foo 尽管出现在 function foo()... 的声明之前，但它是重复的声明（因此被忽

略了），因为函数声明会被提升到普通变量之前。

foo(); // "b"

var a = true;

if (a) {

function foo() { console.log("a"); }

}

else {

function foo() { console.log("b"); }

}

以同步方式加载模块，主要用在后端。

var clock = require('clock');

clock.start();

这种写法适合服务端，因为在服务器读取模块都是在本地磁盘，加载速度很快。但是如果在客户端，加载模块的时候有可能出现“假死”状况。