javescript經驗文檔（Array篇）

XFLY 發布于2019-08-23 11:28 / 2695人閱讀

摘要：返回結果注意方法返回的是數組長度，如上示例，返回值為方法把一個或多個參數插入到數組頭部，返回數組長度。整數，規定添加刪除項目的位置，使用負數可從數組結尾處規定位置。返回值類型描述包含被刪除項目的新數組，如果有的話。

數組去重 ...set(array)去重

{
    let array = ["aa",12,"aa",16,12,"ab"];
    function dedupe(array) { //es6
        return [...new Set(array)] 
    }
    dedupe(array);
    //等價于
    Array.from(new Set(array));
}

array.filter()方法去重

{
    let array = ["aa",12,"aa",16,12,"ab"];
    array.filter((item, index) => {
        return array.indexOf(item) == index;
    });
}

數組翻轉

reverse()

{
    let arr = ["a","b","c",1,3];
    arr.reverse(); 
}

返回結果： [3, 1, "c", "b", "a"]

連接兩個或多個數組 concat() 方法

concat() 方法用于連接兩個或多個數組,該方法不會改變現有的數組，而僅僅會返回被連接數組的一個副本
arr0.concat(arr1, arr2, arr3, ......, arrx);
例：

{
    [1,2,3].concat(4,5)
    
    [1,2,3].concat([4,5],6)
    
    [1,2,3].concat([4,5],[6,7,8])
}

返回結果：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8]

... 方法

es6 擴展運算符，最簡單的寫法，一萬個推薦！！！

{
    let arr = ["1s","2s","3s",4];
    let arr2 = ["1a","2a"];
    console.log([...arr,...arr2]);
}

返回結果：["1s", "2s", "3s", 4, "1a", "2a"]

push() 方法

push()把一個或多個參數附加在數組末尾，返回數組長度。改變數組自身。

{
    let a = ["a","b","v"];
    let b = ["c","d","g"];
    a.push(...b)
    console.log(a)
}

返回結果：["a", "b", "v", "c", "d", "g"]
注意： push()方法返回的是數組長度，如上示例，console.log(a.push(...b))返回值為6

unshift() 方法

unshift()把一個或多個參數插入到數組頭部，返回數組長度。改變數組自身。

{
    let arr = [1, 2, 3];
    let count = arr.unshift(4, 5);

    console.log(count); 
    console.log(arr); 
}

返回結果：
5
[4, 5, 1, 2, 3]

數組與字符串相互轉化 數組轉字符串

join()方法，Array.join(標識符)

{
    ["as2",12,"ss"].join("/");
}

返回結果："as2/12/ss"

字符串轉數組

split()方法，string.split(標識符)

{
    "as2/12/ss".split("/")
}

返回結果：["as2", "12", "ss"]

數組刪除、插入、替換

arrayObject.splice(index,howmany,item1,.....,itemX)

參數描述：
index：必需。整數，規定添加/刪除項目的位置，使用負數可從數組結尾處規定位置。
howmany：必需。要刪除的項目數量。如果設置為 0，則不會刪除項目。
item1, ..., itemX 可選。向數組添加的新項目。
返回值：
類型描述：Array 包含被刪除項目的新數組，如果有的話。
說明：splice() 方法可刪除從 index 處開始的零個或多個元素，并且用參數列表中聲明的一個或多個值來替換那些被刪除的元素。

如果從 arrayObject 中刪除了元素，則返回的是含有被刪除的元素的數組。

splice插入操作

示例：在 aa 和 bb 之間插入 aabb

{
    let str = ["aa","bb",123,"sd13cx","jj",45];
    str.splice(1,0,"aabb");
    console.log(str)
}

返回結果：["aa", "aabb", "bb", 123, "sd13cx", "jj", 45]

拓展練習：

在 aa 和 bb 之間批量插入 ab、aabb、aaabbb
{

let str = ["aa","bb",123,"sd13cx","jj",45];
str.splice(1,0,"ab","aabb","aaabbb");
console.log(str);

}
返回結果：["aa", "ab", "aabb", "aaabbb", "bb", 123, "sd13cx", "jj", 45]

深層拓展：

es6方法，使用‘...’擴展運算符

{
    let str = ["aa","bb",123,"sd13cx","jj",45];
    let arr = ["ab","aabb","aaabbb"];
    //巧用es6 "..."
    str.splice(1,0,...arr);
    console.log(str);
}

splice替換操作

示例：把 123 替換為 ccdd

{
    let str = ["aa","bb",123,"sd13cx","jj",45];
    str.splice(2,1,"ccdd");
    console.log(str)
}

返回結果：["aa", "bb", "ccdd", "sd13cx", "jj", 45]

拓展練習：

把 123 替換為 1234、12345

{
    let str = ["aa","bb",123,"sd13cx","jj",45];
    str.splice(2,1,1234,12345);
    console.log(str);
}

