Polymorphism in Typescript

Posted on 2025-03-10 Edited on 2025-07-03 In TypeScript

Subtype Polymorphism

通过类继承和方法重写，子类可以提供与父类方法相同的接口，但实现不同的行为。

class Animal {
  makeSound(): void {
    console.log("Some generic animal sound")
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log("Woof!")
  }
}

class Cat extends Animal {
  makeSound(): void {
    console.log("Meow!")
  }
}

function makeAnimalSound(animal: Animal): void {
  animal.makeSound()
}

const dog = new Dog()
const cat = new Cat()

makeAnimalSound(dog) // Woof!
makeAnimalSound(cat) // Meow!

key points:

类型兼容性：TypeScript 的类型系统允许子类实例赋值给父类类型的变量（向上转型）。
运行时行为：实际执行的方法取决于对象的运行时类型，而不是声明时的类型。

Promise a+

Posted on 2021-10-08 Edited on 2025-07-03 In JavaScript

Promise A+ 规范

promise：是一个拥有then方法的对象或函数，其行为符合本规范。
thenable：是一个定义了then方法的对象或函数。这个主要是用来兼容一些老的Promise实现，只要一个Promise实现是thenable，也就是拥有then方法的，就可以跟Promises/A+
兼容。
value：指reslove出来的值，可以是任何合法的 JS 值(包括 undefined , thenable 和 promise等)
exception：异常，在Promise里面用throw抛出来的值
reason：拒绝原因，是reject里面传的参数，表示reject的原因

Promise Status

pending: 一个promise在resolve或者reject前就处于这个状态。
fulfilled: 一个promise被resolve后就处于fulfilled状态，这个状态不能再改变，而且必须拥有一个不可变的值(value)。
rejected: 一个promise被reject后就处于rejected状态，这个状态也不能再改变，而且必须拥有一个不可变的拒绝原因(reason)。

thenable

1	promsie.then(onFulfilled, onRejected)

Optional parameters

如果 onFulfilled 不是函数，其必须被忽略
如果 onRejected 不是函数，其必须被忽略

onFulfilled

如果 onFulfilled 是函数：

当 promise 执行结束后其必须被调用，其第一个参数为 promise 的终值value
在 promise 执行结束前其不可被调用
其调用次数不可超过一次

onRejected

如果 onRejected 是函数：

当 promise 被拒绝执行后其必须被调用，其第一个参数为 promise 的据因reason
在 promise 被拒绝执行前其不可被调用
其调用次数不可超过一次

then

then 方法可以被同一个 promise 调用多次

当 promise 成功执行时，所有 onFulfilled 需按照其注册顺序依次回调
当 promise 被拒绝执行时，所有的 onRejected 需按照其注册顺序依次回调

Return

then 方法必须返回一个 promise 对象。

1	promise2 = promise1.then(onFulfilled, onRejected)

如果 onFulfilled 或者 onRejected 返回一个值 x ，则运行 Promise 解决过程：[[Resolve]](promise2, x)
如果 onFulfilled 或者 onRejected 抛出一个异常 e ，则 promise2 必须拒绝执行，并返回拒因 e
如果 onFulfilled 不是函数且 promise1 成功执行， promise2 必须成功执行并返回相同的值
如果 onRejected 不是函数且 promise1 拒绝执行， promise2 必须拒绝执行并返回相同的据因

实现

var PENDING = "pending"
var FULFILLED = "fulfilled"
var REJECTED = "rejected"

function Promise(fn) {
  this.status = PENDING // initial status
  this.value = null // initial value
  this.reason = null // initial reason
  this.onFulfilledCallbacks = []
  this.onRejectedCallbacks = []

  var _this = this

  function resolve(value) {
    if (_this.status === PENDING) {
      _this.status = FULFILLED
      _this.value = value

      _this.onFulfilledCallbacks.forEach((i) => i(_this.value))
    }
  }

  function reject(reason) {
    if (_this.status === PENDING) {
      _this.status = REJECTED
      _this.reason = reason

      _this.onRejectedCallbacks.forEach((i) => i(_this.reason))
    }
  }

  try {
    fn(resolve, reject)
  } catch (e) {
    reject(e)
  }
}

function resolvePromise(promise, x, resolve, reject) {
  if (promise === x) {
    reject(new TypeError("The promise and the return value are the same"))
  }

  if (x instanceof Promise) {
    x.then(function (y) {
      resolvePromise(promise, y, resolve, reject)
    }, reject)
  } else if (typeof x === "object" || typeof x === "function") {
    if (x === null) {
      return resolve(x)
    }

    try {
      var then = x.then
    } catch (e) {
      return reject(e)
    }

    if (typeof then === "function") {
      var called = false

      try {
        then.call(
          x,
          function (y) {
            if (called) return
            called = true
            resolvePromise(promise, y, resolve, reject)
          },
          function (r) {
            if (called) return
            called = true
            reject(r)
          }
        )
      } catch (e) {
        if (called) return

        reject(e)
      }
    } else {
      resolve(x)
    }
  } else {
    resolve(x)
  }
}

