Kartenkopieren in Golang (Karte kopieren)

Kartenkopieren In Golang Karte Kopieren



In Go beziehen sich Karten auf eine Datenstruktur, die es uns ermöglicht, die Schlüssel-Wert-Paare zu speichern. Karten sind äußerst vielseitig und spielen eine wichtige Rolle beim Erstellen komplexer und realer Anwendungen. In anderen Programmiersprachen hört man Karten oft als Wörterbücher, assoziative Arrays oder Hash-Maps bezeichnet.

Bei der Arbeit mit Karten kann es jedoch vorkommen, dass wir eine Kopie einer vorhandenen Karte erstellen müssen.

In diesem Tutorial tauchen wir in die Welt der Karten in Go ein und erfahren etwas über das Kopieren von Karten, was es ist und wie man es verwendet.







Golang-Karten

Bevor wir uns mit dem Kopieren von Karten befassen, beginnen wir mit den Grundlagen von Karten in Go.



Erklärung

In Go können wir eine Karte mit dem Schlüsselwort „map“ deklarieren, gefolgt von den Schlüssel- und Werttypen, die in eckigen Klammern eingeschlossen sind.



Die Syntax lautet wie folgt:





War M Karte [ Schlüsselart ] Werttyp

Ein Beispiel ist wie folgt:

War M Karte [ Zeichenfolge ] int

Initialisierung

Bevor wir eine Karte verwenden können, müssen wir eine Karte initialisieren. In Go können wir dies mit der Funktion „make“ wie folgt tun:



M := machen ( Karte [ Zeichenfolge ] int )

Elemente hinzufügen und darauf zugreifen

Sobald wir eine Karte initialisiert haben, können wir die Elemente zu einer Karte hinzufügen, indem wir einem bestimmten Schlüssel einen Wert zuweisen.

Ein Beispiel ist wie folgt:

M [ „MySQL“ ] = 3306
M [ „PostgreSQL“ ] = 5094

Um auf den mit einem Schlüssel verknüpften Wert zuzugreifen, verwenden Sie den Schlüssel in eckigen Klammern, wie im folgenden Beispiel gezeigt:

fmt . Druckenln ( M [ „PostgreSQL“ ])

Dies sollte den mit dem angegebenen Schlüssel verknüpften Wert zurückgeben.

Kopieren Sie eine Karte in Golang

Nachdem wir die Grundlagen geklärt haben, besprechen wir nun, wie man eine Karte kopiert.

Was ist das Kopieren von Karten?

Unter Kartenkopieren versteht man die Technik des Erstellens eines Duplikats oder Klonens einer vorhandenen Karte. Obwohl es wie eine triviale Aufgabe erscheinen mag, spielt das Kopieren von Karten eine entscheidende Rolle, wie zum Beispiel:

  1. Wenn Sie Änderungen an einer Karte vornehmen müssen, ohne die ursprüngliche Karte zu beeinträchtigen.
  2. Beim Übergeben einer Karte an eine Funktion nach Wert. Standardmäßig übergibt Go die Karten als Referenz. Um also zu vermeiden, dass die ursprüngliche Karte verändert wird, wenn sie als Argument in einer Funktion verwendet wird, empfiehlt es sich, eine Kopie der Karte zu erstellen.
  3. Wenn Sie die nebenläufigkeitssicheren Karten implementieren.

Nachdem wir nun verstanden haben, warum das Kopieren von Karten wichtig ist, wollen wir mit der Erkundung der verschiedenen Methoden zum Kopieren von Karten in Go fortfahren.

Methode 1: Manuelles Kopieren

Eine Methode zum Kopieren einer Karte besteht darin, eine neue Karte zu erstellen und jedes Schlüssel-Wert-Paar manuell hinein zu kopieren.

Ein Beispiel dafür ist wie folgt:

