this
1,apply、call 、bind有什么作用，什么区别
- apply/call:调用一个函数，传入函数执行上下文及参数
fn.call(context,param1,param2...);
fn.apply(context,paramArray;
语法很简单，第一个参数都是希望设置的this对象，不同之处在于call方法接收参数列表，而apply接收参数数组
var value = 100;
var obj4 = {
value: 200
}
function fn4(a,b) {
console.log(this.value + a + b);
}
fn4(3,4); // 107
fn4.call(obj4,3,4);//207
fn4.apply(obj4,[3,4]); //207
- bind:返回一个函数，并且使函数内部的this为传入的第一个参数
var obj1 = {
name: 'deejay',
age: 20,
fn: function () {
console.log(this);
}
};
var obj3 = {
a: 3,
}
var fn3 = obj1.fn.bind(obj3);
fn3(); //obj3
apply/call是指的调用一个函数，传入这个函数的执行上下文和参数。而bind是指的是返回一个函数，并且使函数内部的this为传入的第一个参数。
call/apply在函数调用时使用，bind在函数声明时使用。 bind() 方法会返回执行上下文被改变的函数而不会立即执行，而call/apply是直接执行该函数。
2,以下代码输出什么?
var john = {
firstName: "John"
}
function func() {
alert(this.firstName + ": hi!")
}
john.sayHi = func
john.sayHi()//John: hi!
3,以下代码输出什么?
func()
function func() {
alert(this) //window
}
可以看做window.func();
4，下面代码输出什么
document.addEventListener('click', function(e){
console.log(this); //#document
setTimeout(function(){
console.log(this);//window
}, 200);
}, false);
setTimeoutl这个方法执行的函数this是全局对象,
在事件处理程序中this代表事件源DOM对象
5，下面代码输出什么
var john = {
firstName: "John"
}
function func() {
alert( this.firstName )
}
func.call(john);//John
使用了call方法，调用了func(),并且将内部this修改为john
6，以下代码有什么问题，如何修改
var module= {
bind: function(){
$btn.on('click', function(){
console.log(this) //this指什么
this.showMsg();
})
},
showMsg: function(){
console.log('deejay');
}
}
问题出在了在事件处理程序中this代表事件源DOM对象，所以点击的时候的this是当前点击的DOM元素，没有showMsg这个方法，解决方法如下：
var module= {
bind: function(){
var self = this;
console.log(self);
$btn.on('click', function(){
console.log(this); //this指的是当前触发点击事件的DOM元素
self.showMsg()
})
},
showMsg: function(){
console.log('deejay');
}
}
这里设置一个self保存有showMsg()方法的this，即module，然后调用showMsg
原型链
7，有如下代码，解释Person、 prototype、proto、p、constructor之间的关联。
function Person(name){
this.name = name;
}
Person.prototype.sayName = function(){
console.log('My name is :' + this.name);
}
var p = new Person("deejay")
p.sayName();//My name is :deejay
本例中，Person作为构造函数，创建了它的实例p,实例p存在一个属性__proto__，等于Person.prototype,而Person中存在一个Person.prototype对象，其有一个属性constructor，这个属性又指向Person。
即有：
p.__proto__ === Person.prototype;
Person.prototype.constructor === Person;
8，上例中，对对象 p可以这样调用 p.toString()。toString是哪里来的? 画出原型图?并解释什么是原型链。
原型图如图所示，当调用p的toString()时，会先在实例中寻找，如果找不到，再到p.__proto__属性中，即Person.prototype中寻找，当在Person.prototype中寻找不到时，会到Person.prototype.__proto__中也就是Object.prototype中寻找，然后就寻找到了toString()。
所以整个过程为p 到 p.__proto__ 再到 p.__proto__.__proto__中，逐级向上查找即为原型链。
9，对String做扩展，实现如下方式获取字符串中频率最高的字符
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次
给str的构造函数String的prototype添加函数
String.prototype.getMostOften = function () {
//等价于 str.__proto__.getMostOften = ...
var dict = {};
var count;
var maxvalue = 0;
for (var i = 0; i < this.length; i ++) {
if (dict[this[i]]) {
dict[this[i]]++;
}
else {
dict[this[i]] = 1;
}
}
for (var key in dict) {
if (dict[key] > maxvalue) {
maxvalue = dict[key];
count = key;
}
}
return count;
}
var str = 'ahbbccdeddddfg';
var ch = str.getMostOften();
console.log(ch); //d , 因为d 出现了5次
10， instanceOf有什么作用？内部逻辑是如何实现的？
instanceOf用来判断某个对象是否是某函数的实例
主要实现逻辑为，先判断p.__proto__ 是否为Person.prototype，如果不是，接着判断p.__proto__ .__proto__ 是否为Person.prototype,...直到为null返回false，如果在查找途中发现是Person.prototype的实例，返回true
继承
11，继承有什么作用?
继承是指一个对象直接使用另一对象的属性和方法。
如果要创建一个子类，不用重新复制一遍父类的代码，可以直接继承然后进行添加子类自己的属性和方法
12，下面两种写法有什么区别?
//方法1
function People(name, sex){
this.name = name;
this.sex = sex;
this.printName = function(){
console.log(this.name);
}
}
var p1 = new People('前端', 2)
//方法2
function Person(name, sex){
this.name = name;
this.sex = sex;
}
Person.prototype.printName = function(){
console.log(this.name);
}
var p1 = new Person('deejay', 21);
方法1是在每次创建一个实例的时候都会相应的给实例也创建一个printName()，如果创建了多个实例的话每个实例都会有一个相同的printName()。
方法2是在构造函数的prototype中添加一个printName()，作为所有实例的公共方法，这样多个所有被创建的实例自身只有自身的属性，而printName()是公用的，只有一个，节省了内存。
13， Object.create 有什么作用？兼容性如何？
Object.create() 方法会使用指定的原型对象及其属性去创建一个新的对象。
Object.create是ES5方法
14， hasOwnProperty有什么作用？ 如何使用？
是Object.prototype的一个方法，可以判断一个对象是否包含自定义属性而不是原型链上的属性，hasOwnProperty是JS中唯一一个处理属性但是不查找原型链的函数
function Person(name,age) {
this.name = name;;
this.age = age;
}
Person.prototype.sayName = function () {
console.log(this.name);
}
var p1 = new Person('deejay',21);
p1.hasOwnProperty('name');//true
p1.hasOwnProperty('age');//true
p1.hasOwnProperty('sayName');//false
15，如下代码中call的作用是什么?
function Person(name, sex){
this.name = name;
this.sex = sex;
}
function Male(name, sex, age){
Person.call(this, name, sex); //这里的 call 有什么作用
this.age = age;
}
这里的call即为在Male构造函数内部调用Person构造函数，将Male创建的实例this传给Person，达到的效果就是复制了Person构造函数中的所有属性
16，补全代码，实现继承
function Person(name, sex){
// todo ...
}
Person.prototype.getName = function(){
// todo ...
};
function Male(name, sex, age){
//todo ...
}
//todo ...
Male.prototype.getAge = function(){
//todo ...
};
var deejay= new Male('deejay', '男', 21);
deejay.printName();
实现如下：
function Person(name, sex){
this.name = name;
this.sex = sex;
}
Person.prototype.printName = function(){
console.log(this.name)
};
function Male(name, sex, age){
Person.call(this,name,sex); // 复制Person内部的属性
this.age = age;
}
Male.prototype = Object.create(Person.prototype); // 实现方法的继承
Male.prototype.getAge = function(){
console.log(this.age)
};
var deejay = new Male('deejay', '男', 21);
deejay.printName();//deejay
