)
一、apply()
在JavaScript中，apply()是函数的原型方法（Function.prototype.apply），用于调用一个函数，并显式指定该函数内部的this值，同时以数组（或类数组对象）的形式传入参数。
基本语法：
func.apply(thisArg,[argsArray]);func：要调用的函数。thisArg：在函数执行时，绑定到this的对象。如果传
null或undefined，在非严格模式下this指向全局对象（浏览器中是window，Node.js 中是global）；严格模式下为null。[argsArray]：一个数组或类数组对象（如arguments、NodeList），其元素将作为参数依次传给函数。如果不需要传参，可传
[]或null/undefined。
返回值：被调用函数的返回值。
核心作用：
改变函数内部的
this指向。以数组形式传递参数。
经典示例：
借用数组方法（最常见用途）。
// 类数组对象（有length和索引，但不是Array）。constarrayLike={0:'a',1:'b',2:'c',length:3};// 借用Array.prototype.slice方法。constrealArray=Array.prototype.slice.apply(arrayLike);console.log(realArray);// ['a', 'b', 'c']。现代写法可用
Array.from(arrayLike)，但apply在旧代码中很常见。求最大值/最小值（配合Math）。
constnumbers=[5,6,2,8,1];// Math.max接收多个参数，不接受数组。// Math.max(numbers) → NaN。// 使用apply展开数组。constmax=Math.max.apply(null,numbers);constmin=Math.min.apply(null,numbers);console.log(max);// 8。console.log(min);// 1。ES6+可用扩展运算符替代：
Math.max(...numbers)。改变
this上下文。constperson={name:'Alice'};functiongreet(greeting,punctuation){return`${greeting},${this.name}${punctuation}`;}// 使用apply调用greet，指定this为person，参数以数组传入。constresult=greet.apply(person,['Hello','!']);console.log(result);// "Hello, Alice!"。继承中调用父类构造函数（ES5写法）。
functionAnimal(name){this.name=name;}functionDog(name,breed){// 调用父类构造函数，绑定this到当前实例。Animal.apply(this,[name]);this.breed=breed;}constdog=newDog('Buddy','Golden Retriever');console.log(dog.name);// 'Buddy'。console.log(dog.breed);// 'Golden Retriever'。ES6+可用
super(name)替代。
applyvscallvsbind：
| 方法 | 参数形式 | 是否立即执行 | 返回值 |
|---|---|---|---|
func.apply(thisArg, [arg1, arg2, ...]) | 数组/类数组 | 是 | 函数执行结果 |
func.call(thisArg, arg1, arg2, ...) | 逐个列出 | 是 | 函数执行结果 |
func.bind(thisArg, arg1, arg2, ...) | 逐个列出（可部分预设） | 否 | 新函数（绑定后的） |
greet.apply(person,['Hi','.']);// "Hi, Alice."。greet.call(person,'Hi','.');// "Hi, Alice."。constboundGreet=greet.bind(person,'Hi');boundGreet('.');// "Hi, Alice."。二、call()
在JavaScript中，call()是函数的原型方法（Function.prototype.call），用于立即调用一个函数，并显式指定该函数内部的this值，同时以逐个参数的形式传入参数。
它和apply()非常相似，核心区别只在于参数的传递方式。
基本语法：
func.call(thisArg,arg1,arg2,...,argN);func：要调用的函数。thisArg：函数执行时绑定到this的对象。若为
null或undefined：- 非严格模式 →
this指向全局对象（浏览器中是window）。 - 严格模式 →
this就是null。
- 非严格模式 →
arg1, arg2, ...：逐个列出的参数（不是数组！）。
返回值：被调用函数的返回值。
核心作用：
改变函数内部的
this指向。以“展开”的形式传参（与
apply的数组形式相对）。
经典示例：
借用其他对象的方法。
constobj1={name:'Alice',greet:function(greeting){return`${greeting}, I'm${this.name}`;}};constobj2={name:'Bob'};// 让 obj1.greet 在obj2的上下文中执行。constresult=obj1.greet.call(obj2,'Hello');console.log(result);// "Hello, I'm Bob"。这里
this指向了obj2，所以this.name是'Bob'。将类数组转为真数组（配合
Array.prototype.slice）。functiondemo(){// arguments是类数组。constargsArray=Array.prototype.slice.call(arguments);console.log(argsArray);// [1, 2, 3]。}demo(1,2,3);现代写法：
Array.from(arguments)或[...arguments]（但需注意arguments不是真正的可迭代对象，在某些环境下需谨慎）。检查数据类型（利用
Object.prototype.toString）。functiongetType(value){returnObject.prototype.toString.call(value).slice(8,-1);/* 若不加“.slice(8, -1)”进行切分，输出结果如下： [object Array] [object Date] [object Null] */}console.log(getType([]));// "Array"。console.log(getType(newDate()));// "Date"。console.log(getType(null));// "Null"。这是判断JS数据类型的最可靠方法之一，因为
call能确保toString在目标值上正确执行。继承（ES5写法）。
functionAnimal(name){this.name=name;}functionDog(name,breed){// 调用父构造函数，绑定this到当前实例。Animal.call(this,name);this.breed=breed;}constdog=newDog('Max','Labrador');console.log(dog.name);// 'Max'。console.log(dog.breed);// 'Labrador'。ES6+可用
class+super()替代。
callvsapplyvsbind：
| 方法 | 参数形式 | 是否立即执行 | 返回值 |
|---|---|---|---|
func.call(thisArg, arg1, arg2, ...) | 逐个参数 | 是 | 函数执行结果 |
func.apply(thisArg, [argsArray]) | 数组/类数组 | 是 | 函数执行结果 |
func.bind(thisArg, arg1, arg2, ...) | 逐个参数（可预设） | 否 | 新函数 |
functiongreet(a,b){return`${a}${this.name}${b}`;}constperson={name:'Tom'};greet.call(person,'Hi','!');// "Hi Tom !"。greet.apply(person,['Hi','!']);// "Hi Tom !"。constbound=greet.bind(person,'Hi');bound('!');// "Hi Tom !"。三、bind()
在JavaScript中，bind()是函数的原型方法（Function.prototype.bind），用于创建一个新函数（绑定函数），该新函数在被调用时：
永久绑定指定的
this值。可预设部分参数（称为“柯里化”或“部分应用”）。
bind()不会立即执行原函数，而是返回一个绑定了上下文和参数的新函数。
基本语法：
constnewFunc=func.bind(thisArg,arg1,arg2,...);func：原始函数。thisArg：新函数执行时，内部this指向的对象。arg1, arg2, ...：可选，预设的参数（会填充到新函数参数的前面）。- 返回值：一个全新的函数。
核心特性：
永久绑定
this（不可再被call/apply覆盖）。constperson={name:'Alice'};functiongreet(){return`Hello,${this.name}`;}constboundGreet=greet.bind(person);console.log(boundGreet());// "Hello, Alice"。// 即使用call/apply也无法改变this。console.log(boundGreet.call({name:'Bob'}));// 仍然是"Hello, Alice"！一旦用
bind绑定this，就永久固定了。支持预设参数（部分应用 / 柯里化）。
functionmultiply(a,b){returna*b;}// 预设第一个参数为 2constdouble=multiply.bind(null,2);console.log(double(5));// 10 (2 * 5)console.log(double(10));// 20 (2 * 10)也可以预设多个参数：
functionadd(a,b,c){returna+b+c;}constaddFiveAndTen=add.bind(null,5,10);console.log(addFiveAndTen(3));// 18 (5 + 10 + 3)
经典使用场景：
解决回调函数中
this丢失问题。classTimer{constructor(){this.seconds=0;}start(){// 问题：setTimeout 中的回调函数this指向window（非严格模式）。// setTimeout(function() {// this.seconds++; // 报错或无效。// }, 1000);// 解决方案：用bind绑定this。setTimeout(function(){this.seconds++;console.log(this.seconds);}.bind(this),1000);}}consttimer=newTimer();timer.start();// 正常输出1。现代写法更推荐用箭头函数（自动继承外层
this）：setTimeout(()=>{this.seconds++;},1000);事件监听器中保持上下文。
classButton{constructor(element){this.element=element;this.clickCount=0;// 绑定this，确保handleClick中的this指向当前实例。this.element.addEventListener('click',this.handleClick.bind(this));}handleClick(){this.clickCount++;console.log(`Clicked${this.clickCount}times`);}}若不用
bind，handleClick被调用时this会指向element（DOM元素），导致错误。创建专用函数（函数工厂）
functionlog(level,message){console.log(`[${level}]${message}`);}consterrorLog=log.bind(null,'ERROR');constinfoLog=log.bind(null,'INFO');errorLog('Something went wrong');// [ERROR] Something went wronginfoLog('Process started');// [INFO] Process started
bindvscallvsapply：
| 方法 | 是否立即执行 | 参数形式 | 主要用途 |
|---|---|---|---|
func.bind(thisArg, ...args) | 否 | 逐个参数 | 创建绑定后的新函数（用于回调、事件等）。 |
func.call(thisArg, arg1, arg2, ...) | 是 | 逐个参数 | 立即调用，临时指定this。 |
func.apply(thisArg, [args]) | 是 | 数组 | 立即调用，参数以数组传入。 |
注意事项：
bind返回的是新函数，原函数不变。多次
bind只有第一次生效：constf=function(){returnthis.value;};constg=f.bind({value:1});consth=g.bind({value:2});console.log(h());// 1（不是 2！）绑定函数的
length属性会变化：functionfn(a,b,c){}console.log(fn.length);// 3。console.log(fn.bind(null,1).length);// 2（已预设1个参数）。对
bind返回的新函数使用new关键字创建实例：letfoo={value:1,};functionPerson(name,age){this.name=name;this.age=age;console.log(this.name);console.log(this.age);console.log(this.value);}Person.prototype.getName=function(){returnthis.name;};letPer=Person.bind(foo,"xiaoming");Per(18);// 输出：xiaoming 18 1。console.log(foo.name);// 输出：xiaoming。console.log(foo.age);// 输出：18。console.log(foo.value);// 输出：1。letper=newPer(18);// 输出：xiaoming 18 undefined。console.log(per.getName());// 输出：xiaoming。console.log(foo.name);// 输出：xiaoming。console.log(foo.age);// 输出：18。console.log(foo.value);// 输出：1。// 由上述结果可知，对bind方法返回的绑定对象的函数使用new关键字创建实例时，原绑定的对象在创建的实例中会失效。
