国内精品久久久久影院薰衣草,少年男妓被迫张开腿供人玩弄,找工作

定義數組

用字面量創建

var arr = [1,2,3,'hello',null,true];

用`new Array()`創建

var arr=new Array();
arr[0]=1;
arr[1]=2;
arr[2]=3;
arr[3]='hello';
...

或

var arr=new Array(1,2,3,'hello',null,true);

Array.indexOf

返回在數組中可以找到給定元素的第一個索引，如果不存在，則返回-1。
Array.indexOf(searchElement[,fromIndex = 0])

searchElement —— 要查找的元素
fromIndex —— 開始查找的位置。如果該索引值大于或等于數組長度，意味著不會在數組里查找，返回-1。如果參數中提供的索引值是一個負值，則將其作為數組末尾的一個抵消，即-1表示從最后一個元素開始查找，-2表示從倒數第二個元素開始查找，以此類推。注意：如果參數中提供的索引值是一個負值，仍然從前向后查詢數組。如果抵消后的索引值仍小于0，則整個數組都將會被查詢。其默認值為0.

// 找出指定元素出現的所有位置
var indices = [];
var array = ['a', 'b', 'a', 'c', 'a', 'd'];
var element = 'a';
var idx = array.indexOf(element);
while (idx != -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}
console.log(indices);
// [0, 2, 4]

Array.lastIndexOf

返回指定元素在數組中的最后一個的索引，如果不存在則返回-1,。從數組的后面向前查找，從fromIndex開始。
arr.lastIndexOf(searchElement[, fromIndex = arr.length -1])

searchElement —— 被查找的元素
fromIndex —— 從此位置開始逆向查找。默認為數組的長度減 1，即整個數組都被查找。如果該值大于或等于數組的長度，則整個數組會被查找。如果為負值，將其視為從數組末尾向前的偏移。即使該值為負，數組仍然會被從后向前查找。如果該值為負時，其絕對值大于數組長度，則方法返回 -1，即數組不會被查找。

// 查找所有元素,下例使用 lastIndexOf 查找到一個元素在數組中所有的索引（下標），并使用 push 將所有添加到另一個數組中。
var indices = [];
var array = ['a', 'b', 'a', 'c', 'a', 'd'];
var element = 'a';
var idx = array.lastIndexOf(element);

while (idx != -1) {
  indices.push(idx);
  idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1);
}

console.log(indices);
// [4, 2, 0];

Array.slice

將數組的一部分淺拷貝, 返回到從開始到結束（不包括結束）選擇的新數組對象。原始數組不會被修改。
arr.slice(begin, end)

begin —— 從該處開始提取原數組中的元素（從0開始）
end —— 在該處結束提取原數組的元素（從0開始）。slice會提取原數組中索引從begin到end的所有元素（包含begin，不包含end）

var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
//起始索引1，終止索引3，獲取的數組為原數組的1-2
var citrus = fruits.slice(1, 3);
// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
// citrus contains ['Orange','Lemon']

Array.splice

可以從指定的索引開始刪除若干個元素，然后再從該位置添加若干元素
Array.splice(startIndex,deleteCount,[item...])

//定義數組
var arr1 = ['Microsoft','Apple','Yahoo','AOL','Excite','Oracle'];

//從索引為2開始刪除3個元素，然后再添加2個元素,返回刪除的元素
arr1.splice(2,3,'Google','Facebook');  //刪除的元素["Yahoo", "AOL", "Excite"],arr1為["Microsoft", "Apple", "Google", "Facebook", "Oracle"]

//只刪除，不添加
arr1.splice(2,2);// 刪除["Yahoo", "AOL"]，arr1為["Microsoft", "Apple", "Excite", "Oracle"]

//只添加，不刪除
arr1.splice(2,0,"Google",'Facebook');
alert(arr1.toString());
//復制數組,結果為副本
var arrCopy = arr1.slice();

Array.push

將一個或多個元素添加到數組的末尾，并返回數組的長度。
arr.push(element1, ..., elementN)

var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");
// ["soccer", "baseball", "football", "swimming"]
console.log(sports);

Array.pop

