简述Promise的创建

Promise是一种处理异步操作的对象，在JavaScript中广泛用于处理回调地狱的问题。它代表了一个可能会返回值、也可能抛出错误的结果。Promise有三种状态：pending（等待中）、fulfilled（已成功）和rejected（已失败）。创建一个Promise通常涉及以下几个步骤：

1. 使用`new Promise`构造函数初始化一个新的Promise实例，传入一个函数作为参数。这个函数接收两个回调函数：`resolve`和`reject`。这两个函数分别在操作成功和失败时被调用。

const promise = new Promise((resolve, reject) => {
  // 异步操作
  // 如果操作成功，调用resolve并传递结果
  // 如果操作失败，调用reject并传递错误信息
});

2. `resolve`函数会改变Promise的状态为fulfilled，并将结果传递给接收到的结果。`reject`函数则相反，改变状态为rejected，并提供错误信息。

promise.then(result => {
  // 成功回调，这里可以访问到操作的结果
}).catch(error => {
  // 失败回调，处理错误
});

相关问题

简述 es6的 promise 对象

ES6 中的 Promise 是一种处理异步操作的方式，它可以使异步代码看起来像同步代码，更易于阅读和维护。Promise 是一个对象，它代表了一个异步操作最终的完成（或失败），并且可以返回一个值或抛出一个异常。

Promise 对象有三种状态：

1. Pending（进行中）：Promise 对象刚被创建时的初始状态，此时还没有完成或失败。

2. Fulfilled（已完成）：异步操作成功完成时的状态。

3. Rejected（已失败）：异步操作失败时的状态。

当 Promise 对象的状态从 Pending 转变为 Fulfilled 或 Rejected 时，它会触发 then 方法中对应的回调函数。then 方法接收两个参数：第一个参数是处理 Fulfilled 状态的回调函数，第二个参数是处理 Rejected 状态的回调函数。

例如，以下代码创建了一个 Promise 对象，并在异步操作完成时将其状态改为 Fulfilled，并将字符串“Hello, Promise!”作为返回值：

const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("Hello, Promise!");
  }, 1000);
});

然后可以通过 then 方法来处理 Promise 对象的状态：

promise.then((value) => {
  console.log(value); // 输出：Hello, Promise!
});

如果 Promise 对象的状态变为 Rejected，则可以通过 catch 方法来处理：

promise.catch((error) => {
  console.log(error); // 输出：Error!
});

js 实现一个简单的 Promise 构造函数

JavaScript 中的 `Promise` 对象是用来处理异步操作的一种数据结构。它表示了一个尚未完成的任务，并允诺在将来提供一个结果。Promise 可以处于三种状态之一：pending（待定）、fulfilled（已完成，成功） 或 rejected（已完成，失败）。在实际应用中，通常会通过 `then` 和 `catch` 方法来链式处理这些状态变化。

### 创建简单的 Promise 构造函数

下面是一个基础的 `Promise` 的实现示例：

function simplePromise(value) {
    return new Promise(function(resolve, reject) {
        // 根据值判断是否是已经成功的状态
        if (value === true) {
            resolve("任务成功！");
        } else {
            reject("任务失败！");
        }
    });
}

在这个简单的 `simplePromise` 函数里，我们创建了一个 `Promise` 对象并传入了两个回调函数作为参数：`resolve` 和 `reject`。这两个函数分别用于处理 `fulfilled` 状态和 `rejected` 状态。

### 使用简单 `Promise` 实现的功能

一旦我们有了这个构造函数，就可以使用它来包装异步操作。例如：

simplePromise(true)
.then(result => console.log(result))
.catch(error => console.error(error));

上述代码将首先尝试执行 `simplePromise(true)`，由于给定的 `true` 表示成功，因此会进入 `.then` 方法并打印出 "任务成功！” 到控制台。如果在实现中使用了 `false` 或其他导致错误的情况，则会触发 `.catch` 方法并打印错误信息。

### 扩展功能

为了更完整地体现 `Promise` 的功能，可以进一步增加返回结果、处理多个状态等特性。比如添加返回值的能力以及 `finally` 方法供清理操作使用：

class SimplePromise {
    constructor(executor) {
        this.resolve = null;
        this.reject = null;
        this.state = 'pending';
        this.value = null;

        const resolveReject = (state, value) => {
            if (this.state === 'pending') {
                this.state = state;
                this.value = value;
                if (this.resolve && this.reject) {
                    this.resolve(this.value);
                    this.reject = undefined;
                    this.resolve = undefined;
                }
            }
        };

        try {
            executor(resolveReject);
        } catch(e) {
            resolveReject('rejected', e);
        }
    }

    then(onFulfilled, onRejected) {
        return new SimplePromise((resolve, reject) => {
            this.resolve = (result) => {
                try {
                    let x = onFulfilled ? onFulfilled(result) : result;
                    if (x instanceof SimplePromise) {
                        x.then(resolve, reject);
                    } else {
                        resolve(x);
                    }
                } catch(e) {
                    reject(e);
                }
            };
            
            this.reject = error => {
                try {
                    let x = onRejected ? onRejected(error) : error;
                    if (x instanceof SimplePromise) {
                        x.then(resolve, reject);
                    } else {
                        reject(x);
                    }
                } catch(e) {
                    reject(e);
                }
            };
        });
    }

    catch(rejectHandler) {
        return this.then(null, rejectHandler);
    }

    finally(callback) {
        let promise = this;
        return this.then(() => callback(), () => callback());
    }
}

// 使用新的 Promise 类
new SimplePromise((resolve, reject) => {
    setTimeout(() => resolve('Hello'), 500);
}).then(result => console.log(result)).catch(err => console.error(err));

在这个版本中，我们引入了类封装来简化 API 和增强功能，如允许返回值、链式调用 `then` 方法和通过 `finally` 完成清理操作。

---

### 相关问题 - JavaScript Promise 的基本概念:

1. **Promise 的状态是什么？** 分别解释它们的意义及如何从 `pending` 转变到其他状态。
2. **简述 `.then()` 和 `.catch()` 方法的作用以及区别。**
3. **在什么情况下使用 `.finally()` 方法？给出一个场景说明它的用途。**

通过这些问题，你可以更深入地理解 Promise 结构和其在 JavaScript 异步编程中的作用。