JS 系列五：深入 call 、 apply 、 bind

最新推荐文章于 2024-03-29 23:48:23 发布
最新推荐文章于 2024-03-29 23:48:23 发布
阅读量144 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lunahaijiao/article/details/100789263
版权

引言

JS系列暂定 27 篇，从基础，到原型，到异步，到设计模式，到架构模式等。

本篇是JS系列中第 5 篇，文章主讲 JS 中 call 、 apply 、 bind 、箭头函数以及柯里化，着重介绍它们之间的区别、对比使用，深入了解 call 、 apply 、 bind 。

一、Function.prototype.call()

call() 方法调用一个函数, 其具有一个指定的 this 值和多个参数(参数的列表)。

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

它运行 func，提供的第一个参数 thisArg 作为 this，后面的作为参数。

1. func 与 func.call

先看一个例子：

func(1, 2, 3);
func.call(obj, 1, 2, 3)

他们都调用的是 func，参数是 1，2 和 3。

唯一的区别是 func.call 也将 this 设置为 obj。

需要注意的是，设置的 thisArg 值并不一定是该函数执行时真正的 this 值，如果这个函数处于非严格模式下，则指定为 null 和 undefined 的 this 值会自动指向全局对象(浏览器中就是 window 对象)，同时值为原始值(数字，字符串，布尔值)的 this 会指向该原始值的自动包装对象。

2. func.call 绑定上下文

例如，在下面的代码中，我们在对象的上下文中调用 sayWord.call(bottle) 运行 sayWord ，并 bottle 传递为 sayWord 的 this：

function sayWord() {
  var talk = [this.name, 'say', this.word].join(' ');
  console.log(talk);
}

var bottle = {
  name: 'bottle', 
  word: 'hello'
};

// 使用 call 将 bottle 传递为 sayWord 的 this
sayWord.call(bottle); 
// bottle say hello
3. 使用 func.call 时未指定 this
非严格模式
// 非严格模式下
var bottle = 'bottle'
function say(){
   // 注意：非严格模式下，this 为 window
   console.log('name is %s',this.bottle)
}

say.call()
// name is bottle
严格模式
// 严格模式下
'use strict'
var bottle = 'bottle'
function say(){
   // 注意：在严格模式下 this 为 undefined
   console.log('name is %s',this.bottle)
}

say.call()
// Uncaught TypeError: Cannot read property 'bottle' of undefined
4. call 在 JS 继承中的使用: 构造继承

基本思想：在子类型的构造函数内部调用父类型构造函数。

注意：函数只不过是在特定环境中执行代码的对象，所以这里使用 apply/call 来实现。

使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类（没用到原型）

// 父类
function SuperType (name) {
  this.name = name; // 父类属性
}
SuperType.prototype.sayName = function () { // 父类原型方法
  return this.name;
};

// 子类
function SubType () {
  // 调用 SuperType 构造函数
  // 在子类构造函数中，向父类构造函数传参
  SuperType.call(this, 'SuperType'); 
  // 为了保证子父类的构造函数不会重写子类的属性，需要在调用父类构造函数后，定义子类的属性
  this.subName = "SubType"; 
  // 子类属性
};

// 子类实例
let instance = new SubType(); 
// 运行子类构造函数，并在子类构造函数中运行父类构造函数，this绑定到子类
5. 解决 var 作用域问题
var bottle = [
  {name: 'an', age: '24'},
  {name: 'anGe', age: '12'}
];

for (var i = 0; i < bottle.length; i++) {
  // 匿名函数
  (function (i) { 
    setTimeout(() => {
      // this 指向了 bottle[i]
      console.log('#' + i  + ' ' + this.name + ': ' + this.age); 
    }, 1000)
  }).call(bottle[i], i);
  // 调用 call 方法，同时解决了 var 作用域问题
}

打印结果：

#0 an: 24
#1 anGe: 12

在上面例中的 for 循环体内，我们创建了一个匿名函数，然后通过调用该函数的 call 方法，将每个数组元素作为指定的 this 值立即执行了那个匿名函数。这个立即执行的匿名函数的作用是打印出 bottle[i] 对象在数组中的正确索引号。

二、Function.prototype.apply()