Promise.prototype.then = function (onFulfilled, onRejected) {
  var checkOnFulfilled = onFulfilled
  if (typeof onFulfilled !== "function") {
    checkOnFulfilled = function (value) {
      return value
    }
  }

  var checkOnRejected = onRejected
  if (typeof onRejected !== "function") {
    checkOnRejected = function (reason) {
      throw reason
    }
  }

  var _this = this

  if (this.status === FULFILLED) {
    // 如果前面的 promise 抛出异常，后面的必须拒绝执行
    var promise2 = new Promise(function (resolve, reject) {
      setTimeout(function () {
        try {
          if (typeof onFulfilled !== "function") {
            resolve(_this.value)
          } else {
            var x = checkOnFulfilled(_this.value)
            resolvePromise(promise2, x, resolve, reject)
          }
        } catch (e) {
          reject(e)
        }
      }, 0)
    })

    return promise2
  }

  if (this.status === REJECTED) {
    var promise2 = new Promise(function (resolve, reject) {
      setTimeout(function () {
        try {
          if (typeof onRejected !== "function") {
            reject(_this.reason)
          } else {
            var x = checkOnRejected(_this.reason)
            resolvePromise(promise2, x, resolve, reject)
          }
        } catch (e) {
          reject(e)
        }
      }, 0)
    })

    return promise2
  }

  if (this.status === PENDING) {
    var promise2 = new Promise(function (resolve, reject) {
      _this.onFulfilledCallbacks.push(function () {
        setTimeout(function () {
          try {
            if (typeof onFulfilled !== "function") {
              resolve(_this.value)
            } else {
              var x = checkOnFulfilled(_this.value)
              resolvePromise(promise2, x, resolve, reject)
            }
          } catch (e) {
            reject(e)
          }
        }, 0)
      })

      _this.onRejectedCallbacks.push(function () {
        setTimeout(function () {
          try {
            if (typeof onRejected !== "function") {
              reject(_this.reason)
            } else {
              var x = checkOnRejected(_this.reason)
              resolvePromise(promise2, x, resolve, reject)
            }
          } catch (e) {
            reject(e)
          }
        }, 0)
      })
    })

    return promise2
  }
}

Promise.resolve = function (parameter) {
  if (parameter instanceof Promise) {
    return parameter
  }

  return new Promise(function (resolve) {
    resolve(parameter)
  })
}

Promise.reject = function (reason) {
  return new Promise(function (resolve, reject) {
    reject(reason)
  })
}

Promise.all = function (promises) {
  return new Promise(function (resolve, reject) {
    var count = 0
    var result = []
    var len = promises.length

    if (length === 0) {
      return resolve(result)
    }

    promises.forEach(function (promise, index) {
      Promise.resolve(promise).then(
        function (value) {
          count++
          result[index] = value

          if (count === len) {
            resolve(result)
          }
        },
        function (reason) {
          reject(reason)
        }
      )
    })
  })
}

Promise.race = function (promises) {
  return new Promise(function (resolve, reject) {
    var len = promises.length

    if (length === 0) {
      return resolve()
    } else {
      for (var i = 0; i < len; i++) {
        Promise.resolve(promises[i]).then(
          function (value) {
            return resolve(value)
          },
          function (reason) {
            return reject(reason)
          }
        )
      }
    }
  })
}

Promise.catch = function (onRejected) {
  this.then(null, onRejected)
}

Promise.finally = function (fn) {
  return this.then(
    function (value) {
      return Promise.resolve(fn()).then(function () {
        return value
      })
    },
    function (error) {
      return Promise.resolve(fn()).then(function () {
        throw error
      })
    }
  )
}

Promise.allSettled = function (promises) {
  return new Promise(function (resolve) {
    var len = promises.length
    var result = []
    var count = 0

    if (len === 0) {
      resolve(result)
    } else {
      for (let i = 0; i < len; i++) {
        ;(function (i) {
          var current = Promise.resolve(promises[i])

          current.then(
            function (value) {
              count++
              result[i] = {
                status: "fulfilled",
                value,
              }

              if (count === len) {
                return resolve(result)
              }
            },
            function (reason) {
              count++
              result[i] = {
                status: "rejected",
                reason,
              }

              if (count === len) {
                return resolve(result)
              }
            }
          )
        })(i)
      }
    }
  })
}

// for promises-aplus-tests test
Promise.deferred = function () {
  var result = {}
  result.promise = new Promise(function (resolve, reject) {
    result.resolve = resolve
    result.reject = reject
  })

  return result
}

module.exports = Promise

Promise

Posted on 2018-08-31 Edited on 2025-07-03 In ECMAScript

Promise 的特点

对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态：Pending（进行中）、Fulfilled（已成功）、Rejected（已失败）。只有异步操作的结果可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。
一旦状态改变就不会再变，任何时候得到的都是这个结果。Promise 对象的状态改变只有两个可能：从 Pending 变为 Fulfilled，从 Pending 变为 Rejected。只要这两种情况发生，这时就成为 resolve。就算改变已经发生，再对 Promise 对象添加回调函数，也会立即得到这个结果。与 Event 完全不同，Event 一旦错过再监听是得不到结果的。

基本用法

var promise = new Promise(function (resolve, reject) {
    //some code

    if (/*异步操作成功*/) {
        resolve(value);
    } else {
        reject(error);
    }
})

Proxy

Posted on 2018-08-20 Edited on 2025-07-03 In ECMAScript

Proxy 用于修改某些操作的默认行为，等同与在语言层面做出修改，属于一种 meta programming。

let obj = new Proxy(
  {},
  {
    get: function (target, key, receiver) {
      console.log(`getting ${key}`)
      return Reflect.get(target, key, receiver)
    },
    set: function (target, key, receiver) {
      console.log(`setting ${key}`)
      return Reflect.set(target, key, receiver)
    },
  }
)
obj.count = 1
//setting count
obj.count
//getting count

Number的扩展

Posted on 2018-08-11 Edited on 2025-07-03 In ECMAScript

进制表示

0b(0B)表示二进制，0o(0O)表示八进制

Number.isFinite()、Number.isNaN()

Number.isFinite 用来检查一个数值是否为有限的。

Number.isFinite(NaN) //false
Number.isFinite(Infinity) //false
Number.isFinite(-Infinity) //false
Number.isFinite("15") //false
Number.isFinite("foo") //false
Number.isFinite(true) //false