一文读懂Js中的this指向

js的基础笔记4:作用域(全局作用域、局部作用域、js中没有块级作用域、变量的作用域、作用域链)、预编译、对象(创建对象的三种方式) 1 - 作用域 1.1 作用域概述 通常来说,一段程序代码中所用到的名字并不总是有效和可用的,而限定这个名字的可用性的代码范围就是这个名字的作用域。作用域的使用提高了程序逻辑的局部性,增强了程序的可靠性,减少了名字冲突。 JavaScript(es6前)中的作用域有两种: 全局作用域 局部作用域(函数作用域) 1.2 全局作用域 作用于所有代码执行的环境(整个 script 标签内部)或者一个独立的 js 文件。 1.3 局部作用域 作用于函数内的代码环境,就是局部作用域。 因为跟函数有关系,所以 阅读详情

前言

this关键字是一个非常重要的语法点。毫不夸张地说,不理解它的含义,大部分开发任务都无法完成。

简单说,this就是属性或方法“当前”所在的对象。

this.property

上面代码中,this就代表property属性当前所在的对象。

下面是一个实际的例子。

var person = {
  name: '张三',
  describe: function () {
    return '姓名:'+ this.name;
  }
};

person.describe()
// "姓名:张三"

上面代码中,this.name表示name属性所在的那个对象。由于this.name是在describe方法中调用,而describe方法所在的当前对象是person,因此this指向person,this.name就是person.name。

由于对象的属性可以赋给另一个对象,所以属性所在的当前对象是可变的,即this的指向是可变的。

var A = {
  name: '张三',
  describe: function () {
    return '姓名:'+ this.name;
  }
};

var B = {
  name: '李四'
};

B.describe = A.describe;
B.describe() // "姓名:李四"

上面代码中,A.describe属性被赋给B,于是B.describe就表示describe方法所在的当前对象是B,所以this.name就指向B.name。

只要函数被赋给另一个变量,this的指向就会变。

var A = {
  name: '张三',
  describe: function () {
    return '姓名:'+ this.name;
  }
};

var name = '李四';
var f = A.describe;
f() // "姓名:李四"

上面代码中,A.describe被赋值给变量f,内部的this就会指向f运行时所在的对象(本例是顶层对象,在浏览器中就是window),因此name为全局name的值。

实质

JavaScript 语言之所以有 this 的设计,跟内存里面的数据结构有关系。

var obj = { foo:  5 };

上面的代码将一个对象赋值给变量obj。JavaScript 引擎会先在内存里面,生成一个对象{ foo: 5 },然后把这个对象的内存地址赋值给变量obj。也就是说,变量obj是一个地址(reference)。后面如果要读取obj.foo,引擎先从obj拿到内存地址,然后再从该地址读出原始的对象,返回它的foo属性。

原始的对象以字典结构保存,每一个属性名都对应一个属性描述对象。举例来说,上面例子的foo属性,实际上是以下面的形式保存的。

{
  foo: {
    [[value]]: 5
    [[writable]]: true
    [[enumerable]]: true
    [[configurable]]: true
  }
}

注意,foo属性的值保存在属性描述对象的value属性里面。

这样的结构是很清晰的,问题在于属性的值可能是一个函数。

var obj = { foo: function () {} };

这时,引擎会将函数单独保存在内存中,然后再将函数的地址赋值给foo属性的value属性。

{
  foo: {
    [[value]]: 函数的地址
    ...
  }
}

由于函数是一个单独的值,所以它可以在不同的环境(上下文)执行。

var f = function () {};
var obj = { f: f };

f() // 单独执行

obj.f() // obj 环境执行

JavaScript 允许在函数体内部,引用当前环境的其他变量。

var f = function () {
  console.log(x);
};

上面代码中,函数体里面使用了变量x。该变量由运行环境提供。

现在问题就来了,由于函数可以在不同的运行环境执行,所以需要有一种机制,能够在函数体内部获得当前的运行环境(context)。所以,this就出现了,它的设计目的就是在函数体内部,指代函数当前的运行环境。

var f = function () {
  console.log(this.x);
}

上面代码中,函数体里面的this.x就是指当前运行环境的x。this 就是指代当前运行在什么环境。

var f = function () {
  console.log(this.x);
}

