手写promis(1)---核心功能篇

已于 2023-11-22 10:48:41 修改
阅读量70 收藏
点赞数
分类专栏： promise 文章标签： 前端
于 2023-11-20 17:40:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63358859/article/details/134103048
版权

目录

前言

核心功能--构造函数 

核心功能--状态及原因

then方法

成功和失败回调

异步及多次调用

异步任务--核心api

Promise.then:

queueMicrotask:

MutationObserver:

setImmediate:

setTimeout:

异步任务---函数封装

前言

Promise（承诺）是一种用于处理异步操作的JavaScript编程技术。它是一种代表一个尚未完成的操作的对象，该操作可能会在将来的某个时刻完成或失败。Promise提供了一种更结构化和可维护的方式来处理异步代码，特别是在处理网络请求、文件I/O、定时器等操作时非常有用。

Promise对象有三种状态：

  1. Pending（进行中）：初始状态，表示操作尚未完成或失败。
  2. Fulfilled（已完成）：表示操作成功完成。
  3. Rejected（已失败）：表示操作失败。

Promise对象具有两个重要的方法：

  1. then(): 用于注册回调函数，当Promise状态变为Fulfilled时执行。
  2. catch(): 用于注册回调函数，当Promise状态变为Rejected时执行。

使用Promise，可以更清晰地定义异步操作的工作流程，避免了回调地狱（Callback Hell）的问题，使代码更易于理解和维护。以下是一个简单的Promise示例：

const myPromise = new Promise((resolve, reject) => {
  // 异步操作
  setTimeout(() => {
    const randomValue = Math.random();
    if (randomValue > 0.5) {
      resolve("操作成功");
    } else {
      reject("操作失败");
    }
  }, 1000);
});

myPromise
  .then(result => {
    console.log(result); // 在操作成功时执行
  })
  .catch(error => {
    console.error(error); // 在操作失败时执行
  });

这个示例创建了一个Promise对象，模拟了一个异步操作，并根据随机值决定是成功还是失败。通过.then()和.catch()方法，我们可以分别处理成功和失败的情况。这使得异步代码的处理更加结构化和可控。

手写原来步骤

核心功能--构造函数 

  1. 定义类（Define the class）: 这里定义了一个名为MyPromise的类，用于创建自定义Promise对象。

  2. 添加构造函数（Add a constructor）: 在构造函数中，通过constructor方法定义了一个新的MyPromise对象。当创建MyPromise对象时，会执行构造函数。构造函数接受一个函数func作为参数，这个函数在创建MyPromise对象时传入。

  3. 定义resolve/reject（Define resolve and reject functions）: 在构造函数中，定义了resolve和reject函数，它们分别用于处理Promise的成功和失败情况。resolve函数用于处理成功情况，它接受一个参数result，表示成功的原因。reject函数用于处理失败情况，它也接受一个参数result，表示失败的原因。

  4. 执行回调函数（Execute the callback function）: 最后，构造函数中调用了传入的func函数，这个函数接受resolve和reject作为参数。这意味着在创建MyPromise对象时，会执行传入的回调函数，并在适当的时候调用resolve或reject函数来处理异步操作的结果

/**
 * 构造函数
 * 1. 定义类
 * 2. 添加构造函数
 * 3. 定义reslove/reject
 * 4. 执行回调函数
 */

//1.定义类
class MyPromise {
    // 2.添加构造函数 new时会执行 constructor 传入回调函数
    constructor(func) {
        // 3.func 接受两个行参 成功回调（成功原因），失败回调（失败原因）
        // resolve：<Function>(result:<any>)  reject：<Function>(result:<any>) 
        const resolve = (result) => {
            console.log('resolve执行了--', result);
        }
        const reject = (result) => {
            console.log('reject执行了--', result);
        }

        // 4. 执行回调函数
        func(resolve, reject)
    }
}


// 测试代码
const p = new MyPromise((resolve, reject) => {
    console.log('执行回调函数');
    // resolve('success')
    reject('error')
})