返回結果:["aa", "bb", 1234, 12345, "sd13cx", "jj", 45]

splice刪除操作

示例：把 123 刪除

{
    let str = ["aa","bb",123,"sd13cx","jj",45];
    str.splice(2,1);
    console.log(str)
}

delete刪除操作

{
    let arr = ["aaa",111,222];
    delete arr[1]
    console.log(arr,arr.length)
    //delete 只刪除值，不刪除引用空間
}

返回結果：["aaa", empty, 222] 3

數組排序 冒泡排序

{
    let array = [1,4,-8,-3,6,12,9,8];
    let bubbleSort = function(arr){
        for(let i = 0;i < arr.length-1;i++){
            for(let j = 0;j < arr.length-i-1;j++){
                if(arr[j] < arr[j+1]){
                    let temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        return arr;
    }
    bubbleSort(array);
}

（1）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個位置。
（2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
（3）針對所有的元素重復以上的步驟，除了最后一個。
（4）持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

快速排序排序

{
    //遞歸思想，兩邊快速的排序，冒泡排序的改進
    let array = [1,4,-8,-3,6,12,9,8];
    let quickSort = function(arr){
        if(arr.length <= 1){
            return arr;
        }
        let index = Math.floor(arr.length/2);
        let temp = arr.splice(index,1);
        let left = [],right = [];
        for(let item of arr){
            if(item < temp){
                left.push(item);
            }else{
                right.push(item);
            }
        }
        return quickSort(left).concat(temp,quickSort(right));
    }
    quickSort(array);
}

Math.floor(x)方法是向下取整，返回小于或等于x的最接近的整數。

splice(index,num,item)方法是向數組中添加項目，或是從數組中刪除項目，并返回被刪除的項目。

index是整數，被操作項目所在的位置（必須）
num是整數，要刪除的項目的數量，如果為0，表示不刪除（必須）
item是向數組中添加的新項目，可以是多個（可選）
push()方法是向數組末尾添加一個或多個新項目并返回新數組的長度

concat()方法連接兩個或多個數組，不會改變原有數組，返回一個新數組

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/97013.html

javescript經驗文檔（循環語句篇）

摘要：循環語句一般循環方法注意在使用遍歷數組之前一定要判斷數組是否已經定義用的方法遍歷數組對對象操作為對象的鍵用的方法總結來說總是得到對像的或數組字符串的下標而和一樣是直接得到值。所以，不能對象用循環循環循環語句一般for循環 { let array = [1,2,3,4,5,6,7]; for (let i = 0; i < array.length; i++) ...

BearyChat 2019-08-23 11:28 評論0 收藏0
javescript經驗文檔（es6/es2017篇）

摘要：迭代器西紅柿孫雙雙結果西紅柿孫雙雙生成器西紅柿炒蛋結果西紅柿孫雙雙模版字符串普通字符串多行字符串字符串中嵌入變量函數的參數默認值之前，當未傳入參數時，操作符當被用于迭代器中時，它是一個操作符當被用于函數傳參時，是一個操作符當被用于函迭代器 - Iterators { use strict function chef(foods){ let i = 0;...

fyber 2019-08-23 11:27 評論0 收藏0
javescript經驗文檔（Object篇）

摘要：判斷自身屬性是否存在方法返回一個布爾值，判斷對象是否包含特定的自身非繼承屬性。判斷自身屬性是否存在 hasOwnProperty()方法返回一個布爾值，判斷對象是否包含特定的自身（非繼承）屬性。 { let obj = {a:1,b:2}; obj.hasOwnProperty(a) } 返回結果：true

developerworks 2019-08-23 12:23 評論0 收藏0
javescript經驗文檔（技巧篇）

摘要：與用來賦值的奇怪用法如果存在，反之則相當于注意強烈要求注意一下，如果的值為，那么就要詳細的考慮一下，因為千萬不要玩脫了與判斷奇偶隱式返回值注意一哈，這里是括號 && 與 || 用來賦值的奇怪用法 o_0 let a = x || y; // 如果 x 存在， a = x,反之則 a = y;相當于 if(x){ let a = x; ...

jzman 2019-08-23 12:23 評論0 收藏0
JavaScript中的數組

摘要：數組數組概述數組是什么數組是值的有序集合數組中的每一個值叫做一個元素而每個元素在數組中都有一個唯一的位置這個位置用數字表示叫做索引數組用字符串表示叫做關聯數組數組是無類型的數組的元素可以是任何類型例如字符串數字值布爾值等而且每個數組中的不同數組數組概述數組是什么數組是值的有序集合數組中的每一個值叫做一個元素而每個元素在數組中都有一個唯一的位置這個位置用數字表示叫做索引數組...

Genng 2019-08-23 10:53 評論0 收藏0