进阶Javascript

• isPrototypeOf()：这个方法用来判断，某个proptotype对象和某个实例之间的关系。
• hasOwnProperty()：用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。
• in运算符：in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。

RegExp

Function

This

原型

默认的prototype对象可以被用户创建的对象替换掉。这样做的话，我们必须重复javascript运行时在幕后对默认的prototype对象所做的那样去手动设置constructor属性。

function foo() { } ; var f1 = new foo();
f1.constructor === foo.prototype.constructor === foo
//replace the default prototype object
foo.prototype = new Object();
//now we have:
f1.constructor === foo.prototype.constructor === Object
//so now we say:
foo.prototype.constructor = foo
//all is well again
f1.constructor === foo.prototype.constructor === foo

每一个的prototype对象自己都是由Object()函数（默认情况下）创建而来，所以prototype有它自己的原型那就是Object.prototype。因此无论什么类型的实例最终都会继承Object.prototype对象的属性。

• Function.proto指向Function.prototype。这使得：Function.constructor === Function，也就是说：Function是它自己的构造函数！
• Object instanceof Object == true。这是因为：Object.proto.proto.constructor == Object。注意，跟Object instanceof Object不一样的是Foo instanceof Foo == false，这是因为：Foo并没有作为它原型链上的某个构造函数。
• Function.prototype.toString是一个内置的函数，它有别于另外一个内置的函数：Object.prototype.toString。
• Function instanceof Object //true Object instanceof Function //true

深拷贝与浅拷贝

function deepCopy(p, c) {
　　var c = c || {};
　　for (var i in p) {
　　　　if (typeof p[i] === ‘object’) {
　　　　　　c[i] = (p[i].constructor === Array) ? [] : {};
　　　　　　deepCopy(p[i], c[i]);
　　　　} else {
　　　　　　　c[i] = p[i];
　　　}
　　}
　　return c;
}

内置对象

函数

*. 建立阶段(发生在当调用一个函数时，但是在执行函数体内的具体代码以前)

* 建立变量，函数，arguments对象，参数
* 建立作用域链
* 确定this的值

*. 代码执行阶段:

* 变量赋值，函数引用，执行其它代码

    function Person(name) { 
         this.name = name;  
     this.sayName = sayName;
    }
    function sayName() { 
         console.log(this.name);
    }   
var name = "111"
    var p = new Person("222");
console.log(sayName());    //111
console.log(p.sayName());  //222

创建对象

  function SuperType() {
  this.flag = true;
}
SuperType.prototype.getSuperFlag = function() {
  return this.flag;
};
    function SubType() {     
  this.subFlag = false;
}
//继承了SuperType  先确立了继承关系之后，又添加了方法 
SubType.prototype = new SuperType();
//注意添加方法的方式与位置
SubType.prototype.getSubFlag = function() { 
 return this.subFlag;
 };
 var st = new SubType();
 alert(st.getSuperFlag());  //true
 //测试继承关系
 alert(st instanceof Object);  //true
 alert(st instanceof SuperType);  //true
 alert(st instanceof SubType);  //true
 alert(Object.prototype.isPrototypeOf(st));  //true
 alert(SuperType.prototype.isPrototypeOf(st));  //true
 alert(SubType.prototype.isPrototypeOf(st));  //true

对上面代码的总结：

*1、代码的顺序以及继承关系的测试结果。    
*2、继承是通过创建SuperType的实例，并将该实例赋给SubType.prototype实现的。
    实现的本质是重写原型对象，代之以一个新类型的实例。

确定原型和实例的关系：可以通过两种方法来确定原型和实例之间的关系。第一种方式是使用instanceof操作符；第二种方法是使用isPrototypeOf()方法。

匿名函数

(function () { //这里是块级作用域
})();

• 1、以上代码定义并立即调用了一个匿名函数。将函数声明包含在一对圆括号中。表示实际上是一个函数表达式。而紧随其后的另一对圆括号会立即调用这个函数。
• 2、这种做法可以减少闭包占用的内存问题，因为没有指向匿名函数的引用。只要函数执行完毕，就可以立即销毁其作用域链了。