核心功能--状态及原因

  1. 添加实例属性状态（pending / fulfilled / rejected）(默认为等待）

  2. 添加实例属性原因（默认为undefined）

  3. 调整resolve函数和reject函数 resolve和reject函数改变状态和保存原因，这是Promise的核心功能之一。

  4. 添加状态检查：在resolve和reject函数中，添加状态检查来确保状态只能从pending改变一次。这可以防止状态被多次改变。
/**
 * 状态及原因
 * 1. 添加状态 pending / fulfilled / rejected
 * 2. 添加原因
 * 3. 调整reslove/reject
 * 4. 状态不可逆
 */

//通过变量保存状态，方便使用
const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

class MyPromise {
    // 1. 添加实例属性 状态（pending / fulfilled / rejected）(默认为等待)
    state = PENDING
    // 2. 添加实例属性 原因（默认为undefined）
    result = undefined
    constructor(func) {
        // this 箭头函数this-->上级作用域（构造函数）-->  实例 
        // 3. 调整reslove pending-- > fulfilled 添加原因
        const resolve = (result) => {
            // 4. 状态不可逆
            if (this.state == PENDING) {
                this.state = FULFILLED
                this.result = result
            }
        }

        // 3. reject pending-- > rejected 添加原因
        const reject = (result) => {
            if (this.state == PENDING) {
                this.state = REJECTED
                this.result = result
            }
        }

        func(resolve, reject)
    }
}


// 测试代码
const p = new MyPromise((resolve, reject) => {

    resolve('success')
    // reject('error')
})

then方法

成功和失败回调

  1. 添加实例方法(then)

  2. 参数判断（参考文档）

如果是个函数 执行回调函数 

如果 onFulfilled 不是一个函数，则内部会被替换为一个恒等函数（(x) => x），它只是简单地将兑现值向前传递。

如果 onRejected 不是一个函数，则内部会被替换为一个抛出器函数（(x) => { throw x; }），它会抛出它收到的拒绝原因。

3.判断状态执行成功回调函数or失败回调函数（实例化完成后状态已经确定）

/**
 * 成功和失败回调
 * 1. 添加实例方法
 * 2. 参数判断（参考文档）
 *  2.1. 执行成功回调
 *  2.2. 执行失败回调
 */

//通过变量保存状态，方便使用
const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

class MyPromise {
    state = PENDING
    result = undefined
    constructor(func) {
        const resolve = (result) => {
            if (this.state == PENDING) {
                this.state = FULFILLED
                this.result = result
            }
        }

        const reject = (result) => {
            if (this.state == PENDING) {
                this.state = REJECTED
                this.result = result
            }
        }

        func(resolve, reject)
    }
    // 添加实例方法
    then(onFulfilled, onRejected) {
        // 参数判断  如果 onFulfilled 不是一个函数，则内部会被替换为一个恒等函数（(x) => x），它只是简单地将兑现值向前传递。
        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : x => x
        // 参数判断  如果 onRejected 不是一个函数，则内部会被替换为一个抛出器函数（(x) => { throw x; }），它会抛出它收到的拒绝原因。
        onRejected = typeof onRejected === 'function' ? onRejected : (x) => { throw x }

        // 执行成功回调or执行失败回调(状态实例化完成就立即调用了，所以可以执行返回结果--》异步暂时不考虑)
        if (this.state === FULFILLED) {
            onFulfilled(this.result)
        } else if (this.state === REJECTED) {
            onRejected(this.result)
        }

    }
}


// 测试代码
const p = new MyPromise((resolve, reject) => {

    // resolve('success')
    reject('error')
})
// p.then((result) => {
//     console.log('成功回调', result)
// }, err => {
//     console.log('失败回调', err);
// })
p.then((result) => {
    console.log('成功回调', result)
})

异步及多次调用

  1. 定义实例属性，添加#为类内部使用标识
  2. 如果then执行后状态为pending存储异步时成功回调与失败回调

  3. 定时器两秒后 resolve执行 取出成功回调函数放入成功原因

  4. 定时器两秒后 reject执行 取出失败回调函数放入失败原因

/**
 * then-异步及多次调用
 * 1. 定义实例属性
 * 2. 保存回调函数
 * 3. 调用成功回调
 * 4. 调用失败回调
 */

//通过变量保存状态，方便使用
const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

class MyPromise {
    state = PENDING
    result = undefined
    // 定义实例属性 #外部不能访问 保存回调
    #handlers = []//[{onFulfilled,onRejected}...]
    constructor(func) {
        const resolve = (result) => {
            if (this.state == PENDING) {
                this.state = FULFILLED
                this.result = result
                // 3.定时器两秒后 resolve执行 取出成功回调函数放入成功原因
                this.#handlers.forEach(({ onFulfilled }) => {
                    onFulfilled(this.result)
                })
            }
        }

        const reject = (result) => {
            if (this.state == PENDING) {
                this.state = REJECTED
                this.result = result
                // 4.定时器两秒后 reject执行 取出失败回调函数放入失败原因
                this.#handlers.forEach(({ onRejected }) => {
                    onRejected(this.result)
                })
            }
        }

        func(resolve, reject)
    }

    then(onFulfilled, onRejected) {

        onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : x => x

        onRejected = typeof onRejected === 'function' ? onRejected : (x) => { throw x }

        if (this.state === FULFILLED) {
            onFulfilled(this.result)
        } else if (this.state === REJECTED) {
            onRejected(this.result)
        } else if (this.state === PENDING) {
            // 2. 代表状态还没有发生过改变，保存回调函数
            this.#handlers.push({
                onFulfilled, onRejected
            })
        }

    }
}


