// before
function getPrice(price,discount){
	return price * discount;
}

let price = getPrice(500,0.1);


// after 
function getPrice(discount){
	return price =>{
 	return price * discount
 }
}
// 使用,在這種使用效果下，我們可以固定的肢解拿到百分之十折扣的函數(shù)，
//也就是針對使用0.1折扣的商品價格都可以簡化這個折扣的傳遞,從而達到簡化參數(shù)的目的
//那么從函數(shù)的運行上來講，也比之前的效率高了，如果解析折扣的過程比較復(fù)雜
let tenDiscount = getPrice(0.1);
let price = tenDiscount(500);

let price = getPrice(0.1)(500)

// complexed fun 
function getPriceComplex(price,discount){
 let actualDiscount = 1;
 if(discount > 0.8 ) {
 	actualDiscount = 0.8;
 } else if(discount > 0.5){
 	actualDiscount = 0.5;
 } else {
 actualDiscount = 0.1;
 }
 let actualPrice = price - price % 100 ;
	return actualPrice * actualDiscount;
}

// complexed fun better
function getPriceComplexBetter(discount){
 let actualDiscount = 1;
 if(discount > 0.8 ) {
 	actualDiscount = 0.8;
 } else if(discount > 0.5){
 	actualDiscount = 0.5;
 } else {
 actualDiscount = 0.1;
 }
 return price => {
 	 let actualPrice = price - price % 100 ;
			return actualPrice * actualDiscount;
 }
}


console.log(getPriceComplex(500,0.9))
let exp1 = getPriceComplexCp(0.9);
console.log(exp1);
/** price => {
 let actualPrice = price - price % 100;
 return actualPrice * actualDiscount;
}*/
// 相同的輸入?yún)?shù)時 可以緩存下之前代碼邏輯的執(zhí)行結(jié)果 實現(xiàn)模塊的可重用，如果你之前的邏輯是一個純函數(shù)
console.log(exp1(500))// 400
console.log(exp1(400))// 320


// get real discount 
// 當(dāng)你針對第一個參數(shù)的邏輯較為復(fù)雜時，出于可維護角度，建議如此 ;
// 當(dāng)你另外一個邏輯也是基于這個返回結(jié)果時，出于重用角度，建議如此
function getActualDiscount(discount){
 let actualDiscount = 1;
 if(discount > 0.8 ) {
 	actualDiscount = 0.8;
 } else if(discount > 0.5){
 	actualDiscount = 0.5;
 } else {
 actualDiscount = 0.1;
 }
 return actualDiscount;
}
// complexed fun best
function getPriceComplexBest(discount){
 let actualDiscount =getActualDiscount(discount);
 return price => {
 	 let actualPrice = price - price % 100 ;
			return actualPrice * actualDiscount;
 }
}

// 只考慮兩個參數(shù)
function add(a,b){
 return a + b
}

// 但如果你是用柯里化的方式:兩個參數(shù)的時候 ，但這樣對原代碼變動非常大，對于一些復(fù)雜的邏輯，這基本不可能
function curryAdd(...args){
 return (...newArgs) => {
 	return anoNumber * number;
 };
}

// 我們寫一個通用的柯里化函數(shù)的方式,經(jīng)過這個函數(shù)的轉(zhuǎn)換，我們可以將調(diào)用方式簡化
function curry = (fn,...args){
	return (..._args)=>{
 	return fn(...args, ..._arg);
 }
}

let curryAdd = curry(add,10);
let curryAdd2 = curryAdd(11)

function add() {
 // 第一次執(zhí)行時，定義一個數(shù)組專門用來存儲所有的參數(shù)
 var _args = [].slice.call(arguments);
 // 在內(nèi)部聲明一個函數(shù)，利用閉包的特性保存_args并收集所有的參數(shù)值,執(zhí)行時已經(jīng)收集所有參數(shù)為數(shù)組
 var adder = function () {
  var _adder = function() {
   // 執(zhí)行收集動作，每次傳入的參數(shù)都累加到原參數(shù)
   [].push.apply(_args, [].slice.call(arguments));
   return _adder;
  };
  // 利用隱式轉(zhuǎn)換的特性，當(dāng)最后執(zhí)行時隱式轉(zhuǎn)換，并計算最終的值返回
  _adder.toString = function () {
   return _args.reduce(function (a, b) {
    return a + b;
   });
  }
  return _adder;
 }
 return adder(_args);
}

function getActualDiscount(custoemrLevel,discount){
	
}
function getPriceComplex (custoemrLevel,discount){
	let actualDiscount = getActualDiscount(custoemrLevel,discount);
 return price=>{
 	return price * actualDiscount;
 }
}
// 等級一的折扣策略 
let strategyLev1WithOnepoint = getPriceComplex('lev1',0.1) ;
let actualPrice = strategyLev1WithOnepoint(500);