Paket hauptsächlich
importieren (
„fmt“
)
Funktion hauptsächlich () {
Datenbanken := Karte [ Zeichenfolge ] int {
„MySQL“ : 3306 ,
„PostgreSQL“ : 5094 ,
„MongoDB“ : 27071 ,
}
Datenbanken_Kopie := machen ( Karte [ Zeichenfolge ] int )
für Schlüssel , Wert := Reichweite Datenbanken {
Datenbanken_Kopie [ Schlüssel ] = Wert
} fmt . Druckenln ( „Originalkarte:“ )
für Schlüssel , Wert := Reichweite Datenbanken {
fmt . Druckenf ( „%v: %v \N ' , Schlüssel , Wert )
}
fmt . Druckenln ( ' \N Kopierte Karte:“ )
für Schlüssel , Wert := Reichweite Datenbanken_Kopie {
fmt . Druckenf ( „%v: %v \N ' , Schlüssel , Wert )
}
}

Im gegebenen Beispiel initialisieren wir eine leere Map namens „databases_copy“ und kopieren jedes Schlüssel-Wert-Paar von der ursprünglichen Map in die neue.

Sie werden bei dieser Technik feststellen, dass sie recht ausführlich und unkompliziert ist. Bei der Arbeit mit einer großen Karte kann es jedoch zu Wiederholungen und Ineffizienz kommen.

Methode 2: Verwenden einer Konstruktorfunktion

Wir können auch eine Konstruktorfunktion verwenden, um eine Karte zu erstellen und zu kopieren. Schauen Sie sich das folgende Beispiel an:

Paket hauptsächlich
importieren (
„fmt“
)
Funktion hauptsächlich () {
Datenbanken := Karte [ Zeichenfolge ] int {
„MySQL“ : 3306 ,
„PostgreSQL“ : 5094 ,
„MongoDB“ : 27071 ,
}
Datenbanken_Kopie := machen ( Karte [ Zeichenfolge ] int , Nur ( Datenbanken ))
für Schlüssel , Wert := Reichweite Datenbanken {
Datenbanken_Kopie [ Schlüssel ] = Wert
}
fmt . Druckenln ( „Originalkarte:“ )
für Schlüssel , Wert := Reichweite Datenbanken {
fmt . Druckenf ( „%s: %d \N ' , Schlüssel , Wert )
}
fmt . Druckenln ( ' \N Kopierte Karte:“ )
für Schlüssel , Wert := Reichweite Datenbanken_Kopie {
fmt . Druckenf ( „%s: %d \N ' , Schlüssel , Wert )
}
}

In diesem Beispiel erstellen wir mithilfe eines konstruktorähnlichen Ansatzes eine Kopie der Originalkarte. Dadurch wird eine neue leere Map namens „databases_copy“ mit einer ähnlichen Speicherkapazität wie das Original initialisiert.

Schließlich kopieren wir jedes Schlüssel-Wert-Paar vom Original in die neue Karte.

Im Gegensatz zum ersten Ansatz können wir mit dieser Methode die Kapazität der neuen Karte angeben, was bei großen Karten effizienter sein kann.

Methode 3: Copy-On-Write (COW)

Der dritte Ansatz ist als Copy-On-Write bekannt. Hierbei handelt es sich um eine Technik, die nur dann eine Kopie der Karte erstellt, wenn die Karte geändert wird.

Ein großer Vorteil dieses Ansatzes ist die Speichereffizienz, insbesondere beim Umgang mit großen Karten.

Um den COW-Ansatz in Aktion zu demonstrieren, sehen Sie sich den folgenden Code an:

Paket hauptsächlich
importieren (
„fmt“
„synchronisieren“
)

Typ COWMap Struktur {
M Karte [ Zeichenfolge ] int
sperren synchronisieren. RWMutex
}

Funktion NeueCOWMap ( Original Karte [ Zeichenfolge ] int ) * COWMap {
zurückkehren &COWMap { M : Original }
}

Funktion ( cm * COWMap ) Erhalten ( Schlüssel Zeichenfolge ) ( int , bool ) {
cm . sperren . RLock ()
verschieben cm . sperren . REntsperren ()
Wert , existiert := cm . M [ Schlüssel ]
zurückkehren Wert , existiert
}

Funktion ( cm * COWMap ) Satz ( Schlüssel Zeichenfolge , Wert int ) {
cm . sperren . Sperren ()
verschieben cm . sperren . Freischalten ()
Wenn cm . M == Null {
cm . M = machen ( Karte [ Zeichenfolge ] int )
}
cm . M [ Schlüssel ] = Wert
}

Funktion ( cm * COWMap ) Kopieren () * COWMap {
cm . sperren . RLock ()
verschieben cm . sperren . REntsperren ()
Kopieren := machen ( Karte [ Zeichenfolge ] int , nur ( cm . M ))
für Schlüssel , Wert := Reichweite cm . M {
Kopieren [ Schlüssel ] = Wert
}
zurückkehren &COWMap { M : Kopieren }
}

Funktion hauptsächlich () {
// Originalkarte
Original := Karte [ Zeichenfolge ] int {
„MySQL“ : 3306 ,
„PostgreSQL“ : 5049 ,
„MongoDB“ : 27071 ,
}
// Erstellen Sie eine COWMap mit der Konstruktorfunktion
cowMap := NeueCOWMap ( Original )

// Einen Wert aus der COWMap abrufen
Schlüssel := „MySQL“
Wert , existiert := cowMap . Erhalten ( Schlüssel )
Wenn existiert {
fmt . Druckenf ( „Wert für Schlüssel %v: %v \N ' , Schlüssel , Wert )
} anders {
fmt . Druckenf ( „Schlüssel %v existiert nicht \N ' , Schlüssel )
}

// Einen neuen Wert in der COWMap festlegen
neuer Schlüssel := „PostgreSQL“
neuer Wert := 5076
cowMap . Satz ( neuer Schlüssel , neuer Wert )

// Eine Kopie der COWMap erstellen
kopierteKarte := cowMap . Kopieren ()

fmt . Druckenln ( ' \N Original COWMap:' )
für Schlüssel , Wert := Reichweite cowMap . M {
fmt . Druckenf ( „%v: %v \N ' , Schlüssel , Wert )
}
fmt . Druckenln ( ' \N COWMap kopiert:' )
für Schlüssel , Wert := Reichweite kopierteKarte . M {
fmt . Druckenf ( „%v: %v \N ' , Schlüssel , Wert )
}
}

Bei dieser Technik erstellen wir einen COWMap-Typ, der die ursprüngliche Karte umschließt und die Methode zum Lesen und Ändern dieser bereitstellt.

Dadurch können wir nur dann eine Kopie der Methode erstellen, wenn die Methode „Copy“ aufgerufen wird, also nach der Änderung.

Abschluss

Karten sind für die Erstellung vielseitiger und leistungsstarker Anwendungen von entscheidender Bedeutung. Wie Sie sehen, ist das Kopieren von Karten bei der Bewältigung verschiedener Szenarien praktisch. Glücklicherweise haben wir in diesem Tutorial alle Methoden zum Durchführen des Kartenkopierens in Go besprochen.