apply() 方法调用一个具有给定 this 值的函数，以及作为一个数组（或[类似数组对象）提供的参数。

func.apply(thisArg, [argsArray])

它运行 func 设置 this = context 并使用类数组对象 args 作为参数列表。

例如，这两个调用几乎相同：

func(1, 2, 3);
func.apply(context, [1, 2, 3])

两个都运行 func 给定的参数是 1,2,3。但是 apply 也设置了 this = context。

call 和 apply 之间唯一的语法区别是 call 接受一个参数列表，而 apply 则接受带有一个类数组对象。

需要注意：Chrome 14 以及 Internet Explorer 9 仍然不接受类数组对象。如果传入类数组对象，它们会抛出异常。

1. call、apply 与 扩展运算符

我们已经知道了JS 基础之:  var、let、const、解构、展开、函数  一章中的扩展运算符 ...，它可以将数组（或任何可迭代的）作为参数列表传递。因此，如果我们将它与 call 一起使用，就可以实现与 apply 几乎相同的功能。

这两个调用结果几乎相同：

let args = [1, 2, 3];

func.call(context, ...args); // 使用 spread 运算符将数组作为参数列表传递
func.apply(context, args);   // 与使用 call 相同

如果我们仔细观察，那么 call 和 apply 的使用会有一些细微的差别。

  • 扩展运算符 … 允许将 可迭代的 参数列表 作为列表传递给 call。

  • apply 只接受 类数组一样的 参数列表。

2. apply 函数转移

apply 最重要的用途之一是将调用传递给另一个函数，如下所示：

let wrapper = function() {
  return anotherFunction.apply(this, arguments);
};

wrapper 通过 anotherFunction.apply 获得了上下文 this 和 anotherFunction 的参数并返回其结果。

当外部代码调用这样的 wrapper 时，它与原始函数的调用无法区分。

3. apply 连接数组

array.push.apply 将数组添加到另一数组上：

var array = ['a', 'b']
var elements = [0, 1, 2]
array.push.apply(array, elements)
console.info(array) // ["a", "b", 0, 1, 2]
4. apply 来链接构造器
Function.prototype.constructor = function (aArgs) {
  var oNew = Object.create(this.prototype);
  this.apply(oNew, aArgs);
  return oNew;
};
5. apply 和内置函数
/* 找出数组中最大/小的数字 */
let numbers = [5, 6, 2, 3, 7]
/* 应用(apply) Math.min/Math.max 内置函数完成 */

let max = Math.max.apply(null, numbers) 
/* 基本等同于 Math.max(numbers[0], ...) 或 Math.max(5, 6, ..) */

let min = Math.min.apply(null, numbers)

console.log('max: ', max)
// max: 7
console.log('min: ', min)
// min: 2

它相当于：

/* 代码对比： 用简单循环完成 */
let numbers = [5, 6, 2, 3, 7]
let max = -Infinity, min = +Infinity
for (var i = 0; i < numbers.length; i++) {
  if (numbers[i] > max)
    max = numbers[i]
  if (numbers[i] < min) 
    min = numbers[i]
}

console.log('max: ', max)
// max: 7
console.log('min: ', min)
// min: 2

但是：如果用上面的方式调用 apply，会有超出 JavaScript 引擎的参数长度限制的风险。更糟糕的是其他引擎会直接限制传入到方法的参数个数，导致参数丢失。

所以，当数据量较大时

function minOfArray(arr) {
  var min = Infinity
  var QUANTUM = 32768 // JavaScript 核心中已经做了硬编码  参数个数限制在65536

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)))
    min = Math.min(submin, min)
  }
  return min
}
var min = minOfArray([5, 6, 2, 3, 7])
// max 同样也是如此

三、Function.prototype.bind()

JavaScript 新手经常犯的一个错误是将一个方法从对象中拿出来，然后再调用，希望方法中的 this 是原来的对象（比如在回调中传入这个方法）。如果不做特殊处理的话，一般 this 就丢失了。

例如：

let bottle = {
  nickname: "bottle",
  sayHello() {
    console.log(`Hello, ${this.nickname}!`)
  },
  sayHi(){
    setTimeout(function(){
      console.log('Hello, ', this.nickname)
    }, 1000)
  }
};

// 问题一
bottle.sayHi();
// Hello, undefined!

// 问题二
setTimeout(bottle.sayHello, 1000); 
// Hello, undefined!

问题一的 this.nickname 是 undefined ，原因是 this 指向是在运行函数时确定的，而不是定义函数时候确定的，再因为 sayHi  中 setTimeout 在全局环境下执行，所以 this 指向 setTimeout 的上下文：window。