var x = 1;
var obj = {
  f: f,
  x: 2,
};

// 单独执行
f() // 1

// obj 环境执行
obj.f() // 2

上面代码中,函数f在全局环境执行,this.x指向全局环境的x;在obj环境执行,this.x指向obj.x。参考视频讲解:进入学习

使用场合

this主要有以下几个使用场合。

全局环境下

  • 在浏览器全局环境下,this 始终指向全局对象(window), 无论是否严格模式;
this === window // true
  • 普通函数,非严格模式下,指向window。严格模式下,指向 undefined。
function f() {
    console.log(this === window);
}
f() // true

function f() {
    'use strict';
    console.log(this === undefined);
}
f() // true

构造函数中

构造函数中的this,指的是实例对象。

var Obj = function (p) {
  this.p = p;
};

上面代码定义了一个构造函数Obj。由于this指向实例对象,所以在构造函数内部定义this.p,就相当于定义实例对象有一个p属性。

var o = new Obj('Hello World!');
o.p // "Hello World!"

对象的方法中

如果对象的方法里面包含this,this的指向就是方法运行时所在的对象。该方法赋值给另一个对象,就会改变this的指向。

但是,这条规则很不容易把握。请看下面的代码。

var obj ={
  foo: function () {
    console.log(this);
  }
};

obj.foo() // obj

上面代码中,obj.foo方法执行时,它内部的this指向obj。

但是,下面这几种用法,都会改变this的指向。

// 情况一
(obj.foo = obj.foo)() // window
// 情况二
(false || obj.foo)() // window
// 情况三
(1, obj.foo)() // window

上面代码中,obj.foo就是一个值。这个值真正调用的时候,运行环境已经不是obj了,而是全局环境,所以this不再指向obj。

可以这样理解,JavaScript 引擎内部,obj和obj.foo储存在两个内存地址,称为地址一和地址二。

obj.foo()这样调用时,是从地址一调用地址二,因此地址二的运行环境是地址一,this指向obj。

但是,上面三种情况,都是直接取出地址二进行调用,这样的话,运行环境就是全局环境,因此this指向全局环境。上面三种情况等同于下面的代码:

// 情况一
(obj.foo = function () {
  console.log(this);
})()
// 等同于
(function () {
  console.log(this);
})()

// 情况二
(false || function () {
  console.log(this);
})()

// 情况三
(1, function () {
  console.log(this);
})()

如果this所在的方法不在对象的第一层,这时this只是指向当前一层的对象,而不会继承更上面的层。

var a = {
  p: 'Hello',
  b: {
    m: function() {
      console.log(this.p);
    }
  }
};

a.b.m() // undefined

上面代码中,a.b.m方法在a对象的第二层,该方法内部的this不是指向a,而是指向a.b,因为实际执行的是下面的代码。

var b = {
  m: function() {
   console.log(this.p);
  }
};

var a = {
  p: 'Hello',
  b: b
};

(a.b).m() // 等同于 b.m()

数组方法中的this

数组的map和foreach方法,允许提供一个函数作为参数。这个函数内部不应该使用this。

var o = {
  v: 'hello',
  p: [ 'a1', 'a2' ],
  f: function f() {
    this.p.forEach(function (item) {
      console.log(this.v + ' ' + item);
    });
  }
}

o.f()
// undefined a1
// undefined a2

上面代码中,foreach方法的回调函数中的this,其实是指向window对象,因此取不到o.v的值。原因跟上一段的多层this是一样的,就是内层的this不指向外部,而指向顶层对象。

解决这个问题的一种方法,就是前面提到的,使用中间变量固定this。

var o = {
  v: 'hello',
  p: [ 'a1', 'a2' ],
  f: function f() {
    var that = this;
    this.p.forEach(function (item) {
      console.log(that.v+' '+item);
    });
  }
}

o.f()
// hello a1
// hello a2

另一种方法是将this当作foreach方法的第二个参数,固定它的运行环境。

var o = {
  v: 'hello',
  p: [ 'a1', 'a2' ],
  f: function f() {
    this.p.forEach(function (item) {
      console.log(this.v + ' ' + item);
    }, this);
  }
}

o.f()
// hello a1
// hello a2

或者使用es6的箭头函数。

