javascript的有趣邏輯片斷

準備面試的刷題過程當中，遇到了一些題，比較有意思，輕巧。
增強運用一下js原生語法，多解。

題目來源：https://github.com/rmurphey/j...
A test-driven approach to assessing JS skills

• 統計數組 arr 中值等於 item 的元素出現的次數

function count(arr, item) {
     var count = 0;
     arr.forEach(function(e){
         //e爲arr中的每個元素，與item相等則count+1
         e == item ? count++ : 0;
     });
     return count;
 }

function count(arr, item) {
    return arr.filter(function(a){
        return (a==item);
    }).length
}

function count(arr, item) {
    var res;
    return (res = arr.toString().match(new RegExp("\\b"+item+"\\b","g")))?res.length:0;
}

function count(arr, item) {
            var count = 0;
            arr.map(function(a) {
                if(a === item) {
                    count++;
                }
            });
            return count;
        }

• 爲數組 arr 中的每一個元素求二次方。不要直接修改數組 arr，結果返回新的數組

function square(arr) {
    return arr.map(function(item,index,array){
        return item*item;
    })
}

function square(arr) {
   //聲明一個新的數組存放結果
     var a = [];
     arr.forEach(function(e){
         //將arr中的每個元素求平方後，加入到a數組中
         a.push(e*e);
     });
     return a;
 }

function square(arr) {
//複製一個arr數組
    var newarr = arr.slice(0);
    for (var i=0;i<newarr.length;i++){
        newarr[i]= newarr[i]* newarr[i];
    }
    return newarr;
}

function square(arr) {
    return arr.map(function(item){
        return Math.pow(item, 2);
    })
}

• 將數組 arr 中的元素做爲調用函數 fn 的參數

function argsAsArray(fn, arr) {
  return fn.apply(this, arr);
 }

function argsAsArray(fn, arr) {
    return function(para1,para2){ 
        return  para1.apply(this,para2);
    }(fn,arr);
}

• 完成函數 createModule，調用以後知足以下要求：

一、返回一個對象
二、對象的 greeting 屬性值等於 str1，name 屬性值等於 str2
三、對象存在一個 sayIt 方法，該方法返回的字符串爲 greeting屬性值 + ', ' +name屬性值

function createModule(str1, str2) {
     var obj = {
         greeting : str1,
         name     : str2,
         sayIt    : function(){
             //兩個屬性前面都須要加上this
             return this.greeting+", "+this.name;
         }
     };
     return obj;
 }

//使用構造函數法
function createModule(str1, str2) {
    function Obj(){
        this.greeting = str1;
        this.name = str2;
        this.sayIt = function(){
            return this.greeting + ', ' + this.name;
        };
    }
    return new Obj();
}

//構造函數與原型組合
function createModule(str1, str2) {
    function CreateMod(){
        this.greeting = str1;
        this.name = str2;
    }
    CreateMod.prototype.sayIt = function(){
        return this.greeting + ', '  + this.name;
    }
    return new CreateMod();
}

• 已知 fn 爲一個預約義函數，實現函數 curryIt，調用以後知足以下條件：

一、返回一個函數 a，a 的 length 屬性值爲1（即顯式聲明 a 接收一個參數）
二、調用 a 以後，返回一個函數 b, b 的 length 屬性值爲 1
三、調用 b以後，返回一個函數 c, c 的 length 屬性值爲 1
四、調用 c 以後，返回的結果與調用 fn 的返回值一致
五、fn的參數依次爲函數 a, b, c 的調用參數

輸入例子:

var fn = function (a, b, c) {return a + b + c}; curryIt(fn)(1)(2)(3);

function curryIt(fn) {
     //獲取fn參數的數量
     var n = fn.length;
     //聲明一個數組args
     var args = [];
     //返回一個匿名函數
     return function(arg){
         //將curryIt後面括號中的參數放入數組
         args.push(arg);
         //若是args中的參數個數小於fn函數的參數個數，
         //則執行arguments.callee（其做用是引用當前正在執行的函數，這裏是返回的當前匿名函數）。
         //不然，返回fn的調用結果
         if(args.length < n){
            return arguments.callee;
         }else return fn.apply("",args);
     }
 }

function curryIt(fn) {
    return function a(xa){
        return function b(xb){
            return function c(xc){
                return fn.call(this,xa,xb,xc);
            };
        };
    };
}

• 數組中輸出元素位置

function indexof(arr,item){
    for(var i = 0,len = arr.length;i<len;i++){
        var ite = arr[i];
        if(ite == item){
            console.log(ite == item);
            return i;
        }else{
            return -1;
        }
    }
}

function indexof(arr,item){
    return arr.indexOf(item);
}

• 數組求和

function sum(arr) {
    return eval(arr.join("+"));
};

• 刪除給定元素

function remove(arr, item) {
        for(var i=0, m=arr.length, res=[]; i<m; i++){
            if(item === arr[i]) continue;
            else res.push(arr[i]);
        }
        return res;
    }

