Das Schlüsselwort des Go-Elements lautet: Chan-Kanal

HTML-Validierung bezieht sich auf die HTML-Validierung. Dabei handelt es sich um einen Prozess zur Analyse von HTML-Dokumenten und zur Markierung von Fehlern und nicht standardmäßigem Code durch Vergleich mit Standard-HTML-Regeln. Webseiten werden mit HTML gerendert, und HTML selbst übernimmt HTML-Spezifikationen als Regeln und Standards. Validieren Sie HTML-Code über mehrere Browserstandards hinweg!

chan

chan wird auch Kanal genannt. Seine Form ähnelt einer Pipe. Der Inhalt wird von einem Ende eingesendet und vom anderen Ende ausgelesen. Im Folgenden wird beschrieben, wie Sie einen Kanal definieren:

var 变量名 chan dataType

Bei der Definition eines Kanals müssen Sie den Datentyp angeben, was bedeutet, dass nur Variablen des angegebenen Datentyps den Kanal passieren dürfen.

Kanal initialisieren

Beim Initialisieren von Kanaltypvariablen in Golang kann der Kanal in zwei Situationen unterteilt werden: eine ist ein gepufferter Kanal und die andere ist ein ungepufferter Kanal.
Lassen Sie uns die Initialisierungsmethoden in den folgenden zwei Situationen vorstellen:

// 初始化不带缓冲的通道，通道中数据类型是intvar ch1 = make(chan int)// 初始化带10个缓冲的通道，通道中数据类型是stringvar ch2 = make(chan string,10)

Eine andere Möglichkeit, es zu schreiben, besteht darin, den Kanal zu definieren und zu initialisieren,

// 定义通道，并给通道初始化8个缓冲ch3 ：= make(chan int ,8)// 定义通道，并初始化为不带缓冲通道ch4 := make(chan string)

Kanalzuweisung

Sowohl das Lesen als auch das Schreiben des Kanals kann in einen Blockierungszustand geraten.

1. Ein Kanal ohne Pufferung blockiert beim Schreiben. Die Blockierung endet erst, wenn die Informationen im Kanal gelesen wurden.

2. Gepufferter Kanal, jedes Mal, wenn Informationen in den Kanal geschrieben werden, wird die Kanallänge um 1 erhöht, und jedes Mal, wenn Informationen erfolgreich vom Kanal gelesen werden, wird die Kanallänge verringert um 1. Wenn die Kanallänge gleich der Kanalpufferlänge ist, führt das weitere Schreiben von Informationen in den Kanal zu einer Blockierung des Programms. Wenn die Kanallänge kleiner als die Kanalpufferlänge ist, führt das Schreiben von Informationen in den Kanal nicht zu einer Blockierung. Wenn die Kanallänge 5 beträgt, führt das sechste Schreiben von Informationen in den Kanal dazu, dass das Programm blockiert, wenn der Kanal nicht gelesen wurde.

Das Syntaxformat für das Schreiben von Kanälen lautet:

var ch = make(chan string,10)// 将字符串”hello"写入到通道中，通道长度加1ch <- "hello"

Kanal lesen

Der Kanal ist leer
1. Wenn der Kanal nicht geschlossen ist, wechselt das Programm in einen Sperrzustand und wartet, bis Informationen in den Kanal geschrieben werden
2. Der Kanal wurde geschlossen und wird nicht blockiert. Der Anfangswert des Datentyps im Kanal (dirty data) wird zurückgegeben. Wenn der Kanal beispielsweise chan int ist, ist der Rückgabewert 0. Wenn der Kanal chan ist string, der Rückgabewert ist leer.
Der Kanal ist nicht leer
1. Der Kanal ist nicht einmal geschlossen. Nachdem der Lesevorgang abgeschlossen ist, fahren Sie mit der Ausführung fort
2. Der Kanal wurde einmal geschlossen. Nachdem der Lesevorgang abgeschlossen ist, fahren Sie mit dem Vorgang

zum Lesen des Kanals fort:

val,ok := <-ch

Verwenden Sie die Behauptung, um zu lesen Kanal Der Wert in prüft, ob der Kanal noch Inhalt hat, und bestimmt, ob der Kanal geschlossen wurde. Wenn der Kanal keine Informationen enthält und der Kanal geschlossen wurde, ist der ok-Wert falsch. Wenn der Kanal jedoch keine Informationen enthält, blockiert das Programm. Wenn der Kanal Inhalte enthält, ist der ok-Wert wahr.

