Zeiger in Go beherrschen: Sicherheit, Leistung und Wartbarkeit des Codes verbessern

Zeiger in der Go-Sprache: ein leistungsstarkes Tool für effiziente Datenoperationen und Speicherverwaltung

Zeiger in der Go-Sprache bieten Entwicklern ein leistungsstarkes Werkzeug, um direkt auf die Speicheradresse von Variablen zuzugreifen und diese zu manipulieren. Im Gegensatz zu herkömmlichen Variablen, die tatsächliche Datenwerte speichern, speichern Zeiger den Speicherort, an dem sich diese Werte befinden. Diese einzigartige Funktion ermöglicht es Zeigern, Originaldaten im Speicher zu ändern und bietet so eine effiziente Methode zur Datenverarbeitung und Optimierung der Programmleistung.

Speicheradressen werden im Hexadezimalformat (z. B. 0xAFFFF) dargestellt und bilden die Grundlage für Zeiger. Wenn Sie eine Zeigervariable deklarieren, handelt es sich im Wesentlichen um eine spezielle Variable, die die Speicheradresse einer anderen Variablen und nicht die Daten selbst enthält.

Zum Beispiel enthält der Zeiger p in der Go-Sprache die Referenz 0x0001, die direkt auf die Speicheradresse einer anderen Variablen x zeigt. Diese Beziehung ermöglicht es p, direkt mit dem Wert von x zu interagieren, was die Leistungsfähigkeit und Nützlichkeit von Zeigern in der Go-Sprache demonstriert.

Hier ist eine visuelle Darstellung der Funktionsweise von Zeigern:

Erkunden Sie die Hinweise in der Go-Sprache eingehend

Um einen Zeiger in der Go-Sprache zu deklarieren, lautet die Syntax var p *T, wobei T den Typ der Variablen darstellt, auf die der Zeiger verweist. Betrachten Sie das folgende Beispiel, in dem p ein Zeiger auf eine int-Variable ist:

<code class="language-go">var a int = 10
var p *int = &a</code>

Hier speichert p die Adresse von a und durch Zeiger-Dereferenzierung (*p) kann auf den Wert von a zugegriffen oder dieser geändert werden. Dieser Mechanismus ist die Grundlage für eine effiziente Datenmanipulation und Speicherverwaltung in der Go-Sprache.

Sehen wir uns ein einfaches Beispiel an:

<code class="language-go">func main() {
    x := 42
    p := &x
    fmt.Printf("x: %v\n", x)
    fmt.Printf("&x: %v\n", &x)
    fmt.Printf("p: %v\n", p)
    fmt.Printf("*p: %v\n", *p)

    pp := &p
    fmt.Printf("**pp: %v\n", **pp)
}</code>

Ausgabe

<code>Value of x: 42
Address of x: 0xc000012120
Value stored in p: 0xc000012120
Value at the address p: 42
**pp: 42</code>

Zeiger in der Go-Sprache unterscheiden sich von Zeigern in C/C

Ein häufiges Missverständnis darüber, wann Zeiger in Go verwendet werden sollten, rührt vom direkten Vergleich von Zeigern in Go mit Zeigern in C her. Wenn Sie den Unterschied zwischen den beiden verstehen, können Sie nachvollziehen, wie Zeiger im Ökosystem der einzelnen Sprachen funktionieren. Schauen wir uns diese Unterschiede genauer an:

• Keine Zeigerarithmetik

Im Gegensatz zur C-Sprache ermöglicht die Zeigerarithmetik in der C-Sprache die direkte Manipulation von Speicheradressen, während die Go-Sprache keine Zeigerarithmetik unterstützt. Diese bewusste Designwahl der Go-Sprache führt zu mehreren wesentlichen Vorteilen:

1. Verhindern Sie Pufferüberlauf-Schwachstellen: Durch die Eliminierung der Zeigerarithmetik verringert die Go-Sprache grundlegend das Risiko von Pufferüberlauf-Schwachstellen, die ein häufiges Sicherheitsproblem in C-Sprachprogrammen darstellen. Dadurch können Angreifer beliebigen Code ausführen.
2. Machen Sie Code sicherer und einfacher zu warten: Ohne die Komplexität direkter Speicheroperationen ist Go-Sprachcode einfacher zu verstehen, sicherer und einfacher zu warten. Entwickler können sich auf die Logik der Anwendung konzentrieren und müssen sich nicht mit der Komplexität der Speicherverwaltung befassen.
3. Speicherbezogene Fehler reduzieren: Durch die Eliminierung der Zeigerarithmetik werden häufige Fallstricke wie Speicherlecks und Segfaults minimiert, wodurch Go-Programme robuster und stabiler werden.
4. Vereinfachte Speicherbereinigung: Der Ansatz der Go-Sprache für Zeiger und Speicherverwaltung vereinfacht die Speicherbereinigung, da der Compiler und die Laufzeit ein klareres Verständnis der Objektlebenszyklen und Speichernutzungsmuster haben. Diese Vereinfachung führt zu einer effizienteren Speicherbereinigung und damit zu einer Verbesserung der Leistung.

Durch die Eliminierung der Zeigerarithmetik verhindert die Go-Sprache den Missbrauch von Zeigern, was zu zuverlässigerem und einfacher zu wartendem Code führt.

• Speicherverwaltung und hängende Zeiger

In der Go-Sprache ist die Speicherverwaltung aufgrund des Garbage Collectors viel einfacher als in Sprachen wie C.

<code class="language-go">var a int = 10
var p *int = &a</code>

1. Keine manuelle Speicherzuweisung/-freigabe erforderlich: Die Go-Sprache abstrahiert die Komplexität der Speicherzuweisung und -freigabe durch ihren Garbage Collector, was die Programmierung vereinfacht und Fehler minimiert.
2. Keine baumelnden Zeiger: Ein baumelnder Zeiger ist ein Zeiger, der auftritt, wenn die vom Zeiger referenzierte Speicheradresse freigegeben oder neu zugewiesen wird, ohne den Zeiger zu aktualisieren. Baumelnde Zeiger sind eine häufige Fehlerquelle in manuellen Speicherverwaltungssystemen. Der Garbage Collector von Go stellt sicher, dass ein Objekt nur dann bereinigt wird, wenn keine Verweise darauf vorhanden sind, wodurch baumelnde Zeiger wirksam verhindert werden.
3. Speicherlecks verhindern: Speicherlecks, die oft dadurch verursacht werden, dass vergessen wird, nicht mehr benötigten Speicher freizugeben, wurden in der Go-Sprache erheblich gemildert. Während in Go Objekte mit erreichbaren Zeigern nicht freigegeben werden, um Lecks aufgrund verlorener Referenzen zu verhindern, müssen Programmierer in C den Speicher sorgfältig manuell verwalten, um solche Probleme zu vermeiden.

• Nullzeigerverhalten

In der Go-Sprache führt der Versuch, einen Nullzeiger zu dereferenzieren, zu Panik. Dieses Verhalten erfordert, dass Entwickler sorgfältig mit allen möglichen Nullreferenzsituationen umgehen und versehentliche Änderungen vermeiden. Dies kann zwar den Aufwand für die Codewartung und das Debuggen erhöhen, kann aber auch als Sicherheitsmaßnahme gegen bestimmte Arten von Fehlern dienen:

<code class="language-go">func main() {
    x := 42
    p := &x
    fmt.Printf("x: %v\n", x)
    fmt.Printf("&x: %v\n", &x)
    fmt.Printf("p: %v\n", p)
    fmt.Printf("*p: %v\n", *p)

    pp := &p
    fmt.Printf("**pp: %v\n", **pp)
}</code>

Die Ausgabe weist auf eine Panik aufgrund einer ungültigen Speicheradresse oder einer Nullzeiger-Dereferenzierung hin:

<code>Value of x: 42
Address of x: 0xc000012120
Value stored in p: 0xc000012120
Value at the address p: 42
**pp: 42</code>

Da student ein Nullzeiger ist und keiner gültigen Speicheradresse zugeordnet ist, führt der Versuch, auf seine Felder (Name und Alter) zuzugreifen, zu einer Laufzeitpanik.

Im Gegensatz dazu gilt in der C-Sprache die Dereferenzierung eines Nullzeigers als unsicher. Nicht initialisierte Zeiger in C verweisen auf zufällige (undefinierte) Teile des Speichers, was sie noch gefährlicher macht. Die Dereferenzierung eines solchen undefinierten Zeigers kann dazu führen, dass das Programm weiterhin mit beschädigten Daten ausgeführt wird, was zu unvorhersehbarem Verhalten, Datenbeschädigung oder noch schlimmeren Ergebnissen führt.

