golang padam elemen peta

Dengan golang digunakan secara meluas dalam industri Internet, semakin ramai pembangun menggunakannya untuk membina aplikasi berprestasi tinggi. Antaranya, peta adalah salah satu jenis penting dalam golang Ia menyediakan kaedah untuk mencari dan menyimpan pasangan nilai kunci dengan cepat. Dalam aplikasi praktikal, kita mungkin sering perlu memadamkan elemen daripada peta. Artikel ini akan memperkenalkan beberapa kaedah untuk memadam elemen peta dalam golang.

1 Gunakan kata kunci padam

Golang menyediakan fungsi pemadaman terbina dalam untuk memadam elemen dalam peta. Sintaksnya adalah seperti berikut:

delete(map, key)

Antaranya, peta ialah objek peta elemen yang hendak dipadam, dan kunci ialah kunci elemen yang hendak dipadam. Berikut ialah contoh mudah yang menunjukkan cara menggunakan kata kunci padam untuk memadam elemen:

package main

import "fmt"

func main() {
    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }
    delete(m, "a")
    fmt.Println(m)
}

Hasil output ialah:

map[b:2 c:3]

Seperti yang dapat dilihat daripada contoh di atas, menggunakan delete boleh dengan cepat memadamkan elemen peta. Tetapi harus diingat bahawa jika kunci yang ditentukan tidak wujud dalam peta, padam tidak akan melakukan sebarang operasi.

2. Gunakan julat traversal untuk memadamkan elemen

Dalam sesetengah kes, kita mungkin perlu melintasi peta dan memadamkan elemen yang memenuhi syarat. Dalam kes ini, penggunaan padam terus tidak boleh dilaksanakan kerana mengubah suai peta semasa merentasi peta akan menyebabkan ralat. Pada masa ini, anda boleh menggunakan julat untuk melintasi peta dan menandai elemen yang akan dipadamkan, dan akhirnya melintasi peta sekali lagi untuk memadamkan elemen yang ditanda. Berikut ialah contoh yang menunjukkan cara menggunakan traversal julat untuk memadam elemen:

package main

import "fmt"

func main() {
    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }
    deleteKeys := make([]string, 0)
    for k, v := range m {
        if v > 2 {
            deleteKeys = append(deleteKeys, k)
        }
    }
    for _, k := range deleteKeys {
        delete(m, k)
    }
    fmt.Println(m)
}

Hasil output ialah:

map[a:1 b:2]

Dalam contoh di atas, kami mula-mula menggunakan julat traversal untuk memetakan dan menyimpan kunci yang memenuhi syarat dalam kepingan. Kemudian gunakan julat sekali lagi untuk melintasi hirisan dan padamkan elemen yang perlu dipadamkan mengikut turutan. Perlu diingatkan bahawa kepingan lain digunakan untuk menyimpan kunci yang hendak dipadamkan, dan ia tidak boleh dipadamkan terus semasa merentasi peta, kerana mengubah suai peta semasa traversal akan menyebabkan ralat.

3. Gunakan penyegerakan.Peta untuk memadam elemen secara serentak

Dalam aplikasi konkurensi tinggi, kita mungkin perlu menggunakan peta dengan fungsi baca dan tulis serentak, dan pakej penyegerakan golang menyediakan satu Thread- penyegerakan jenis pemetaan selamat.Peta. Memadamkan elemen menggunakan sync.Map agak mudah dan tidak perlu risau tentang isu persaingan membaca dan menulis semasa penulisan serentak. Berikut ialah contoh yang menunjukkan cara menggunakan penyegerakan.Peta untuk memadamkan elemen:

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := &sync.Map{}
    m.Store("a", 1)
    m.Store("b", 2)
    m.Store("c", 3)
    m.Range(func(k, v interface{}) bool {
        if k == "b" {
            m.Delete(k)
        }
        return true
    })
    m.Range(func(k, v interface{}) bool {
        fmt.Printf("%s:%v
", k, v)
        return true
    })
}

Outputnya ialah:

a:1
c:3

Dalam contoh di atas, kami mula-mula mencipta objek penyegerakan.Peta dan menambah Beberapa pasangan nilai kunci ditambah kepadanya. Kemudian gunakan kaedah Julat untuk melintasi peta dan memadam elemen yang memenuhi syarat. Perlu diingat bahawa apabila memadam elemen, anda perlu menggunakan kaedah Padam dan bukannya kata kunci padam.

4. Gunakan penugasan baharu peta

Selain kaedah di atas, satu lagi cara biasa untuk memadamkan elemen peta ialah menggunakan penetapan peta baharu. Idea kaedah ini adalah untuk mencipta objek peta baharu dan menetapkan elemen yang perlu dikekalkan kepada objek peta baharu. Berikut ialah contoh yang menunjukkan cara untuk memadam elemen menggunakan tugasan baharu peta:

package main

import "fmt"

func main() {
    m := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
    }
    newM := make(map[string]int)
    for k, v := range m {
        if k != "a" {
            newM[k] = v
        }
    }
    fmt.Println(newM)
}

Outputnya ialah:

map[b:2 c:3]

Dalam contoh di atas, kami mula-mula mencipta objek peta kosong baharu newM, Kemudian lintasi objek peta asal m dan tetapkan elemen yang tidak perlu dipadamkan kepada newM. Perlu diingatkan bahawa kaedah ini lebih berkesan apabila terdapat lebih sedikit elemen dalam peta, tetapi ia akan menyebabkan kemerosotan prestasi apabila bilangan elemen dalam peta adalah besar. Oleh itu, adalah disyorkan untuk menggunakan kaedah padam atau Julat apabila memadamkan elemen dalam peta untuk mendapatkan prestasi yang lebih baik.

Kesimpulan

Dalam golang, terdapat banyak cara untuk memadam elemen peta, antaranya padam adalah kaedah yang paling mudah dan biasa digunakan; kaedah Julat sesuai untuk senario di mana elemen yang memenuhi syarat perlu dipadamkan ; Kaedah Padam penyegerakan. Peta sesuai untuk aplikasi konkurensi tinggi menggunakan penugasan baharu peta boleh memadamkan elemen dalam peta, tetapi akan ada overhed tertentu dalam prestasi. Bergantung pada senario tertentu, kita boleh memilih kaedah yang paling sesuai untuk kita untuk meningkatkan prestasi dan kebolehbacaan aplikasi.

Atas ialah kandungan terperinci golang padam elemen peta. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!