var o = {
  v: 'hello',
  p: [ 'a1', 'a2' ],
  f: function f() {
    this.p.forEach((item)=>{
        console.log(this.v + ' ' + item);
    });
  }
}

o.f()
// hello a1
// hello a2

原型链中 this

  • 原型链中的方法的this仍然指向调用它的对象
var o = {
  f : function(){ 
    return this.a + this.b; 
  }
};
var p = Object.create(o);
p.a = 1;
p.b = 4;

console.log(p.f()); // 5
  • 以上代码,可以看出, 在p中没有属性f,当执行p.f()时,会查找p的原型链,找到 f 函数并执行,但这与函数内部this指向对象 p 没有任何关系,只需记住谁调用指向谁。

DOM事件处理函数

  • 事件处理函数内部的 this 指向触发这个事件的对象
var oBox = document.getElementById('box');
oBox.onclick = function () {
    console.log(this)   //oBox
}

setTimeout & setInterval

对于延时函数内部的回调函数的this指向全局对象window(当然我们可以通过bind方法改变其内部函数的this指向)

//默认情况下代码
function Person() {  
    this.age = 0;  
    setTimeout(function() {
        console.log(this);
    }, 3000);
}

var p = new Person();//3秒后返回 window 对象
==============================================
//通过bind绑定
function Person() {  
    this.age = 0;  
    setTimeout((function() {
        console.log(this);
    }).bind(this), 3000);
}

var p = new Person();//3秒后返回构造函数新生成的对象 Person{...}

箭头函数中的 this

由于箭头函数不绑定this, 它会捕获其所在(即定义的位置)上下文的this值, 作为自己的this值,

  • 所以 call() / apply() / bind() 方法对于箭头函数来说只是传入参数,对它的 this 毫无影响。
  • 考虑到 this 是词法层面上的,严格模式中与 this 相关的规则都将被忽略。(可以忽略是否在严格模式下的影响)
function Person() {  
    setInterval(() => {
        console.log(this)    //Person
    }, 3000);
}

var p = new Person();

以上 this 指向 Person

let a = ()=> {
  console.log(this)
}
a()

以上代码 this 指向 window

this的动态切换,固然为 JavaScript 创造了巨大的灵活性,但也使得编程变得困难和模糊。有时,需要把this固定下来,避免出现意想不到的情况。JavaScript 提供了call、apply、bind这三个方法,来切换/固定this的指向。以下是绑定 this 的方法。

Function.prototype.call()

使用

函数实例的call方法,可以指定函数内部this的指向(即函数执行时所在的作用域),然后在所指定的作用域中,调用该函数。

var obj = {};

var f = function () {
  return this;
};

f() === window // true
f.call(obj) === obj // true

上面代码中,全局环境运行函数f时,this指向全局环境(浏览器为window对象);call方法可以改变this的指向,指定this指向对象obj,然后在对象obj的作用域中运行函数f。

call方法的参数,应该是一个对象。如果参数为空、null和undefined,则默认传入全局对象。

var n = 123;
var obj = { n: 456 };

function a() {
  console.log(this.n);
}

a.call() // 123
a.call(null) // 123
a.call(undefined) // 123
a.call(window) // 123
a.call(obj) // 456

上面代码中,a函数中的this关键字,如果指向全局对象,返回结果为123。如果使用call方法将this关键字指向obj对象,返回结果为456。可以看到,如果call方法没有参数,或者参数为null或undefined,则等同于指向全局对象。

注意:如果是严格模式或者vue(vue默认严格模式)中,传入null则指向null,传入window则指向window

如果call方法的参数是一个原始值,那么这个原始值会自动转成对应的包装对象,然后传入call方法。

var f = function () {
  return this;
};

f.call(5)
// Number {[[PrimitiveValue]]: 5}

上面代码中,call的参数为5,不是对象,会被自动转成包装对象(Number的实例),绑定f内部的this。

参数

call方法还可以接受多个参数。

func.call(thisValue, arg1, arg2, ...)

call的第一个参数就是this所要指向的那个对象,后面的参数则是函数调用时所需的参数。

function add(a, b) {
  return a + b;
}

add.call(this, 1, 2) // 3