Eine andere Möglichkeit, einen Kanal zu lesen, ohne Behauptungen zu verwenden

val := <-ch

Schreiben und Lesen eines Kanals

Beispiel für das Lesen eines Kanals ohne Pufferung Methode:

package mainimport (    "fmt")func main() {    // 定义一个不带缓冲的通道，通道中数据类型是int
    var c = make(chan int)    // 开启一个携程，读取通道中的内容
    go func() {
        fmt.Println("写入信息是：", <-c)
    }()    // 向通道中写入数据
    c <- 1}

Ausgabeergebnis:

写入信息是： 1

Beim Lesen und Schreiben eines gepufferten Kanals erfolgt keine Blockierung, solange die Datenlänge im Kanal nicht größer als die Pufferlänge ist Bei gepufferten Kanälen erfolgt keine Blockierung, wenn kein Inhalt im Kanal vorhanden ist. Daher wirken sich gepufferte Kanäle nur auf Schreibvorgänge aus. Hier ist ein Beispiel:

package mainimport (    "fmt")func main() {    var c = make(chan int, 3)
    c <- 1
    c <- 2
    c <- 3
    //c <- 4
    fmt.Println("end")
}

Die Ausgabeinformationen lauten:

end

Wenn Inhalte in einen Kanal mit 3 Puffern geschrieben werden, ist die Länge des Kanals genau gleich, da er nur dreimal geschrieben wird bis Die Länge des Puffers bedeutet, dass das Programm nicht blockiert ist. Wenn der Kommentar vor c <- 4 entfernt wird, gerät das Hauptprogramm in einen Deadlock-Zustand und verursacht eine Ausnahme, da kein Programm zum Lesen dieses Kanals vorhanden ist.

Coroutine-Kommunikation

Eine Kanaltypvariable ist im Wesentlichen eine Adresse, wie im folgenden Beispielcode gezeigt:

package mainimport (    "fmt")func main() {    var c = make(chan int, 3)
    fmt.Println(c)
}

Ausgabeergebnis:

0xc042072080

Wenn also die Kanaltypvariable als Parameter an die Funktion übergeben wird, kann der Wert im Kanal direkt in der Funktion geändert werden. Obwohl es sich bei der Variablen vom Typ Chan um eine Adresse handelt, erlaubt Golang nicht die Verwendung des Wertoperators (*) zum Betreiben der Variablen vom Typ Chan. Wenn Sie jedoch zuerst den Adressoperator (&) für die Variable vom Typ chan und dann den Wertoperator (*) verwenden, kann diese Operationsmethode weiterhin normal ausgeführt werden, hat jedoch keine große Bedeutung, es sei denn, Ihr Zweck besteht im Funktionsaufruf. Definieren Sie eine Variable vom Typ Chan neu, um die ursprüngliche Variable zu ersetzen.

Diese Funktionen von Chan können die Synchronisationsfunktion zwischen Coroutinen effektiv realisieren. Der ungepufferte Kanal ist ein Null-Toleranz-Wartekanal, der eine erzwungene Synchronisation erreichen kann; der gepufferte Kanal ist ein gewisser Toleranzbereich und kann eine Synchronisation erreichen, die einen bestimmten Zeitunterschied zulässt.

Einfaches Beispiel für die Kommunikation zwischen Coroutinen:

package mainimport (    "fmt"
    "time")func main() {    var c = make(chan int)    go func() {
        fmt.Println("待命模式：")        // 读取通道时产生阻塞，等待其他协程向通道写入信息
        fmt.Println("命令代码是：", <-c)
    }()    go func() {        // 延时3秒，向通道中写入信息
        time.Sleep(time.Second * 3)
        fmt.Println("发送命令：")
        c <- 8
        close(c)
    }()
    time.Sleep(time.Second * 5)
    fmt.Println("执行完成")
}

Die Ausgabeinformationen sind:

待命模式：
发送命令：
命令代码是： 8
执行完成

Verwandte Empfehlungen:

HTML validieren HTML validation_HTML /Xhtml_Web Seitenproduktion

HTML-Kompilierung_CSS/HTML

Das obige ist der detaillierte Inhalt vonDas Schlüsselwort des Go-Elements lautet: Chan-Kanal. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!