面试题-原型链问题

1、如何准确判断一个变量是数组类型？

	var str=[];
	console.log(typeof str);//object
	console.log(str.constructor===Array);//true
	console.log(Object.prototype.toString.call([]));//[object Array]
	console.log(Array.isArray(str));//true
	console.log(str instanceof Array);//true;

2、写一个原型链继承的的例子

    function SuperType(){
		this.property=true;
	}
	SuperType.prototype.getSuperValue=function(){
		return this.property;
	}
	function SubType(){
		this.Subproperty=false;
	}
	//继承
	SubType.prototype=new SuperType();
	SubType.prototype.getSubValue=function(){
		return this.Subproperty;
	}
	var instance=new SubType();
	console.log(instance.getSubValue());
	console.log(instance.getSuperValue());

3、描述new一个对象的过程
（1）创建一个新对象（2）this指向这个新对象（3）执行代码，即对this进行赋值（4）返回this

    //创建构造函数
    function  Foo(name,age){
        //var this={};
        this.name=name;
       // return this;
    }
    Foo.prototype.alertName=function(){
        console.log(this.name);//zahngshan
    }
    //创建示例
    var f=new Foo('zahngshan');
    f.printName=function(){
        console.log(this.name);//zahngshan
    };
    //测试
    f.printName();
    f.alertName();

4.测试题：b继承n=1;c继承n=2;m=3;

    var A=function(){}
	A.prototype.n=1;
	var b=new A();
	A.prototype={
		n:2,
		m:3
	}
	var c=new A();
	console.log(b.n,b.m,c.n,c.m)//1,undefined,2,3

5.测试题：Function是由function关键字定义的函数对象的原型,Function就相当于一个系统原型，可以把它理解为一种“基本对象类型”，是“对象”这个概念范畴类的基本数据类型；Function是所有函数对象的构造对象，Function（）为构造函数，所以Object和Function都有prototype属性

    var F=function(){};
	Object.prototype.a=function(){
		console.log('a()');
	};
	Function.prototype.b=function(){
		console.log('b()');
	}
	var f=new F();
	f.a()//a()
	f.b()//报错找不到b这个函数
	F.a()//a()
	F.b()//b()

1.创建一个函数F   var F = function(){};

//F.__proto__ ---> Function.prototype    (__proto__ 指向了它的构造函数的原型)

//F.prototype.__proto__ --->Object.prototype  (每个prototype都有__proto__属性)

2.给Object的原型定义一个方法a；Object.prototype.a = function( ){ };

3.给Function的原型定义一个方法b；Function.prototype.b = function( ){ };

4.用F当做构造函数去构造一个对象f；var f = new F( );这里是我们需要拆分一下才能看懂（不然鬼知道经历了什么！）：

var f={ };

f.__proto__=F.prototype;

F.prototype.__proto__= Object.prototype

//f.__proto__ --->F.prototype

//F.prototype.__proto__--->Object.prototype

//f.__proto__.__proto__ ---> Object.prototype

其实可以得到：f.__proto__ --->F.prototype     F.prototype.__proto__ ---> Object.prototype

所以我们最终可以得到 f.__proto__.__proto__ ---> Object.prototype

我们这边逆推一下：Function.prototype --->F.__proto__    而我们的F.prototype ！=F.__proto__  所以我们不能使用b方法。