深入浅出JS—18 手把手实现一个Promise类

最新推荐文章于 2024-04-30 00:26:55 发布
最新推荐文章于 2024-04-30 00:26:55 发布
阅读量450 收藏 3
点赞数 1
文章标签： javascript 前端 js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36154157/article/details/124768363
版权

Promise类的实现是高级面试中常考的题目，由于Promise包含的方法比较多，一般写到Promise1.0或者2.0版本已经能够满足面试要求了，不过全面深入理解Promise对于工作中Promise的使用也非常有帮助

Promise1.0版本⭐

实现constrcutor函数，then函数

  • Promise是一个类，要创建对象就要调用new关键字，传入的参数为一个函数executor
  • executor函数有两个入参，为两个回调函数resolve，reject，它们已经在Promise类内部实现好了
  • executor函数传入之后会被立即执行
class MyPromise {
  // 构造函数
  constructor(executor) {
    const resolve = (value) => {
      this.value = value;
    };
    const reject = (reason) => {
      this.reason = reason;
    };
    // 立即执行函数
    executor(resolve, reject);
  }
}

then基本实现

class MyPromise {
  constructor(executor) {
    const resolve = (value) => {
      this.value = value;
    };
    const reject = (reason) => {
      this.reason = reason;
    };
    executor(resolve, reject);
  }
  
  // then方法
  then(onFulfilled, onRejected) {
    onFulfilled(this.value);
    onRejected(this.reason);
  }
}

/* ---------------- 测试代码 ----------------------*/
const promise = new MyPromise((resolve, reject) => {
  setTimeout(() => {
    resolve("resolve value");
    reject("reject reason");
  }, 100);
});

promise.then(
  (res) => { console.log("res:", res); }, 
  (err) => { console.log("err:", err); }
);
// undefined undefined

❎问题：顺序执行到then方法时，setTimeout函数还没执行回调，this.value和this.reason还没为undefined

✅改进：onFulfilled(this.value)和 onRejected(this.reason)入参不应该在then方法中调用，应该在resolve和reject中调用
每次对代码改进的关键步骤都用⭐进行了标识

class MyPromise {
  constructor(executor) {
    const resolve = (value) => {
      this.value = value;
      this.onFulfilled(this.value); // ⭐
    };
    const reject = (reason) => {
      this.reason = reason;
      this.onRejected(this.reason); // ⭐
    };
    executor(resolve, reject);
  }

  // then方法
  then(onFulfilled, onRejected) {
    this.onFulfilled = onFulfilled; // ⭐
    this.onRejected = onRejected; // ⭐
  }
}
/* ---------------- 测试代码 ----------------------*/
const promise = new MyPromise((resolve, reject) => {
    resolve("resolve value");
    reject("reject reason");
});

promise.then(
  (res) => { console.log("res:", res); }, 
  (err) => { console.log("err:", err); }
);
// 报错：TypeError: this.onFulfilled is not a function

❎问题：调用this.onFulfilled时，还没执行到then，所以还是undefined

✅改进：必须更改顺序，先执行then，拿到回调函数，然后再在resolve、reject函数中调用回调函数
⭐重点：queueMicrotask() 主动调用异步函数，来更改代码的执行顺序

class MyPromise {
  // 构造函数
  constructor(executor) {
    const resolve = (value) => {
      this.value = value;
      queueMicrotask(() => this.onFulfilled(this.value));// ⭐
    };
    const reject = (reason) => {
      this.reason = reason;
      queueMicrotask(() => this.onRejected(this.reason));// ⭐
    };
    executor(resolve, reject);
  }

  // then方法
  then(onFulfilled, onRejected) {
    this.onFulfilled = onFulfilled;
    this.onRejected = onRejected;
  }
}

❎问题：resolve和reject只能执行一个

✅改进：引入Promise状态变量
⭐重点：对于三种固定的状态，一般使用枚举来书写（ts），没有枚举就定义常量

const PROMISE_STATUS_PENDING = "pending";
const PROMISE_STATUS_FULFILLED = "fulfilled";
const PROMISE_STATUS_REJECTED = "rejected";