Dieser Ansatz hat seine Nachteile – er führt zu einem Go-Compiler, der komplexer ist als ein C-Compiler. Infolgedessen kann diese Komplexität manchmal dazu führen, dass Go-Programme langsamer ausgeführt werden als ihre C-Gegenstücke.

• Häufiges Missverständnis: „Zeiger sind immer schneller“

Eine weit verbreitete Meinung ist, dass die Nutzung von Zeigern die Geschwindigkeit einer Anwendung verbessern kann, indem Datenkopien minimiert werden. Dieses Konzept stammt aus der Architektur von Go als einer durch Müll gesammelten Sprache. Wenn ein Zeiger an eine Funktion übergeben wird, führt die Go-Sprache eine Escape-Analyse durch, um zu bestimmen, ob die zugehörige Variable auf dem Stapel liegen oder auf dem Heap zugewiesen werden soll. Dieser Prozess ist zwar wichtig, bringt jedoch einen gewissen Mehraufwand mit sich. Wenn die Ergebnisse der Analyse darüber hinaus entscheiden, Heap für eine Variable zuzuweisen, wird mehr Zeit im Garbage Collection (GC)-Zyklus verbraucht. Diese Dynamik zeigt, dass Zeiger zwar direkte Datenkopien reduzieren, ihr Einfluss auf die Leistung jedoch subtil ist und von den zugrunde liegenden Mechanismen der Speicherverwaltung und Speicherbereinigung in der Go-Sprache beeinflusst wird.

Fluchtanalyse

Die Go-Sprache verwendet die Escape-Analyse, um den dynamischen Wertebereich in ihrer Umgebung zu bestimmen. Dieser Prozess ist ein wesentlicher Bestandteil der Art und Weise, wie die Go-Sprache die Speicherzuweisung und -optimierung verwaltet. Sein Hauptziel besteht darin, wann immer möglich Go-Werte innerhalb von Funktionsstapelrahmen zuzuweisen. Der Go-Compiler übernimmt die Aufgabe, im Voraus zu bestimmen, welche Speicherzuweisungen sicher freigegeben werden können, und gibt anschließend Maschinenanweisungen aus, um diesen Bereinigungsprozess effizient durchzuführen.

Der Compiler führt eine statische Codeanalyse durch, um zu bestimmen, ob ein Wert im Stapelrahmen der Funktion, die ihn erstellt hat, zugewiesen werden soll oder ob er auf den Heap „entkommen“ muss. Es ist wichtig zu beachten, dass die Go-Sprache keine spezifischen Schlüsselwörter oder Funktionen bereitstellt, die es Entwicklern ermöglichen, dieses Verhalten explizit zu steuern. Vielmehr sind es die Konventionen und Muster in der Art und Weise, wie der Code geschrieben wird, die diesen Entscheidungsprozess beeinflussen.

Werte können aus verschiedenen Gründen in den Heap gelangen. Wenn der Compiler die Größe der Variablen nicht bestimmen kann, wenn die Variable zu groß ist, um auf den Stapel zu passen, oder wenn der Compiler nicht zuverlässig sagen kann, ob die Variable nach Beendigung der Funktion verwendet wird, wird der Wert wahrscheinlich auf dem zugewiesen Haufen. Wenn außerdem der Funktionsstapelrahmen veraltet ist, kann dies auch dazu führen, dass Werte in den Heap entweichen.

Aber können wir endlich feststellen, ob der Wert auf dem Heap oder dem Stack gespeichert ist? Die Realität ist, dass nur der Compiler vollständig weiß, wo ein Wert zu einem bestimmten Zeitpunkt gespeichert wird.

Immer wenn ein Wert außerhalb des unmittelbaren Bereichs des Stapelrahmens einer Funktion gemeinsam genutzt wird, wird er auf dem Heap zugewiesen. Hier kommen Escape-Analysealgorithmen ins Spiel, die diese Szenarien identifizieren, um sicherzustellen, dass das Programm seine Integrität behält. Diese Integrität ist entscheidend für die Aufrechterhaltung eines genauen, konsistenten und effizienten Zugriffs auf jeden Wert im Programm. Die Escape-Analyse ist daher ein grundlegender Aspekt des Speicherverwaltungsansatzes der Go-Sprache und optimiert die Leistung und Sicherheit des ausgeführten Codes.

