前端基础总结

JS知识整合

Talk is cheap,show me the code.

js数据类型

基本数据类型：String，Number，Boolean，Null，Undefined
复杂数据类型：Object
引用数据类型：Object，Function，Array
ES6：Symbol
掌握：判断数据类型方法：typeof、instanceof、constructor、Object.prototype.toString.call();
几种false：null，undefined，空字符串，0
除了null、undefined，其它数据类型都为对象。判断：Number instanceof Object == true
*注意：Function实际上也是一种对象。Object对象字面量是通过构造函数创建。
相关文章：
link
link2

typeof Object; // Function
typeof Function; // Function
Function instanceof Object; // true
Object instanceof Function; // true
// 关系
Object.__proto__ = Function.prototype;
Object.prototype.__proto__ = null;
Function._proto_ = Function.prototype;
Function.prototype._proto_ = Object.prototype;

判断数据类型：
typeof的弊端，对于基本数据类型（包括Function）有效，但是对于引用类型，都会返回Object。

typeof null;// Object，这很奇怪。可能跟js底层有关，不同对象最后都存为二进制，null二进制都为0，js把二进制形式中前三位为0的均判断为Object。
typeof Array; // Function

'aaa' instanceof String; // false，str只是一个String类型的字面值，并非是String对象
var str = new String(); // 创建对象
str instanceof String; // true

String instanceof Object; // true
String instanceof Function; // true

// constructor来判断不可靠，因为constructor可被修改
'aaa'.constructor == String; // true
null.constructor == null; // 报错
undefined.constructor == undefined; // 报错

// 使用Object.prototype.toString.call()
// 原理，子类型内部借用了Object的toString方法。toString方法为Object对象的方法，默认返回调用者的对象类型(this的类型)
// call()可以调用所有者对象作为参数的方法
var str = 'hello';
Object.prototype.toString.call(str); // [Object String]

闭包

闭包就是内部函数访问外部函数的变量。即子函数访问父函数变量

1.闭包特性：

• 函数嵌套函数
• 函数内部可以引用函数外部的参数或引用
• 参数不会被js垃圾回收机制回收
• 不会污染全局环境

function a() {
	var num = 0;
	var b = function() {
		console.log(++num);
	};
	return b;
};
var c = a();
a()(); // 1
a()(); // 1
c(); // 1
c(); // 2

原因：a()()相当于执行b()，当内部函数b没有被全局变量引用时，单独调用a()，num并不会保存在内存中，即使是调用了b()。而var c = a()，a函数被全局变量c引用了，不会被垃圾回收，所以每次c()时num都会叠加。

例2

var add;
var bar = function () {
        var n = 999;
        add = function () {
            n += 1;
        }
        return function () {
           return n;
        }
    }
var outer = bar();
console.log(outer()); // 999 
add();
console.log(outer()); // 1000
add();
console.log(outer()); // 1001

这个例子中，add()和bar()都被全局变量add和outer引用了，因此n都被内存保存起来了。

单例模式

var singleton = function( fn ){
    var result;
    return function(){
        return result || ( result = fn .apply( this, arguments ) );
    }
}
// 简洁模式
var singleton = (function () {
  var instance;
  return function (object) {
    if(!instance){
      instance = new object();
    }
    return instance;
  }
})();
console.log(singleton(Object)); // {}

附一面试题（其它面试题例）

var x = 0;
var foo = {
    x:1,
    bar:function () {
        console.log(this.x);
        var that = this;
        return function () {
           console.log(this.x)
           console.log(that.x)
        }
    }
}
foo.bar()       // this.x:1
foo.bar()()     // this.x: undefined, that.x: 1

ES6

symbol

解构