六大类型

Undefined
Null
Bollean
String
Number
Object

对象类型

原生对象：

• 构造函数：Boolean, String, Number, Object, Function, Array, Date, RegExp, Error
• 对象: Math, JSON
  宿主对象: window, navigator, document
  浏览器扩展对象：
• ActiveXObject, XML, Debug, Script, VBArray
• 逐渐被弃用

隐式类型转换:

• Undefined转为Number为NAN
• 空字符串转为Boolean为false
• 所有的对象转为Boolean都是true

类型识别：

• typeof:
  • 判断基础类型，返回的是字符串
  • 如果是对象则返回'object'。
  • typeof null === 'object'
  • typeof Function === 'function'
• instanceof
  • 判断对象类型，可判断子类
  • 不能判别原始类型：1 instanceof Number === false
• Object.prototype.toString.call
  • 可以识别标准类型和内置对象类型
  • 不能识别自定义对象类型
  • Object.prototype.toString.call(123) === 'Number'
• constructor
  • 可以判别准备类型、内置对象类型、自定义对象类型
  • 不能判别null,Undefined
  • (1).constructor === Number

function getConstructorName(obj){
  return ( obj === undefined || obj === null )? obj+'' : obj.constructor.toString().match(/function\s*([^(]*)/)[1];
}

• getConstructorName(null) --> null
• getConstructorName(new Date()) --> 'Date'

函数

//函数声明
function foo(){}

//函数表达式
var foo = function(){};

//函数实例化
var foo = new Function('i','console.log(1);');

//变量、函数声明前置：

//function
console.log(foo);
//undefined
console.log(bar);

function foo(){}

var bar = function(){};

js作用域：对象、函数有独立作用域

函数调用方式

Function.prototype.apply(this, [])
Function.prototype.call(this, ...args)

//保存函数的参数，以便直接调用
var fooCopy = foo.bind(this, ..args);
fooCopy();

arguments

arguments是一个Array-like对象

闭包

• 相当于一个对象，内部可以维护成员变量和成员函数

原型vs类

• 类是抽象概念，java中用类构造对象。
• 原型是一个对象(Function)，js中用对象(Function)构造对象。

设置对象的原型

1. Object.create(proto);

• 传入一个原型，返回一个对象

var Car = {
  start: function(){
    console.log('start');
  }
}
var landRover = Object.create(Car);
//'start'
landRover.start();

2. 使用构造函数构造对象，使用prototype设置原型

var Car = function(){

}
Car.prototype.start = function(){
  console.log('start');
}

var landRover = new Car();
//'start'
landRover.start();

原型链继承

//Car构造函数
var Car = function(){

}
Car.prototype.start = function(){
  console.log('start');
}

//LandRover构造函数
var LandRover = function(){

}
LandRover.prototype = new Car();

var landRover = new LandRover();
//start
landRover.start();

obj.hasOwnProperty(name);

• 对象自身是否有该属性

构造函数的原型链

Car --> Function --> Object

LandRover --> Function --> Object

• 因为Car和LandRover都是函数(Function)的实例，所以可以访问Function的原型方法，即Function.prototype的方法，即Car.proto = Function.prototype
• Function是Object的实例，所以可以访问对象的原型方法，即Object.prototype的方法

JS变量作用域

• JS使用静态作用域

var x = 10;
function foo(){
  console.log(x);
}
function bar(){
  var x = 20;
  foo();
}
//10
bar();

• JS没有块级作用域，只有全局作用域和对象(函数)作用域
• ES5中使用词法环境管理静态作用域(使用outer指向外层环境，内层函数可以访问外层变量)
• with关键字可以创建临时环境

var obj = {foo:'bar'};
with(obj){
  //'bar'
  console.log(foo);
}

声明函数与函数表达式

• 声明函数会被提前定义，他的作用域为静态作用域，outer指向全局环境。
• 函数表达式在执行的时候才会被创建，他的作用域为动态作用域，outer指向当前环境。

带名称的函数表达式

• 执行该表达式的时候，会动态创建一个作用域，使得在函数内可以使用A来访问该函数。
• 在函数外并不能访问到A

(function foo(){
  //foo并没有被修改
  foo = 1;
  //function
  console.log(foo);
})();
//error
console.log(foo);

使用函数表达式创建闭包

• 利用函数表达式的作用域特性，可以创建闭包(内部函数访问外部函数的变量)。

function foo(){
  var i = 0;
  return function(){
    console.log(i++);
  }
}
var bar = foo();
//0
bar();
//1
bar();

闭包的应用

• 保存现场(变量的值、状态等)

//错误实例
function addHandlers(nodes){
  for(var i=0; i<nodes.length;i++){
    nodes[i].onclick = function(){
      //当函数执行的时候，i已经变成了nodes.length，所以所有的node都会打印nodes.length
      console.log(i);
    }
  }
}

//使用闭包
function addHandlers(nodes){
  //每调用一次helper，都会创建一个闭包，保存i的值
  function helper(i){
    return function(){
      //0 1 2 3
      console.log(i);
    };
  }
  for(var i=0;i<nodes.length;i++){
    nodes[i].onclick = helper(i);
  }
}

• 封装(信息隐藏，提供接口)