class MyPromise {
  // 构造函数
  constructor(executor) {
    this.status = PROMISE_STATUS_PENDING;

    const resolve = (value) => {
      if (this.status !== PROMISE_STATUS_PENDING) return; // ⭐
      this.status = PROMISE_STATUS_FULFILLED;
      this.value = value;
      queueMicrotask(() => {
        this.onFulfilled(this.value);
      });
    };

    const reject = (reason) => {
      if (this.status !== PROMISE_STATUS_PENDING) return; //⭐
      this.status = PROMISE_STATUS_REJECTED;
      this.reason = reason;
      queueMicrotask(() => {
        this.onRejected(this.reason);
      });
    };

    executor(resolve, reject);
  }

  then(onFulfilled, onRejected) {
    this.onFulfilled = onFulfilled;
    this.onRejected = onRejected;
  }
}

Promise2.0版本⭐

then多次调用

/* ---------------- 测试代码 ----------------------*/
const promise = new MyPromise((resolve, reject) => {
    resolve("resolve value");
    reject("reject reason");
});

promise.then(
  (res) => { console.log("res:", res); }, 
  (err) => { console.log("err:", err); }
);

promise.then(
  (res) => { console.log("res1:", res); }, 
  (err) => { console.log("err1:", err); }
);

// 宏任务在微任务之后，数组已经遍历执行结束了，怎么办
setTimeout(() => {
  promise.then(
  (res) => { console.log("res2:", res); }, 
  (err) => { console.log("err2:", err); }
  );
}, 100);

❎问题：
1 由于this.onFulfilled函数赋值是异步进行的，所以顺序执行的最后一个then方法会覆盖之前的，将自己的回调onFulfilled赋值给this.onFulfilled函数
2 若then回调是在异步函数中，在微任务之后，无法加入回调函数队列中执行

✅改进：
1 采用数组存取回调函数
2 在微任务之后，说明已经拿到了this.value和this.reason，那么回调函数在then函数中直接执行即可

const PROMISE_STATUS_PENDING = "pending";
const PROMISE_STATUS_FULFILLED = "fulfilled";
const PROMISE_STATUS_REJECTED = "rejected";

class MyPromise {
  // 构造函数
  constructor(executor) {
    this.status = PROMISE_STATUS_PENDING;
    this.onFulfilledFns = [];//⭐ 数组保存
    this.onRejectedFns = [];
    
    const resolve = (value) => {
      if (this.status !== PROMISE_STATUS_PENDING) return;
      queueMicrotask(() => {
        if (this.status !== PROMISE_STATUS_PENDING) return; //⭐ 防止resolve和reject都执行
        this.value = value;
        this.onFulfilledFns.forEach((fn) => fn(this.value));
        this.status = PROMISE_STATUS_FULFILLED;
      });
    };

    const reject = (reason) => {
      if (this.status !== PROMISE_STATUS_PENDING) return;
      queueMicrotask(() => {
        if (this.status !== PROMISE_STATUS_PENDING) return;
        this.reason = reason;
        this.onRejectedFns.forEach((fn) => fn(this.reason));
        this.status = PROMISE_STATUS_REJECTED;
      });
    };

    executor(resolve, reject);
  }

  then(onFulfilled, onRejected) {
    if (this.status === PROMISE_STATUS_FULFILLED && onFulfilled) {
      onFulfilled(this.value); //⭐状态已经确定，说明微任务执行完毕，this.value已经有值，直接执行就可以 
    }

    if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
      onRejected(this.reason);
    }

    if (this.status === PROMISE_STATUS_PENDING) {
      onFulfilled && this.onFulfilledFns.push(onFulfilled);//⭐ 加入数组
      onRejected && this.onRejectedFns.push(onRejected);
    }
  }
}

then链式调用

then能链式调用，说明then函数能够返回一个Promise对象
⭐重点：
1 如何拿到回调函数的结果？再包裹一层回调函数
2 reject的函数的返回值也是一个Promise对象，和resolve没有区别
3 如果要在reject抛出出错，需要用try-catch捕获

