【call apply】盛年不重来，一日难再晨，及时当勉励，岁月不待人。这篇文章主要讲述call apply相关的知识，希望能为你提供帮助。

< !DOCTYPE html>
< html lang="en">
< head>
< meta charset="UTF-8">
< title> call apply< /title>
< /head>
< body>
< div id="div1"> div1< /div>
< !----------------------------------------------------------------------------------------------------------------------
它们各自的定义：

apply：应用某一对象的一个方法，用另一个对象替换当前对象。例如：B.apply(A, arguments); 即A对象应用B对象的方法。

call：调用一个对象的一个方法，以另一个对象替换当前对象。例如：B.call(A, args1,args2); 即A对象调用B对象的方法。

它们的共同之处：

都“可以用来代替另一个对象调用一个方法，将一个函数的对象上下文从初始的上下文改变为由thisObj指定的新对象”。

它们的不同之处：

apply：最多只能有两个参数——新this对象和，第二个参数为一个带下 标的集合，这个集合可以为数组，也可以为类数组。
如果给该方法传递多个参数，则把参数都写进这个数组里面，
当然，即使只有一个参数，也要写进数组里。如果argArray不是一个有效的数组或arguments对象，那么将导致一个TypeError。
如果没有提供argArray和thisObj任何一个参数，那么Global对象将被用作thisObj，并且无法被传递任何参数。

call：它可以接受多个参数，第一个参数与apply一样，后面则是一串参数列表。这个方法主要用在js对象各方法相互调用的时候，
使当前this实例指针保持一致，或者在特殊情况下需要改变this指针。如果没有提供thisObj参数，那么 Global 对象被用作thisObj。

实际上，apply和call的功能是一样的，只是传入的参数列表形式不同。

---------------------------------------------------------------------------------------------------------------------------->

< !--实现继承-->
< script>
function Animal(name){
this.name = name;
this.showName = function () {
console.log(this.name);
};
}
Animal.prototype = {
publicProperty:function (arg1) {
console.log(arg1);
}
};

function Dog(speak) {
Animal.apply(this,[speak]);
}
Dog.prototype = new Animal();
var dog1 = new Dog("旺旺");
console.log(dog1);
dog1.showName();
dog1.publicProperty("dog1 publicProperty");
var dog2 = new Animal("animal");
console.log(dog2);
dog2.publicProperty("dog2");

< /script>
< !--实现多重继承-->
< script>
function Add() {
this.showAdd = function (a,b) {
console.log(a + b);
}
}
function Sub() {
this.showSub = function (c, d) {
console.log(c - d);
}
}
function Add_Sub(a,b) {
Add.apply(this,[a,b]);
Sub.apply(this,[a,b]);
}
var aa = new Add_Sub();
aa.showAdd(43,67);
aa.showSub(66,66);

< /script>

< !--apply的一些其他巧妙用法-->
< script>
//得到数组中最大(小)的一项; 这块在调用的时候第一个参数给了null，这是因为没有对象去调用这个方法，我只需要用这个方法帮我运算，得到返回的结果就行，所以直接传递了一个null过去。
//当使用 call 或者 apply 的时候，如果我们传入的第一个参数为 null，函数体内的 this 会指 向默认的宿主对象，在浏览器中则是 window
//有时候我们使用 call 或者 apply 的目的不在于指定 this 指向，而是另有用途，比如借用其 他对象的方法。那么我们可以传入 null 来代替某个具体的对象
var arr = [1,2,3,4,5];
Math.min.apply(null,arr);
Math.max.apply(null,arr);
//Array.prototype.push可以实现两个数组的合并
var arr1 = [1,2,3];
var arr2 = [4,5,6,7,8,9];
Array.prototype.push.apply(arr1,arr2);
console.log(arr1);
< /script>

< script>
//四。原型式继承

//这种继承借助原型*****并基于已有的对象创建新对象*****，
//同时还不必因此创建自定义类型

function obj(o) { //传递一个字面量函数
function F() {} //创建一个构造函数
F.prototype = o; //把字面量函数赋值给构造函数的原型
return new F(); //最终返回出实例化的构造函数
}
var box = { //字面量对象
name : ‘Lee‘,
arr : [‘哥哥‘,‘妹妹‘,‘姐姐‘]
};
var box1 = obj(box); //传递
console.log(box1);
console.log(box1.name); // => "Lee"
box1.name = ‘Jack‘;
console.log(box1.name); // => "Jack"
console.log(box1.arr); // => [‘哥哥‘,‘妹妹‘,‘姐姐‘]
box1.arr.push(‘父母‘);
console.log(box1.arr); // => [‘哥哥‘,‘妹妹‘,‘姐姐‘,‘父母‘]
var box2 = obj(box); //传递
console.log(box);
console.log(box2.name); // => "Lee"
console.log(box2.arr); //引用类型共享了 => [‘哥哥‘,‘妹妹‘,‘姐姐‘,‘父母‘]
< /script>

