Promise基础 #

const promise = new Promise<string>((resolve, reject) => {
  // 异步操作
  setTimeout(() => {
    resolve("成功");
  }, 1000);
});

const success = new Promise<string>((resolve, reject) => {
  resolve("成功结果");
});

const failure = new Promise<string>((resolve, reject) => {
  reject(new Error("失败原因"));
});

function delay(ms: number): Promise<void> {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function example() {
  console.log("开始");
  await delay(1000);
  console.log("1秒后");
}

example();

function fetchJSON<T>(url: string): Promise<T> {
  return new Promise((resolve, reject) => {
    fetch(url)
      .then(response => {
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }
        return response.json();
      })
      .then(data => resolve(data))
      .catch(error => reject(error));
  });
}

// pending: 初始状态，既没有被完成，也没有被拒绝
// fulfilled: 意味着操作成功完成
// rejected: 意味着操作失败

const pending = new Promise(() => {}); // 永远pending
const fulfilled = Promise.resolve("成功");
const rejected = Promise.reject("失败");

const promise = new Promise<string>((resolve, reject) => {
  resolve("第一次");
  resolve("第二次"); // 被忽略
  reject("失败"); // 被忽略
});

promise.then(value => console.log(value)); // "第一次"

Promise.resolve(1)
  .then(value => value + 1)
  .then(value => value * 2)
  .then(value => console.log(value)); // 4

Promise.resolve(1)
  .then(value => Promise.resolve(value + 1))
  .then(value => Promise.resolve(value * 2))
  .then(value => console.log(value)); // 4

fetch("https://api.example.com/users/1")
  .then(response => response.json())
  .then(user => user.name)
  .then(name => console.log(name));

Promise.reject(new Error("出错了"))
  .catch(error => {
    console.error(error.message);
    return "默认值";
  })
  .then(value => console.log(value)); // "默认值"

Promise.resolve()
  .then(() => {
    throw new Error("第一步失败");
  })
  .then(() => {
    console.log("不会执行");
  })
  .catch(error => {
    console.error(error.message);
  });

Promise.resolve("成功")
  .then(value => console.log(value))
  .catch(error => console.error(error))
  .finally(() => console.log("清理工作"));

const p1 = Promise.resolve("值");
const p2 = Promise.resolve(Promise.resolve("嵌套"));

p1.then(v => console.log(v)); // "值"
p2.then(v => console.log(v)); // "值"（自动解包）

const p = Promise.reject(new Error("失败"));

p.catch(e => console.error(e.message)); // "失败"

const promises = [
  Promise.resolve(1),
  Promise.resolve(2),
  Promise.resolve(3)
];

Promise.all(promises)
  .then(values => console.log(values)); // [1, 2, 3]

// 一个失败则全部失败
Promise.all([
  Promise.resolve(1),
  Promise.reject("失败"),
  Promise.resolve(3)
]).catch(error => console.error(error)); // "失败"

const promises = [
  Promise.resolve(1),
  Promise.reject("失败"),
  Promise.resolve(3)
];

Promise.allSettled(promises)
  .then(results => console.log(results));
// [
//   { status: "fulfilled", value: 1 },
//   { status: "rejected", reason: "失败" },
//   { status: "fulfilled", value: 3 }
// ]

const promises = [
  new Promise(resolve => setTimeout(() => resolve("慢"), 200)),
  new Promise(resolve => setTimeout(() => resolve("快"), 100))
];

Promise.race(promises)
  .then(value => console.log(value)); // "快"

const promises = [
  Promise.reject("失败1"),
  Promise.resolve("成功"),
  Promise.reject("失败2")
];

Promise.any(promises)
  .then(value => console.log(value)); // "成功"

// 全部失败
Promise.any([
  Promise.reject("失败1"),
  Promise.reject("失败2")
]).catch(error => {
  console.error(error.errors); // ["失败1", "失败2"]
});

async function fetchAll(urls: string[]): Promise<Response[]> {
  const promises = urls.map(url => fetch(url));
  return Promise.all(promises);
}

const responses = await fetchAll([
  "https://api.example.com/users",
  "https://api.example.com/posts",
  "https://api.example.com/comments"
]);

function fetchWithTimeout(
  url: string,
  timeout: number
): Promise<Response> {
  return Promise.race([
    fetch(url),
    new Promise<never>((_, reject) => 
      setTimeout(() => reject(new Error("Timeout")), timeout)
    )
  ]);
}

async function retry<T>(
  fn: () => Promise<T>,
  maxRetries: number = 3
): Promise<T> {
  let lastError: Error | undefined;
  
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error as Error;
      console.log(`尝试 ${i + 1} 失败: ${lastError.message}`);
    }
  }
  
  throw lastError;
}