我的创作纪念日-优快云博客

本文链接：https://blog.youkuaiyun.com/to_the_Future/article/details/142843887

引言：

在技术的海洋里遨游，每一个里程碑都值得铭记。今天，我站在一个新的起点上，庆祝自己作为优快云博主创作者的又一个重要时刻。回望过去，每一篇文章都承载着我对技术的热爱与追求；展望未来，我将继续在这条充满挑战与机遇的路上前行，与广大技术爱好者一同成长。

从初次接触编程到成为一名热衷于分享的博主，这段旅程既充满了艰辛也充满了喜悦。每一次敲击键盘，都是对未知世界的探索；每一篇文章的发布，都是与读者心灵的碰撞。优快云不仅是一个记录我技术成长的地方，更是一个见证无数开发者梦想启航的港湾。

在此特别的日子里，我想与大家分享我的创作心得，以及在技术探索之路上所收获的点点滴滴。无论是面对技术难题时的困惑与解决，还是在自我提升中的感悟与收获，我都希望通过我的文字，能够为后来者照亮前路，同时也为自己留下一份珍贵的记忆。

让我们一起回顾过往，珍惜现在，并共同期待更加辉煌灿烂的明天。

1. 机缘

1.1 分享实战经验：

在实际项目开发过程中，经常会遇到各种技术难题。通过记录和分享这些解决过程，可以帮助其他开发者避免相同的错误，提高工作效率。例如，在使用 Vue.js 开发大型应用时，可能会遇到性能优化、状态管理等问题，分享这些问题的解决方案可以惠及更多人。

1.2 自我提升：

写作是一个很好的自我学习和总结的过程。通过撰写技术文章，可以迫使自己深入理解某个技术细节，从而达到更好的掌握。例如，在研究某个复杂的前端框架时，通过详细记录其内部机制，可以加深自己的理解。

1.3 建立个人品牌：

技术博客是展示个人技能和专业知识的有效途径。通过持续输出高质量的技术内容，可以逐渐建立起个人品牌，提高在行业内的知名度。这对于职业发展和个人影响力都有很大的帮助。

1.4 促进技术交流：

技术博客是一个开放的平台，可以吸引来自世界各地的开发者进行交流。通过文章评论、社交媒体等方式，可以与同行进行互动，共同探讨技术问题，形成良好的技术社区氛围。

1.5 帮助初学者：

对于很多初学者来说，技术博客是一个重要的学习资源。通过撰写入门级的文章，可以帮助初学者更快地掌握基础知识，降低学习曲线。例如，编写一篇关于 Vue.js 基础用法的文章，可以帮助新手快速上手。

1.6 记录成长历程：

技术博客不仅是对外分享的平台，也是个人成长的记录。通过记录自己的学习过程和项目经历，可以清晰地看到自己的进步和发展轨迹，对未来的职业规划也有很大帮助。

1.7 获得成就感：

当看到自己的文章被广泛传播，收到读者的正面反馈时，会感到非常满足和自豪。这种成就感是推动持续创作的重要动力之一。

2. 收获

撰写技术博客不仅可以帮助他人，还能给自己带来多方面的收获。

2.1 技术深度理解：

深入研究：撰写技术博客需要对某个主题进行深入研究，这有助于全面理解和掌握相关技术细节。
查缺补漏：在准备文章的过程中，会发现自己的知识盲点，从而进行补充学习，弥补不足。

2.2 提升写作能力：

逻辑思维：撰写技术文章需要清晰的逻辑思维，能够将复杂的概念分解成易于理解的部分。
表达能力：通过不断练习，可以提高文字表达能力和沟通技巧，使文章更加流畅、准确。

2.3 扩大影响力：

个人品牌：长期坚持撰写高质量的技术博客，可以逐步建立起个人品牌，提高在行业内的知名度。
粉丝关注：随着文章质量的提升，会吸引越来越多的粉丝关注，形成稳定的读者群体。

2.4 获得正向反馈：

点赞与评论：读者的点赞、评论和转发是对作者最大的鼓励，这些正向反馈可以增强写作的动力。
技术交流：通过文章评论区与其他开发者交流，可以获得宝贵的建议和反馈，进一步完善自己的技术理解。

2.5 拓宽人脉圈：

结识同行：撰写技术博客可以结识许多志同道合的技术同行，形成良好的社交网络。
合作机会：通过技术博客，可能会获得更多的合作机会，如项目合作、技术讲座等。

2.6 自我成长：

记录成长历程：通过撰写技术博客，可以记录自己的学习和成长过程，回顾过去，展望未来。
反思与总结：每次撰写文章后，都会进行反思和总结，不断提高自己的技术水平和写作能力。

2.7 职业发展：

简历加分项：拥有丰富的技术博客内容可以作为简历上的亮点，展示自己的专业能力和实践经验。
面试优势：在面试时，可以引用自己的博客内容，展示自己的技术深度和广度，提高竞争力。

2.8 社区贡献：

帮助他人：通过分享自己的经验和知识，可以帮助其他开发者解决问题，提高整个技术社区的整体水平。
回馈社会：撰写技术博客也是一种回馈社会的方式，让更多人受益于技术知识。

2.9 提升解决问题的能力：

实践检验：在撰写技术博客的过程中，会遇到各种实际问题，通过解决问题，可以提升自己的综合能力。
案例积累：通过记录和分析实际案例，可以积累丰富的经验，提升解决复杂问题的能力。

3. 日常