// 测试代码
const p = new MyPromise((resolve, reject) => {

    setTimeout(() => {
        // resolve('success')
        reject('error')
    }, 2000);
})
p.then((result) => {
    console.log('成功回调', result)
}, err => {
    console.log('失败回调', err);
})
p.then((result) => {
    console.log('成功回调', result)
})

异步任务--核心api

 * Vue Promise.then, MutationObserver,setImmediate,setTimeout

 * 我们选用 queueMicrotask MutationObserver setTimeout

  • Promise.then,手写promise 不考虑这个
  • queueMicrotask：node11,新式浏览器(不包括ie11)
  • MutationObserver node不支持 ie11支持
  • setImmediate：ie10，11支持 edge:(12-18)支持（不考虑）
  • setTimeout：node，浏览器全支持

Promise.then:

  • 兼容性: 几乎所有现代浏览器和Node.js都支持Promise。
  • 用法: Promise是一种用于处理异步操作的机制，通过.then()方法可以注册回调函数来处理异步任务的完成或失败。例如：
const myPromise = new Promise((resolve, reject) => {
  // 异步操作
  if (/* 操作成功 */) {
    resolve(result);
  } else {
    reject(error);
  }
});

myPromise.then(
  (result) => {
    // 处理成功的情况
  },
  (error) => {
    // 处理失败的情况
  }
);

queueMicrotask:

Window 或 Worker 接口的 queueMicrotask() 方法，将微任务加入队列以在控制返回浏览器的事件循环之前的安全时间执行。

微任务是一个简短的函数，它将在当前任务完成其工作后运行，并且在执行上下文的控制权返回到浏览器的事件循环之前没有其他代码等待运行时运行。

它让你的代码在运行时不会干扰任何可能具有更高优先级的代码的运行，但在浏览器重新获得对执行上下文的控制之前，这可能取决于你需要完成的工作。你可以在我们的微任务指南中了解更多关于如何使用微任务以及选择这样做的原因。

微任务的重要性在于它能够以特定顺序异步执行任务。查看在 JavaScript 中通过 queueMicrotask() 使用微任务的详情。

微任务对于需要执行最后阶段的任务或其他在渲染之前的任务的库和框架特别有用。

参数

当浏览器引擎确定可以安全调用你的代码时执行的 function。微任务（microtask）的执行顺序在所有进行中的任务（pending task）完成之后，在对浏览器的事件循环产生控制（yielding control to the browser's event loop）之前。