问题二的 this.nickname 是 undefined ，是因为 setTimeout 仅仅只是获取函数 bottle.sayHello 作为 setTimeout 回调函数，this 和 bottle 对象分离了。

问题二可以写为：

// 在这种情况下，this 指向全局作用域
let func = bottle.sayHello;
setTimeout(func, 1000); 
// 用户上下文丢失
// 浏览器上，访问的实际上是 Window 上下文

那么怎么解决这两个问题喃？

解决方案一：缓存 this 与包装

首先通过缓存 this 解决问题一 bottle.sayHi(); ：

let bottle = {
  nickname: "bottle",
  sayHello() {
    console.log(`Hello, ${this.nickname}!`)
  },
  sayHi(){
    var _this = this // 缓存this
    setTimeout(function(){
      console.log('Hello, ', _this.nickname)
    }, 1000)
  }
};

bottle.sayHi();
// Hello,  bottle

那问题二 setTimeout(bottle.sayHello, 1000); 喃？

let bottle = {
  nickname: "bottle",
  sayHello() {
    console.log(`Hello, ${this.nickname}!`);
  }
};

// 加一个包装层
setTimeout(() => {
  bottle.sayHello()
}, 1000); 
// Hello, bottle!

这样看似解决了问题二，但如果我们在 setTimeout 异步触发之前更新 bottle 值又会怎么样呢？

var bottle = {
  nickname: "bottle",
  sayHello() {
    console.log(`Hello, ${this.nickname}!`);
  }
};

setTimeout(() => {
  bottle.sayHello()
}, 1000); 

// 更新 bottle
bottle = {
  nickname: "haha",
  sayHello() {
    console.log(`Hi, ${this.nickname}!`)
  }
};
// Hi, haha!

bottle.sayHello() 最终打印为 Hi, haha! ，那么怎么解决这种事情发生喃？

解决方案二：bind

bind() 最简单的用法是创建一个新绑定函数，当这个新绑定函数被调用时，this 键值为其提供的值，其参数列表前几项值为创建时指定的参数序列，绑定函数与被调函数具有相同的函数体（ES5中）。

let bottle = {
  nickname: "bottle",
  sayHello() {
    console.log(`Hello, ${this.nickname}!`);
  }
};

// 未绑定，“this” 指向全局作用域
let sayHello = bottle.sayHello
console.log(sayHello())
// Hello, undefined!

// 绑定
let bindSayHello = sayHello.bind(bottle)
// 创建一个新函数，将 this 绑定到 bottle 对象
console.log(bindSayHello())
// Hello, bottle!

所以，从原来的函数和原来的对象创建一个绑定函数，则能很漂亮地解决上面两个问题：

let bottle = {
  nickname: "bottle",
  sayHello() {
    console.log(`Hello, ${this.nickname}!`);
  },
  sayHi(){
    // 使用 bind
    setTimeout(function(){
      console.log('Hello, ', this.nickname)
    }.bind(this), 1000)

    // 或箭头函数
    setTimeout(() => {
      console.log('Hello, ', this.nickname)
    }, 1000)
  }
};

// 问题一：完美解决
bottle.sayHi()
// Hello,  bottle
// Hello,  bottle

let sayHello = bottle.sayHello.bind(bottle); // (*)

sayHello(); 
// Hello, bottle!

// 问题二：完美解决
setTimeout(sayHello, 1000); 
// Hello, bottle!

// 更新 bottle
bottle = {
  nickname: "haha",
  sayHello() {
    console.log(`Hi, ${this.nickname}!`)
  }
};

问题一，可以通过 bind 或箭头函数完美解决。

最终更新 bottle 后， setTimeout(sayHello, 1000); 打印依然是 Hello, bottle!， 问题二完美解决！

1. bind 与 new

再看一个例子：

this.nickname = 'window'
let bottle = {
  nickname: 'bottle'
}
function sayHello() {
  console.log('Hello, ', this.nickname)
}

let bindBottle = sayHello.bind(bottle) // this 指向 bottle
console.log(bindBottle()) 
// Hello,  bottle

console.log(new bindBottle())  // this 指向 sayHello {}
// Hello,  undefined

上面例子中，运行结果 this.nickname 输出为 undefined ，这不是全局 nickname ， 也不是 bottle 对象中的 nickname ，这说明 bind 的 this 对象失效了，new 的实现中生成一个新的对象，这个时候的 this 指向的是 sayHello 。