创作已经是我生活的一部分了：写作已经成为我日常生活不可或缺的一部分。它不仅是一种表达方式，更是自我反思和成长的过程。
有限的精力下，如何平衡创作和工作学习：我会利用碎片时间来进行思考和构思，比如上下班途中、午休时间等。同时，合理安排每周固定的时间段专注于写作，确保既能完成日常工作，也能保证内容的质量。

4. 成就

class MyPromise {
  constructor(exector) {
    // 初始化状态及初始值
    this.initValue();
    // 初始化的时候改变 this 指向，将 this 指向实例对象
    this.initBind();
    // 执行器，当 new MyPromise()时，这个callback要接受 resolve 和 reject 函数
    try {
      // 正常执行的话，执行 exector
      exector(this.resolve, this.reject);
    } catch (error) {
      // 捕获到异常，则执行一次 reject
      this.reject(error);
    }
  }
  initValue() {
    this.PromiseState = "pending"; // Promise 状态
    this.PromiseResult = null; // Promise 返回值
    this.onFulfilledCallbacks = []; // 保存成功的回调
    this.onRejectedCallbacks = []; // 保存失败的回调
  }
  initBind() {
    this.resolve = this.resolve.bind(this);
    this.reject = this.reject.bind(this);
  }
  resolve(value) {
    // 只要状态已经改变，就不允许继续修改状态
    if (this.PromiseState !== "pending") {
      return;
    }
    // 此时状态改为 fulfilled
    this.PromiseState = "fulfilled";
    // 将传递进来的参数赋值
    this.PromiseResult = value;
    // 执行成功的回调
    while (this.onFulfilledCallbacks.length) {
      // 每次从队列中取出一个来执行
      this.onFulfilledCallbacks.shift()(this.PromiseResult);
    }
  }
  reject(reason) {
    // 只要状态已经改变，就不允许继续修改状态
    if (this.PromiseState !== "pending") {
      return;
    }
    // 此时状态改为 rejected
    this.PromiseState = "rejected";
    // 将传递进来的错误抛出
    this.PromiseResult = reason;
    // 执行成功的回调
    while (this.onRejectedCallbacks.length) {
      // 每次从队列中取出一个来执行
      this.onRejectedCallbacks.shift()(this.PromiseResult);
    }
  }
  then(onFulfilled, onRejected) {
    // then 函数接收两个callback，一个是成功回调，一个是失败回调
    // 参数兜底处理，确保返回的都是回调函数
    onFulfilled =
      typeof onFulfilled === "function" ? onFulfilled : (value) => value;
    onRejected =
      typeof onRejected === "function"
        ? onRejected
        : (reason) => {
            throw reason;
          };
    var promiseThen = new MyPromise((resolve, reject) => {
      const handlePromise = (fn) => {
        setTimeout(() => {
          try {
            let f = fn(this.PromiseResult);
            if (f === promiseThen) {
              // 不能返回自身
              throw new Error("不能返回自身。。。");
            }
            if (f instanceof MyPromise) {
              // 如果是 Promise 则执行对应的回调
              f.then(resolve, reject);
            } else {
              // 如果不是 Promise 则直接成功
              resolve(f);
            }
          } catch (error) {
            // 处理报错, 预防一些边界情况
            reject(error);
            throw new Error(error);
          }
        });
      };
      // 如果成功，则执行成功回调
      // 如果失败，则执行失败回调
      if (this.PromiseState === "fulfilled") {
        // onFulfilled(this.PromiseResult);
        handlePromise(onFulfilled);
      } else if (this.PromiseState === "rejected") {
        // onRejected(this.PromiseResult);
        handlePromise(onRejected);
      } else if (this.PromiseState === "pending") {
        // 将成功回调放入队列
        this.onFulfilledCallbacks.push(handlePromise.bind(this, onFulfilled));
        // 将失败回调放入队列
        this.onRejectedCallbacks.push(handlePromise.bind(this, onRejected));
      }
    });

    // 返回包装的 Promise
    return promiseThen;
  }
  static all(promises) {
    const result = [];
    let count = 0;
    return new MyPromise((resolve, reject) => {
      const addData = (index, value) => {
        result[index] = value;
        count++;
        if (count === promises.length) resolve(result);
      };
      promises.forEach((promise, index) => {
        if (promise instanceof MyPromise) {
          promise.then(
            (res) => {
              addData(index, res);
            },
            (err) => reject(err)
          );
        } else {
          addData(index, promise);
        }
      });
    });
  }

  static race(promises) {
    return new MyPromise((resolve, reject) => {
      promises.forEach((promise, index) => {
        if (promise instanceof MyPromise) {
          promise.then(
            (res) => resolve(res),
            (err) => reject(err)
          );
        } else {
          resolve(promise);
        }
      });
    });
  }

  static allSettled(promises) {
    return new MyPromise((resolve, reject) => {
      let result = [];
      let count = 0;
      let addData = (status, value, index) => {
        result[index] = {
          status,
          value,
        };
        count++;
        if (count === promises.length) {
          resolve(result);
        }
      };
      promises.forEach((promise, index) => {
        if (promise instanceof MyPromise) {
          promise.then(
            (res) => addData("fulfilled", res, index),
            (err) => addData("rejected", err, index)
          );
        } else {
          addData("fulfilled", promise, index);
        }
      });
    });
  }

  static any(promises) {
    return new MyPromise((resolve, reject) => {
      let count = 0;
      promises.forEach((promise, index) => {
        if (promise instanceof MyPromise) {
          promise.then(
            (res) => resolve(res),
            (err) => {
              count++;
              if (count === promises.length) {
                reject("都执行失败了~");
              }
            }
          );
        }
      });
    });
  }
}