js中數組操做
數組API
- API: Application Programming Interface,應用程序編程接口;
- js中對象提供的方法就叫作API；
instanceof
檢測一個對象是不是數組;(用來對付複雜數據類型;)
// 簡單數據類型 typeof ;
A instanceof B // A是否是B造出來的;
例：
var arr = [1,2,3];
console.log(arr instanceof Array); //arr屬不屬於Array類型;
Array.isArray( )
Array.isArray(參數); // 判斷參數是否是數組,返回布爾值;
例：
var arr = [1,2,3];
var num = 123;
console.log(Array.isArray(arr)); //true
console.log(Array.isArray(num)); //false
toString( )
數組.toString(); // 把數組變成字符串,去除了[],內容用逗號連接;
例：
var arr = ["aaa","bbb","ccc"];
console.log(arr.toString()); //返回 aaa,bbb,ccc
valueOf( )
數組.valueOf(); //返回數組自己;
例：
var arr = ["aaa","bbb","ccc"];
console.log(arr.valueOf()); //返回數組自己 ["aaa","bbb","ccc"]
數組.join(參數)
數組.join(參數); // 數組中的元素能夠按照參數進行連接變成一個字符串;
console.log(arr.join()); //和toString()同樣用逗號連接
console.log(arr.join("|")); //用參數連接
console.log(arr.join("&")); //用參數連接
console.log(arr.join(" ")); //若是是空格，真的用空格連接
console.log(arr.join("")); //空字符是無縫鏈接
數組元素的添加和刪除
push( )和pop( )
1. 數組.push() //在數組的最末尾添加元素;
2. 數組.pop() //不須要參數;在數組的最末尾刪除一項;
例：
var arr = [1,2,3];
var aaa = arr.push("abc");//在數組的最末尾添加一個元素;
console.log(arr);//元素被修改了
console.log(aaa);//返回值是數組的長度;
aaa = arr.pop();//不須要參數;在數組的最末尾刪除一項;
console.log(arr);//元素被修改了
console.log(aaa);//被刪除的那一項
unshift( )和shift( )
1. 數組.unshift() //在數組的最前面添加一個元素;
2. 數組.shift() //不須要參數;在數組的最前面刪除一項;
例：
var arr = [1,2,3];
aaa = arr.unshift("abc");//在數組的最前面添加一個元素;
console.log(arr);//元素被修改了
console.log(aaa);//返回值是數組的長度;
aaa = arr.shift();//不須要參數;在數組的最前面刪除一項;
console.log(arr);//元素被修改了
console.log(aaa);//被刪除的那一項
數組元素排序
reverse( )
reverse() //翻轉數組
例:
var arr1 = [1,2,3,4,5];
var aaa = arr1.reverse(); // [5,4,3,2,1]
sort( )
sort() // 數組中元素排序;(默認：從小到大)
// 默認：按照首個字符的Unicode編碼排序;若是第一個相同那麼就比較第二個...
例：
var arr = [4,5,1,3,2,7,6];
var aaa =arr.sort();
console.log(aaa); // [1, 2, 3, 4, 5, 6, 7]
console.log(aaa === arr);// true 原數組被排序了(冒泡排序)
//默認還能夠排列字母;
var arr2 = ["c","e","d","a","b"];
var bbb = arr2.sort();
console.log(bbb); // ["a", "b", "c", "d", "e"]
console.log(bbb===arr2); // true 原數組被排序了(冒泡排序)
sort() //數值大小排序方法,須要藉助回調函數;
例：
var arr = [4,5,1,13,2,7,6];
//回調函數裏面返回值若是是：參數1-參數2;升冪； 參數2-參數1;降冪；
arr.sort(function (a,b) {
return a-b; //升序
//return b-a; //降序
//return b.value-a.value; //按照元素value屬性的大小排序;
});
console.log(arr); // [1, 2, 4, 5, 6, 7, 13]
sort( )底層原理
var aaa = bubbleSort([1,12,3], function (a,b) {
// return a-b;//實參：array[j]-array[j+1]；
return b-a;//實參：array[j+1]-array[j]；
});
console.log(aaa);
function bubbleSort(array,fn){
//外循環控制輪數，內循環控制次數，都是元素個數-1;
for(var i=0;i<array.length-1;i++){
for(var j=0;j<array.length-1-i;j++){//次數優化，多比較一輪，少比較一次;
//知足條件交換位置;
// if(array[j]>array[j+1]){//大於升冪排序；不然降冪;
//a-b>0 和 a>b是一個意思;
//b-a>0 和 a<b是一個意思;
// if(array[j]-array[j+1]>0){//升冪排序
// if(array[j+1]-array[j]>0){//降冪排序
//把兩個變量送到一個函數中;
if(fn(array[j],array[j+1])>0){
var temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
//返回數組
return array;
}
數組元素的操做
concat( )
數組1.concat(數組2); // 連接兩個數組; var arr1 = [1,2,3]; var arr2 = ["a","b","c"]; var arr3 = arr1.concat(arr2); console.log(arr3) // [1, 2, 3, "a", "b", "c"]
slice( )
數組.slice(開始索引值，結束索引值); //數組截取;
例 ：
var arr = [1, 2, 3, "a", "b", "c"];
console.log(arr.slice(3)); //從索引值爲3截取到最後;["a", "b", "c"]
console.log(arr.slice(0,3)); //包左不包右;[1, 2, 3]
console.log(arr.slice(-2)); //負數是後幾個;["b", "c"]
console.log(arr.slice(3,0)); //若是前面的比後面的大，那麼就是[];[]
console.log(arr); //原數組不被修改;[1, 2, 3, "a", "b", "c"]
splice( )
數組.splice(開始索引值，刪除幾個，替換內容1，替換內容2，...); // 替換和刪除;
//改變原數組;返回值是被刪除/替換的內容
例:
var arr = [1,2,3,4,5,6,"a", "b", "c"]
arr.splice(5); //從索引值爲3截取到最後;(刪除)
console.log(arr); // [1, 2, 3, 4, 5]
arr.splice(1,2); //(刪除指定個數)從索引爲1的開始刪除2個
console.log(arr); //[1, 4, 5]
//替換
var arr = [1,2,3,4,5,6,"a", "b", "c"];
console.log(arr.splice(3,3,"aaa","bbb","ccc")); //(刪除指定數並替換)
console.log(arr); // [1, 2, 3, "aaa", "bbb", "ccc", "a", "b", "c"]
// 添加
arr.splice(3,0,"aaa","bbb","ccc");//(刪除指定個數)
//
console.log(arr);//截取或者替換以後的; [1, 2, 3, "aaa", "bbb", "ccc", "aaa", "bbb", "ccc", "a", "b", "c"]
indexOf / lastIndexOf
數組.indexOf(元素); // 給元素，查索引(從前日後)
數組.lastIndexOf(元素); // 給元素，查索引(從後往前)
例：
var arr = ["a","b","c","d","c","b","b"];
console.log(arr.indexOf("b")); // 1 查到之後馬上返回
console.log(arr.lastIndexOf("b")); // 6 找到之後馬上返回
console.log(arr.indexOf("xxx")); // -1; 查不到就返回-1；
數組迭代(遍歷)
every()
對數組中每一項運行回調函數，若是都返回true，every返回true，
若是有一項返回false，則中止遍歷 every返回false；不寫默認返回false
像保鏢失誤一次，遊戲結束！！！
例：
1. var arr = [111,222,333,444,555];
arr.every(function (a,b,c) {
console.log(a); //元素
console.log(b); //索引值
console.log(c); //數組自己;
console.log("-----"); //數組自己;
//數組中元素賦值：c[b] = 值; a=有時候沒法賦值;
return true;
});
2. //every返回一個bool值，所有是true纔是true；有一個是false，結果就是false
var bool = arr.every(function (element, index, array) {
//判斷：咱們定義全部元素都大於200;
//if(element > 100){
if(element > 200){
return true;
}else{
return false;
}
})
alert(bool); //false
filter()
// 對數組中每一項運行回調函數，該函數返回結果是true的項組成的新數組
// 新數組是有老數組中的元素組成的，return爲ture的項;
例：
var arr = [111,222,333,444,555];
var newArr = arr.filter(function (element, index, array) {
//只要是奇數，就組成數組;(數組中辨別元素)
if(element%2 === 0){
return true;
}else{
return false;
}
})
console.log(newArr); // [222, 444]
forEach()
// 和for循環同樣；沒有返回值;
例：
var arr = [111,222,333,444,555];
var sum = 0;
var aaa = arr.forEach(function (element,index,array) {
console.log(element); // 輸出數組中的每個元素
console.log(index); // 數組元素對應的索引值
console.log(array); // 數組自己 [111, 222, 333, 444, 555]
sum += element; //數組中元素求和;
});
console.log(sum); // 數組元素加起來的和
console.log(aaa);//undefined；沒有返回值 因此返回undefined
map()
// 對數組中每一項運行回調函數，返回該函數的結果組成的新數組
// return什麼新數組中就有什麼; 不return返回undefined; 對數組二次加工
例：
var arr = [111,222,333,444,555];
var newArr = arr.map(function (element, index, array) {
if(index == 2){
return element; // 這裏return了 因此下面返回的值是333
}
return element*100; // 返回的元素值都乘上100後的值
})
console.log(newArr); // [11100, 22200, 333, 44400, 55500]
some()
//對數組中每一項運行回調函數，若是該函數對某一項返回true，則some返回true; 像殺手，有一個成功，就勝利了！！！
例：
var arr = [111,222,333,444,555];
var bool = arr.some(function (ele,i,array) {
//判斷：數組中有3的倍數
if(ele%3 == 0){
return true;
}
return false;
})
alert(bool); //true ; 有一個成功就是true
數組清空
1. arr.length = 0; // (很差，僞數組沒法清空)
2. arr.splice(0); // 僞數組沒有這個方法;
3. arr = []; // 能夠操做僞數組; (推薦!)
// 僞數組: 就是長的像數組，可是沒有數組的方法;也不能添加和刪除元素;
例： // arguments
fn(111,222,333);
function fn(){
arguments.length = 0; // 沒法清空 返回 [1, 2, 3]
arguments.splice(0); // 會報錯 arguments.splice is not a function
arguments = []; // 能夠清空,返回空數組[]
console.log(arguments);
}
數組案例
1.將一個字符串數組輸出爲|分割的形式，好比「劉備|張飛|關羽」。使用兩種方式實現編程
var arr = ["劉備","張飛","關羽"];
var separator = "|";
//經過for循環累加
var str = arr[0];
for(var i=1;i<arr.length;i++){
str += separator+arr[i];
}
console.log(str); // 劉備|張飛|關羽
//join()能夠把數組中的元素連接成字符串;
console.log(arr.join("|")); // 劉備|張飛|關羽
2.將一個字符串數組的元素的順序進行反轉。["a", "b", "c", "d"] -> [ "d","c","b","a"]。使用兩種種方式實現。提示：第i個和第length-i-1個進行交換數組
// 數組.reverse() 方法
var arr = ["a", "b", "c", "d"];
console.log(arr.reverse()); // ["d", "c", "b", "a"]
// 三種：1.正向遍歷，反向添加; 2.反向遍歷，正向添加; 3.元數組元素交換位置;
for(var i=0;i<arr.length/2;i++){
var temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
console.log(arr);
3.工資的數組[1500, 1200, 2000, 2100, 1800],把工資超過2000的刪除函數
var arr = [1500, 1200, 2000, 2100, 1800];
//利用filter()造成一個數組;return true;組成的數組;
var newArr = arr.filter(function (ele, i, array) {
//2000以上返回false;
if(ele<2000){
return true;
}else{
return false;
}
});
console.log(newArr); // [1500, 1200, 1800]
4.["c", "a", "z", "a", "x", "a"]找到數組中每個a出現的位置優化
var arr = ["c", "a", "z", "a", "x", "a"];
//遍歷數組(for/while/do...while) forEach();
arr.forEach(function (ele, index, array) {
//若是元素等於「a」，那麼就輸出索引值；
if("a" === ele){
console.log(index);
}
});
5.編寫一個方法去掉一個數組的重複元素 (數組去重)編碼
var arr = ["鳴人","鳴人","佐助","佐助","小櫻","小櫻"];
// 方法1： 思路：定義一個新數組，遍歷老數組，判斷，若是新數組裏面沒有老數組的元素就添加，不然就不添加；
var newArr = [];
//遍歷老數組
arr.forEach(function (ele,index,array) {
//檢測老數組中的元素，若是新數組中存在就不添加了，不存在才添加;
if(newArr.indexOf(ele) === -1){//不存在就添加;（去新數組中查找元素索引值，若是爲-1就是沒有）
newArr.push(ele);
}
});
console.log(newArr); // ["鳴人", "佐助", "小櫻"]
也能夠利用ES6中的Set方法達到快速去重,一行代碼解決:
[...new Set(arr)] 或者：Array.from(new Set(arr)) // ["鳴人", "佐助", "小櫻"]
相關文章
- 1. JS中數組的操做
- 2. js中的數組操做
- 3. js 數組操做
- 4. js數組操做
- 5. JS操做數組
- 6. Js數組操做
- 7. JS數組操做
- 8. js中數組操做函數之some
- 9. js中的數組定義與操做
- 10. js中數組的操做方法
- 更多相關文章...
- • Java 中操作 R - R 語言教程
- • Lua 數組 - Lua 教程
- • Flink 數據傳輸及反壓詳解
- • Scala 中文亂碼解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. JS中數組的操做
- 2. js中的數組操做
- 3. js 數組操做
- 4. js數組操做
- 5. JS操做數組
- 6. Js數組操做
- 7. JS數組操做
- 8. js中數組操做函數之some
- 9. js中的數組定義與操做
- 10. js中數組的操做方法