上面代码中,call方法指定函数add内部的this绑定当前环境(对象),并且参数为1和2,因此函数add运行后得到3。

call方法的一个应用是调用对象的原生方法。

var obj = {};
obj.hasOwnProperty('toString') // false

// 覆盖掉继承的 hasOwnProperty 方法
obj.hasOwnProperty = function () {
  return true;
};
obj.hasOwnProperty('toString') // true

Object.prototype.hasOwnProperty.call(obj, 'toString') // false

上面代码中,通过obj对象继承Object的hasOwnProperty方法判断obj对象自身是没有 toString这个方法的,hasOwnProperty是obj对象继承的方法,如果这个方法一旦被覆盖(这里的覆盖并不是覆盖了Object原型上的方法,而是在obj创建了与原型一样的方法,执行的时候优先调用自身的方法),就不会得到正确结果。call方法可以解决这个问题,它将hasOwnProperty方法的原始定义放到obj对象上执行,这样无论obj上有没有同名方法,都不会影响结果。

手动实现

实现思路:

  • 改变this指向:可以将目标函数作为这个对象的属性
  • 利用arguments类数组对象实现参数不定长
  • 不能增加对象的属性,所以在结尾需要delete

以下是手动实现方式:

/***@desc 描述*@param object [Object] 需要指向的对象*/
Function.prototype.myCall = function (object) {
    let obj = object || window;    // 如果没有传this参数,this将指向window
    var fn = Symbol();       //  Symbol属性来确定fn唯一
    obj[fn] = this;                // 这里的this指向调用myCall的函数(代指a函数),同时将a函数的引用赋值给obj的fn属性。此时,当a函数调用的时候就是指向obj的了
    let arg = [...arguments].slice(1);    // 获取第二个及后面的所有参数(arg是一个数组)
    let result = obj[fn](...arg); // a函数的引用调用,指向obj,也就是传入的对象
    delete obj[fn] // 不能增加obj的属性,所以要删除
    return result // 如果a函数有返回值这里就有返回值,如果a函数没有返回值,同样的这里也没有
}

以上代码:

  • 当myCall没有传参的时候,做兼容,指向window。
  • myCall函数中this指向调用者,也就是执行myCall的函数,这里称之为a函数。
  • 将a函数的引用赋值给obj.fn,等同于a函数执行的时候,内部的this指向obj。这里就实现了this的绑定。
  • 将a参数使用arguments通过slice取出,当然,a函数的参数是从第二位开始,因此是slice(1)
  • 执行obj.fn等同于执行a函数,返回结果也等同于a函数的返回结果,如果a函数有返回值,则result有值,反之则没有。

以下是执行结果:

function a(c) {
    console.log('aaa', this.a + this.b + c);
}
const obj = {
    a: 1,
    b: 2
}
a.myCall(obj, 1) // 打印 4

myCall改变了a函数内的指向,指向obj,x相当于obj是a的实例,即obj调用a,a.myCall(obj, 1)等价于obj.a(1)因此打印 1+2+1=4。

Function.prototype.apply()

apply方法的作用与call方法类似,也是改变this指向,然后再调用该函数。唯一的区别就是,它接收一个数组作为函数执行时的参数,使用格式如下。

func.apply(thisValue, [arg1, arg2, ...])

apply方法的第一个参数也是this所要指向的那个对象,如果设为null或undefined,则等同于指定全局对象。第二个参数则是一个数组,该数组的所有成员依次作为参数,传入原函数。原函数的参数,在call方法中必须一个个添加,但是在apply方法中,必须以数组形式添加。

function f(x, y){
  console.log(x + y);
}

f.call(null, 1, 1) // 2
f.apply(null, [1, 1]) // 2

上面代码中,f函数本来接受两个参数,使用apply方法以后,就变成可以接受一个数组作为参数。

利用这一点,可以做一些有趣的应用。

将数组的空元素变为undefined

通过apply方法,利用Array构造函数将数组的空元素变成undefined。

Array.apply(null, ['a', ,'b']) // [ 'a', undefined, 'b' ]

空元素与undefined的差别在于,数组的forEach方法会跳过空元素,但是不会跳过undefined。因此,遍历内部元素的时候,会得到不同的结果。

当然,es6可以使用扩展运算符实现。