注意 ：绑定函数也可以使用 new 运算符构造：这样做就好像已经构造了目标函数一样。提供的 this 值将被忽略，而前置参数将提供给模拟函数。

2. 二次 bind
function sayHello() {
  console.log('Hello, ', this.nickname)
}

sayHello = sayHello.bind( {nickname: "Bottle"} ).bind( {nickname: "AnGe" } );
sayHello();
// Hello,  Bottle

输出依然是 Hello, Bottle ，这是因为 func.bind(...) 返回的外来的绑定函数对象仅在创建的时候记忆上下文（如果提供了参数）。

一个函数不能作为重复绑定。

2. 偏函数

当我们确定一个函数的一些参数时，返回的函数（更加特定）被称为偏函数。我们可以使用 bind 来获取偏函数：

function list() {
  return Array.prototype.slice.call(arguments);
}

var list1 = list(1, 2, 3); // [1, 2, 3]

var leadingThirtysevenList = list.bind(undefined, 37);
var list2 = leadingThirtysevenList(); // [37]
var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]

当我们不想一遍又一遍重复相同的参数时，偏函数很方便。

3. 作为构造函数使用的绑定函数
function Bottle(nickname) {
  this.nickname = nickname;
}
Bottle.prototype.sayHello = function() { 
  console.log('Hello, ', this.nickname)
};

let bottle = new Bottle('bottle');
let BindBottle = Bottle.bind(null, 'bindBottle');

let b1 = new BindBottle('b1');
b1 instanceof Bottle; // true
b1 instanceof BindBottle; // true
new Bottle('bottle1') instanceof BindBottle; // true

b1.sayHello()
// Hello,  bindBottle

四、柯里化

在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。

var add = function(x) {
  return function(y) {
    return x + y;
  };
};

var increment = add(1);
var addTen = add(10);

increment(2);
// 3

addTen(2);
// 12

add(1)(2);
// 3

这里定义了一个 add 函数，它接受一个参数并返回一个新的函数。调用 add 之后，返回的函数就通过闭包的方式记住了 add 的第一个参数。所以说 bind 本身也是闭包的一种使用场景。

柯里化是将 f(a,b,c) 可以被以 f(a)(b)(c) 的形式被调用的转化。JavaScript 实现版本通常保留函数被正常调用和在参数数量不够的情况下返回偏函数这两个特性。

五、扩展：箭头函数

1. 没有 this
let bottle = {
  nickname: "bottle",
  sayHi(){
    setTimeout(function(){
      console.log('Hello, ', this.nickname)
    }, 1000)

    // 或箭头函数
    setTimeout(() => {
      console.log('Hi, ', this.nickname)
    }, 1000)
  }
};

bottle.sayHi()
// Hello,  undefined
// Hi,  bottle

报错是因为 Hello, undefined 是因为运行时 this=Window ， Window.nickname  为 undefined。

但箭头函数就没事，因为箭头函数没有 this。在外部上下文中，this 的查找与普通变量搜索完全相同。this 指向定义时的环境。

2. 不可 new 实例化

不具有 this 自然意味着另一个限制：箭头函数不能用作构造函数。他们不能用 new 调用。

3. 箭头函数 vs bind

箭头函数 => 和正常函数通过 .bind(this) 调用有一个微妙的区别：

  • .bind(this) 创建该函数的 “绑定版本”。

  • 箭头函数 =&gt; 不会创建任何绑定。该函数根本没有 this。在外部上下文中，this 的查找与普通变量搜索完全相同。

4. 没有 arguments 对象

箭头函数也没有 arguments 变量。

因为我们需要用当前的 this 和 arguments 转发一个调用，所有这对于装饰者来说非常好。

例如，defer(f, ms) 得到一个函数，并返回一个包装函数，以 毫秒 为单位延迟调用：

function defer(f, ms) {
  return function() {
    setTimeout(() => f.apply(this, arguments), ms)
  };
}

function sayHi(who) {
  alert('Hello, ' + who);
}

let sayHiDeferred = defer(sayHi, 2000);
sayHiDeferred("John"); // 2 秒后打印 Hello, John

没有箭头功能的情况如下所示：

function defer(f, ms) {
  return function(...args) {
    let ctx = this;
    setTimeout(function() {
      return f.apply(ctx, args);
    }, ms);
  };
}