返回值

无 undefined

  • 兼容性: 支持新式浏览器，但不包括IE11。
  • 用法: queueMicrotask用于将微任务排入微任务队列中，通常在Promise处理中使用，以确保微任务在宏任务之后执行。示例：
queueMicrotask(() => {
  // 这里执行微任务
});

MutationObserver:

MutationObserver 接口提供了监视对 DOM 树所做更改的能力。它被设计为旧的 Mutation Events 功能的替代品，该功能是 DOM3 Events 规范的一部分。

构造函数

MutationObserver()

创建并返回一个新的 MutationObserver 它会在指定的 DOM 发生变化时被调用。

方法

disconnect()

阻止 MutationObserver 实例继续接收的通知，直到再次调用其 observe() 方法，该观察者对象包含的回调函数都不会再被调用。

observe()

配置 MutationObserver 在 DOM 更改匹配给定选项时，通过其回调函数开始接收通知。

takeRecords()

从 MutationObserver 的通知队列中删除所有待处理的通知，并将它们返回到 MutationRecord 对象的新 Array 中。

  • 兼容性: 在大多数现代浏览器中支持，但Node.js不支持，而IE11也支持。
  • 用法: MutationObserver用于监视DOM树的变化，并在发生变化时触发回调函数。这通常用于监听DOM元素的变化。示例：
// 选择需要观察变动的节点
const targetNode = document.getElementById("some-id");

// 观察器的配置（需要观察什么变动）
const config = { attributes: true, childList: true, subtree: true };

// 当观察到变动时执行的回调函数
const callback = function (mutationsList, observer) {
  // Use traditional 'for loops' for IE 11
  for (let mutation of mutationsList) {
    if (mutation.type === "childList") {
      console.log("A child node has been added or removed.");
    } else if (mutation.type === "attributes") {
      console.log("The " + mutation.attributeName + " attribute was modified.");
    }
  }
};

// 创建一个观察器实例并传入回调函数
const observer = new MutationObserver(callback);

// 以上述配置开始观察目标节点
observer.observe(targetNode, config);

// 之后，可停止观察
observer.disconnect();

setImmediate:

setImmediate参数设置：第一个参数是需要执行的方法，第二个参数到第n个参数是传入方法中的参数。

setImmediate表示立即执行，它是宏任务，回调函数会被放置到事件循环的check阶段。
在应用中如果大量的计算型任务，它是不适合放在主线程中执行的，因为计算任务会阻塞主线程，主线程一旦被阻塞，其他任务就需要等待，
可以通过setImmediate方法将任务放入事件循环中的check阶段，因为代码在这一个阶段执行不会阻塞主线程，也不会阻塞事件循环
 

  • 兼容性: 主要支持IE10和IE11，以及一些较旧版本的Edge浏览器。
  • 用法: setImmediate用于将函数排入宏任务队列，以便在当前任务完成后立即执行。示例：
function sleep(delay) {
  var start = new Date().getTime()
  while (new Date().getTime() - start < delay) {
    continue
  }
  console.log('ok')
}

console.log('start')
setImmediate(sleep, 2000)
console.log('end')

先打印出start，然后再打印end,最后等待2000ms后打印ok。 

setTimeout:

  • 兼容性: 在Node.js和几乎所有现代浏览器中都支持。
  • 用法: setTimeout用于在一定时间后将函数排入宏任务队列。它是处理异步操作的常用方法。示例：
setTimeout(() => {
  // 这里执行宏任务
}, 1000);

异步任务---函数封装

  •  1.定义函数
  •  2.调用核心api（queueMicrotask，MutationObserver，setTimeout）
  •  3.使用封装的函数

 在then方法中使用无论promse是啥状态都需要直接或者间接的执行回调函数

/**
 * 异步任务--函数封装
 * 1.定义函数
 * 2.调用核心api（queueMicrotask，MutationObserver，setTimeout）
 * 3.使用封装的函数
 */