const arr = ['a',,'b'];
[...arr] // 'a',undefined,'b'

转换类似数组的对象

另外,利用数组对象的slice方法,可以将一个类似数组的对象(比如arguments对象)转为真正的数组。

Array.prototype.slice.apply({0: 1, length: 1}) // [1]
Array.prototype.slice.apply({0: 1}) // []
Array.prototype.slice.apply({0: 1, length: 2}) // [1, undefined]
Array.prototype.slice.apply({length: 1}) // [undefined]

上面代码的apply方法的参数都是对象,但是返回结果都是数组,这就起到了将对象转成数组的目的。从上面代码可以看到,这个方法起作用的前提是,被处理的对象必须有length属性,以及相对应的数字键。

手动实现

其实call和applay之间的差别就是后面的传参

/***@desc 描述*@param object [Object] 需要指向的对象*/
Function.prototype.myCall = function (object) {
    let obj = object || window;    // 如果没有传this参数,this将指向window
    var fn = Symbol();       //  Symbol属性来确定fn唯一
    obj[fn] = this;                // 这里的this指向调用myCall的函数(代指a函数),同时将a函数的引用
    let arg = [...arguments].slice(1);    // 获取第二个及后面的所有参数(arg是一个数组)
    let result = obj[fn](arg); // a函数的引用调用,指向obj,也就是传入的对象,这里直接传一个数组
    delete obj[fn] // 不能增加obj的属性,所以要删除
    return result // 如果a函数有返回值这里就有返回值,如果a函数没有返回值,同样的这里也没有
}

和call的区别就在于,以下代码传一个数组

let result = obj.fn(arg);

Function.prototype.bind()

bind()方法用于将函数体内的this绑定到某个对象,然后返回一个新函数。

var d = new Date();
d.getTime() // 1481869925657

var print = d.getTime;
print() // Uncaught TypeError: this is not a Date object.

上面代码中,我们将d.getTime()方法赋给变量print,然后调用print()就报错了。这是因为getTime()方法内部的this,绑定Date对象的实例,赋给变量print以后,内部的this已经不指向Date对象的实例了。

bind()方法可以解决这个问题。

var print = d.getTime.bind(d);
print() // 1481869925657

上面代码中,bind()方法将getTime()方法内部的this绑定到d对象,这时就可以安全地将这个方法赋值给其他变量了。

bind方法的参数就是所要绑定this的对象,下面是一个更清晰的例子。

var counter = {
  count: 0,
  inc: function () {
    this.count++;
  }
};

var func = counter.inc.bind(counter);
func();
counter.count // 1

上面代码中,counter.inc()方法被赋值给变量func。这时必须用bind()方法将inc()内部的this,绑定到counter,否则就会出错。

bind()还可以接受更多的参数,将这些参数绑定原函数的参数。

var add = function (x, y) {
  return x * this.m + y * this.n;
}

var obj = {
  m: 2,
  n: 2
};

var newAdd = add.bind(obj, 5); // 将5传给x
newAdd(5) // 20 将5传给y

上面代码中,bind()方法除了绑定this对象,还将add()函数的第一个参数x绑定成5,然后返回一个新函数newAdd(),这个函数只要再接受一个参数y就能运行了。

注意:如果bind()方法的第一个参数是null或undefined,等于将this绑定到全局对象,函数运行时this指向顶层对象(浏览器为window)。

bind()方法有一些使用注意点。

每一次返回一个新函数

bind()方法每运行一次,就返回一个新函数,这会产生一些问题。比如,监听事件的时候,不能写成下面这样。

element.addEventListener('click', o.m.bind(o));

上面代码中,click事件绑定bind()方法生成的一个匿名函数。这样会导致无法取消绑定,所以下面的代码是无效的。

element.removeEventListener('click', o.m.bind(o));

正确的方法是写成下面这样:

var listener = o.m.bind(o);
element.addEventListener('click', listener);
//  ...
element.removeEventListener('click', listener);

结合回调函数使用

回调函数是 JavaScript 最常用的模式之一,但是一个常见的错误是,将包含this的方法直接当作回调函数。解决方法就是使用bind()方法,将counter.inc()绑定counter。

var counter = {
  count: 0,
  inc: function () {
    'use strict';
    this.count++;
  }
};