從數組中刪除最后一個元素，并返回該元素的值。此方法改變數組的長度。
arr.pop()

let myFish = ["angel", "clown", "mandarin", "surgeon"];
let popped = myFish.pop();
console.log(myFish);

Array.shift

從數組中刪除第一個元素，并返回該元素的值。此方法更改數組的長度。
arr.shift()

let myFish = ['angel', 'clown', 'mandarin', 'surgeon'];
console.log('調用 shift 之前: ' + myFish);
// "調用 shift 之前: angel,clown,mandarin,surgeon"
var shifted = myFish.shift(); 
console.log('調用 shift 之后: ' + myFish); 
// "調用 shift 之后: clown,mandarin,surgeon" 
console.log('被刪除的元素: ' + shifted); 
// "被刪除的元素: angel"

Array.unshift

將一個或多個元素添加到數組的開頭，并返回新數組的長度。
arr.unshift(element1, ..., elementN)

element1, ..., elementN —— 要添加到數組開頭的元素。

var arr = [1, 2];
arr.unshift(0); //result of call is 3, the new array length
//arr is [0, 1, 2]
arr.unshift(-2, -1); // = 5
//arr is [-2, -1, 0, 1, 2]
arr.unshift( [-3] );
//arr is [[-3], -2, -1, 0, 1, 2]

Array.sort

在適當的位置對數組的元素進行排序，并返回數組。sort 排序不一定是穩定的。默認排序順序是根據字符串Unicode碼點。
arr.sort([compareFunction])

compareFunction —— 可選。用來指定按某種順序進行排列的函數。如果省略，元素按照轉換為的字符串的諸個字符的Unicode位點進行排序。

如果 compareFunction(a, b) 小于 0 ，那么 a 會被排列到 b 之前；

如果 compareFunction(a, b) 等于 0 ， a 和 b 的相對位置不變。備注： ECMAScript 標準并不保證這一行為，而且也不是所有瀏覽器都會遵守（例如 Mozilla 在 2003 年之前的版本）；
如果 compareFunction(a, b) 大于 0 ， b 會被排列到 a 之前。
compareFunction(a, b) 必須總是對相同的輸入返回相同的比較結果，否則排序的結果將是不確定的。

alert(arr.sort().toString());

Array.reverse

顛倒數組中元素的位置。第一個元素會成為最后一個，最后一個會成為第一個。

var myArray = ['one', 'two', 'three'];
myArray.reverse(); 

console.log(myArray) // ['three', 'two', 'one']

Array.concat

concat() 方法用于合并兩個或多個數組。此方法不會更改現有數組，而是返回一個新數組。

語法

var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])

參數

valueN
需要與原數組合并的數組或非數組值。詳見下文。

返回值

如果對象是 Array，則為true; 否則為false。

描述

concat 方法將創建一個新的數組，然后將調用它的對象(this 指向的對象)中的元素以及所有參數中的數組類型的參數中的元素以及非數組類型的參數本身按照順序放入這個新數組,并返回該數組.

concat 方法并不修改調用它的對象(this 指向的對象) 和參數中的各個數組本身的值,而是將他們的每個元素拷貝一份放在組合成的新數組中.原數組中的元素有兩種被拷貝的方式:

對象引用(非對象直接量):concat 方法會復制對象引用放到組合的新數組里,原數組和新數組中的對象引用都指向同一個實際的對象,所以,當實際的對象被修改時,兩個數組也同時會被修改.
字符串和數字(是原始值,而不是包裝原始值的 String 和 Number 對象): concat 方法會復制字符串和數字的值放到新數組里.
注意: 連接一個或多個數組（值）將不會改變原本的數組/值。進一步說，任何對新數組的操作都不會對原有的數組造成影響（僅當該元素不是對象的引用時），反之亦然。

該方法對數組的復制適用于非引用元素，當遇到對象或數組時，復制失效。

示例
連接兩個數組

var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];

// 組成新數組 ["a", "b", "c", 1, 2, 3]; 原數組 alpha 和 numeric 未被修改
var alphaNumeric = alpha.concat(numeric);

連接三個數組

var num1 = [1, 2, 3];
var num2 = [4, 5, 6];
var num3 = [7, 8, 9];