//1.定义函数
function runAsyncTask(callback) {
  //  2.调用核心api（queueMicrotask，MutationObserver，setTimeout）
  if (typeof queueMicrotask === "function") {
    queueMicrotask(callback);
  } else if (typeof MutationObserver == "function") {
    const obs = new MutationObserver(callback);
    const divNode = document.createElement("div");
    obs.observe(divNode, { childList: true });
    divNode.innerHTML = "贾公子";
  } else {
    setTimeout(callback, 0);
  }
}

const PENDING = "pending";
const FULFILLED = "fulfilled";
const REJECTED = "rejected";

class MyPromise {
  state = PENDING;
  result = undefined;
  #handlers = [];
  constructor(func) {
    const resolve = (result) => {
      if (this.state == PENDING) {
        this.state = FULFILLED;
        this.result = result;
        this.#handlers.forEach(({ onFulfilled }) => {
          onFulfilled(this.result);
        });
      }
    };

    const reject = (result) => {
      if (this.state == PENDING) {
        this.state = REJECTED;
        this.result = result;
        this.#handlers.forEach(({ onRejected }) => {
          onRejected(this.result);
        });
      }
    };

    func(resolve, reject);
  }

  then(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === "function" ? onFulfilled : (x) => x;

    onRejected =
      typeof onRejected === "function"
        ? onRejected
        : (x) => {
            throw x;
          };
    // 3.使用封装的函数
    if (this.state === FULFILLED) {
      runAsyncTask(() => {
        onFulfilled(this.result);
      });
    } else if (this.state === REJECTED) {
      runAsyncTask(() => {
        onRejected(this.result);
      });
    } else if (this.state === PENDING) {
      this.#handlers.push({
        // 成功或者失败后调用 onFulfilled
        // onFulfilled 执行之后调用runAsyncTask（传入:promise传入的回调）
        //runAsyncTask内部执行了回调 onFulfilled
        onFulfilled: () => {
          runAsyncTask(() => {
            onFulfilled(this.result);
          });
        },
        onRejected: () => {
          runAsyncTask(() => {
            onRejected(this.result);
          });
        },
      });
    }
  }
}

// 测试代码
console.log("TOP");
const p = new MyPromise((resolve, reject) => {
  // resolve("success");
  reject("error");
});
p.then(
  (result) => {
    console.log("成功回调", result);
  },
  (err) => {
    console.log("失败回调", err);
  }
);
console.log("BOTTOM");