function callIt(callback) {
  callback();
}

callIt(counter.inc.bind(counter));
counter.count // 1

上面代码中,callIt()方法会调用回调函数。这时如果直接把counter.inc传入,调用时counter.inc()内部的this就会指向全局对象。使用bind()方法将counter.inc绑定counter以后,就不会有这个问题,this总是指向counter。

还有一种情况比较隐蔽,就是某些数组方法可以接受一个函数当作参数。这些函数内部的this指向,很可能也会出错。

var obj = {
  name: '张三',
  times: [1, 2, 3],
  print: function () {
    this.times.forEach(function (n) {
      console.log(this.name);
    });
  }
};

obj.print()
// 没有任何输出

上面代码中,obj.print内部this.times的this是指向obj的,这个没有问题。但是,forEach()方法的回调函数内部的this.name却是指向全局对象,导致没有办法取到值

解决这个问题,也是通过bind()方法绑定this。

obj.print = function () {
  this.times.forEach(function (n) {
    console.log(this.name);
  }.bind(this));
};

obj.print()
// 张三
// 张三
// 张三

结合call()方法使用

利用bind()方法,可以改写一些 JavaScript 原生方法的使用形式,以数组的slice()方法为例。

[1, 2, 3].slice(0, 1) // [1]
// 等同于
Array.prototype.slice.call([1, 2, 3], 0, 1) // [1]

上面的代码中,数组的slice方法从[1, 2, 3]里面,按照指定的开始位置和结束位置,切分出另一个数组。这样做的本质是在[1, 2, 3]上面调用Array.prototype.slice()方法,因此可以用call方法表达这个过程,得到同样的结果。

call()方法实质上是调用Function.prototype.call()方法,因此上面的表达式可以用bind()方法改写。

var slice = Function.prototype.call.bind(Array.prototype.slice);
slice([1, 2, 3], 0, 1) // [1]

上面代码的含义就是:

call 方法是Function原型上的方法,而slice也是方法。因此,通过bind改变call的指向,指向slice,slice就相当于Function的实例,call是slice实例下的一个方法,也就是将slice变成call方法所在的对象。当call执行的时候,其实就等同于slice调用了call方法 Array.prototype.slice.call。

类似的写法还可以用于其他数组方法。

var push = Function.prototype.call.bind(Array.prototype.push);
var pop = Function.prototype.call.bind(Array.prototype.pop);

var a = [1 ,2 ,3];
push(a, 4)
a // [1, 2, 3, 4]

pop(a)
a // [1, 2, 3]

如果再进一步,将Function.prototype.call方法绑定到Function.prototype.bind对象,就意味着bind的调用形式也可以被改写。

function f() {
  console.log(this.v);
}

var o = { v: 123 };
var bind = Function.prototype.call.bind(Function.prototype.bind);
bind(f, o)() // 123

上面代码的含义就是:

  • 通过bind改变call的指向,指向bind。也就是bind成为了call的实例,相当于bind调用call。因此,返回Function.prototype.bind.call函数。

  • bind(f,o) 的含义是:调用Function.prototype.bind.call函数,第一个参数是改变bind指向,指向f。第二个参数是bind的参数。也就是f调用了bind函数,结果返回一个指向o的f函数。

  • 然后再加括号执行bind(f,o)(),就等于执行了指向o的f函数。最后打印结果的this指向o,因此打印出123。

手动实现

同call和applay不同的是,bind返回一个函数

