1、查找数组中重复元素

方法1:创建一个新的临时数组来保存数组中已有的元素

function duplicates(arr) {
     //声明两个数组，a数组用来存放结果，b数组用来存放arr中每个元素的个数
     var a = [],b = [];
     //遍历arr，如果以arr中元素为下标的的b元素已存在，则该b元素加1，否则设置为1
     for(var i = 0; i < arr.length; i++){
         if(!b[arr[i]]){
             b[arr[i]] = 1;
             continue;
         }
         b[arr[i]]++;
     }
     //遍历b数组，将其中元素值大于1的元素下标存入a数组中
     for(var i = 0; i < b.length; i++){
         if(b[i] > 1){
             a.push(i);
         }
     }
     return a;
 }

方法2: 使用indexOf判断数组元素第一次出现的位置是否为当前位置

Array.prototype.unique3 = function(){
    var n = [this[0]]; 
    for(var i=1; i<this.length; i++)    //从第二项开始遍历
    {
        //如果当前数组元素在数组中出现的第一次的位置不是i
        //说明是重复元素
        if(this.indexOf(this[i]) == i){
            n.push(this[i]);
        }
    }
    return n;
}

方法3:先排序再去重

Array.prototype.unique4 = function(){
    this.sort(function(a, b){ return a - b;});
    var n = [this[0]];
    for(var i=1; i<this.length; i++){
        if(this[i] != this[i-1]){
            n.push(this[i]);
        }
    }
    return n;
}

2、求数组二次方

为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组

function square(arr) {
    //声明一个新的数组存放结果
    var a = [];
    arr.forEach(function(e){
        //将arr中的每一个元素求平方后，加入到a数组中
        a.push(e*e);
    });
    return a;
}

3、查找数组元素位置

在数组 arr 中，查找值与 item 相等的元素出现的所有位置

function findAllOccurrences(arr, target) {
     var a=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]===target){
            a.push(i);
        }
    }
    return a;
}

4、正确使用parseInt()

parseInt(string, radix)当参数 radix 的值为 0，或没有设置该参数时，parseInt() 会根据 string 来判断数字的基数。
举例，如果 string 以 "0x" 开头，parseInt() 会把 string 的其余部分解析为十六进制的整数。如果 string 以 0 开头，那么 ECMAScript v3 允许 parseInt() 的一个实现把其后的字符解析为八进制或十六进制的数字。如果 string 以 1 ~ 9 的数字开头，parseInt() 将把它解析为十进制的整数。

function parse2Int(num)
{
    return parseInt(num,10);
}

5、实现对象的深克隆

因为js中数据类型分为基本数据类型(number, string, boolean, null, undefined)和引用类型值(对象, 数组, 函数). 这两类对象在复制克隆的时候是有很大区别的. 原始类型存储的是对象的实际数据, 而对象类型存储的是对象的引用地址(对象的实际内容单独存放, 为了减少数据开销通常放在内存中). 此外, 对象的原型也是引用对象, 它把原型的属性和方法放在内存中, 通过原型链的方式来指向这个内存地址.

于是克隆也会分为两类:

• 浅度克隆: 原始类型为值传递, 对象类型仍为引用传递
• 深度克隆: 所有元素或属性均完全复制, 与原对象完全脱离, 也就是说所有对于新对象的修改都不会反映到原对象中

function clone(obj){
    if(typeof(obj)== 'object'){
        var result = obj instanceof Array ? [] : {};
        for(var i in obj){
            var attr = obj[i];
            result[i] = arguments.callee(attr);
        }
        return result;
    } else {
        return obj;
    }
};

6、回文判断

方法1:

function isPalindrome(line) {
    line += "";
    return line === line.split("").reverse().join("");
}

方法2:从字符串头部和尾部，逐次向中间检测

function isPalindrome(line) {  
    line += "";  
    for(var i=0,j=line.length-1;i<j;i++,j--){  
        if(line.charAt(i) !== line.charAt(j)){  
            return false;  
        }  
    }  
    return true;  
}  

7、计时器

实现一个打点计时器，要求
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);
         }
     };
 }

8、流程控制

实现 fizzBuzz 函数，参数 num 与返回值的关系如下：
1、如果 num 能同时被 3 和 5 整除，返回字符串 fizzbuzz
2、如果 num 能被 3 整除，返回字符串 fizz
3、如果 num 能被 5 整除，返回字符串 buzz
4、如果参数为空或者不是 Number 类型，返回 false
5、其余情况，返回参数 num

function fizzBuzz(num) {
    var a = num % 3;
    var b = num % 5;
    if (a == 0 && b == 0) {
        return 'fizzbuzz';
    } else if (a == 0) {
        return 'fizz'
    } else if (b == 0) {
        return 'buzz'
    } else if (num == 'null' || typeof (num) != 'number') {
        return false
    } else {
        return num
    }
}