原型原型链 面试题

//测试题1

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

 

//测试题2

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、题目

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

 

var array=[];
console.log(array instanceof Array);//true 判断引用类型的具体类型要用instanceof
console.log(typeof array);//Object

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

 

//封装一个DOM查询实例
function Elem(id){
    this.elem=document.getElementById(id);
}
Elem.prototype.html=function(val){
    var elem=this.elem;
    if(val){
        elem.innerHTML=val;
    }else{
        return elem.innerHTML;
    }
}
Elem.prototype.on=function(type,fn){
    var elem=this.elem;
    elem.addEventListener(type,fn);
    return this;
}
var dev=new Elem('dev1');
console.log(dev.html('<p>hello world!</p>'));
dev.on('click',function(){
    alert('clicked');
})

三、描述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);
}
//建立示例
var f=new Foo('zahngshan');
f.printName=function(){
    console.log(this.name);
};
//测试
f.printName();
f.alertName();

四、zepto(或其余框架)源码中如何使用原型链
（1）阅读源码是高效提升技能的方式
（2）但不能‘埋头苦钻’有技巧在其中
（3）慕课网搜索‘zepto设计和源码分析’
2、知识点
一、构造函数
构造函数有个特色，函数名首字母大写，构造函数就相似于一个模板，能够new出来多个实例
二、构造函数-扩展

（1）var a={}实际上是var a=new Object()的语法糖

（2）var a=[]实际上是var a=new Array()的语法糖

（3）function Foo(){}实际上是var Foo=new Function(...)

（4）使用instanceof判断一个函数是不是一个变量的构造函数
三、原型规则和示例
（1）全部的引用类型（数组，对象，函数），都具备对象特征，即自由扩展属性（除了null之外），以下代码所示，均可以自由扩展属性a

 

var obj = {};
obj.a = 100;
var arr = [];
arr.a = 100;
function fn() {
};
var f1=new fn();
fn.a = 100;

（2）全部的引用类型（数组，对象，函数），都有一个__proto__属性，属性值是一个普通的对象,以下代码所示：

 

var obj = {};
obj.a = 100;
var arr = [];
arr.a = 100;
function fn() {
};
var f1=new fn();
fn.a = 100;
console.log(obj.__proto__);
console.log(arr.__proto__);
console.log(fn.__proto__);

（3）全部的函数，都有一个prototype属性，属性值也是一个普通的对象

 

function fn() {
};
var f1=new fn();
fn.a = 100;
console.log(fn.__proto__);
console.log(fn.prototype);

（4）全部的引用类型（数组，对象，函数），__proto__属性值指向他的构造函数的“prototype”属性值

 

var obj = {};
obj.a = 100;
var arr = [];
arr.a = 100;
function fn() {
};
var f1=new fn();
fn.a = 100;
console.log(obj.__proto__);
console.log(arr.__proto__);
console.log(fn.__proto__);
console.log(fn.prototype);
console.log(obj.__proto__ === Object.prototype);//true
console.log(fn.__proto__ === fn.prototype);//true

（5）当试图获得一个对象的某个属性时，若是这个对象自己没有这个属性，那么会去它的__proto__(即它的构造函数的prototype)中寻找，即console.log(obj.__proto__ === Object.prototype);
四、原型链