Sehen Sie sich dieses Beispiel an, um den grundlegenden Mechanismus hinter der Escape-Analyse zu verstehen:

<code class="language-go">var a int = 10
var p *int = &a</code>

Die

//go:noinline-Direktive verhindert, dass diese Funktionen inline sind, und stellt so sicher, dass unser Beispiel klare Aufrufe zur Veranschaulichung der Escape-Analyse zeigt.

Wir definieren zwei Funktionen, createStudent1 und createStudent2, um die unterschiedlichen Ergebnisse der Escape-Analyse zu demonstrieren. Beide Versionen versuchen, Benutzerinstanzen zu erstellen, unterscheiden sich jedoch in ihrem Rückgabetyp und der Art und Weise, wie sie mit Speicher umgehen.

1. createStudent1: Wertesemantik

Erstellen Sie in createStudent1 die Student-Instanz und geben Sie sie als Wert zurück. Das bedeutet, dass bei der Rückkehr der Funktion eine Kopie von st erstellt und an den Aufrufstapel weitergegeben wird. Der Go-Compiler stellt fest, dass &st in diesem Fall nicht auf den Heap entkommt. Dieser Wert ist im Stapelrahmen von createStudent1 vorhanden und es wird eine Kopie für den Stapelrahmen von main erstellt.

Abbildung 1 – Wertesemantik 2. createStudent2: Zeigersemantik

Im Gegensatz dazu gibt createStudent2 einen Zeiger auf die Student-Instanz zurück, der darauf ausgelegt ist, den Student-Wert über Stapelrahmen hinweg zu teilen. Diese Situation unterstreicht die entscheidende Rolle der Fluchtanalyse. Wenn gemeinsam genutzte Zeiger nicht ordnungsgemäß verwaltet werden, besteht die Gefahr, dass sie auf ungültigen Speicher zugreifen.

Wenn die in Abbildung 2 beschriebene Situation eintreten würde, würde dies ein erhebliches Integritätsproblem darstellen. Der Zeiger zeigt auf den Speicher im abgelaufenen Aufrufstapel. Nachfolgende Funktionsaufrufe von main führen dazu, dass der Speicher, auf den zuvor verwiesen wurde, neu zugewiesen und neu initialisiert wird.

Abbildung 2 – Zeigersemantik

Hier greift die Escape-Analyse ein, um die Integrität des Systems aufrechtzuerhalten. Angesichts dieser Situation stellt der Compiler fest, dass es unsicher ist, den Student-Wert innerhalb des Stapelrahmens von createStudent2 zuzuweisen. Daher wird dieser Wert stattdessen auf dem Heap zugewiesen, eine Entscheidung, die zum Zeitpunkt der Erstellung getroffen wird.

Eine Funktion kann über den Frame-Zeiger direkt auf den Speicher in ihrem eigenen Frame zugreifen. Der Zugriff auf Speicher außerhalb seines Rahmens erfordert jedoch eine Indirektion über Zeiger. Dies bedeutet, dass auch indirekt auf Werte zugegriffen wird, die dazu bestimmt sind, in den Heap zu gelangen.

In der Go-Sprache gibt der Prozess der Wertkonstruktion nicht unbedingt die Position des Werts im Speicher an. Erst beim Ausführen der return-Anweisung wird deutlich, dass der Wert auf den Heap entkommen muss.

Somit kann der Stack nach der Ausführung einer solchen Funktion so konzipiert werden, dass er diese Dynamik widerspiegelt.

Nach dem Funktionsaufruf kann der Stapel wie unten dargestellt visualisiert werden.

Die st-Variable im Stapelrahmen von createStudent2 stellt einen Wert dar, der sich auf dem Heap statt auf dem Stapel befindet. Das bedeutet, dass der Zugriff auf einen Wert mit st einen Zeigerzugriff erfordert und nicht einen direkten Zugriff, wie die Syntax nahelegt.

Um die Entscheidungen des Compilers bezüglich der Speicherzuweisung zu verstehen, können Sie einen detaillierten Bericht anfordern. Dies kann durch die Verwendung des Schalters -gcflags mit der Option -m im Befehl go build erreicht werden.

