js物件導向程式設計OOP及函數語言程式設計FP區別

2022-07-06 18:03:05

寫在前面

瀏覽下文我覺得還是要有些基礎的！下文涉及的知識點太多，基本上每一個拿出來都能寫幾篇文章，我在寫文章的過程中只是做了簡單的實現，我只是提供了一個思路，更多的細節還是需要自己去鑽研的，文章內容也不少，辛苦，如果有其他的看法或者意見，歡迎指點，最後紙上得來終覺淺，絕知此事要躬行

javscript 中函數和物件的關係

javscript 一切皆為物件，但基本型別之外，函數是物件，物件是由函數建立而來，從而衍生出我對這兩種程式設計方式的探討。下面對型別判斷和原型做了一個簡單的表述，這裡不是重點，不做具體的表述，感興趣的可以自己百度/谷歌。

// 型別判斷
// 基本型別
console.log(typeof 1)                               // | ==> number
console.log(typeof '2')                             // | ==> string
console.log(typeof undefined)                       // | ==> undfined
// null 型別判斷【特殊】
console.log(typeof null)                            // | ==> object
console.log(Object.prototype.toString.call(null))   // | ==> [object Null]
// 報錯【null 不是一個物件】TypeError: Right-hand side of 'instanceof' is not an object
console.log(null instanceof null)                   
console.log(typeof Symbol())                        // | ==> symbol 【ES6 新型別】
console.log(typeof false)                           // | ==> boolean
console.log(typeof BigInt(9007199254740991n))       // | ==> bigint 【新型別】
// 參照型別 - 物件
console.log(typeof (() => {}))                      // | ==> function
console.log((() => {}) instanceof Object)           // true
console.log(typeof [])                              // | ==> object
console.log(typeof {})                              // | ==> object
console.log(typeof (/./))                          // | ==> object
console.log(typeof new Date())                      // | ==> object
console.log(typeof new String())                    // | ==> object
console.log(typeof new Number())                    // | ==> object

// 原型鏈
// fn ====> function fn () {}
// Object ====> function Object () {}
// Function ====> function Funtion()
    new fn() - __proto__ --|
      ↑                    ↓
---→ fn ----------- fn.prototype -------- __proto__ -----→ Object.prototype -- __proto__--→ null
      |                                                                  ↑
      |--------- __proto__ ------→ Function.prototype --- __proto__ -----|
                                        ↑
                  Function -------→ __proto__
                                        |
                                      Object

物件導向程式設計（OOP）

在物件導向程式設計中最常見的表現形式就是類，提供了物件導向的 3⃣ 大特點和 5⃣️ 大原則，這東西網上特別多，我只做簡單的羅列，下面我會對特點進行實現，我的理解: 原則是物件導向程式設計的規範，而特點是物件導向程式設計的實現，前提是你已經仔細理解過下面對核心概念。

三大特點

繼承
多型
封裝

五大原則

單一【一個類應該有且只有一個去改變它的理由，這意味著一個類應該只有一項工作】
開放封閉【物件或實體應該對擴充套件開放，對修改封閉。】
里氏替換【即對父類別的呼叫同樣適用於子類】
依賴倒置【高層次的模組不應該依賴於低層次的模組】
介面隔離【不應強迫使用者端實現一個它用不上的介面，或是說使用者端不應該被迫依賴它們不使用的方法】

繼承

繼承是物件導向一個特點，可以實現子類呼叫自己沒有的屬性方法【父類別屬性方法】

/** ES6 **/
class Parent {}
class Child extends Parent { constructor () { super() } }
/** ES5 **/
function parent () { this.run () {} }
parent.prototype.eat = function () {}
function child () {}
// 原型式繼承
child.prototype = parent.prototype
child.prototype.constructor = child
// 原型鏈繼承
child.prototype = new parent()
child.prototype.constructor = child
// 構造器繼承
function boyChild (..arg) { parent.apply(this, arg) }
// 組合繼承
function boyChild (..arg) { parent.apply(this, arg) }
boyChild.prototype = new parent()
child.prototype.constructor = child
// 寄生組合繼承
function child (..arg) { parent.apply(this, arg) }
// ${1}
(
  function () { 
    function transmit () {};
    transmit.prototype = parent.prototype
    child.prototype = new prototype()
    child.prototype.constructor = child
  }
)()
// ${2}
child.prototype = Object.create(parent.prototype)
// ......
// 總結
// 繼承的方式方法多種多樣，不外乎，就是通過，某一種方式將不屬於自己的屬性方法可以呼叫，沿著原型的方式和拷貝賦值就可以總結出很多種不同的繼承方式，每種方式的優缺點，多是考慮，繼承的屬性方法的完整性和對範例化物件的影響，如範例上方法和原型鏈上方法是否都可以呼叫有或者參照傳遞改變同一原型鏈問題。

/** 上面為對範例對繼承，下面說一說對於介面對繼承 **/
// ES6 中並沒有提供介面這個概念，但是 Typescript 中對於介面又很好對支援，typescript 是 javascript 對超集，對物件導向提供了非常好對支援
// Typescript 【一時用一時爽，一直用一直爽】
// 很推薦用這個，他能避免很多低階錯誤，提供型別檢查，特別是寫過 java 轉前端的。
interface parent { run: () => void }
class child implements parent { run () {} }
// 轉碼後
var child = /** @class */ (function () {
    function child() {
    }
    child.prototype.run = function () { };
    return child;
}());

多型

多型是物件導向一個特點，可以實現子類有不同對錶現形態，可以實現同一種表現形式，可以有不同對狀態

