JavaScript异步编程Promise模式的6个特性

当我们使用JavaScript编写复杂的应用时，经常会遇到需要进行异步操作的情况，例如异步请求数据或处理大量的计算任务。Promise模式是一种异步编程的解决方案，它对异步操作进行了抽象和封装，并提供了一些特性来更好地处理和管理异步操作。下面是JavaScript Promise模式的6个特性的详细讲解：

1. Promise是一个对象

在JavaScript中，Promise是一个对象，可以通过构造函数Promise()来创建Promise对象。Promise对象封装了异步操作的状态和潜在的结果。当创建Promise对象时，会立即执行传入的函数，并按照该函数处理异步操作。

const promise = new Promise((resolve, reject) => {
  // 异步操作
  // resolve(result)或reject(error)
});

2. Promise状态不可逆

Promise对象有三种状态，分别是pending（等待中）、fulfilled（已成功）和rejected（已失败）。Promise对象被创建时处于等待中的状态。异步操作成功时，状态会改变为已成功，并返回一个结果对象；异步操作失败时，状态会改变为已失败，并返回一个错误对象。Promise状态一旦改变就不可逆，即无法从已成功或已失败状态转换回等待中的状态。

const promise = new Promise((resolve, reject) => {
  // 异步操作
  if (异步操作成功) {
    resolve(操作结果);
  } else {
    reject(错误信息);
  }
});

promise.then(
  result => {
    // 操作成功
  },
  error => {
    // 操作失败
  }
);

3. Promise链式调用

Promise对象提供了then()方法用于处理异步操作成功或失败的结果，并返回一个新的Promise对象，因此可以链式调用多个then()方法处理异步操作结果。在链式调用中，每个then()方法都可以处理上一个Promise对象的成功或失败结果，并返回一个新的Promise对象，依次传递给下一个then()方法。

getData()
  .then(result => {
    // 处理结果
    return processData(result);
  })
  .then(result => {
    // 处理结果
    return saveData(result);
  })
  .then(result => {
    // 处理结果
  })
  .catch(error => {
    // 处理错误
  });

4. Promise实现异步并发控制

异步并发控制是指限制同时进行的异步操作数量，以避免对系统资源造成过多负荷。Promise提供了Promise.all()和Promise.race()方法实现异步并发控制。Promise.all()方法接收一个Promise对象数组，当数组中所有的Promise对象都成功时，返回一个结果数组；如果其中任何一个Promise对象失败，直接返回一个错误对象并终止后续操作。Promise.race()方法接收一个Promise对象数组，返回最先成功或失败的Promise对象。

Promise.all([promise1, promise2, promise3])
  .then(results => {
    // 处理结果数组
  })
  .catch(error => {
    // 处理错误
  });

Promise.race([promise1, promise2, promise3])
  .then(result => {
    // 处理最先解决的异步操作结果
  })
  .catch(error => {
    // 处理错误
  });

5. Promise支持多态

Promise对象可以处理任何类型的操作结果，包括普通值、对象和Promise对象等。如果一个then()方法返回一个值，该值会被自动包装为Promise对象，并转换为fulfilled状态；如果一个then()方法返回一个Promise对象，则该Promise对象的状态和结果会传递给下一个then()方法。

Promise.resolve(value) // value可以是普通值、对象或Promise对象
  .then(result => {
    console.log(result);
    return Promise.reject('出错了');
  })
  .catch(error => {
    console.error(error);
    return {
      message: '操作失败'
    };
  })
  .then(result => {
    console.log(result);
  })
  .catch(error => {
    console.error(error);
  });

6. Promise具有优异性能

Promise对象可以很好地处理异步操作，并能够利用浏览器或Node.js的异步模式执行异步操作。与回调函数相比，Promise更容易处理错误和异步操作的顺序。Promise还具有性能优越的优势，因为它可以利用异步操作的并行性来提高代码效率，并且可以通过链式调用简化代码逻辑。

示例1：使用Promise实现异步请求数据

function getData() {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open('GET', 'https://jsonplaceholder.typicode.com/todos/1');
    xhr.onload = () => {
      if (xhr.status === 200) {
        resolve(xhr.response);
      } else {
        reject(new Error(xhr.statusText));
      }
    };
    xhr.onerror = () => {
      reject(new Error(xhr.statusText));
    };
    xhr.send();
  });
}

getData()
  .then(result => {
    console.log(result);
  })
  .catch(error => {
    console.error(error);
  });

示例2：使用Promise.all()实现异步并发控制

function getData(id) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open('GET', `https://jsonplaceholder.typicode.com/todos/${id}`);
    xhr.onload = () => {
      if (xhr.status === 200) {
        resolve(xhr.response);
      } else {
        reject(new Error(xhr.statusText));
      }
    };
    xhr.onerror = () => {
      reject(new Error(xhr.statusText));
    };
    xhr.send();
  });
}

const promises = [];
for (let i = 1; i <= 10; i++) {
  promises.push(getData(i));
}

Promise.all(promises)
  .then(results => {
    console.log(results);
  })
  .catch(error => {
    console.error(error);
  });