// 組成新數組[1, 2, 3, 4, 5, 6, 7, 8, 9]; 原數組 num1, num2, num3 未被修改
var nums = num1.concat(num2, num3);

將非數組值合并到數組里

var alpha = ['a', 'b', 'c'];

// 組成新數組 ["a", "b", "c", 1, 2, 3], 原alpha數組未被修改
var alphaNumeric = alpha.concat(1, [2, 3]);

對對象或數組的引用

var a = [{ name: 'xiaoming', age: 18 }, { name: 'xiaopang', age: 20 }];
var b = [1, 2];
var c = a.concat(b);
console.log(c); // concat_pic_1
c[0].name = 'mingming'
console.log(c); // concat_pic_2

concat_pic_1

concat_pic_2

Array.join

將當前數組的每個元素都用指定的字符串連接起來，然后返回連接后的字符串。
Array.join([separator = ","])

separator —— 分割符，默認為","

var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join();      // myVar1的值變為"Wind,Rain,Fire"
var myVar2 = a.join(', ');  // myVar2的值變為"Wind, Rain, Fire"
var myVar3 = a.join(' + '); // myVar3的值變為"Wind + Rain + Fire"
var myVar4 = a.join('');    // myVar4的值變為"WindRainFire"

Array.keys

返回一個新的Array迭代器，它包含數組中每個索引的鍵。
arr.keys()

var arr = ["a", "b", "c"];
var iterator = arr.keys();

console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

Array.toLocaleString

返回一個字符串表示數組中的元素。數組中的元素將使用各自的toLocaleString方法轉成字符串，這些字符串將使用一個特定語言環境的字符串（例如一個逗號 ","）隔開。

var number = 1337;
var date = new Date();
var myArr = [number, date, "foo"];
var str = myArr.toLocaleString(); 
console.log(str); 
// 輸出 "1337,2015/2/27 下午8:29:04,foo" 
// 假定運行在中文（zh-CN）環境，北京時區

多維數組

var arr1 = [[1,2,3],[4,5],['abc','def','ghj','hhh']];
var str='';
for (var i=0;i<arr1.length ; i++ )
{
    for (var j=0; j<arr1[i].length ; j++ )
    {   
        str =str +arr1[i][j]+';' ;
    }
    str +="\n";
}
alert(str);

Array.every

對數組中的每一項運行給定函數，如果該函數對每一項都返回true，則返回true。
Array.every(function(item, index, array){})

item —— 數組中的每一項
index —— 當前項的索引
array —— 數組本身

var arr = [1, 2, 3, 'blue', 'red'];
arr.every(function(item, index, array){
    return typeof item == 'number';
}); //false

由于第4、5項結果為false，因此不滿足所有返回值都要求是true的條件，因此返回值為false。

Array.some

對數組中的每一項運行給定函數，如果函數對任一項返回true，則返回true。
Array.some(function(item, index, array){})各項參數同every

var arr = [1, 2, 3, 'blue', 'red'];
arr.some(function(item, index, array){
    console.log(item);
    return typeof item == 'number';
}); // true

由于第1項即為true，已滿足任一項為true的條件，因此停止對數組的遍歷（迭代），返回true。

Array.filter

對數組中的每一項運行給定函數，返回由該函數中返回值為true的項所組成的數組。
Array.filter(function(item, index, array){})各項參數同every

var arr = [1, 2, 3, 'blue', 'red'];
arr.filter(function(item, index, array){
    return typeof item == 'number';
}); // [1, 2, 3]

由于第4、5項不是數字，所以沒有包含在返回值中。

Array.map

對數組中的每一項運行給定函數，返回由函數運行結果所組成的數組。
Array.map(function(item, index, array){})各項參數同every

var arr = [1, 2, 3, 'blue', 'red'];
arr.map(function(item, index, array){
    return typeof item == 'number';
}); // [true, true, true, false, false]

判斷數組中的每一項是否為數字，結果分別為[true, true, true, false, false],即為返回值。

Array.forEach

對數組中的每一項運行給定函數，無返回值。
Array.forEach(function(item, index, array){})各項參數同every