/**      *@desc 描述      *@param object [Object] 需要指向的对象      */
Function.prototype.myBind = function (object) {
    let obj = object || window;    // 如果没有传this参数,this将指向window
    var fn = Symbol();       //  Symbol属性来确定fn唯一
    obj[fn] = this;                // 这里的this指向调用myCall的函数(代指a函数),同时将a函数的引用
    let arg = [...arguments].slice(1);    // 获取第二个及后面的所有参数(arg是一个数组)
    /* 返回一个函数,函数内部执行调用的a函数,并传入参数 */
    const fBind = function () {
        /* 如果当前函数执行中的this是fBound的实例,说明是fBind被new了,那么当前 this就是函数的实例,否则是obj */
        if (this instanceof fBind) {
            object[fn].applay(this, arg)
        } else {
            object[fn](...arg)
        }
        delete object[fn]
    }
    return fBind
}
function a(c) {
    console.log('aaa', this.a + this.b + c);
}
const obj = {
    a: 1,
    b: 2
}
a.myBind(obj, 1)(); // 打印 4
本地大模型部署实战:LM Studio与Ollama的易用性与性能深度评测 本文对两款主流本地大模型部署工具LM Studio和Ollama进行了深度评测。LM Studio凭借图形化界面和内置模型库,为新手提供了开箱即用的便捷体验,并支持OpenAI兼容API,易于生态集成。Ollama则以命令行驱动,轻量高效,凭借其原生API和Modelfile自定义能力,在自动化集成和性能方面表现突出。文章从易用性、模型生态、性能及扩展性多维度对比,帮助用户根据自身技术背景和使用场景做出最佳选择。 阅读详情

相关推荐

硬件开发实践:高速 PCB 差分信号与时钟同步优化

由两条互补信号线组成(正负极)接收端只关注两线之间电压差共模噪声对两线同时作用,可被抵消。

2501_93174775的博客 394

前端开发之彻底搞懂this指向

this是JavaScript中的一个关键字,但是有一个相对比较特别的关键字,不像function、var、for、if这些关键字一样,可以很清楚的搞清楚它到底是如何使用的。this会在执行上下文中绑定一个对象,但是是根据什么条件绑定的呢?在不同的执行条件下会绑定不同的对象,这也是让人捉摸不定的地方。这一次,我们一起来彻底搞定this到底是如何绑定的吧! 一. 理...

青梅煮码 1318

InSAR数据获取实战指南:Sentinel-1、精密轨道与ALOS PALSAR DEM的下载与应用

本文详细介绍了InSAR数据获取的实战指南,重点解析Sentinel-1数据、精密轨道数据(OPOD)和ALOS PALSAR DEM的下载与应用技巧。通过实际案例和代码示例,帮助读者掌握数据筛选、下载加速、校验及多源数据协同使用的关键方法,提升地面形变监测的精度与效率。

weixin_29215815的博客 433

javascript中this的指向问题和重构forEach方法中第二个参数

this指向问题

weixin_55269913的博客 341

别再乱提MR了!手把手教你配置GitLab的CI/CD与分支保护规则,让团队协作更丝滑

本文详细介绍了如何配置GitLab的CI/CD与分支保护规则,以优化团队协作流程。通过设置Protected Branches、MR流水线检查和自动化审批规则,有效防止不规范操作和合并冲突,提升开发效率与代码质量。特别强调MR(Merge Request)的正确使用,确保团队协作更丝滑。

weixin_28840591的博客 236

WebRTC音频传输实战:从采集到播放的完整链路解析(附RTP包处理细节)

本文深入解析了WebRTC音频传输的完整链路,从麦克风采集、音频处理与编码,到RTP打包、网络发送,再到接收端的NetEQ抗抖动处理与最终播放。文章以Linux PulseAudio为例,详细剖析了线程模型、缓冲区管理及RTP包处理等关键细节,旨在帮助开发者优化实时音频应用的延迟、卡顿与回声问题。

tea88的博客 853

JavaScript数组forEach方法及实现

一、forEach( function( element,index,self ){ },this):遍历数组每个元素,没有返回值,如果遍历数组的目的是为了得到返回值,那么使用map,否则使用forEach; 参数一:(必传) 需要传一个函数,函数参数: element:数组的每一项; index:每一项所对应的的索引; self:数组本身; 参数二:...

记录点滴 6542

LTSPICE使用教程:入门指导

LTSPICE仿真工具入门指导

焊武大帝的专栏 5万+

数组.forEach方法的回调函数this指向问题

