一些题目

1. 有一个长度未知的数组a，如果它的长度为0就把数字1添加到数组里面，否则按照先进先出的队列规则让第一个元素出队

arr.length === 0 ? a.push(1) : a.shift()

push()方法：将一组数据追加到数组尾部，并返回新数组的长度
pop()方法：移除数组的最后 一个，返回被移除的值
shift()方法：不接收参数，将数组的第一个移除，并返回移除的值
unshift()方法：接收参数，并放在数组的开头，返回新数组的长度

let arr = [3,2,4]let a = arr.pop()console.log(a)  // 4console.log(arr)    // [3,2]let a = arr.push(5,6,3)console.log(a)  // 6console.log(arr)    // [3,2,4,5,6,3]let a = arr.unshift(5,6,3)console.log(a)  // 6console.log(arr)    // [5,6,3,3,2,4]let a = arr.shift()console.log(a)  // 3console.log(arr)    // [2,4]

2. 不使用loop循环，创建一个长度为100的数组，并且每个元素的值等于它的下标。

Array(100).join(",").split(",").map(function(item,index){return index})

1. JavaScript数组是稀疏数组，比如通过new Array(100)创建数组，实际上它是一个空数组

2. arr.join(',') 表示将一个数组分割成字符串，字符串之间是逗号

3. arr.split(",") 表示将字符串按照逗号分割成字符串数组

4. arr.map()函数接收一个函数作为参数，函数的参数有item(数组的每个值)和index(数组值的下标)

[1,2,3,4].join("^")   // "1^2^3^4""1^2^3^4".split("^")   //  ["1", "2", "3", "4"]
[1,2,3,4].map(function(item,index){return index})  // [0,1,2,3]
[1,2,3,4].map(function(item,index){return item})  // ["1", "2", "3", "4"]

map函数

3. 数组排序

arr.sort()方法，会先调用toString()方法，然后进行排序。而如果我们希望按照数字从小到大排序，就可以给sort()传入一个比较函数。
sort()方法可以传入一个比较函数

// 正序排序[1,2,3,4,5,6,7,8,9,10].sort(function(a,b){return a-b})

// 乱序排序。0.5表示左右两边平分[1,2,3,4,5,6,7,8,9,10].sort(function(a,b){return ((Math.random() > 0.5) ? 1 : -1)*(a-b)})

4. 求数组的前10项和

[1,2,3,4,5,6,7,8,9,10,11,12,13,14].slice(0,10).reduce(function (pre,cur){return pre+cur})

5. 找出元素 item 在给定数组 arr 中的位置

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

6. 计算给定数组 arr 中所有元素的总和

function sum(arr) {    return arr.reduce(function(pre,cur){        return pre+cur
    })
}

7. 移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组

function remove(arr, item) {    return arr.filter(function(x){        return x !== item
    })
}

8.移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回

function remove(arr,item){    for(let i=0;i<arr.length;i++){        if(arr[i] === item){
            arr.splice(i,1)            // 当去除这个值后，后面的每一个index都-1了，所以i也要-1
            i--
        }
    }    return arr
}

9. 在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组

function append(arr, item) {    return arr.concat(item)
}

10.删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组

function truncate(arr) {    return arr.slice(0,-1)   
}

11.在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组

function prepend(arr, item) {    return [item].concat(arr)
}function prepend(arr, item) {    var a = arr.slice(0)
    a.unshift(item)    return a
}

12.删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组

function curtail(arr) {    var newArr = arr.concat()
    newArr.shift()    return newArr
}function curtail(arr) {    return arr.slice(1)
}

13. 合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组

function concat(arr1, arr2) {    return arr1.concat(arr2)
}function concat(arr1, arr2) {    var str = arr1.toString() + "," + arr2.toString()    return str.split(",")
}

14. 在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组

function insert(arr, item, index) {    var newArr = arr.concat()    // 位置，删除几项，添加的值（可以为多个）
    newArr.splice(index,0,item)    return newArr
}

15.统计数组 arr 中值等于 item 的元素出现的次数

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

16.找出数组 arr 中重复出现过的元素

function duplicates(arr) {    return arr.filter(function(item,index,array){        return array.indexOf(item) !== array.lastIndexOf(item) && array.indexOf(item) === index
    })
}

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

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

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

function findAllOccurrences(arr, target) {    var newArr = []
    arr.filter(function(item,index){        return item===target&&newArr.push(index)
    })    return newArr
}

19.parseInt()操作
parseInt(num,radix)：radix表示按照什么样的规则取整。不写的话，0x那种的会转化为16进制，10的话表示都按10进制处理
20.实现一个打点计时器，要求
1、从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
2、返回的对象中需要包含一个 cancel 方法，用于停止定时操作
3、第一个数需要立即输出

function count(start, end) {    if(start<=end){        console.log(start)
        start++
    }
    timer = setTimeout(function(){
        count(start,end)
    },100)    return {        cancel:function(){
            clearTimeout(timer)
        }
    }
}

流程控制

function fizzBuzz(num) {    switch(true){        case num == null || typeof num != "number":return false;break;        case num%3===0&&num%5===0:return "fizzbuzz";break;        case num%3===0:return "fizz";break;        case num%5===0:return "buzz";break;        default:return num;            
    }
}

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

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

函数 useArguments 可以接收 1 个及以上的参数。请实现函数 useArguments，返回所有调用参数相加后的结果。本题的测试参数全部为 Number 类型，不需考虑参数转换。

function useArguments() {    return Array.prototype.slice.call(arguments).reduce(function(pre,cur){        return pre+cur
    })
}

实现函数 callIt，调用之后满足如下条件
1、返回的结果为调用 fn 之后的结果
2、fn 的调用参数为 callIt 的第一个参数之后的全部参数

function callIt(fn) {    return fn.apply(this,[].slice.call(arguments,1))
}

返回参数 a 和 b 的逻辑或运算结果

function or(a, b) {    return a || b
}

完成函数 createModule，调用之后满足如下要求：
1、返回一个对象
2、对象的 greeting 属性值等于 str1， name 属性值等于 str2
3、对象存在一个 sayIt 方法，该方法返回的字符串为 greeting属性值 + ', ' + name属性值

function createModule(str1, str2) {    return {        greeting : str1,        name : str2,        sayIt : function(){            return this.greeting + ", " + this.name
        }
    }
}

获取数字 num 二进制形式第 bit 位的值。注意：
1、bit 从 1 开始
2、返回 0 或 1
3、举例：2 的二进制为 10，第 1 位为 0，第 2 位为 1

function valueAtBit(num, bit) {   var s = num.toString(2)   return s[s.length-bit]
}function valueAtBit(num, bit) {    return (num >> (bit -1)) & 1;
}

给定二进制字符串，将其换算成对应的十进制数字

function base10(str) {    return parseInt(str,2)
}

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

function convertToBinary(num) {    var str = num.toString(2)    while(str.length<8){
        str = "0" + str
    }    return str
}

将函数 fn 的执行上下文改为 obj，返回 fn 执行后的值

function alterContext(fn, obj) {    return fn.bind(obj)()
}

找出对象 obj 不在原型链上的属性(注意这题测试例子的冒号后面也有一个空格~)
1、返回数组，格式为 key: value
2、结果数组不要求顺序

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

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

function containsNumber(str) {    var reg = /\d/
    return reg.test(str)    return !!str.match(reg)
}

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

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

或者    return /([a-zA-Z])\1/.test(str)

作者：椰果粒
链接：https://www.jianshu.com/p/fa1d8cd68068