前端 贾公子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
training-promis-2.docx
09-01
1
手写promise
GuoZebin的博客
05-31 363
前几天在看知乎的时候，无意间发现了一道面试题，手写promise，因为没研究过promise的实现，所以对这个问题也是一脸懵逼，忍不住就研究了一下。 try { module.exports = Promise } catch (e) {} function Promise(executor) { var self = this self.status = 'pendi...
手写Promise
XunLin233的博客
05-30 1861
在index.html中编写如下代码resolve("执行成功");})})创建一个promise.js文件在index.html中引入1. Promise能够通过new的方式调用，所以Promise是构造函数的形式。2. 构造Promise实例的时候传过去了一个函数，使用executor（执行器函数接收这个形参）。3. Promise实例能够调用then方法，所以在构造函数的原型上要添加then方法。4. then方法接收两个函数。// Promsie构造函数// 添加then方法。
【手写Promise】史上最最最详细的手写Promise教程
Anles的博客
05-19 3606
转载自https://yq.aliyun.com/articles/613412 class Promise{ constructor(executor){ this.state = 'pending'; this.value = undefined; this.reason = undefined; this.onResolvedCallbacks = []; this.onRejectedCallbacks = []; let resolve = va
ES6 - 从Promise入门到深入原理（手写一个自己的Promise）
前端攻城狮Dannis
04-17 4803
事件和回调函数的缺陷 我们习惯于使用传统的回调或者事件处理来解决异步问题 事件: 某个对象的属性是一个函数, 当发生一件事时, 运行该函数 dom.onclick = function() { // ...执行的代码 } 回调：运行某个函数以实现某个功能的时候, 传入一个函数作为参数, 当某个特定的条件下的时候, 就会触发该函数 dom.addEventListner('click', ...
Promis.all-async-await:Promis.all-asyncawait实践
03-30
Promis.all-async / await Promis.all-async / await练习
training-promis.docx
09-01
-
js代码-promis封装
07-16
js代码-promis封装
Promise的用法&原理&手写实现
hangao233的博客
03-31 2424
Promise的用法&原理&手写实现
史上最最最易懂的手写Promise原理及实现
smilelixiaojie的博客
06-12 616
手写promise原理 1、promise原理及实现 1）、Promise 就是一个类 在执行这个类的时候 需要传递一个执行器进去 执行器会立即执行 2）、Promise 中有三种状态 分别为 成功 fulfilled 失败 rejected 等待 pending pending -> fulfilled pending -> rejected 一旦状态确定就不可更改 3）、resolve和reject函数是用来更改状态的 resolve: fulfilled reject: rejected
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 668
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
vue3.0+antdv的admin管理系统vue-admin-beautiful推荐
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
05-15 1108
几年前，笔者自学了vue这一优秀的前端框架，但苦于没项目练手，无意间发现了这一优秀的前端集成框架。当时就使用它做了一很有意思的小项目---终端监控云平台，实现了前端和后台的整体功能。整体方案介绍参见博文《》，前端使用vue-admin-beautiful框架，后端使用go-zero微服务框架，几天内就搞出来了一个包含前端和后台的小项目。我的monitor-ui前端运行界面：后续有机会介绍下我这个终端监控云平台小项目的具体实现，挺有意思的。几年前还用到过几个地方的公交客户现场，客户挺喜欢这个功能的。
Unable to start ServletWebServerApplicationContext due to missing ServletWeb
s_sos0的博客
05-14 506
Unable to start ServletWebServerApplicationContext due to missing ServletWeb
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
最新发布
shijialeya
05-18 379
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
综合性练习-验证码
cj13106811623的博客
05-15 822
生成验证码param(参数): 无Return: 图片的内容校验验证码用户输入的验证码5. 代码编写生成验证码://图型验证码写出,可以写出到文件,也可以写出到流try {//返回到浏览器修改前端代码相对应的接口验证成功。
vue3专栏项目 -- 五、权限管理（下）
m0_64931189的博客
05-15 819
我们这一系列做的就是，我们刚开始做了message组件，我们可以直接在某个组件中通过即可调用这个message组件，从而展示出这个提示信息框但是我们觉得它可以像以前用过的alert一样，直接通过一个函数调用就可以展示出这个组件，所以有了如下一步步改进：
【VueRouter 的基本使用】
2302_76611599的博客
05-17 172
完成Vue Router 安装后，就可以使用路由了，路由的基本使用步骤，首先定义路由组件，以便使用Vue Router控制路由组件展示与 切换，接着定义路由链接和路由视图，以便告知路由组件渲染到哪个位置，然后再项目中创建路由模块，最后导入并挂载路由模块。为了在页面中将路由对应的组件显示出来，还要在App组件中定义路由视图。路由视图标签定义，该标签会被渲染成当前路由对应组件，另外，为了方便在不同组件之间切换，可以通过标签定义路由链接，该标签的to属性表示链接地址，与路由匹配规则中的path属性对应。
前端之电力系统SVG图低代码
weixin_38233449的博客
05-14 262
有了线，当然需要面，这时候一个polygon类就可以解决，唯一和polyline不同的是，path最后一个点需要Z闭合。两点一线，只要知道两个点的坐标就可以，但是基础图元可以旋转，也可以闪烁，所以这些属性都需要动态计算。其实所有的图形都是由点，线，面组成的。ployline也是用path就可以了，但是中间的点需要连起来，样式的计算需要循环拼接字符串。两点可以组成线，多点可以组成折线，这就需要一个polyline类去解析每个折线。svg里面的渲染最有难度的大圆弧和小圆弧，需要用到三角函数。
函数转为promis异步
07-27
chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值