<code class="language-go">var a int = 10
var p *int = &a</code>

Bedenken Sie die Ausgabe dieses Befehls:

<code class="language-go">func main() {
    x := 42
    p := &x
    fmt.Printf("x: %v\n", x)
    fmt.Printf("&x: %v\n", &x)
    fmt.Printf("p: %v\n", p)
    fmt.Printf("*p: %v\n", *p)

    pp := &p
    fmt.Printf("**pp: %v\n", **pp)
}</code>

Diese Ausgabe zeigt die Ergebnisse der Escape-Analyse des Compilers. Hier ist die Aufschlüsselung:

• Der Compiler meldet, dass er einige Funktionen (createUser1, createUser2 und main) aufgrund einer bestimmten Direktive (go:noinline) oder weil es sich um Nicht-Blattfunktionen handelt, nicht einbinden kann.
• Für createUser1 zeigt die Ausgabe, dass der Verweis auf st innerhalb der Funktion nicht auf den Heap entkommt. Dies bedeutet, dass die Lebensdauer des Objekts auf den Stapelrahmen der Funktion beschränkt ist. Stattdessen wird während „createUser2“ angegeben, dass &st auf den Heap entkommt. Dies hängt eindeutig mit der return-Anweisung zusammen, die bewirkt, dass die innerhalb der Funktion zugewiesene Variable u in den Heap-Speicher verschoben wird. Dies ist notwendig, da die Funktion einen Verweis auf st zurückgibt, der außerhalb des Funktionsbereichs vorhanden sein muss.

Müllabfuhr

Die Go-Sprache verfügt über einen integrierten Garbage-Collection-Mechanismus, der die Speicherzuweisung und -freigabe automatisch übernimmt, im krassen Gegensatz zu Sprachen wie C/C, die eine manuelle Speicherverwaltung erfordern. Während die Garbage Collection Entwickler von der Komplexität der Speicherverwaltung entlastet, führt sie als Kompromiss zu Latenz.

Ein bemerkenswertes Merkmal der Go-Sprache ist, dass die Übergabe von Zeigern möglicherweise langsamer ist als die direkte Übergabe von Werten. Dieses Verhalten ist auf die Natur von Go als Garbage-Collected-Sprache zurückzuführen. Immer wenn ein Zeiger an eine Funktion übergeben wird, führt die Go-Sprache eine Escape-Analyse durch, um zu bestimmen, ob sich die Variable auf dem Heap oder dem Stack befinden soll. Dieser Prozess verursacht Overhead und auf dem Heap zugewiesene Variablen können die Latenz während der Garbage-Collection-Zyklen weiter verschärfen. Im Gegensatz dazu umgehen auf den Stapel beschränkte Variablen den Garbage Collector vollständig und profitieren von einfachen und effizienten Push/Pop-Vorgängen im Zusammenhang mit der Stapelspeicherverwaltung.

Die Speicherverwaltung auf dem Stapel ist von Natur aus schneller, da er über ein einfaches Zugriffsmuster verfügt, bei dem die Speicherzuweisung und -freigabe einfach durch Inkrementieren oder Dekrementieren eines Zeigers oder einer Ganzzahl erfolgt. Im Gegensatz dazu erfordert die Heap-Speicherverwaltung eine komplexere Buchhaltung für die Zuweisung und Freigabe.

Wann Zeiger in Go verwendet werden sollten

1. Große Strukturen kopieren
   Obwohl Zeiger aufgrund des Mehraufwands der Speicherbereinigung möglicherweise weniger leistungsfähig zu sein scheinen, bieten sie in großen Strukturen Vorteile. In diesem Fall kann die durch die Vermeidung des Kopierens großer Datenmengen gewonnene Effizienz den durch die Speicherbereinigung verursachten Mehraufwand überwiegen.
2. Variabilität
   Um eine an eine Funktion übergebene Variable zu ändern, muss ein Zeiger übergeben werden. Der Standardansatz der Wertübergabe bedeutet, dass alle Änderungen an der Kopie vorgenommen werden und sich daher nicht auf die ursprüngliche Variable in der aufrufenden Funktion auswirken.
