JS偏函数、组合函数、缓存函数

一、JavaScript代码

[附件]/functools.js

 
  
     
   
  1. (function( window ) { 
    2.  
   
  2. "use strict"; 
    3.  
   
  3.  
    4.  
   
  4. var functools = window.functools || {}; 
    5.  
   
  5.  
    6.  
   
  6. /** 
    7.  
   
  7.  * partial function 
    8.  
   
  8.  */ 
    9.  
   
  9. functools.curry = function( f, ctx ) { 
    10.  
   
  10.     var args = Array.prototype.slice.call( arguments, 2 ); 
    11.  
   
  11.     return function() { 
    12.  
   
  12.         var newArgs = args.concat(Array.prototype.slice.call( arguments )); 
    13.  
   
  13.         return f.apply( ctx, newArgs ); 
    14.  
   
  14.     } 
    15.  
   
  15. } 
    16.  
   
  16.  
    17.  
   
  17. /** 
    18.  
   
  18.  * right-left partial function 
    19.  
   
  19.  */ 
    20.  
   
  20. functools.rcurry = function( f, ctx ) { 
    21.  
   
  21.     var args = Array.prototype.slice.call( arguments, 2 ); 
    22.  
   
  22.     return function() { 
    23.  
   
  23.         var newArgs = Array.prototype.slice.call( arguments ).concat( args ); 
    24.  
   
  24.         return f.apply( ctx, newArgs ); 
    25.  
   
  25.     } 
    26.  
   
  26. } 
    27.  
   
  27.  
    28.  
   
  28. /** 
    29.  
   
  29.  * composite function 
    30.  
   
  30.  * @description `compose(f, g, x)(y) = f(g(y), x)` 
    31.  
   
  31.  */ 
    32.  
   
  32. functools.compose = function( f, g, f_ctx, g_ctx ) { 
    33.  
   
  33.     var args_for_f = Array.prototype.slice.call( arguments, 4 ); 
    34.  
   
  34.     return function() { 
    35.  
   
  35.         var args_for_g = Array.prototype.slice.call( arguments ); 
    36.  
   
  36.         var mid = g.apply( g_ctx, args_for_g ); 
    37.  
   
  37.         args_for_f.unshift(mid); 
    38.  
   
  38.         return f.apply( f_ctx, args_for_f); 
    39.  
   
  39.     } 
    40.  
   
  40. } 
    41.  
   
  41.  
    42.  
   
  42. /** 
    43.  
   
  43.  * Memoizer, and allows multiple arguments. 
    44.  
   
  44.  * @description Recursion needs to override function literal.  
    45.  
   
  45.  *              e.g. `func = memoize( func, null )` 
    46.  
   
  46.  */ 
    47.  
   
  47. functools.memoize = function( f, ctx ) { 
    48.  
   
  48.     var memo = {}; 
    49.  
   
  49.     return function() { 
    50.  
   
  50.         var key = Array.prototype.join.call(arguments, "_"); 
    51.  
   
  51.         var res = memo[ key ]; 
    52.  
   
  52.         if ( res === undefined ) { 
    53.  
   
  53.             res = f.apply( ctx, arguments ); 
    54.  
   
  54.             memo[ key ] = res; 
    55.  
   
  55.         } 
    56.  
   
  56.         return res; 
    57.  
   
  57.     } 
    58.  
   
  58. } 
    59.  
   
  59.  
    60.  
   
  60. /** 
    61.  
   
  61.  * Return the result and runtime of the function. 
    62.  
   
  62.  */ 
    63.  
   
  63. functools.timeit = function( f, ctx ) { 
    64.  
   
  64.     var args = Array.prototype.slice.call( arguments, 2 ); 
    65.  
   
  65.     var started = +new Date(); 
    66.  
   
  66.     var result = f.apply( ctx, args ); 
    67.  
   
  67.     var runtime = +new Date() - started; 
    68.  
   
  68.     return { 
    69.  
   
  69.         result: result, 
    70.  
   
  70.         runtime: runtime 
    71.  
   
  71.     } 
    72.  
   
  72. } 
    73.  
   
  73.  
    74.  
   
  74. function extend( a, b ) { 
    75.  
   
  75.     for ( var prop in b ) { 
    76.  
   
  76.         if ( b[ prop ] === undefined ) { 
    77.  
   
  77.             delete a[ prop ]; 
    78.  
   
  78.         // Avoid "Member not found" error in IE8 caused by setting window.constructor 
    79.  
   
  79.         } else if ( prop !== "constructor" || a !== window ) { 
    80.  
   
  80.             a[ prop ] = b[ prop ]; 
    81.  
   
  81.         } 
    82.  
   
  82.     } 
    83.  
   
  83.     return a; 
    84.  
   
  84. } 
    85.  
   
  85.  
    86.  
   
  86. if ( window.functools === undefined ) { 
    87.  
   
  87.     extend( window, functools ); 
    88.  
   
  88.     window.functools = functools; 
    89.  
   
  89. } 
    90.  
   
  90.  
    91.  
   
  91. // get at whatever the global object is, like window in browsers 
    92.  
   
  92. }( (function() {return this;}.call()) )); 
    93.  
  
 
  

