JS笔记-常见函数与问题

1、请给Array本地对象增加一个原型方法，它用于删除数组条目中重复的条目(可能有多个)，返回值是一个包含被删除的重复条目的新数组。

Array.prototype.distinct = function() {
    var ret = [];
    for (var i = 0; i < this.length; i++)
    {
        for (var j = i+1; j < this.length;) {   
            if (this[i] === this[j]) {
                ret.push(this.splice(j, 1)[0]);
            } else {
                j++;
            }
        }
     }
     return ret;
}
//for test
alert(['a','b','c','d','b','a','e'].distinct());

2、找出数组 arr 中重复出现过的元素

function duplicates(arr) {
  var result = new Array();
    arr.forEach(function(item){
       if(arr.indexOf(item) !=arr.lastIndexOf(item) && result.indexOf(item) == -1){
           result.push(item);
       }
    });
    return result;
}

3、写一个函数使mySort()，能使传入的参数按照从小到大的顺序显示出来

function mySort() {
    var tags = new Array();
    for(var i = 0;i < arguments.length;i++) {
        tags.push(arguments[i]);
    }
    tags.sort(function(compare1,compare2) {
        return compare1- compare2;
    });
    return tags;
}
 
var result = mySort(50,11,16,32,24,99,57,100);
console.info(result);

4、实现一个打点计时器，要求

1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3、第一个数需要立即输出

function count(start, end) {
    console.log(start++);
    var timer = setInterval(function(){
        if(start<=end){
            console.log(start++);
        }else{
            clearInterval(timer);
        }
    },100);
    
    return {
      cancel : function () {
          clearInterval(timer);
        }
    };
}

5、将数组 arr 中的元素作为调用函数 fn 的参数 

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

6、将函数 fn 的执行上下文改为 obj 对象

function speak(fn, obj) {
return fn.call(obj,obj);
}

7、实现函数 makeClosures，调用之后满足如下条件：

   1、返回一个函数数组 result，长度与 arr 相同
   2、运行 result 中第 i 个函数，即 result[i]()，结果与 fn(arr[i]) 相同

function makeClosures(arr, fn) {
   return arr.map(function(item){
        return function(){
            return fn(item);
                
        }
    });
}

8、已知函数 fn 执行需要 3 个参数。请实现函数 partial，调用之后满足如下条件：

　　1、返回一个函数 result，该函数接受一个参数
　　2、执行 result(str3) ，返回的结果与 fn(str1, str2, str3) 一致

function partial(fn, str1, str2) {
return function(str3){
        return fn(str1,str2,str3);
    }
}

9、useArguments，返回所有调用参数相加后的结果

function useArguments() {
return Array.prototype.reduce.call(arguments,function(a,b){
        return a + b;
});
}

10、实现函数 callIt，调用之后满足如下条件

　　1、返回的结果为调用 fn 之后的结果
　　2、fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {
     return fn.apply(this,Array.prototype.slice.call(arguments,1));
}

11、实现函数 partialUsingArguments，调用之后满足如下条件：

　　1、返回一个函数 result
　　2、调用 result 之后，返回的结果与调用函数 fn 的结果一致
　　3、fn 的调用参数为 partialUsingArguments 的第一个参数之后的全部参数以及 result 的调用参数

function partialUsingArguments(fn) {
var args = [].slice.call(arguments, 1);
  return function () {
    return fn.apply(this, args.concat([].slice.call(arguments, 0)));
  };
}

12、柯里化是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术

　　已知 fn 为一个预定义函数，实现函数 curryIt，调用之后满足如下条件：
　　1、返回一个函数 a，a 的 length 属性值为 1（即显式声明 a 接收一个参数）
　　2、调用 a 之后，返回一个函数 b, b 的 length 属性值为 1
　　3、调用 b 之后，返回一个函数 c, c 的 length 属性值为 1
　　4、调用 c 之后，返回的结果与调用 fn 的返回值一致
　　5、fn 的参数依次为函数 a, b, c 的调用参数

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);
     }
 }

13、将给定数字转换成二进制字符串。如果字符串长度不足 8 位，则在前面补 0 到满8位。

function convertToBinary(num) {
    var result = num.toString(2);
    result=result.split("");
    if(result.length<8){
        for(var i=0;i<8-result.length;i++){
            result.unshift(0);
        }
    }
    return result.join("");
}

14、求 a 和 b 相乘的值，a 和 b 可能是小数，需要注意结果的精度问题 

toFixed() 方法可把 Number 四舍五入为指定小数位数的数字

function multiply(a, b) {
return parseFloat((a*b).toFixed(10));
}

15、找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)

　　1、返回数组，格式为 key: value
　　2、结果数组不要求顺序

function iterate(obj) {
 var arr = [];
     for(var key in obj){       
         if(obj.hasOwnProperty(key)){
             arr.push(key+": "+obj[key]);
         }
     }
     return arr;
}

16、给定字符串 str，检查其是否包含数字，包含返回 true，否则返回 false

function containsNumber(str) {
     return (/d/).test(str);
}

17、给定字符串 str，检查其是否包含连续重复的字母（a-zA-Z），包含返回 true，否则返回 false

　　在正则表达式中，利用()进行分组，使用斜杠加数字表示引用，1就是引用第一个分组，2就是引用第二个分组。
　　将[a-zA-Z]做为一个分组，然后引用，就可以判断是否有连续重复的字母。
     

function containsRepeatingLetter(str) {
return /([a-zA-Z])1/.test(str);
}

18、给定字符串 str，检查其是否符合如下格式

　　1、XXX-XXX-XXXX
　　2、其中 X 为 Number 类型

function matchesPattern(str) {
 var reg=/^(d{3}-){2}d{4}$/;
    return reg.test(str);
}

19、给定字符串 str，检查其是否符合美元书写格式

　　1、以 $ 开始
　　2、整数部分，从个位起，满 3 个数字用 , 分隔
　　3、如果为小数，则小数部分长度为 2
　　4、正确的格式如：$1,023,032.03 或者 $2.03，错误的格式如：$3,432,12.12 或者 $34,344.3

分析：

　　首先，开头必是$，而正则表达式中$表示结尾，需要进行转义，因此开头为^$
　　然后$后必然接数字，并且最少一位，最多三位数，可用{m,n}表示,最少m位，最多n位，因此此段为d{1,3}
　　接着，后面如还有数，则必然有，分隔，并且后面必有3个数，类似于，XXX的格式会出现0或者n次，因此此段可表示为(,d{3})*
　　最后，如有小数部分，则注意对小数点进行转义，此段可表示为(.d{2})?
　　因此，最后的正则表达式为/^$d{1,3}(,d{3})*(.d{2})?$/
　　使用test方法去检测str

function isUSD(str) {
 return /^$d{1,3}(,d{3})*(.d{2})?$/.test(str);
}

20、js 将多个空格替换为一个空格

str = str.replace(/s+/g,'');