// 工具函数
function execFunctionWithCatchError(execFn, value, resolve, reject) {
  try {
    const result = execFn(value);
    resolve(result);
  } catch (err) {
    reject(err);
  }
}

 then(onFulfilled, onRejected) {
 	//⭐ then返回一个MyPromise对象
    return new MyPromise((resolve, reject) => {
      if (this.status === PROMISE_STATUS_FULFILLED && onFulfilled) {
        execFunctionWithCatchError(onFulfilled, this.value, resolve, reject);
      }

      if (this.status === PROMISE_STATUS_REJECTED && onRejected) {
        execFunctionWithCatchError(onRejected, this.reason, resolve, reject);
      }

      if (this.status === PROMISE_STATUS_PENDING) {
       //⭐push到数组的函数外层又包裹了一个回调函数，为了得到返回结果
        onFulfilled &&
          this.onFulfilledFns.push(() => {
            execFunctionWithCatchError(onFulfilled, this.value, resolve, reject);
          });
        onRejected &&
          this.onRejectedFns.push(() => {
            execFunctionWithCatchError(onRejected, this.reason, resolve, reject);
          });
      }
    });
  }

Promise3.0版本

实现catch对象方法，finally对象方法

  • catch方法
    基于then方法实现，由于catch是在then后调用，实质上是then返回的promise对象调用的then方法，为了捕获原始的promise对象抛出的reject，需要将错误抛出
then(onFulfilled, onRejected) {
 	onRejected = onRejected || (err=> {throw new Error(err)}); // 将错误抛出去
 	
    return new MyPromise((resolve, reject) => {
     /*原来代码*/
    });
  }
  
 catch(onRejected) {
    return this.then(undefined, onRejected);
  }
  • finally方法
  finally(onFinally) {
    return this.then(onFinally, onFinally);
  }

Promise4.0版本

实现类静态方法resolve、reject

  static resolve(value) {
    return new MyPromise((resolve, reject) => {
      resolve(value);
    });
  }

  static reject(reason) {
    return new MyPromise((resoble, reject)=>{
      reject(reason);
    })
  }

Promise5.0版本

实现类方法all allSettled race any

⭐重点：什么时机调用resolve和reject

  • all
  static all(promises) {
    const results = [];
    let i = 0;
    // 如何让保存取结果与顺序有关，与返回顺序无关
    return new MyPromise((resolve, reject) => {
      promises.forEach((p, index) => {
        p.then(
          (res) => {
            results[index] = res;
            i++;
            if (i === promises.length) {
              resolve(results);
            }
          },
          (err) => {
            reject(err);
          }
        );
      });
    });
  }
  • allSettled
  static allSettled(promises) {
    return new MyPromise((resolve, reject) => {
      const results = [];
      let i = 0;
      promises.forEach((p, index) => {
        p.then(
          (res) => {
            results[index] = { status: PROMISE_STATUS_FULFILLED, value11: res };
            i++;
            if (i === promises.length) {
              resolve(results);
            }
          },
          (err) => {
            results[index] = { status: PROMISE_STATUS_REJECTED, reason: err };
            i++;
            if (i === promises.length) {
              resolve(results);
            }
          }
        );
      });
    });
  }
  • race
  static race(promises) {
    return new MyPromise((resolve, reject) => {
      promises.forEach((promise) => {
        promise.then(
          resolve,
          reject
        );
      });
    });
  }
  • any
  static any(promises) {
    return new MyPromise((resolve, reject) => {
      const reasons = [];
      promises.forEach((promise) => {
        promise.then(
          (res) => {
            resolve(res);
          },
          (err) => {
            reasons.push(err);
            if (reasons.length === promises.length) {
              reject(reasons);
            }
          }
        );
      });
    });
  }

代码整合

const PROMISE_STATUS_PENDING = "pending";
const PROMISE_STATUS_FULFILLED = "fulfilled";
const PROMISE_STATUS_REJECTED = "rejected";

function execFunctionWithCatchError(execFn, value, resolve, reject) {
  try {
    const result = execFn(value);
    resolve(result);
  } catch (err) {
    reject(err);
  }
}