function remove(arr, item) {
    var newA=arr.slice(0);
    for(var i=newA.indexOf(item);i>-1;i=newA.indexOf(item)){
        newA.splice(i,1);
    }
    return newA;
}

• 將函數放入數組，參數放入函數，調用數組裏面的函數，返回函數執行的結果。

function makeclosures(arr,fn){
    var funcs = [];
    for(var i = 0;i<arr.length;++i){
        (function(v){
            funcs[v] = function(){
                return fn.call(null,arr[v])
            }
        })(i)
    }
}

• 將函數a暫時保存在一個內建函數result中，返回這個result函數，再執行.（有閉包，call/apply）

partialUsingArguments(test,a,b)(c,d);//用法

function partialUsingArguments(fn){
    var args1  = Array.prototype.slice.call(arguments,1);
    var result = function(){
        var args2 = Array.prototype.slice.call(arguments,0);
        var args = args1.concat(args2);
        return fn.apply(null,args);
    }
    return result;
}

• 判斷字符串是否連續重複（如果，則返回true）

function containRepeatingLetter(str){
    var re = /[a-zA-Z]/;
    for(var i = 0,len = str.length;i<len;i++){
        if(str.charAt(i) == str.charAt(i+1) && reg.test(str.charAt(i))){
    return true;
       }
    }
return false;
}


--------------------------------------------------------------------

• 以下的結果是？

var m= 1, 
j = k = 0; 
function add(n) { 
    return n = n+1; 
　 } 
y = add(m);   //4
function add(n) { 
    return n = n + 3; 
} 
z = add(m);   //4

全部聲明的函數都會被提早。因此function add(){}定義的函數會優先解析，而不是順序解析；所以整個過程當中，首先依次解析兩個add function，因爲同名，因此後者會覆蓋前者；而後，順序解析其他的JS代碼，y = add(m);語句和z = add(m); 語句調用的都是第二個add function，所以返回的都是4.

• 以下的結果是？

(function() {
          var a = b = 5;
      })();   
    console.log(b);  //5
    console.log(a);   //a is not defined

vara=b=5;其中var a表示a爲當前做用域的全局變量，b=5並無定義爲當前做用域的全局變量，它會申明提早在全局做用域中。
可表示以下：

var b=5;
(function() {
      var a = b ;
  })();        
  console.log(b);  //5
  console.log(a);   //a is not defined

• 給出參數 str,start,end 表示當前字符串中從下標爲 start 的字符開始的長度爲 end
  的一個子串。你要將這個子串左右翻轉後插在這個子串原來位置的正後方，求最後獲得的字符串是什麼。

function reverseString(str,start,end){
     var slice = str.slice(start,end);
     var sliceReverse = slice.split('').reverse().join(''); //string -> array ->反array -> 反string
     var reverseString = str.slice(0,start+end)+sliceReverse+str.slice(start+end); //拼接新的字符串
     return reverseString;
}

• apply,bind(es5)結合，返回二維數組中每一個一維數組的最大值

function largestOfFour(arr) {
  return arr.map(Function.apply.bind(Math.max, null));
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

• 用JS實現一個數組合並的方法（要求去重）。

var arr1 = ['a'];
var arr2 = ['b', 'c'];
var arr3 = ['c', ['d'], 'e', undefined, null];

var concat = (function(){
  // concat arr1 and arr2 without duplication.
  var concat_ = function(arr1, arr2) {
    for (var i=arr2.length-1;i>=0;i--) {
      arr1.indexOf(arr2[i]) === -1 ? arr1.push(arr2[i]) : 0;
    }
  };
  // concat arbitrary arrays.
  // Instead of alter supplied arrays, return a new one.
  return function(arr) {
    var result = arr.slice();
    for (var i=arguments.length-1;i>=1;i--) {
      concat_(result, arguments[i]);
    }
    return result;
  };
}());

• 爲字符串實現一個render方法，實現下面的變量替換功能

var greeting = 'my name is $(name),age $(age)';
var result = greeting.render({name:'XiaoMing',age:11});
console.log(result); // my name is XiaoMing,age 11

answer:

String.prototype.render = function(option){
        var s = this,
                reg;
        Object.keys(option).forEach(function(k){
            reg = new RegExp("\\$\\("+k+"\\)","g");
            s = s.replace(reg,option[k])
        });
        return s
    };

    var greeting = 'my name is $(name),age $(age)';
    var result = greeting.render({name:'XiaoMing',age:11});
    console.log(result); // my name is XiaoMing,age 11

• 取字符串中間的字符，奇數取1，偶數取2

function getMiddle(str){
   return str.substr(Math.ceil(str.length/2-1),str.length % 2 == 0 ? 2: 1)
 }
var p1 = getMiddle("test"); //es
    var p2 = getMiddle("testing"); //t
    var p3 = getMiddle("middle"); //dd
    var p4 = getMiddle("A"); //A