< !--------------------------------------------------------------------------------------------------------------------->
< script>
/***********Array.prototype.slice.call(arguments)*********************************/
//Array.prototype.slice.call(arguments)能将具有length属性的对象转成数组，
// 除了IE下的节点集合（因为ie下的dom对象是以com对象的形式实现的，js对象与com对象不能进行转换）
var a={length:2,0:‘first‘,1:‘second‘};
Array.prototype.slice.call(a); //["first", "second"]
var a={length:2};
Array.prototype.slice.call(a); //[undefined, undefined]
//slice有两个用法，一个是String.slice,一个是Array.slice，第一个返回的是字符串，第二个返回的是数组，
//Array.prototype.slice.call(arguments)能够将arguments转成数组，那么就是arguments.toArray().slice();
//是不是就可以说Array.prototype.slice.call(arguments)的过程就是先将传入进来的第一个参数转为数组，再调用slice？
var b = function () {
console.log(this); // ‘littledu‘
console.log(typeof this); //Object
console.log(this instanceof String); // true
};
b.call(‘littledu‘);
//我们可以大胆猜一下slice的内部实现，如下:
Array.prototype.slice = function (start, end) {
var result = new Array();
start = start || 0;
end = end || this.length; //this指向调用的对象，当用了call后，能够改变this的指向，也就是指向传进来的对象，这是关键
for (var i = start; i < end; i++) {
result.push(this[i]);
}
return result;
};
//转成数组的通用函数
var toArray = function (s) {
try {
return Array.prototype.slice.call(s);
} catch (e) {
var arr = [];
for (var i = 0, len = s.length; i < len; i++) {
//arr.push(s[i]);
arr[i] = s[i]; //据说这样比push快
}
return arr;
}
};
< /script>

< script>
/*********************************** Function.prototype.bind**************************************************/
var id = "window";
document.getElementById( ‘div1‘ ).onclick = function(){
console.log( this.id ); // 输出：div1
var func = function(){
console.log( this.id ); // 输出：window,此时的this指向window
};
func();
func.call(this); //输出div1
};

//使用 call 来修正 this 的场景，比如修正 document.getElementById 函数内部“丢失”的 this，代码如下：
document.getElementById = (function( func ){
return function(){
return func.apply( document, arguments );
}
})( document.getElementById );
var getId = document.getElementById;
var div = getId( ‘div1‘ );
console.log ( div.id ); // 输出： div1

//大部分高级浏览器都实现了内置的 Function.prototype.bind，用来指定函数内部的 this指向，
// 即使没有原生的 Function.prototype.bind 实现，我们来模拟一个也不是难事
Function.prototype.bind = function( context ){
var self = this; // 保存原函数
return function(){ // 返回一个新的函数
return self.apply( context, arguments ); // 执行新的函数的时候，会把之前传入的 context
// 当作新函数体内的 this
}
};
var obj = {
name: ‘sven‘
};
var func = function(){
console.log( this.name ); // 输出：sven
}.bind(obj);
func();
var log = console.log.bind(console);
log(6666);

//我们通过 Function.prototype.bind 来“包装”func 函数，并且传入一个对象 context 当作参数，这个 context 对象就是我们想修正的 this 对象。
//在 Function.prototype.bind 的内部实现中，我们先把 func 函数的引用保存起来，然后返回一 个新的函数。当我们在将来执行 func 函数时，
// 实际上先执行的是这个刚刚返回的新函数。在新 函数内部，self.apply( context, arguments )这句代码才是执行原来的 func 函数，
// 并且指定 context 对象为 func 函数体内的 this。这是一个简化版的 Function.prototype.bind 实现，
// 通常我们还会把它实现得稍微复杂一点， 使得可以往 func 函数中预先填入一些参数：
Function.prototype.bind = function(){
var self = this, // 保存原函数
context = [].shift.call( arguments ), //获取传入的第一个参数即arguments[0],亦即 需要绑定的 this 上下文，即下面例子中的func中传入的obj
args = [].slice.call( arguments ); // 剩余的参数转成数组,即将下面func例子中的参数obj后面的1,2参数转为数组[1,2]
return function(){ // 返回一个新的函数
return self.apply( context, [].concat.call( args, [].slice.call( arguments ) ) );
// 执行新的函数的时候，会把之前传入的 context 当作新函数体内的 this
// 并且组合两次分别传入的参数，作为新函数的参数,即下面的func例子中组合bind中传入的1,2和func中传入的3,4
}
};
var obj = {
name: ‘sven‘
};
var func = function( a, b, c, d ){
console.log( this.name ); // 输出：sven
console.log( [ a, b, c, d ] ) // 输出：[ 1, 2, 3, 4 ]
}.bind( obj, 1, 2 );
func( 3, 4 );