数组.forEach的回调函数有两种写法 一、数组.forEach(function(){}) export default { props:["versionList"], data(){ return{ btnArr:[0] } }, methods:{ change(index){ let str=""; //这里this指向btnArr 那么versionList就会报

weixin_46147856的博客 2678

题解:AcWing 6051 看病

等知名刷题平台精心挑选而来,并结合各平台提供的算法标签和难度等级进行了系统分类。题目涵盖了从基础到进阶的多种算法和数据结构,旨在为不同阶段的编程学习者提供一条清晰、平稳的学习提升路径。但医院的排队不同其他排队,因为多数情况下,需要病情严重的人优先看病,所以希望BSNY设计系统时,以病情的严重情况作为优先级,判断接下来谁可以去看病。具体是这样的,最近来医院看病的人越来越多了,因此很多人要排队,只有当空闲时放一批病人看病。的操作,输出此时还在排队人中,优先级最大的患者姓名和优先级。后面没有输入,但需要你输出。

团爸讲算法 589

【推荐100个unity插件】基于关节物理控制的自行车、电动车、摩托车模拟解决方案——Simple Bicycle Physics

摘要 "简易自行车物理"是Unity的自行车模拟资源包,支持Animation Rigging,实现基于关节物理的自行车控制。兼容所有平台和渲染管线,包含预制体、材质、脚本等资源。核心脚本Bicycle Controller管理自行车物理属性,支持自定义角色设置和移动端控制。安装后,用户可快速配置骑行场景,调整转向、速度、重心等参数,并支持地面贴合、兔跳等功能。适用于开发各类自行车模拟游戏和应用。 (字数:149)

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 1367

前端面试必会 | 一文读懂 JavaScript 中的 this 关键字

this 是一个令无数 JavaScript 编程者又爱又恨的知识点。它的重要性毋庸置疑,然而真正想掌握它却并非易事。希望本文可以帮助大家理解 this。JavaScript 中的 th...

止水聊技术 2138

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

一文读懂:this:call、apply、bind

前言The last time, I have learned【THE LAST TIME】一直是我想写的一个系列,旨在厚积薄发,重温前端。也是给自己的查缺补漏和技术分享。欢迎大家多多...

祈澈菇凉 2783

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

JS中的this

*

个人学习的一些笔记 99

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

一文读懂 es6 中class方法中的this绑定

如果你在调用方法时不手动绑定 this,而方法是在类之外的地方被调用,那么 this 就不会自动指向类的实例,而是会丢失绑定,这可能会导致 this 指向全局对象或变为 undefined。class 的方法中没有自动的绑定this 为什么手动绑定之后,在绑定之后的方法里调用class中的其他的方法(这个方法为什么就能使用this,不也应该是null或者undefined或者window吗) 还是说这就是class的机制?当你调用这个新函数时,无论是在哪里调用,this 的值都是你绑定的那个对象。

weixin_55010563的博客 561

一篇文章带你读懂,JavaScript中的this是什么东东?

一篇文章带你读懂 JavaScript 中的 this

ning_mu_的博客 1102

一文读懂:JS箭头函数与普通函数的差异及this指向

了解了箭头函数与普通函数的差异后,我们可以更加明智地选择适合的函数类型。当你需要动态绑定this、使用arguments对象或创建构造函数时,普通函数是更好的选择。而当你追求简洁的语法、处理嵌套函数或回调函数时,箭头函数则显得尤为方便。在JavaScript的编程旅程中,掌握这两种函数类型的差异和用法将使你更加游刃有余。希望这篇文章能帮助你更好地理解它们,并在实际编程中灵活运用。

md_1008的博客 545

call stack是什么错误_一文读懂:this:call、apply、bind

前言The last time, I have learned【THE LAST TIME】一直是我想写的一个系列,旨在厚积薄发,重温前端。也是给自己的查缺补漏和技术分享。欢迎大家多多评论指点吐槽。系列文章均首发于公众号【全栈前端精选】,笔者文章集合详见Nealyang/personalBlog。目录皆为暂定讲道理,这篇文章有些拿捏不好尺度。准确的说,这篇文章讲解的内容基本算是基础的基础...

weixin_39866646的博客 315

一文读懂JS中call()、apply()、bind()的区别及用法

call、apply和bind三个方法都是用来改变this指向的。 // 全局变量 var name = '小包子', age = 18 var moonObj = { name: '小月亮', moonAge: this.age, myMsg: function () { console.log(this.name + '年龄' + this.age); console.log(this); }

小太阳的博客 452
上一篇: 一比一手写迷你版vue,彻底搞懂vue运行机制
下一篇: 彻底搞懂JS原型与原型链
hellocoder2029
博客等级 码龄4年 15粉丝 80原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值