class MyPromise {
  // 构造函数
  constructor(executor) {
    this.status = PROMISE_STATUS_PENDING;
    this.onFulfilledFns = [];
    this.onRejectedFns = [];

    const resolve = (value) => {
      if (this.status !== PROMISE_STATUS_PENDING) return;

      queueMicrotask(() => {
        if (this.status !== PROMISE_STATUS_PENDING) return;
        this.value = value;
        this.onFulfilledFns.forEach((fn) => fn(this.value));
        this.status = PROMISE_STATUS_FULFILLED;
      });
    };

    const reject = (reason) => {
      if (this.status !== PROMISE_STATUS_PENDING) return;
      queueMicrotask(() => {
        if (this.status !== PROMISE_STATUS_PENDING) return;
        this.reason = reason;
        this.onRejectedFns.forEach((fn) => fn(this.reason));
        this.status = PROMISE_STATUS_REJECTED;
      });
    };

    executor(resolve, reject);
  }

  then(onFulfilled, onRejected) {
    onRejected =
      onRejected ||
      ((err) => {
        throw new Error(err);
      });
    onFulfilled = onFulfilled || ((value) => value);

    return new MyPromise((resolve, reject) => {
      if (this.status === PROMISE_STATUS_FULFILLED) {
        execFunctionWithCatchError(onFulfilled, this.value, resolve, reject);
      }

      if (this.status === PROMISE_STATUS_REJECTED) {
        execFunctionWithCatchError(onRejected, this.reason, resolve, reject);
      }

      if (this.status === PROMISE_STATUS_PENDING) {
        this.onFulfilledFns.push(() => {
          execFunctionWithCatchError(onFulfilled, this.value, resolve, reject);
        });

        this.onRejectedFns.push(() => {
          execFunctionWithCatchError(onRejected, this.reason, resolve, reject);
        });
      }
    });
  }

  catch(onRejected) {
    return this.then(undefined, onRejected);
  }

  finally(onFinally) {
    return this.then(onFinally, onFinally);
  }

  static resolve(value) {
    return new MyPromise((resolve, reject) => {
      resolve(value);
    });
  }

  static reject(reason) {
    return new MyPromise((resoble, reject) => {
      reject(reason);
    });
  }

  static all(promises) {
    const results = [];
    let i = 0;
    return new MyPromise((resolve, reject) => {
      promises.forEach((p, index) => {
        p.then(
          (res) => {
            results[index] = res;
            i++;
            if (i === promises.length) {
              resolve(results);
            }
          },
          (err) => {
            reject(err);
          }
        );
      });
    });
  }

  static allSettled(promises) {
    return new MyPromise((resolve, reject) => {
      const results = [];
      let i = 0;
      promises.forEach((p, index) => {
        p.then(
          (res) => {
            results[index] = { status: PROMISE_STATUS_FULFILLED, value11: res };
            i++;
            if (i === promises.length) {
              resolve(results);
            }
          },
          (err) => {
            results[index] = { status: PROMISE_STATUS_REJECTED, reason: err };
            i++;
            if (i === promises.length) {
              resolve(results);
            }
          }
        );
      });
    });
  }

  static race(promises) {
    return new MyPromise((resolve, reject) => {
      promises.forEach((promise) => {
        promise.then(resolve, reject);
      });
    });
  }
  static any(promises) {
    return new MyPromise((resolve, reject) => {
      const reasons = [];
      promises.forEach((promise) => {
        promise.then(
          (res) => {
            resolve(res);
          },
          (err) => {
            reasons.push(err);
            if (reasons.length === promises.length) {
              reject(reasons);
            }
          }
        );
      });
    });
  }
}

// 使用
const promise = new MyPromise((resolve, reject) => {
  setTimeout(() => {
    // resolve("resolve value");
    reject("reject reason");
  }, 100);
});

promise
  .then((res) => {
    console.log("res:", res);
    return "aaa";
  })
  .catch((err) => {
    console.log("err:", err);
  });
