移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr,结果返回新的数组
方法一:
function remove(arr, item) {
var a = [];
//循环遍历
for(var i=0; i < arr.length; i++){
//如果arr[i]不等于item,就加入数组a
if(arr[i] != item){
a.push(arr[i]);
}
}
return a;
}
方法二:
function remove(arr, item) {
var a=[];
arr.forEach(function(e){
if(e!==item){
a.push(e);
}
})
return a;
}
方法三:
function remove(arr,item){
return arr.filter(function(ele){
return ele != item;
})
}
方法四:
function remove(arr,item){
var a= arr.slice(0);//将arr中的元素赋给a
for(var i=0;i<a.length;i++){
if(a[i] == item){
a.splice(i,1);//删除a中第i个元素
i--;
}
}
return a;
}
找出元素 item 在给定数组 arr 中的位置
function indexOf(arr, item) {
if (Array.prototype.indexOf){// 判断浏览器是否支持indexOf方法
return arr.indexOf(item);
} else {
for (var i = 0; i < arr.length; i++){
if (arr[i] === item){
return i;
}
}
}
return -1;
}
计算给定数组 arr 中所有元素的总和
1,常规循坏
function sum(arr) {
var s = 0;
for (var i=arr.length-1; i>=0; i--) {
s += arr[i];
}
return s;
}
2,forEach遍历
function sum(arr) {
var result = 0;
arr.forEach(function(item,index) {
result += item;
});
return result;
};
移除数组 arr 中的所有值与 item 相等的元素,直接在给定的 arr 数组上进行操作,并将结果返回
function removeWithoutCopy(arr, item) {
for(var i=0;i<arr.length;i++){
if(arr[i]==item){
arr.splice(i,1);
i--;
}
}
return arr;
}
在数组 arr 末尾添加元素 item。不要直接修改数组 arr,结果返回新的数组
function append(arr, item) {
var newArr = arr.slice(0);
newArr.push(item);
return newArr;
}
删除数组 arr 最后一个元素。不要直接修改数组 arr,结果返回新的数组
//第一种方法:使用slice或concat
function truncate(arr) {
// var arr1 = arr.concat();
var arr1 = arr.slice(0);
arr1.pop(arr1.length-1);
return arr1;
}
//第二种方法:普通迭代方法
function truncate1(arr) {
var a = new Array();
for (var i = 0;i < arr.length-1;i++){
a.push(arr[i]);
}
return a;
}
//第三种方法:filter
function truncate2(arr) {
//val:当前元素值 i:当前元素索引 arr1:当前数组
return arr.filter(function (val,i,arr1) {
return i!=arr1.length-1;
})
}
//第四种方法:单纯使用slice
function truncate3(arr) {
// slice方法不会改变原数组数据
return arr.slice(0,-1);
}
//第五种方法:split+join
function truncate4(arr) {
var arr1 = arr.join().split(',');
//删除最后一个元素
//pop是指删除最后一个元素;shift是指删除第一个元素;两者返回的都是所删除的元素
arr1.pop();
return arr1;
}
在数组 arr 开头添加元素 item。不要直接修改数组 arr,结果返回新的数组
//方法一:最普通的循环赋值
function prepend(arr, item) {
var a = new Array();
a.push(item);
for (var i =0;i<arr.length;i++){
a.push(arr[i]);
}
return a;
}
//方法二:使用concat
function prepend(arr, item) {
return [item].concat(arr);
}
//方法三:使用push.apply
function prepend(arr, item) {
var arr1 = [item];
//使用此方法改变的数组是arr1,arr数组不变
[].push.apply(arr1,arr);
return arr1;
}
//方法四:使用unshift:在数组头部插入指定元素
//shift是指在头部移除元素
function prepend(arr, item) {
// var arr1 = arr.slice(0);
var arr1 = arr.join().split(',')
arr1.unshift(item);
return arr1;
}
删除数组 arr 最后一个元素。不要直接修改数组 arr,结果返回新的数组
//第一种方法:使用slice或concat
function truncate(arr) {
// var arr1 = arr.concat();
var arr1 = arr.slice(0);
arr1.pop(arr1.length-1);
return arr1;
}
//第二种方法:普通迭代方法
function truncate(arr) {
var a = new Array();
for (var i = 0;i < arr.length-1;i++){
a.push(arr[i]);
}
return a;
}
//第三种方法:filter
function truncate(arr) {
//val:当前元素值 i:当前元素索引 arr1:当前数组
return arr.filter(function (val,i,arr1) {
return i!=arr1.length-1;
})
}
//第四种方法:单纯使用slice
function truncate(arr) {
// slice方法不会改变原数组数据
return arr.slice(0,-1);
}
//第五种方法:split+join
function truncate(arr) {
var arr1 = arr.join().split(',');
//删除最后一个元素
//pop是指删除最后一个元素;shift是指删除第一个元素;两者返回的都是所删除的元素
arr1.pop();
return arr1;
}
合并数组 arr1 和数组 arr2。不要直接修改数组 arr,结果返回新的数组
//方法一:使用concat
function concat(arr1, arr2) {
return arr1.concat(arr2);
}
//方法二:slice+concat
function concat1(arr1, arr2) {
var arr = arr1.slice(0);
arr = arr.concat(arr2);
return arr;
}
//方法三:slice+push.apply
function concat2(arr1, arr2){
var arr = arr1.slice(0);
[].push.apply(arr,arr2);
return arr;
}
在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr,结果返回新的数组
//方法一:先复制前两个元素,将插入元素插入之后,再复制后两个元素
function insert(arr, item, index) {
var arr1 = arr.slice(0,index);
arr1.push(item);
arr1=arr1.concat(arr.slice(index,arr.length));
return arr1;
}
//方法二:使用splice方法插入
//splice方法可以增加或删除元素
//arr1.splice(2,0,'z');------>指的是从arr1数组中的第2个位置删除0个元素,且之前2的位置用‘z’表示
//也可以理解,当第二个参数为0时为插入,为1时为替换,大于1则为删除
function insert1(arr, item, index) {
var arr1 = arr.slice(0);//
arr1.splice(index,0,item);
return arr1;
}
统计数组 arr 中值等于 item 的元素出现的次数
// 方法一
function count(arr, item) {
return arr.toString().split(item+"").length-1;
}
// 方法二:foeEach
function count(arr, item) {
var cnt = 0;
arr.forEach(function (a) {
a===item ? cnt++ : cnt;
})
return cnt;
}
//方法三:for循环
function count(arr, item) {
var cnt=0;
for (var i = 0;i<arr.length;i++){
if (arr[i]===item){
cnt++;
}
}
return cnt;
}
//方法四:使用map函数
function count2(arr, item) {
var cnt = 0;
arr.map(function (a) {
if (a===item){
cnt++;
}
})
return cnt;
}
//方法五
function count(arr, item) {
var cnt = arr.reduce(function (init,curr) {
//如果当前置等于item,该函数值加一
return curr === item ? init+1:init;
},0)
return cnt;
}
找出数组 arr 中重复出现过的元素
//方法一
function duplicates(arr) {
var arr1=[];
for(var i = 0;i<arr.length;i++){
for(var j =i+1;j<arr.length-1;j++){
if(arr[i]===arr[j]&&arr1.indexOf(arr[i]==-1)){
arr1.push(arr[i]);
}
}
}
return arr1.sort();
}
//方法二
function duplicates(arr) {
var newarr = [];
for(var j = 0;j < arr.length;j++){
for(var i = j+1;i < arr.length;i++){
if(arr[j] == arr[i]){
newarr.push(arr[i]);
}
}
}
//return [...new Set(newarr)];
return Array.from(new Set(newarr));
}
为数组 arr 中的每个元素求二次方。不要直接修改数组 arr,结果返回新的数组
//方法一
function square(arr) {
var arr2 = []
for(var i=0; i<arr.length; i++) {
arr2[i] = arr[i]*arr[i]
}
return arr2
}
//方法二
function square(arr) {
return arr.map(function(elem, index, arr) {
return elem*elem
})
}
在数组 arr 中,查找值与 item 相等的元素出现的所有位置
//方法一
function findAllOccurrences(arr, target){
var subArr = [];
for(var i = 0; i < arr.length; i++){
if(arr[i] === target){
subArr.push(i);
}
}
return subArr;
}
//方法二
function findAllOccurrences(arr, target) {
var arr1=[];
var j=0;
for(var i=0;i<arr.length;i++){
if(arr[i]===target){
arr1.push(arr.indexOf(arr[i],j));
j++;
}
}
return arr1;
}
给定的 js 代码中存在全局变量,请修复
function globals() {
myObject = {
name : 'Jory'
};
return myObject;
}
// var
function globals() {
var myObject = {
name : 'Jory'
};
return myObject;
}
请修复给定的 js 代码中,函数定义存在的问题
例如:输入true 输出a
//题目
function functions(flag) {
if (flag) {
function getValue() { return 'a'; }
} else {
function getValue() { return 'b'; }
}
return getValue();
}
//答案
function functions(flag) {
function getValue() { return(flag)?'a':'b'; }
return getValue();
}
判断 val1 和 val2 是否完全等同
function identity(val1, val2) {
return val1===val2?true:false;
}
function identity(val1, val2) {
if(val1===val2){
return true;
}
return false;
}
实现一个打点计时器,要求
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);
}
};
}
实现 fizzBuzz 函数,参数 num 与返回值的关系如下:
1、如果 num 能同时被 3 和 5 整除,返回字符串 fizzbuzz
2、如果 num 能被 3 整除,返回字符串 fizz
3、如果 num 能被 5 整除,返回字符串 buzz
4、如果参数为空或者不是 Number 类型,返回 false
5、其余情况,返回参数 num
function fizzBuzz(num) {
if (num == null || typeof num != "number"){
return false
}
if(num % 3 == 0 && num % 5 == 0){
return "fizzbuzz"
}else if(num % 3 == 0){
return "fizz"
}else if(num % 5 == 0){
return "buzz"
}
return num
}
将数组 arr 中的元素作为调用函数 fn 的参数
//调用函数可以使用call或者apply这两个方法,
//区别在于call()需要将参数挨个列出,call需要将传递给函数的参数明确写出来,是多少参数就需要写多少参数。
//apply则将传递给函数的参数放入一个数组中,传入参数数组即可。apply直接传入数组对象。
function argsAsArray(fn, arr) {
return fn.apply(this, arr);
}
将函数 fn 的执行上下文改为 obj 对象
function speak(fn, obj) {
return fn.apply(obj, obj);
}
function speak(fn, obj) {
return fn.call(obj);
}
function speak(fn, obj) {
return fn.apply(obj);
}
实现函数 functionFunction,调用之后满足如下条件:
1、返回值为一个函数 f
2、调用返回的函数 f,返回值为按照调用顺序的参数拼接,拼接字符为英文逗号加一个空格,即 ', '
3、所有函数的参数数量为 1,且均为 String 类型
//闭包
function functionFunction(str) {
return function(str2){
return str + ', ' + str2;
};
}