设计模式三大原则

设计模式三大原则

1.单一职责原则（一个函数或者一个类只做一件事）

// 定义一个判断参数是否为基本类型的函数
function isPrimitive(value){
  let type = typeof value
  return (type ==='undefined' || value===null ||
     type ==='string' || type ==='number' || type === 'boolean')
}
// 定义一个将所有参数求和的函数
function add(...nums){
  return nums.reduce((pre,current) => {
    if( typeof pre === 'number' && typeof current === 'number'){
    return pre + current
    }else{
      return '参数必须为number'
    }
  })
}
console.log(add(1,2,3))

改进后(遵循单一职责原则)

let isStr = value => typeof value === 'string'
let isBool = value => typeof value === 'boolean'
let isNum = value => typeof value === 'number'
let isNUll = value => value === null
let isUndefined = value => typeof value === 'undefined'
let isSym = value => typeof value === 'symbol'

// 定义一个判断参数是否为基本类型的函数
function isPrimitive(value){
  return (isStr(value) || isBool(value) || isNum(value) || isNUll(value) || isUndefined(value) || isSym(value)) 
}
console.log(isPrimitive(1))

// 定义一个将所有参数求和的函数
function add(...nums){
  return nums.reduce((pre,current) => {
    if( isNum(pre) && isNum(current)){
    return pre + current
    }else{
      return '参数必须为number'
    }
  })
}
console.log(add(1,2,3))

2.开放封闭原则(对扩展开放，对修改关闭)

let isStr = value => typeof value === 'string'
let isBool = value => typeof value === 'boolean'
let isNum = value => typeof value === 'number'
let isNUll = value => value === null
let isUndefined = value => typeof value === 'undefined'
let isSym = value => typeof value === 'symbol'
let isbig = value => typeof value === 'bigint'

// 定义一个判断参数是否为基本类型的函数(基本函数保持不变)
function _isPrimitive(value, fn){
  return (isStr(value) || isBool(value) || isNum(value) || isNUll(value) || isUndefined(value) || (fn && fn(value))) 
}

function isPrimitive(value){
  return _isPrimitive(value)
}

function _is_ES6_Primitive(value){
  return _isPrimitive(value, value => isSym(value))
}

function _is_ES2020_Primitive(value){
  return _isPrimitive(value, value => isSym(value) || isbig(value))
}

console.log(_is_ES2020_Primitive(1))

3.最少知识原则（越少人知道越好，闭包是最好的呈现）

let pow = (...nums) => nums.reduce((pre, cur) => pre ** cur)
console.log(pow(3,2,1))

改进

let pow = (() =>{
  // 缓存对象
  let obj = {} //(obj置于闭包中，就是不想让外面直接访问)
  return (...nums) => {
    // 将所有参数转换为字符串
    let numbers = nums.join(",")
    // 判断这个字符串是否在对象中
    if(numbers in obj){
      return obj[numbers]
    }else{
      return obj[numbers] = nums.reduce((pre, cur) => pre ** cur)
    }
  }
})()
console.log(pow(3,2,1))