var arr = [1, 2, 3, 'blue', 'red'];
arr.forEach(function(item, index, array){
    // 對數字+1
    if(typeof item == 'number'){  
        array[index]  = item +1
    }
});  // arr = [2, 3, 4, "blue", "red"]

Array.find

返回數組中滿足提供的測試函數的第一個元素的值，否則返回undefined。
Array.find(function(item, index, array){})各項參數同上。

var inventory = [
    {name: 'apples', quantity: 2},
    {name: 'bananas', quantity: 0},
    {name: 'cherries', quantity: 5}
];
function findCherries(fruit) { 
    return fruit.name === 'cherries';
}
console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }

Array.findIndex

返回數組中滿足提供的測試函數的第一個元素的索引，否則返回-1。
Array.findIndex(function(item, index, array){})各項參數同上。

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}
console.log( [4, 6, 8, 12].findIndex(isPrime) ); // -1, 沒找到質數元素
console.log( [4, 6, 7, 12].findIndex(isPrime) ); // 2

Array.includes

用來判斷當前數組是否包含指定的值，如果是，則返回True，否則返回False。
Array.includes(searchElement[,fromIndex=0])

searchElement —— 要查找的元素
fromIndex —— 從該索引處開始查找 searchElement。如果為負值，則按升序從 array.length + fromIndex 的索引開始搜索。默認為 0。

[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

includes() 作為一個通用方法

includes() 方法有意設計為通用方法。它不要求this值是數組對象，所以它可以被用于其他類型的對象 (比如類數組對象)。下面的例子展示了在函數的arguments對象上調用的includes() 方法。

(function() {
  console.log([].includes.call(arguments, 'a')); // true
  console.log([].includes.call(arguments, 'd')); // false
})('a','b','c');

Array.reduce

對累加器和數組的每個值（從左到右）應用一個函數，以將其減少為單個值。
arr.reduce(function(accumulator, currentValue, currentIndex, array){}[, initialValue])

accumulator —— 上一次調用回調返回的值，或者是提供的初始值（initialValue）
currentValue —— 數組中正在處理的元素
currentIndex —— 數據中正在處理的元素索引，如果提供了 initialValue ，從0開始；否則從1開始
array —— 調用 reduce 的數組
initialValue —— 可選項，其值用于第一次調用 callback 的第一個參數。

let sum = [0, 1, 2, 3].reduce(function(acc, val) {
  return acc + val;
}, 0);
// 6
console.log(sum);

Array.reduceRight

接受一個函數作為累加器（accumulator），讓每個值（從右到左，亦即從尾到頭）縮減為一個值。（與 reduce() 的執行方向相反）。
arr.reduceRight(function(previousValue, currentValue, currentIndex, array){}[, initialValue])

previousValue —— 上一次調用回調的返回值，或提供的 initialValue
currentValue —— 當前被處理的元素
index —— 當前處理元素的索引
array —— 調用 reduce 的數組
initialValue —— 可作為第一次調用回調 callback 的第一個參數

var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
    return a.concat(b);
}, []);
// flattened is [4, 5, 2, 3, 0, 1]

MDN:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

JavaScript中Array方法

JavaScript中Array方法

定義數組

用字面量創建

用`new Array()`創建

Array.indexOf

Array.lastIndexOf

Array.slice

Array.splice

Array.push

Array.pop

Array.shift

Array.unshift

Array.sort

Array.reverse

Array.concat

Array.join

Array.keys

Array.toLocaleString

多維數組

Array.every

Array.some

Array.filter

Array.map

Array.forEach

Array.find

Array.findIndex

Array.includes

Array.reduce

Array.reduceRight

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

JavaScript中Array方法

定義數組

用字面量創建

用new Array()創建

Array.indexOf

Array.lastIndexOf

Array.slice

Array.splice

Array.push

Array.pop

Array.shift

Array.unshift

Array.sort

Array.reverse

Array.concat

Array.join

Array.keys

Array.toLocaleString

多維數組

Array.every

Array.some

Array.filter

Array.map

Array.forEach

Array.find

Array.findIndex

Array.includes

Array.reduce

Array.reduceRight

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

用`new Array()`創建