爱你小前端
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
222-手把手带你写一个MiniSpring
05-06
222-手把手带你写一个MiniSpring
BERT手把手实现分类任务-Pytorch
03-15
BERT手把手实现分类任务-Pytorch
js常见面试题——详解Promise使用与原理及实现过程（附源码）(1)
最新发布
2401_84103441的博客
04-30 710
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍.value)} else {对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。
手把手教你创造第一个自己的GPTs应用.pdf
11-13
手把手教你创造第一个自己的GPTs应用.pdf
javascript设计模式Constructor（构造器）模式
11-22
Constructor是一种在内存已分配给该对象的情况下，用于初始化新创建对象的特殊方法。Object构造器用于创建特定类型的对象–准备好对象以备使用，同事接收构造器可以使用参数，以在第一次创建对象时，设置成员属性和方法值。 对象创建 创新新对象，在javascript中通常有两种方法：  1.对象直面量方法 var newObj = {};  2.构造器的简洁方法 var newObj = new Object(); 在Object构造器为特定的值创建对象封装，或者没有传递值时，它将创建一个肯那个对象并返回  对象赋值的方法：  1.“点”方法 //设置属性 newObj.na
手把手教你实现 Promise的使用方法
12-17
前言 很多 JavaScript 的初学者都曾感受过被回调地狱支配的恐惧，直至掌握了 Promise 语法才算解脱。虽然很多语言都早已内置了 Promise ，但是 JavaScript 中真正将其发扬光大的还是 jQuery 1.5 对 $.ajax 的重构，支持了 Promise，而且用法也和 jQuery 推崇的链式调用不谋而合。后来 ES6 出世，大家才开始进入全民 Promise 的时代，再后来 ES8 又引入了 async 语法，让 JavaScript 的异步写法更加优雅。 今天我们就一步一步来实现一个 Promise，如果你还没有用过 Promise，建议先熟悉一下 Promi
JS基础知识（二十）：异步编程
前端
11-17 1252
文章目录一、回调函数二、事件监听三、发布订阅四、Promise1、Promise的三种状态2、 Promise的对象创建（参数）3、Promise.then5、Promise.catch6、Promise.all7、Promise.race8、Promise.finally五、生成器Generator/yield六、async/await 一、回调函数 作用：经常用于处理异步任务返回的结果 场景：事件触发调用，控制函数的执行顺序 使用：将回调函数作为参数传递给另外一个函数，回调函数的参数可以作为与回调函数同
JS中的异步处理
docwangsir的博客
09-15 282
JS 中的异步处理 ________________________________________________________________________________ 异步处理的意思是非同步处理，不是按照固定顺序按部就班的处理，简言之代码段不再是一行一行的执行，而是执行到相应函数会跳转到相应函数开始执行。 ES2015新增了Promise对象专用于异步处理 Promise对象...
20210323webdriver高级应用JavascriptExecutor
sunnygao的博客
03-23 1120
复习之前的 String url ="http://localhost:8032/mymovie/admin.php/Login/index.html"; System.setProperty("webdriver.gecko.driver","D:\\demo\\geckodriver.exe"); System.setProperty("webdriver.firefox.bin","D:\\app\\firefox.exe"); WebDriver driver = new FirefoxDriver
BAT前端经典面试问题：史上最最最详细的手写Promise教程
weixin_34082789的博客
06-27 493
我们工作中免不了运用promise用来解决异步回调问题。平时用的很多库或者插件都运用了promise 例如axios、fetch等等。但是你知道promise是咋写出来的呢？ 别怕～这里有本promisesA+规范，便宜点10元卖给你了。 1、Promise 的声明 首先呢，promise肯定是一个类，我们就用class来声明。 由于new Promise((resolve, reject)=...
JavaScript基础：手写Promise（1）
imagine_tion的博客
03-22 194
一、构建 本次推文将会手写开发Promise实现，提升异步编程的能力。 首先声明定义类并声明Promise状态与值，有以下几个细节需要注意。 executor为执行者 当执行者出现异常时触发拒绝状态 使用静态属性保存状态值 状态只能改变一次，所以在resolve与reject添加条件判断 因为 resolve或rejected方法在executor中调用，作用域也是executor作用域，这会造成this指向window，现在我们使用的是class定义，this为undefined class MyP.
深入浅出玩转51单片机
09-25
之后带领读者深入浅出学习51单片机内部资源（如定时器、中断、串口）和经典外围电路（如LED、数码管、按键、液晶、点阵、EEPROM、温度传感器、时钟、红外线解码），同时穿插了一些C语言和基础电路；其后又扩展了一些...
selenium的操作JS命令的接口JavascriptExecutor的介绍
weixin_30438813的博客
04-21 107
1 nterface JavascriptExecutor 2 接口 JS执行器 3 public interface JavascriptExecutor 4 表示可以执行JavaScript的驱动程序，提供对机制的访问。 5 由于跨域策略浏览器强制执行您的脚本执行可能会意外失败，没有足够的错误消息传递。 6 这在创建自己的XHR请求或尝试访问另一个帧时特别...
JavascriptExecutor
dayo9317的博客
11-09 921
Why we use it?To enhance the capabilities of the existing scripts by performing javascript injection into our application under test.In simple words “Javascript can be executed within the browse...
web自动化JS常用实现
qq_16145473的博客
11-29 388
好用的JS
Selenium UI 自动化进阶，JavascriptExecutor总结
qq_39677832的博客
08-31 857
众所周知，在WEB UI自动化过程中经常会遇到一些元素无法定位，因此常常需要加一些JS脚本，本文中总结了测试过程中常用的JS脚本供大家参考，欢迎各位同学指正，大家一起共同进步。 指定element元素 JavascriptExecutor js=null; WebElement element=driver.findElementById("idname"); 1.JS实现Page页面的滚动 js.executeScript(" arguments[0].scrollIntoView(t...
【Thingsboard】js-executor 自定义协议解析
这个人很懒什么都没有~
11-02 778
很多厂家相要直接在 js-executor 里面解析自己的设备二进制数据，如果是传统的json或者xml数据，规则链可以直接进行解析。有些情况下设备上传的二进制数据，可能需要一些特有的 js 解析库，那么可以将特有的 js 库植入到 js-executor 引擎中，然后在规则链中调用该库。经过测试，一个 js-executor 解析水电表等比较复杂的二进制数据，差不多疫苗可以处理几千条。
前端必须学会的经典面试题场景之一 —— 手写Promise
weixin_46709512的博客
06-06 2386
手写Promise的正确姿势~ 前端面试涨薪必学，从0实现Promise
Promise的使用与原理实现过程详解【附源码】
XH_jing的博客
07-10 1254
一、什么是 Promise？ Promise 是目前 JS 异步编程的一种解决方案。 从语法上讲，Promise 是一个对象，从它可以获取异步操作的消息； 从本意上讲，它是承诺，承诺它过一段时间会给你一个结果。 二、Promise 原理简析？ 1、Promise 本身相当于一个状态机，拥有三种状态： pending(等待态) fulfiled(成功态) rejected(失败态) 一个 Promise 对象初始化时的状态是 pending，调用了 resolve 后会将 Promise 的状态扭转
深入浅出python机器学习[pdf]
08-30
《深入浅出Python机器学习》是一本介绍Python机器学习的入门级书籍。本书适合初学者，通过简洁明了的语言和实用的示例来引导读者学习机器学习的基本原理和Python编程技巧。 这本书首先介绍了机器学习的基本概念和应用场景。作者通过举例解释了监督学习、无监督学习和半监督学习等机器学习方法的基本原理和应用领域。读者可以通过这些例子了解到机器学习在图像识别、文本分类、推荐系统等领域的应用。 接下来，本书详细介绍了Python机器学习框架的使用。作者详细介绍了NumPy、Pandas和Scikit-learn等常用的Python机器学习库的基本功能和用法，读者可以通过这些库来实现和优化自己的机器学习算法。 在学习机器学习算法的过程中，本书给出了大量的机器学习算法实例。作者通过手把手地讲解，实战展示了线性回归、决策树、支持向量机等常见的机器学习算法的原理和应用。读者可以通过这些实例学习到如何选择并应用不同的机器学习算法解决实际问题。 此外，本书还介绍了交叉验证、特征选择和模型评估等机器学习相关的技术和方法。这些内容为读者提供了更全面的机器学习知识体系，帮助读者更好地理解和应用机器学习算法。 总的来说，《深入浅出Python机器学习》是一本结合理论与实践的实用教材，对于想要了解机器学习并使用Python实现算法的读者来说是一本很好的参考书籍。它将机器学习的基本原理和Python编程技巧有机地结合在一起，帮助读者快速入门并能够应用机器学习算法解决实际问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值