js-函数式编程-引用透明、默认值函数、规则生成器&验证器生成器

• 引用透明
• 默认值函数
• 规则生成器，验证器生成器

import _ from 'underScore'
import Utils from '../lib/utils.js'
// 捕获变量
// 唯一字符串

function uniqueString(len) {
  return Math.random().toString(36).slice(2, len + 2)
}
console.log( uniqueString(10))

// 前缀唯一字符串
function uniqueString1(prefix) {
  return [prefix, new Date().getTime()].join('')
}
console.log( uniqueString1('hello'))

// 带前缀递增唯一字符串
function uniqueString2(start) {
  let count = isNaN(start) ? 0 : start
  return function(prefix) {
    return [prefix, count++].join('')
  }
}
let id = uniqueString2()
console.log(id('h')) // h0
console.log(id('h')) // h1
console.log(id('h')) // h2
// 当一个函数的返回值只依赖它的参数时，被称为具有引用透明

let ary = [1,2,3,null,4]
console.log(_.reduce(ary, (total, n) => total * n)) // 0

// 防止不存在的函数
function fNull(fun, ...defaults) {
  // 缓存待执行函数及默认值
  // defaults[pre, cur, index, ary]的默认值
  return function() {
    // 遍历所有参数，为空则替换成默认值
    let args = _.map(arguments, function(e, i) {
      return Utils.existy(e) ? e : defaults[i]
    })
    return fun.apply(null, args)
  }
}
let safeMult = fNull((total, n) => total * n, 0, 1) // 24, 设置了默认值为1
console.log(_.reduce(ary, safeMult))

// 解决配置对象问题函数
function defaults(d) {
  // 缓存一个默认对象d
  return function(o, k) {
    let val = fNull(_.identity, d[k]) // 设置d[k]为默认值
    return o && val(o[k])
  }
}

function getCritical(config) {
  let lookup = defaults({critical: 108}) // 检查函数，设置默认值
  return lookup(config, 'critical') // 检查是否存在对应的key
}
console.log(getCritical({critical: 9})) // 9
console.log(getCritical({})) // 108默认值

// 验证器生成器
function checker (...validator) {
  return function(obj) {
    return validator.reduce((errs, check) => {
      if(check(obj)) {
        return errs
      } else {
        return _.chain(errs).push(check.message).value()
      }
    }, [])
  }
}
let alwaysPasses = checker(Utils.k(true), Utils.k(true))
console.log('alwaysPasses', alwaysPasses({}))

// fail规则
let fail = Utils.k(false)
fail.message = 'a fail in life'

// fail验证器
let alwaysFail = checker(fail)

console.log(alwaysFail({}))

// 规则生成器
function validator(message, fun) {
  let f = function(...args) {
    return fun.apply(fun, args)
  }
  f['message'] = message
  return f
}

// let checkAuth = checker(validator('hasAuth', Utils.k(false)))
// console.log(checkAuth(0))

// 进入验证值，返回true/false，是否显示message。
let checkAuth = checker(validator('hasAuth', e => {console.log(e); return true}))
console.log(checkAuth(0)) // 传值

function aMap(obj) {
  return _.isObject(obj)
}
let checkMap = checker(validator('must be a map', aMap))
console.log('checkMap({})', checkMap({}))
console.log('checkMap(123)', checkMap(123))

function hasKeys(...keys) {
  let fun = function(obj) {
    return keys.every(k => _.has(obj, k))
  }
  fun.message = Utils.cat(['Must have values for keys:'], keys).join(' ')
  return fun
}

let checkCommand = checker(validator('Must be a map', aMap), hasKeys('msg', 'type'))
console.log(checkCommand({msg: 'ok', type: 'success'}))
console.log( checkCommand(32) )
console.log( checkCommand({}) )