浅析js中的纯函数、高阶函数、记忆函数、偏函数

let greeting = ‘Hello‘

function greet (name) {
  return greeting + ‘ ‘ + name
}

console.log(greet(‘World‘))  // Hello World

function greet (greeting, name) {
  return greeting + ‘ ‘ + name
}

console.log(greet(‘Hi‘, ‘Savo‘))   // Hi Savo

const user = {
  name: ‘Nick Brown‘
}

let flag = false

function checkData (user) {
  if (user.name.length > 4) {
    flag = true
  }
}

const user = {
  name: ‘Nick Brown‘
}

function checkData (user) {
  return user.name.length > 4
}

const flag = checkData(user)

const arr1 = [0, 1, 2, 3, 4, 5, 6]
const arr2 = [0, 1, 2, 3, 4, 5 ,6]

const spliceArr = arr1.splice(0, 2)
const sliceArr = arr2.slice(0, 2)

console.log(‘arr1: ‘, arr1)
console.log(‘spliceArray: ‘, spliceArr)

console.log(‘arr2: ‘, arr2)
console.log(‘sliceArray: ‘, sliceArr)

// 执行结果
array1: 2,3,4,5,6
spliceArray: 0,1
array2: 0,1,2,3,4,5,6
sliceArray: 0,1

/**
 * Create a cached version of a pure function.
 * 只适用于缓存 接收一个字符串为参数的 fn
 */
export function cached (fn) {
  const cache = Object.create(null)
  return function cachedFn (str) {
    const hit = cache[str]
    return hit || (cache[str] = fn(str))
  }
}

/**
 * Capitalize a string.
 */
export const capitalize = cached((str) => {
  return str.charAt(0).toUpperCase() + str.slice(1)
})

const getData = function(url, callback) {
    ajax.get(url, function(data){
        callback(data)
    })
}

// 这个是用来获取当前时间戳的
function now() {
  return +new Date()
}
/**
 * 防抖函数，返回函数连续调用时，空闲时间必须大于或等于 wait，func 才会执行
 *
 * @param  {function} func        回调函数
 * @param  {number}   wait        表示时间窗口的间隔
 * @param  {boolean}  immediate   设置为ture时，是否立即调用函数
 * @return {function}             返回客户调用函数
 */
function debounce (func, wait = 50, immediate = true) {
  let timer, context, args

  // 延迟执行函数
  const later = () => setTimeout(() => {
    // 延迟函数执行完毕，清空缓存的定时器序号
    timer = null
    // 延迟执行的情况下，函数会在延迟函数中执行
    // 使用到之前缓存的参数和上下文
    if (!immediate) {
      func.apply(context, args)
      context = args = null
    }
  }, wait)

  // 这里返回的函数是每次实际调用的函数
  return function(...params) {
    // 如果没有创建延迟执行函数（later），就创建一个
    if (!timer) {
      timer = later()
      // 如果是立即执行，调用函数
      // 否则缓存参数和调用上下文
      if (immediate) {
        func.apply(this, params)
      } else {
        context = this
        args = params
      }
    // 如果已有延迟执行函数（later），调用的时候清除原来的并重新设定一个
    // 这样做延迟函数会重新计时
    } else {
      clearTimeout(timer)
      timer = later()
    }
  }
}

// 自记忆素数检测函数
function isPrime (value) {
  // 创建缓存
  if (!isPrime.answers) {
    isPrime.answers = {};
  }
  // 检查缓存的值
  if (isPrime.answers[value] !== undefined) {
    return isPrime.answers[value];
  }
  // 0和1不是素数
  var prime = value !== 0 && value !== 1;
  // 检查是否为素数
  for (var i = 2; i 

function toUpperCase(str) {
    return str.toUpperCase() // 将字符串变成大写
}

function add(str) {
    return str + ‘!!!‘ // 将字符串拼接
}

function split(str) {
    return str.split(‘‘) // 将字符串拆分为数组
}

function reverse(arr) {
    return arr.reverse() // 将数组逆序
}

function join(arr) {
    return arr.join(‘-‘) // 将数组按‘-‘拼接成字符串
}

function compose() {
    const args = Array.prototype.slice.call(arguments)  // 类数组转换为数组
    const len = args.length - 1  // 最后一个参数的索引
    return function(x) {
        let result = args[len](x)  // 执行最后一个函数的结果
        while(len--) {
            result = args[len](result)  // 执行每个函数的结果
        }
        return result 
    }
}

const f = compose(add, join, reverse, split, toUpperCase) 
console.log( f(‘cba‘) )  // A-B-C!!!

const compose2 = (...args) => x => args.reduceRight((result, cb) => cb(res), x) 

const f = compose2(add, join, reverse, split, toUpperCase) 
console.log( f(‘cba‘) )   // A-B-C!!!