在这里，我们必须创建额外的变量 args 和 ctx，以便 setTimeout 内部的函数可以接收它们。

5. 总结

  • this 指向定义时的环境

  • 不可 new 实例化

  • this 不可变

  • 没有 arguments 对象

❤️感谢阅读

1. ❤️玩得开心，不断学习，并始终保持编程。????

2. ????点击原文，查看更多精彩文章！????

3. 如有任何问题或更独特的见解，欢迎联系瓶子君！（关注公众号，回复 123 即可）????????

前端瓶子君
关注
js系列十三：手写call，apply，bind及面试题解析
人生代码 ---- 公众号
03-03 2955
他们有什么不同呢？怎么运用他们呢？ call 接收多个参数，第一个为函数上下文也就是this，后边参数为函数本身的参数。 let obj = { name: "一个", } function fn(firstName, lastName) { console.log(this); console.log(`我的全名是${firstName}${this.name}${lastName}`);...
开启Javascript中apply、call、bind的用法之旅模式
10-23
为了控制函数的this指向，JavaScript提供了apply、call以及bind方法。以下详细解释了apply、call以及bind的用法，并通过实例加深理解。 1. apply()和call()方法 apply()和call()方法都用于指定函数体内this的值。...
关于setTimeout()你所不知道的地方
进击的前端小白
07-11 7970
前言：看了这篇文章，1.注意setTimeout引用的是全部变量还是局部变量了，当直接调用外部函数方法时，实际上函数内部的变量已经变成全 局。2.提醒我防止出错的，用匿名函数不容易出错。3.setTimeout最快执行时间是4毫秒。4.使用setTimeout的函数会比当前队列的函 数慢执行，在他们的后面。5.setTimeout中的定时器并不是准确的时间，实际中它需要在执行完前面的函数后才定时执...
this指向三剑客：call apply bind
lucky569的博客
05-17 102
共同点，众所周知都是改变this的指向(也就是函数执行时的上下文) 区别，就先看看传参吧～ call: call接受的是一个参数列表，其中第一个参数表示函数运行时的this值; 如果没有传入第一个参数，this 的值将会被绑定为全局对象. 如： Function.call(thisArgs,args1,arg2...) 返回值：使用调用者提供的 this 值和参数调用该函数的返回值，没有则返回undefined。 例如：使用call调用父构造函数(继承） function Product(name,p
前端面试题：手写call、apply、bind函数
ThisEqualThis的博客
02-21 804
bind() 方法创建一个新的函数，在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用。apply() 方法调用一个具有给定 this 值的函数，以及以一个数组（或一个类数组对象）的形式提供的参数。call() 方法使用一个指定的 this 值和单独给出的一个或多个参数来调用一个函数。说白了就是改变当前调用函数的this指向，并向调用函数中传参。
JavaScript进阶 —— 深入理解 call，apply 和 bind
金戈鐡馬
03-28 2362
在JavaScript 中，call、apply 和 bind 是 Function 对象自带的三个方法，这三个方法的主要作用是改变函数中的 this 指向，从而可以达到`接花移木`的效果。本文将对这三个方法进行详细的讲解，并列出几个经典应用场景。1、call。
JavaScript(12)：apply、call、bind
dawn0718的专栏
02-13 582
　　JavaScript是一门非常灵巧的面向对象的开发语言，函数作为“第一公民”有很多方面的特殊应用手段，比如bind、apply、call等方法函数，它们的使用方式、传递参数都是一样的，也有区别。通过它们的使用，在以后面向对象的开发、建模、多态应用上会有很好的表现手段。 　　不同的是： 　　bind：绑定this的指向，然后返回一个新函数，返回的对应方法不会立即执行，需要调用才执行 　　call、apply：改变this的指向，调用是立即执行的。 　　apply和call的不同点： 　　1、call：
JS面试题：call,apply,bind区别
2401_83127745的博客
03-29 216
call，apply，bind都是改变函数this指向的call和apply用法基本上一致，唯一不同点是apply传参是以数组的方式传入，而call是一个个传入bind用法和call基本上一致，唯一不同的是call和apply是立即执行的，而bind不是立即执行。
前端JS必备知识点： call、apply、bind的区别
weixin_42721322的博客
05-27 209
bind、call、apply的区别 call()、apply()、bind()都是用来改变this的指向，但是他们具体的使用场景和作用存在很大的区别 1、call() 可以直接调用函数，call()方法传递的参数是thisArg（this要指向的对象）,aru1,aru2...形式 改变调用函数内的this指向 call()方法主要作用是可以实现继承 function Father(uname, age, sex) { this.uname = uname; this.ag.
JS：call、apply、bind的作用和区别
elevenhope的博客
02-10 1861
一、call call、apply、bind都是改变this指向的方法 1.call是函数的方法，可以调用函数 function fun(){ console.log(this); } fun.call(); // Window 2.call的第一个参数可以改变函数中this的指向 function fun1(){ console.log(this.name); } let cat = { name: "喵喵" } fun1.call(cat); // 喵喵 let dog
JS核心系列：浅谈 call apply 与 bind
iteye_13833的博客
03-30 151
作者：一像素 网址：http://www.cnblogs.com/onepixel/p/5143863.html   在JavaScript中，call、apply和bind 是Function对象自带的三个方法，这三个方法的主要作用是改变函数中的this指向，从而可以达到接花移木的效果。本文将对这三个方法进行详细的讲解，并列出几个经典应用场景。   call(thisArg...
Javascript中call，apply，bind方法的详解与总结
10-20
本文针对JavaScript中三个重要的函数方法——call、apply和bind，进行详尽的分析，并在文章的结尾部分对这三个方法之间的联系和区别进行了概括，以便于读者更深入地理解它们的用途和应用场景。 首先，我们来探讨...
深入理解JavaScript中的call、apply、bind方法的区别
10-22
call、apply和bind是JavaScript中用于改变函数内部this指向的三个方法。虽然它们的作用都是为了改变函数的上下文，但它们在使用方式和用途上存在一些差异。 首先，我们来看call方法。call方法的第一个参数是作为...
js代码-JavaScript的call/apply/bind函数实现
07-15
在JavaScript中，`call()`, `apply()`, 和 `bind()` 是三个非常重要的函数，它们都与函数调用有关，但各自有不同的应用场景。本文将深入探讨这三个函数的实现原理及其使用方式。 首先，`call()` 函数允许我们调用一...
基于微信小程序的在线办公小程序答辩PPT.pptx
11-04
基于微信小程序的在线办公小程序答辩PPT.pptx
机器学习（预测模型）：2000年至2015年期间193个国家的预期寿命和相关健康因素的数据
11-04
这个数据集来自世界卫生组织（WHO），包含了2000年至2015年期间193个国家的预期寿命和相关健康因素的数据。它提供了一个全面的视角，用于分析影响全球人口预期寿命的多种因素。数据集涵盖了从婴儿死亡率、GDP、BMI到免疫接种覆盖率等多个维度，为研究者提供了丰富的信息来探索和预测预期寿命。 该数据集的特点在于其跨国家的比较性，使得研究者能够识别出不同国家之间预期寿命的差异，并分析这些差异背后的原因。数据集包含22个特征列和2938行数据，涉及的变量被分为几个大类：免疫相关因素、死亡因素、经济因素和社会因素。这些数据不仅有助于了解全球健康趋势，还可以辅助制定公共卫生政策和社会福利计划。 数据集的处理包括对缺失值的处理、数据类型转换以及去重等步骤，以确保数据的准确性和可靠性。研究者可以使用这个数据集来探索如教育、健康习惯、生活方式等因素如何影响人们的寿命，以及不同国家的经济发展水平如何与预期寿命相关联。此外，数据集还可以用于预测模型的构建，通过回归分析等统计方法来预测预期寿命。 总的来说，这个数据集是研究全球健康和预期寿命变化的宝贵资源，它不仅提供了历史数据，还为未来的研究和政策制
基于微信小程序的“健康早知道”微信小程序答辩PPT.pptx
11-04
基于微信小程序的“健康早知道”微信小程序答辩PPT.pptx
基于微信小程序的电影交流平台答辩PPT.pptx
11-04
基于微信小程序的电影交流平台答辩PPT.pptx
计算机字符编码GB18030.PDF
最新发布
11-04
计算机字符编码GB18030
深入理解JavaScript进阶面试必备：call、apply与bind原理剖析
本资源主要聚焦于JavaScript的进阶知识点和常考面试题，特别是关于`call`、`apply`和`bind`这三个核心函数的理解与实现。JavaScript的高级特性往往在面试中成为区分候选人能力的关键部分。 在学习这一章节时，理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值