3. API-Konsistenz
   Durch die konsistente Verwendung von Zeigerempfängern in der gesamten API bleibt diese konsistent. Dies ist besonders nützlich, wenn mindestens eine Methode einen Zeigerempfänger benötigt, um eine Struktur zu verändern.

Warum bevorzuge ich den Wert?

Ich bevorzuge die Übergabe von Werten anstelle von Zeigern, basierend auf ein paar Schlüsselargumenten:

1. Typ mit fester Größe
   Wir betrachten hier Typen wie Ganzzahlen, Gleitkommazahlen, kleine Strukturen und Arrays. Diese Typen behalten einen konsistenten Speicherbedarf bei, der auf vielen Systemen typischerweise gleich oder kleiner als die Größe eines Zeigers ist. Die Verwendung von Werten für diese kleineren Datentypen mit fester Größe ist sowohl speichereffizient als auch im Einklang mit Best Practices zur Minimierung des Overheads.

2. Unveränderlichkeit
   Durch die Wertübergabe wird sichergestellt, dass die empfangende Funktion eine unabhängige Kopie der Daten erhält. Diese Funktion ist von entscheidender Bedeutung, um unbeabsichtigte Nebenwirkungen zu vermeiden. Alle innerhalb einer Funktion vorgenommenen Änderungen bleiben lokal und bewahren die Originaldaten außerhalb des Funktionsumfangs. Daher fungiert der Call-by-Value-Mechanismus als Schutzbarriere und gewährleistet die Datenintegrität.

3. Leistungsvorteile der Übergabe von Werten
   Trotz der möglichen Bedenken geht die Übergabe eines Werts in vielen Fällen oft schnell und kann in vielen Fällen besser sein als die Verwendung von Zeigern:

   • Effizienz des Datenkopierens: Bei kleinen Datenmengen ist das Kopierverhalten möglicherweise effizienter als die Handhabung der Zeigerindirektion. Der direkte Zugriff auf Daten reduziert die Latenz der zusätzlichen Speicherdereferenzierung, die normalerweise bei der Verwendung von Zeigern auftritt.
   • Reduzierte Belastung des Garbage Collectors: Durch die Übergabe von Werten wird die Belastung des Garbage Collectors direkt reduziert. Da weniger Hinweise zu verfolgen sind, wird der Speicherbereinigungsprozess effizienter und die Gesamtleistung verbessert.
   • Speicherort: Als Wert übergebene Daten werden normalerweise zusammenhängend im Speicher gespeichert. Diese Anordnung kommt dem Caching-Mechanismus des Prozessors zugute und ermöglicht aufgrund einer höheren Cache-Trefferrate einen schnelleren Zugriff auf Daten. Die räumliche Lokalität des wertbasierten direkten Datenzugriffs ermöglicht erhebliche Leistungsverbesserungen, insbesondere bei rechenintensiven Vorgängen.

Fazit

Zusammenfassend lässt sich sagen, dass Zeiger in der Go-Sprache einen direkten Zugriff auf Speicheradressen ermöglichen, was nicht nur die Effizienz verbessert, sondern auch die Flexibilität von Programmiermustern erhöht und dadurch die Datenmanipulation und -optimierung erleichtert. Im Gegensatz zur Zeigerarithmetik in C ist Gos Ansatz für Zeiger darauf ausgelegt, die Sicherheit und Wartbarkeit zu verbessern, was durch das integrierte Garbage-Collection-System entscheidend unterstützt wird. Obwohl das Verständnis und die Verwendung von Zeigern und Werten in der Go-Sprache die Leistung und Sicherheit von Anwendungen tiefgreifend beeinflussen wird, leitet das Design der Go-Sprache Entwickler grundsätzlich dazu an, kluge und effektive Entscheidungen zu treffen. Durch Mechanismen wie die Escape-Analyse gewährleistet die Go-Sprache eine optimale Speicherverwaltung und gleicht die Leistungsfähigkeit von Zeigern mit der Sicherheit und Einfachheit der Wertesemantik aus. Dieses sorgfältige Gleichgewicht ermöglicht es Entwicklern, robuste, effiziente Go-Anwendungen zu erstellen und klar zu verstehen, wann und wie sie Zeiger nutzen können.

Das obige ist der detaillierte Inhalt vonZeiger in Go beherrschen: Sicherheit, Leistung und Wartbarkeit des Codes verbessern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!