1.移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组
function remove(arr, item) {
var a=arr.slice(0);
for(var i=0;i<arr.length;i++){
if(a[i]==item){
a.splice(i,1);
i--;
}
}
return a;
};
var b=new Array(1,2,3,4,2);
document.write(remove(b,2));2.如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1
function indexOf(arr, item) {
if (Array.prototype.indexOf){ //判断当前浏览器是否支持
return arr.indexOf(item);
} else {
for (var i = 0; i < arr.length; i++){
if (arr[i] === item){
return i;
}
}
}
return -1; //总是把return -1暴漏在最外层
}3.数组求和
方法1：常规for循环
<script>
function num(arr) {
var s=0;
for(var i=0;i<arr.length;i++){
s+=arr[i];
}
console.log(s);//10
}
num([1,2,3,4]);
</script>方法2：使用递归
<script>
function num(arr){
var len=arr.length;
if(len==0){
return 0;
}
else if(len==1){
return arr[0];
}
else{
return arr[0]+num(arr.slice(1));
}
}
console.log(num([1,2,3,4]));//10
</script>方法3. forEach遍历
forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
array.forEach(function(currentValue, index, arr), thisValue)| 参数 | 描述 | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| function(currentValue, index, arr) | 必需。 数组中每个元素需要调用的函数。 函数参数:
| ||||||||
| thisValue | 可选。传递给函数的值一般用 "this" 值。 如果这个参数为空， "undefined" 会传递给 "this" 值 |
<script>
function num(arr){
var s=0;
arr.forEach(function(value,index,arr){
s+=value;
});
console.log(s);
}
num([1,2,3,4]);//10
</script>方法4. eval函数
eval() 函数可计算某个字符串，并执行其中的的 JavaScript 代码。
eval(string)| 参数 | 描述 |
|---|---|
| string | 必需。要计算的字符串，其中含有要计算的 JavaScript 表达式或要执行的语句。 |
注意：
该方法只接受原始字符串作为参数，如果 string 参数不是原始字符串，那么该方法将不作任何改变地返回。因此请不要为 eval() 函数传递 String 对象来作为参数。
如果试图覆盖 eval 属性或把 eval() 方法赋予另一个属性，并通过该属性调用它，则 ECMAScript 实现允许抛出一个 EvalError 异常。
join() 方法用于把数组中的所有元素放入一个字符串。
元素是通过指定的分隔符进行分隔的。
arrayObject.join(separator)| 参数 | 描述 |
|---|---|
| separator | 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。 |
<script>
function num(arr) {
console.log(eval(arr.join("+")));//join()将数组转化为字符串,用+连接 返回10
}
num([1,2,3,4])
</script>方法5.reduce()
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
reduce() 可以作为一个高阶函数，用于函数的 compose。
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)| 参数 | 描述 | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| function(total,currentValue, index,arr) | 必需。用于执行每个数组元素的函数。 函数参数:
| ||||||||||
| initialValue | 可选。传递给函数的初始值 |
<script>
function num(arr) {
return arr.reduce(function(prev, curr, idx, arr){
return s=prev+curr;
});
}
num([1,2,3,4]);
var s;
console.log(s);//10
</script>3.移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回
function removeWithoutCopy(arr, item) {
for(var i=0;i<arr.length;i++){
if(arr[i]==item){
arr.splice(i,1);
i=0;
}
}
console.log(arr);//[1,3,4
}
removeWithoutCopy([1, 2, 2, 3, 4, 2, 2], 2)4.在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组
方法1.
<script>
function append(arr, item) {
var newArr = arr.slice(0);
newArr.push(item);
console.log(newArr);//[1,2,3,4,10]
}
append([1,2,3,4],10)
</script>注意：不直接var newArr=arr;而用 var newArr = arr.slice(0)是因为直接赋值双方引用相等会改变原数组
方法2.
<script>
var append = function(arr, item) {
var length = arr.length, newArr = [];
for (var i = 0; i < length; i++) {
newArr.push(arr[i]);
}
newArr.push(item);
return newArr;
};
</script>方法3.concat()
concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
arrayObject.concat(arrayX,arrayX,......,arrayX)| 参数 | 描述 |
|---|---|
| arrayX | 必需。该参数可以是具体的值，也可以是数组对象。可以是任意多个。
|
<script>
var append = function(arr, item) {
console.log(arr.concat(item));//[1,2,3,4,10]
console.log(arr);//[1,2,3,4]
};
append([1,2,3,4],10)
</script>由运行结果可以看到，concat方法并不影响原数组的值
5.删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组
<script>
function truncate(arr) {
var newarr=arr.concat();
newarr.pop();
console.log(newarr);//[1,2,3]
console.log(arr);//[1,2,3,4]
}
truncate([1,2,3,4]);
</script>function truncate(arr) {
var newArr = arr.slice(0);
newArr.pop();
return newArr
}6.在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组
方法1.利用concat
<script>
function prepend(arr, item) {
console.log([item].concat(arr));//[10,1,2,3,4]
}
prepend([1,2,3,4],10);
</script>方法2.使用push.apply
<script>
function prepend(arr, item) {
var newArr=[item];
[].push.apply(newArr, arr);
console.log(newArr)//[10,1,2,3,4]
console.log(arr)//[1,2,3,4]
}
prepend([1,2,3,4],10);
</script>方法3.利用slice+unshift/splice
注意：unshift()和splice()方法都会修改原数组的值，所有需要利用slice()来生成一个新的数组进行操作，从而不影响原arr数组的值
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
arrayObject.unshift(newelement1,newelement2,....,newelementX)| 参数 | 描述 |
|---|---|
| newelement1 | 必需。向数组添加的第一个元素。 |
| newelement2 | 可选。向数组添加的第二个元素。 |
| newelementX | 可选。可添加若干个元素。 |
<script>
function prepend(arr, item) {
var newArr=arr.slice(0);
newArr.unshift(item);
console.log(newArr)//[10,1,2,3,4]
console.log(arr)//[1,2,3,4]
}
prepend([1,2,3,4],10);
</script>splice() 方法向/从数组中添加/删除项目，然后返回被删除的项目。
arrayObject.splice(index,howmany,item1,.....,itemX)| 参数 | 描述 |
|---|---|
| index | 必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。 |
| howmany | 必需。要删除的项目数量。如果设置为 0，则不会删除项目。 |
| item1, ..., itemX | 可选。向数组添加的新项目。 |
<script>
function prepend(arr, item) {
var newArr=arr.slice(0);
newArr.splice(0,0,item);
console.log(newArr)//[10,1,2,3,4]
console.log(arr)//[1,2,3,4]
}
prepend([1,2,3,4],10);
</script>方法4.普通的迭代拷贝
<script>
function prepend(arr, item) {
var newArr=[];
for(var i=0;i<arr.length;i++){
newArr.push(arr[i]);
}
newArr.unshift(item);
console.log(newArr);//[10,1,2,3,4]
}
prepend([1,2,3,4],10);
</script>7.删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组
方法1.利用slice
<script>
function curtail(arr) {
return arr.slice(1)//[4,3,2,1]
}
curtail([5,4,3,2,1])
</script>
方法2.利用push.apply+shift
<script>
function curtail(arr) {
var newArr=[];
[].push.apply(newArr, arr);
newArr.shift();
return newArr
}
curtail([5,4,3,2,1])
</script>方法3.利用concat+shift
<script>
function curtail(arr) {
var newArr = arr.concat();
newArr.shift();
return newArr
}
curtail([5,4,3,2,1])
</script>方法4.普通的迭代拷贝
<script>
function curtail(arr) {
var newArr=[];
for(var i=1;i<arr.length;i++){
newArr.push(arr[i]);
}
return newArr;
}
curtail([5,4,3,2,1])
</script>8.合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组
方法1.利用concat
<script>
function prepend(arr1,arr2) {
return arr1.concat(arr2)//[1,2,3,4,'a','b','c',1]
}
prepend([1,2,3,4],['a','b','c',1]);
</script>方法2.利用slice+push.apply
<script>
function concat(arr1, arr2) {
var newArr=arr1.slice(0);
[].push.apply(newArr, arr2);
return newArr;
}
concat([1,2,3,4],['a','b','c',1]);
</script>方法3.利用slice+push
<script>
function concat(arr1, arr2) {
var newArr=arr1.slice(0);
for(var i=0;i<arr2.length;i++){
newArr.push(arr2[i]);
}
return newArr;
}
concat([1,2,3,4],['a','b','c',1]);
</script>方法4.普通的迭代拷贝
<script>
function concat(arr1, arr2) {
var newArr=[];
for(var i=0;i<arr1.length;i++){
newArr.push(arr1[i]);
}
for(var j=0;j<arr2.length;j++){
newArr.push(arr2[j]);
}
return newArr;
}
concat([1,2,3,4],['a','b','c',1]);
</script>9.在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组
方法1.利用slice+concat
<script>
function insert(arr, item, index) {
return arr.slice(0,index).concat(item,arr.slice(index));
}
insert([1,2,3,4],'z',2)
</script>
方法2.利用concat +splice
<script>
function insert(arr, item, index) {
var newArr=arr.concat();
newArr.splice(index,0,item);
return newArr//[1,2,'z',3,4]
}
insert([1,2,3,4],'z',2)
</script>方法3.利用slice+splice
<script>
function insert(arr, item, index) {
var newArr=arr.slice(0);
newArr.splice(index,0,item);
return newArr;
}
insert([1,2,3,4],'z',2)
</script>方法4.普通的迭代拷贝
<script>
function insert(arr, item, index) {
var newArr=[];
for(var i=0;i<arr.length;i++){
newArr.push(arr[i]);
}
newArr.splice(index,0,item);
return newArr;
}
insert([1,2,3,4],'z',2)
</script>10.统计数组 arr 中值等于 item 的元素出现的次数
<script>
function count(arr, item) {
var s=0;
for(var i=0;i<arr.length;i++){
if(arr[i]==item){
s++;
}
}
return s//3
}
count([1,2,4,4,3,4,3],4)
</script>11.找出数组 arr 中重复出现过的元素
<script>
function duplicates(arr) {
var res=arr.sort();
var b=[];
for(var i=0;i<res.length;i++) {
if (res[i] == res[i + 1] && res[i] != res[i - 1]) {
b.push(res[i]);
}
}
console.log(b)//[1,3,4]
}
duplicates([1, 2, 4, 4, 3, 3, 1, 5, 3]);
</script>12.为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组
普通遍历
<script>
function square(arr) {
var b=[];
for(var i=0;i<arr.length;i++){
b.push(arr[i]*arr[i]);
}
console.log(b)//[1,4,9,16]
}
square([1,2,3,4])
</script>
使用map()
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。
注意： map() 不会对空数组进行检测。
注意： map() 不会改变原始数组。
语法：array.map(function(currentValue,index,arr), thisValue)
| 参数 | 描述 | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 函数参数:
| ||||||||
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue，或者传入 null、undefined，那么回调函数的 this 为全局对象。 |
<script>
function square(arr) {
return arr.map(function(item,index,array){
return item*item;
})
}
square([1,2,3,4])
</script>13.在数组 arr 中，查找值与 item 相等的元素出现的所有位置
<script>
function findnum(arr, target) {
var res = [];
for(var i = 0; i < arr.length; i++){
if(target == arr[i])
res.push(i);
}
console.log(res);//[0,4]
}
findnum([1,2,3,4,1,2,3],1)
</script>14.实现一个打点计时器，要求
(1)从 start 到 end（包含 start 和 end），每隔 100 毫秒 console.log 一个数字，每次数字增幅为 1
(2)返回的对象中需要包含一个 cancel 方法，用于停止定时操作
(3)第一个数需要立即输出
<script>
function count(start,end){
if(start<=end){
console.log(start);
start++;
time=setTimeout(function(){
count(start,end)
},100)
}
return{
cancel:function(){
clearTimeout(time)
}
}
}
count(1,20)
</script>15.将数组 arr 中的元素作为调用函数 fn 的参数
输入：function (greeting, name, punctuation) {return greeting + ', ' + name + (punctuation || '!');}, ['Hello', 'Ellie', '!']
输出：Hello, Ellie!
方法1：
function argsAsArray(fn, arr) {
return fn(arr[0],arr[1],arr[2]);
}方法2：
function argsAsArray(fn, arr) {
return fn.apply(fn, arr);
}
//或者
function argsAsArray(fn, arr) {
return fn.apply(this, arr);
}方法3：
function argsAsArray(fn, arr) {
return fn.call(fn, arr[0],arr[1],arr[2]);
}
//或者
function argsAsArray(fn, arr) {
return fn.call(this, arr[0],arr[1],arr[2]);
}
未完待续。。。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
