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})
JavaScript数组是稀疏数组，比如通过new Array(100)创建数组，实际上它是一个空数组
arr.join(',') 表示将一个数组分割成字符串，字符串之间是逗号
arr.split(",") 表示将字符串按照逗号分割成字符串数组
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