/********************************借用其他对象的方法**************************************************/
//借用方法的第一种场景是“借用构造函数”，通过这种技术，可以实现一些类似继承的效果：
var A = function( name ){
this.name = name;
};
var B = function(){
A.apply( this, arguments );
};
B.prototype.getName = function(){
return this.name;
};
var b = new B( ‘sven‘ );
console.log( b.getName() ); // 输出： ‘sven‘
//借用方法的第二种运用场景跟我们的关系更加密切。函数的参数列表 arguments 是一个类数组对象，虽然它也有“下标”，
// 但它并非真正的数组，所以也不能像数组一样，进行排序操作或者往集合里添加一个新的元素。
// 这种情况下，我们常常会借用 Array.prototype 对象上的方法。比如想往 arguments 中添加一个新的元素，通常会借用 Array.prototype.push：
(function(){
Array.prototype.push.call( arguments, 3 );
console.log ( arguments ); // 输出[1,2,3]
})( 1, 2 );
//在操作 arguments 的时候，我们经常非常频繁地找 Array.prototype 对象借用方法。想把 arguments 转成真正的数组的时候，
// 可以借用 Array.prototype.slice 方法；想截去 arguments 列表中的头一个元素时，又可以借用 Array.prototype.shift 方法。
// 那么这种机制的内部实现原理是什么呢？我们不妨翻开 V8 的引擎源码，以 Array.prototype.push 为例，看看 V8 引 擎中的具体实现：
function ArrayPush() {
var n = TO_UINT32( this.length ); // 被 push 的对象的 length
var m = %_ArgumentsLength(); // push 的参数个数
for (var i = 0; i < m; i++) {
this[ i + n ] = %_Arguments( i ); // 复制元素 (1)
}
this.length = n + m; // 修正 length 属性的值 (2)
return this.length;
}

//通过这段代码可以看到，Array.prototype.push 实际上是一个属性复制的过程，把参数按照 下标依次添加到被 push 的对象上面，
// 顺便修改了这个对象的 length 属性。至于被修改的对象是谁，到底是数组还是类数组对象，这一点并不重要。
// 由此可以推断，我们可以把“任意”对象传入 Array.prototype.push：
var a = {};
Array.prototype.push.call( a, ‘first‘ );
console.log ( a.length ); // 输出：1
console.log(a); //输出{0:"first",length:1}
console.log ( a[ 0 ] ); // first
//这段代码在绝大部分浏览器里都能顺利执行，但由于引擎的内部实现存在差异，如果在低版 本的 IE 浏览器中执行，必须显式地给对象 a 设置 length 属性：
var a = {
length: 0
};
//前面我们之所以把“任意”两字加了双引号，是因为可以借用 Array.prototype.push 方法的对象还要满足以下两个条件，从 ArrayPush 函数的(1)处和(2)处也可以猜到，这个对象至少还要满足：
//对象本身要可以存取属性
//对象的 length 属性可读写
//对于第一个条件，对象本身存取属性并没有问题，但如果借用 Array.prototype.push 方法的不是一个 object 类型的数据，而是一个 number 类型的数据呢? 我们无法在 number 身上存取其他数据，那么从下面的测试代码可以发现，一个 number 类型的数据不可能借用到 Array.prototype. push 方法：
var a = 1;
Array.prototype.push.call( a, ‘first‘ );
console.log ( a.length ); // 输出：undefined
console.log ( a[ 0 ] ); // 输出：undefined
//对于第二个条件，函数的 length 属性就是一个只读的属性，表示形参的个数，我们尝试把 一个函数当作 this 传入 Array.prototype.push：
var func = function(){};
Array.prototype.push.call( func, ‘first‘ );
console.log ( func.length );
// 报错：cannot assign to read only property ‘length’ of function(){}
< /script>
< /body>
< /html>

推荐阅读

• 

  同类色对比照片 摄影同类色
• 

  珂的意思和含义
• 

  聊城有哪些县 聊城都有哪些区县
• 

  为什么像汉字一样的象形文字很少,多数语言是拼音文字呢？
• 

  button的超级链接
• 

  支付宝商户如何开通花呗收款？花呗收钱开通的方法
• 

  画新娘妆和盘头多少钱，画一个新娘妆大概多少钱
• 

  坐飞机可以戴隐形眼镜吗？
• 

  茯苓绿豆粥——清热祛湿利尿消肿
• 

  嘉宝果泡酒多久可以喝
• 

  星巴克全职星级咖啡师面试难吗？
• 

  建筑软件,我的世界导入建筑软件
• 

  听书 安卓1.5,喜马拉雅蜻蜓fm懒人听书不错!
• 

  医保卡余额怎么用 医保卡余额使用技巧
• 

  iOS|iOS 碰撞角度矫正 及 applyImpulse 和 applyForce的区别
• 

  唇色发紫日常养护 嘴唇发黑是什么原因
• 

  为什么梦见打雪仗
• 

  榴莲一半硬一半软是什么原因
• 

  顾炀樊渊是哪部小说
• 

  梦见理发 你知道预示着什么吗

• SpringMVC---RequestMapping注解类的使用方法
• wifi 安卓手机
• Android remote gdb
• How to download and compile Android kernel goldfish ?
• 在Android上使用酷狗歌词API
• 安卓热修复测试思路
• SpringMVC——RequestMapping
• APP测试流程和测试点
• 如何在手机APP中集成测试车牌识别sdk