/** ES6 **/
// ${1} 重寫
class Animal {
  eat () { console.log('animal eat') }
}
class Pig extends Animal {
  constructor () { super() }
  eat () { console.log('pig eat grass') }
}
class Tiger extends Animal {
  constructor () { super() }
  eat () { console.log('tiger eat pig') }
}
// ${2} 過載，模擬實現
class Animal {
  eat () { 
    if (typeof arg === '') {
      console.log('操作 one')
    } else if (typeof arg === '') {
      console.log('操作 two')
    } else {
      console.log('操作 three')
    }
  }
}
/** ES5 【提供實現一種】**/
// 原理就是沿著原型鏈往上找，只要在父類別前定義重寫這個方法即可
// ${1} 重寫
function animal () { this.eat = function () { console.log('Animal eat') } }
function pig () {
  animal.call(this)
  this.eat = function () { console.log('pig eat grass') }
}
function tiger () {
  animal.call(this)
  this.eat = function () { console.log('tiger eat pig') }
}
// ${2} 過載
function animal () {
  eat () { 
    if (typeof arg === '') {
      console.log('操作 one')
    } else if (typeof arg === '') {
      console.log('操作 two')
    } else {
      console.log('操作 three')
    }
  }
}

封裝

封裝是物件導向一個特點，將屬性和方法封裝這物件中，可以利用私有或者公有屬性，對外提供可以存取的方法或屬性

/** ES6 **/
// ES6 沒有提供真正的私有方法和屬性，有一個還在提案階段
// 在屬性和方法前面加 #
class Animal {
  #height = ''
  #eat () {}
}
// 模擬實現 【提供一種實現】
class Animal {
  constructor () { this.height = '50' }
  get height() { return undefined }
  set height (value) { return undefined }
}
/** ES5 **/
const animal = (function (arg) {
  let height = 50
  function eat () {console.log(height)}
  return { eat }
})([])
/** Typescript **/
class Animal {
  public height: number
  private name: string
  protected color: string
  constructor (height: number, name: string, color: string) {
    this.height = height
    this.name = name
    this.color = color
  }
  private eat ():void { console.log(this.name) }
}

函數程式設計程式設計(FP)

函數語言程式設計提倡函數是第一公民【指的是函數與其他資料型別一樣，處於平等地位，可以賦值給其他變數，也可以作為引數，傳入另一個函數，或者作為別的函數的返回值】，純粹的函數語言程式設計，是純函數【如果傳入的引數相同，就會返回相同的結果，不依賴於外部的資料狀態【如下範例】】，函數程式設計特點

// 純函數
const add = (one, two) => { return one + two }
// 非純函數
let two = 1
const add = (one) => { return one + two }

閉包和高階函數
柯里化
偏函數
組合和管道
函子

閉包和高階函數

閉包理解函數內部還有其他函數，可以使父函數資料狀態得以儲存高階函數理解函數可以通過變數傳遞給其他函數

// 利用封包實現一個只能呼叫一次的 map 高階函數
const map = (fn) => {
  let once = false
  return (arr) => { return once? null: (once = true, arr.map(fn)) }
}
const fn = (item) => item + 10
const arrMap = map(fn)
arrMap([1, 2, 3]) // [11, 12, 13]
arrMap([4, 5, 6]) // null

柯里化

柯里化理解柯里化是將一個多元函數轉換為巢狀一元函數的過程

function curry (fn) {
  return curryN (...arg) {
    if (arguments.length < fn.length) {
      return function () {
        return curryN.call(null, ...arg.concat(...arguments))
      }
    }
    return fn.call(null, ...arguments)
  }
}
const add = curry ((x, y, z) => x + y + z)
console.log(add(2)(3)(4)) // 9

偏函數

偏函數理解初始化時指定原函數的一些引數並建立一個新函數，這個函數用於接收剩餘引數

function proto(fn, ...pagram) {
  return (...args) => {
    args.forEach((item, index) => { if (item && !pagram[index]) pagram[index] = item })
    return fn.apply(null, pagram)
  }
}
let add = proto((x, y) => { console.log(x + y) }, undefined, 10)
add(2) // 12

組合和管道

組合和管道理解將一個函數的輸出作為另一個函數的輸入，像流水一樣從函數佇列從左到右流動或者從右到左流動

// 單個引數，簡單組合
const compose = (fn, fnc) => (arg) => fn(fnc(arg))
// 多個引數，藉助偏函數實現
function mapArr(arr, fn) { return arr.map(fn) }
function filte (arr, fn) { return arr.filter(fn) }
let map = proto(mapArr, undefined, (item) => { return item + 10 })
let filter  = proto(filte, undefined, (item) => { return item })
let mapFilter = compose(map, filter)
console.log(mapFilter([1, false, 9, 4])) // [11, 19, 14]
// 多個函陣列合
const reduce = (arr, fn, value) => {
  let initValue = value? value: arr[0]
  arr.forEach((item) => { initValue += fn(initValue, item) })
  return initValue
}
const compose = (...arg) => (value) => reduce(arg.reverse(), (acc, fn) => fn(acc), value)
let add = compose(() => { return 1 }, () => { return 2 }, () => { return 3 })
add(6) // 12

函子

函子的定義函子是一個普通物件（在其他語言中，可能是一個類），它實現了 map 函數，在遍歷每個物件值的時候生成一個新物件很抽象，簡單來說函子是一個持有值的容器。嗨難懂，上程式碼。

如圖[網上所盜]

// 實現一個基本定義的函子，滿足定義
// 實現 map 方法，在遍歷物件的時候生成一個新物件
function container (value) { this.value = value }
container.prototype.of = function (value) { return new container(value) }
container.prototype.map = function(fn) { return new container().of(fn(this.value)) }
new container().of([1, 5, 7, 3]).map((arr) => { return arr.filter((item) => item === 5)})
console.log(
  new container().of([1, 5]).map((arr) => { return arr.filter((item) => item === 5)}).value
) // 5