二、QUnit测试代码
 
  
[附件]/functools.html
 
  
 
  
     
   
  1. <!DOCTYPE html> 
    2.  
   
  2. <html> 
    3.  
   
  3. <head> 
    4.  
   
  4.     <meta charset="utf-8"> 
    5.  
   
  5.     <title>functools test case</title> 
    6.  
   
  6.     <link rel="stylesheet" href="./qunit/qunit-1.11.0.css"> 
    7.  
   
  7. </head> 
    8.  
   
  8. <body> 
    9.  
   
  9.     <div id="qunit"></div> 
    10.  
   
  10.     <div id="qunit-fixture"></div> 
    11.  
   
  11.     <script src="./qunit/qunit-1.11.0.js"></script> 
    12.  
   
  12.     <script src="./functools.js"></script> 
    13.  
   
  13.     <script> 
    14.  
   
  14.         test( "curry test case", function() { 
    15.  
   
  15.             function sum() { 
    16.  
   
  16.                 var sum = 0; 
    17.  
   
  17.                 for ( var i = 0; i < arguments.length; i++ ) { 
    18.  
   
  18.                     sum +=  arguments[i]; 
    19.  
   
  19.                 } 
    20.  
   
  20.                 return sum; 
    21.  
   
  21.             } 
    22.  
   
  22.             var sumBase10 = curry( sum, null, 1, 2, 3, 4 ); 
    23.  
   
  23.  
    24.  
   
  24.             var value = sumBase10( 20, 30, 40 ); 
    25.  
   
  25.             equal( value, 100, "We expect value to be 100" ); 
    26.  
   
  26.         }); 
    27.  
   
  27.  
    28.  
   
  28.         test( "rcurry test case", function() { 
    29.  
   
  29.             function between( value, low, high, allowEqual ) { 
    30.  
   
  30.                 if ( value > low && value < high ) { 
    31.  
   
  31.                     return true; 
    32.  
   
  32.                 } 
    33.  
   
  33.                 if ( allowEqual && ( value == low || value == high) ) { 
    34.  
   
  34.                     return true; 
    35.  
   
  35.                 } 
    36.  
   
  36.                 return false; 
    37.  
   
  37.             } 
    38.  
   
  38.             var betweenClosed = rcurry( between, null, true ), 
    39.  
   
  39.                 between10and20 = rcurry( betweenClosed, null, 10, 20 ); 
    40.  
   
  40.  
    41.  
   
  41.             ok( between10and20( 10 ) , "10 is between 10 and 20" ); 
    42.  
   
  42.             ok( between10and20( 20 ) , "20 is between 10 and 20" ); 
    43.  
   
  43.             equal( between10and20( 9 ), false, "9 is not between 10 and 20" ); 
    44.  
   
  44.             equal( between10and20( 21 ), false, "21 is not between 10 and 20" ); 
    45.  
   
  45.         }); 
    46.  
   
  46.  
    47.  
   
  47.         test( "compose test case", function() { 
    48.  
   
  48.             /* only one argument */ 
    49.  
   
  49.             function trim( s ) { 
    50.  
   
  50.                 return s.replace( /(^\s+)|(\s+$)/g, "" ); 
    51.  
   
  51.             } 
    52.  
   
  52.             function upper( s ) { 
    53.  
   
  53.                 return s.toUpperCase(); 
    54.  
   
  54.             } 
    55.  
   
  55.             var trimUpper = compose( upper, trim, null, null ); 
    56.  
   
  56.  
    57.  
   
  57.             var value = trimUpper( "  trim and upper  " ); 
    58.  
   
  58.             equal( value, "TRIM AND UPPER", "trimUpper test case" ); 
    59.  
   
  59.  
    60.  
   
  60.             /* multiple arguments */ 
    61.  
   
  61.             function f( x, y ) { 
    62.  
   
  62.                 return x + y; 
    63.  
   
  63.             } 
    64.  
   
  64.             var g = f; 
    65.  
   
  65.             var fg = compose( f, g, null, null, "F" ); 
    66.  
   
  66.  
    67.  
   
  67.             equal( fg( "X", "Y" ), "XYF", "We expect value to be XYF" ); 
    68.  
   
  68.         }); 
    69.  
   
  69.  
    70.  
   
  70.         test( "memoize test case", function() { 
    71.  
   
  71.             /* only one argument */ 
    72.  
   
  72.             function fib( n ) { 
    73.  
   
  73.                 if ( n == 0 ) return 0; 
    74.  
   
  74.                 if ( n == 1 ) return 1; 
    75.  
   
  75.                 return fib( n - 1) + fib( n - 2 ); 
    76.  
   
  76.             } 
    77.  
   
  77.             var res_old = timeit( fib, null, 30 ); 
    78.  
   
  78.             fib = memoize( fib, null ); // override 
    79.  
   
  79.             var res_new = timeit( fib, null, 30 ); 
    80.  
   
  80.  
    81.  
   
  81.             equal( res_new.result, res_old.result, 
    82.  
   
  82.                 [ "It's expected value.", res_old.runtime, res_new.runtime ].join("|") 
    83.  
   
  83.             ); 
    84.  
   
  84.  
    85.  
   
  85.             /* multiple arguments */ 
    86.  
   
  86.             function func( a, b ) { 
    87.  
   
  87.                 func.counter++; 
    88.  
   
  88.                 if ( a == 1 ) return 1; 
    89.  
   
  89.                 return a + b + func( a - 1, b - 1 ); 
    90.  
   
  90.             } 
    91.  
   
  91.             func = memoize( func, null ); // override 
    92.  
   
  92.  
    93.  
   
  93.             func.counter = 0; // declare 
    94.  
   
  94.             var a = func( 5, 4 ), // = 25 
    95.  
   
  95.                 a_cnt = func.counter; // = 5 
    96.  
   
  96.             func.counter = 0; // reset 
    97.  
   
  97.             var b = func( 6, 5 ), // 6 + 5 + func( 5, 4 ) << cache 
    98.  
   
  98.                 b_cnt = func.counter; // = 1 
    99.  
   
  99.  
    100.  
   
  100.             equal( b, 36, [ "It's expected value.", a_cnt, b_cnt ].join("|") ); 
    101.  
   
  101.         }); 
    102.  
   
  102.     </script> 
    103.  
   
  103. </body> 
    104.  
   
  104. </html> 
    105.  
  
 
  
ps：附件解压，打开functools.html即可测试。