Ringkasan dan perkongsian operasi biasa pada tatasusunan JavaScript

Artikel ini membawa anda pengetahuan tentang operasi tatasusunan biasa dalam javascript, termasuk isu yang berkaitan dengan membuat tatasusunan, menentukan sama ada ia adalah tatasusunan, penukaran seperti tatasusunan dan tatasusunan, dan penyahduplikasian tatasusunan Semoga ia membantu semua orang .

Cadangan berkaitan: Tutorial pembelajaran javascript

Membuat tatasusunan

Mencipta tatasusunan ialah kemahiran asas. Kaedah-kaedah terutamanya termasuk yang berikut:

const arr = [1,2,3]                   
// 数组字面量const arr = [,,,]                     
// 三元素空位数组（hole array）const arr = new Array(4)              
// [,,,,]const arr = new Array(4,2)            
// [4,2]const arr = Array.of(1,2,3)           
// [1,2,3]

Antaranya, kaedah literal tatasusunan secara amnya yang paling biasa digunakan.

Hakim sama ada ia tatasusunan

Kaedah utama untuk menilai sama ada ia tatasusunan ialah:

// 方法一[1,2,3] instanceof Array   
// 方法二[1,2,3].constructor === Array
// 方法三Object.prototype.toString.call([1,2,3]) === '[object Array]'
// 方法四Array.isArray([1,2,3])
// 方法五（兼容写法）function isArray(arr){
    return Array.isArray ? 
        Array.isArray(arr):Object.prototype.toString.call(arr) === '[object Array]'}

Secara amnya kaedah yang paling biasa digunakan hendaklah isArray kaedah.

Penukaran antara tatasusunan dan tatasusunan

Struktur data yang kadangkala kami temui bukanlah tatasusunan tulen Ia biasanya diklasifikasikan sebagai "seperti tatasusunan" boleh ditukar kepada tatasusunan tulen dengan kaedah berikut :

const x = document.querySelectorAll('a');
// 方法一Array.prototype.slice.call(x);
// 方法二Array.from(x);Array.from(x,mapFn,thisArg);
// 方法三[...x]
// 方法四function toArray(x){
    let res = []
    for(item of x){
        res.push(item)
    }
    return res}
    // 方法五Array.apply(null,x)
    // 方法六[].concat.apply([],x)

Kaedah 5 dan 6 pada dasarnya memanfaatkan ciri-ciri penggunaan, iaitu, parameter kedua (tatasusunan atau seperti tatasusunan) yang diluluskan untuk digunakan akan ditukar menjadi senarai parameter , dan parameter ini akan dihantar ke kaedah yang dipanggil (Array atau concat baharu).

Penyahduplikasi tatasusunan

Penyahduplikasi tatasusunan pada asasnya memerlukan perbandingan sama ada dua elemen adalah sama, dan jika ya, buang satu elemen. Untuk menilai dengan tepat, Object.is digunakan di sini sebagai perbandingan.

1) Gunakan set untuk mengalih keluar pendua

set memerlukan elemen tidak diulang, jadi anda boleh mengalih keluar pendua selepas menukar tatasusunan kepada set, dan kemudian menukarnya kembali kepada tatasusunan.

function unique(arr){
    return Array.from(new Set(arr))
    // return [...new Set(arr)]}

2) Sambatan gelung berganda

Gelung luar merentasi semua elemen, dan gelung dalam merentasi semua elemen selepas elemen semasa Jika ia didapati sama, gunakan sambung untuk keluarkan satu. Ingat bahawa gelung dalam mesti kembali satu ruang setiap kali, jika tidak, beberapa elemen akan terlepas

function unique(arr){
    for(let i = 0;i < arr.length;i++){
        for(let j = i + 1;i < arr.length;j++){
            if(Object.is(arr[i],arr[j])){
                arr.splice(j,1)
                j--
            }
        }
    }
    return arr}

3) Buat tatasusunan baharu termasuk

Buat tatasusunan baharu sebelum menambah elemen pada Periksa sama ada elemen sudah wujud dalam tatasusunan:

function unique(arr){
    const res = []
    arr.forEach((item,index) => {
        // 也可以 if(res.indexOf(item) == -1)，但是无法正确判断 NaN
        if(!res,includes(item)){
            res.push(item)
        }
    })}

4) kurangkan termasuk

function unique(arr){
    return arr.reduce((acc,cur) => {
        // return acc.includes(cur) ? acc : acc.concat(cur)
        return acc.includes(cur) ? acc : [...acc,cur]
    },[])}

5) Buat isihan tatasusunan baharu

Mengikut mekanisme isihan (dalam setiap Panggilan keStrng pada setiap elemen, dan kemudian susun pada tahap rentetan) supaya elemen yang sama dikumpulkan bersama. Cipta tatasusunan baharu Setiap kali sebelum menambah elemen pada tatasusunan, semak sama ada elemen itu sama dengan elemen sebelumnya. tatasusunan menggunakan atribut objek

function unique(arr){
    arr.sort()
    const res = [arr[0]]
    for(let i = 1;i < arr.length;i++){
        if(!Object.is(arr[i],arr[i-1])){
            res.push(arr[i])
        }
    }
    return res}

Ini Kaedah ini sebenarnya sama dengan "tatasusunan baharu termasuk". Buat tatasusunan baharu dan setiap kali sebelum menambah elemen pada tatasusunan, semak sama ada elemen itu telah digunakan sebagai atribut objek:

Apa yang dikesan di sini ialah nama atribut objek , dan nama atribut pada dasarnya adalah rentetan Oleh itu,

dan

// 对象属性值可以认为是元素重复的次数function unique(arr){
    const res = []
    const obj = {}
    arr.forEach((item,index) => {
        if(!obj[item]){
            res.push(item)
            obj[item] = 1
        } else {
            obj[item]++
        }
    })
    return res}

dianggap sama, mengakibatkan elemen

atau elemen obj[true] gagal diletakkan ke dalam tatasusunan baharu obj["true"]true7) Menggunakan peta"true"

pada asasnya Kaedahnya adalah sama seperti di atas, tetapi tidak perlu mencipta tatasusunan baharu:

8) penapis indexOf

function unique(arr){
    let map = new Map()
    for(item of arr){
        if(!map.has(item)){
            map.set(item,true)
        }
    }
    return [...map.keys()]}

mengalih keluar elemen pendua . Cara lain untuk memahaminya ialah dengan mengekalkan

indeks

Elemen yang sama dengan indeks

apabila mula-mula muncul dengan penapis dan diletakkan dalam tatasusunan: Kelemahan menggunakan indexOf ialah ia tidak boleh digunakan dengan betul Hakim NaN.

function unique(arr){
    return arr.filter((item,index) => index === arr.indexOf(item))}

Cadangan berkaitan:

Tutorial pembelajaran javascript

Atas ialah kandungan terperinci Ringkasan dan perkongsian operasi biasa pada tatasusunan JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!