Was ist eine Golang-Behauptung?

Es gibt eine Grammatik in der Go-Sprache, die direkt bestimmen kann, ob es sich um eine Variable dieses Typs handelt: value, ok = element.(T), wobei value der Wert der Variablen ist und ok ist ein bool-Typ, element ist die Schnittstellenvariable und T ist der bestätigte Typ.

Wenn das Element einen Wert vom Typ T speichert, gibt ok „true“ zurück, andernfalls gibt es „false“ zurück.

package main
 
import (
  "fmt"
)
 
type Order struct {
  ordId   int
  customerId int
  callback func()
}
 
func main() {
  var i interface{}
  i = Order{
    ordId:   456,
    customerId: 56,
  }
  value, ok := i.(Order)
  if !ok {
    fmt.Println("It's not ok for type Order")
    return
  }
  fmt.Println("The value is ", value)
}

Ausgabe:

The value is  {456 56 <nil>}

Es ist auch üblich, den Schalter zu verwenden, um Folgendes zu bestätigen:

package main
 
import (
  "fmt"
)
 
type Order struct {
  ordId   int
  customerId int
  callback func()
}
 
func main() {
  var i interface{}
  i = Order{
    ordId:   456,
    customerId: 56,
  }
  switch value := i.(type) {
    case int:
      fmt.Printf("It is an int and its value is %d\n", value)
    case string:
      fmt.Printf("It is a string and its value is %s\n", value)
    case Order:
      fmt.Printf("It is a Order and its value is %v\n", value)
    default:
      fmt.Println("It is of a different type")
    }
}

Ausgabe:

It is a Order and its value is {456 56 <nil>}

Die Golang-Sprache stellt die Behauptungsfunktion bereit. Alle Programme in Golang implementieren die Schnittstelle {}, was bedeutet, dass alle Typen wie String, Int, Int64 und sogar benutzerdefinierte Strukturtypen die Schnittstelle {} haben. Der Objekttyp ist relativ ähnlich. Wenn dann ein Datenelement über func funcName(interface{}) übergeben wird, bedeutet dies, dass der Parameter automatisch in den Typ interface{} konvertiert wird.

Zum Beispiel der folgende Code:

func funcName(a interface{}) string {
     return string(a)
}

Der Compiler gibt Folgendes zurück:

cannot convert a (type interface{}) to type string: need type assertion

Zu diesem Zeitpunkt bedeutet dies, dass der gesamte Konvertierungsprozess eine Typzusicherung erfordert. Typzusicherungen haben die folgenden Formen:

Direkte Zusicherungen verwenden

var a interface{}
fmt.Println("Where are you,Jonny?", a.(string))

, aber wenn die Zusicherung fehlschlägt, kommt es im Allgemeinen zu Panik. Um also das Auftreten von Panik zu verhindern, müssen wir bestimmte Urteile fällen, bevor wir etwas behaupten.

value, ok := a.(string)

Wenn die Behauptung fehlschlägt, ist der Wert von ok falsch, aber wenn die Behauptung erfolgreich ist, ist der Wert von ok wahr und der Wert erhält den korrekten erwarteten Wert. Beispiel:

value, ok := a.(string)
if !ok {
    fmt.Println("It's not ok for type string")
    return
}
fmt.Println("The value is ", value)

Darüber hinaus können Sie auch die switch-Anweisung verwenden, um ein Urteil zu fällen:

var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
    fmt.Printf("unexpected type %T", t)       // %T prints whatever type t has
case bool:
    fmt.Printf("boolean %t\n", t)             // t has type bool
case int:
    fmt.Printf("integer %d\n", t)             // t has type int
case *bool:
    fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
case *int:
    fmt.Printf("pointer to integer %d\n", *t) // t has type *int
}

Fügen Sie außerdem ein paar Tipps für die Go-Sprachprogrammierung hinzu:

( 1) Wenn es die Anforderungen nicht erfüllt, können Sie so schnell wie möglich zurückkehren und die Verwendung von else-Anweisungen reduzieren, was intuitiver sein kann.

(2) Wenn es sich beim Konvertieren des Typs um eine Zeichenfolge handelt, ist keine Bestätigung erforderlich. Verwenden Sie die Funktion fmt.Sprint(), um den gewünschten Effekt zu erzielen.

(3) Variablen können in Gruppen definiert und deklariert werden, wie zum Beispiel:

var (
   a string
   b int
   c int64
   ...
)
import (
    "fmt"
    "strings"
    "net/http"
   ...
)

(4) Die Funktionslogik ist relativ komplex und einige Logik kann zur Verbesserung der Lesbarkeit in eine Funktion gekapselt werden .

(5) Funktionen, die das Paket net/http und das Paket net/url verwenden, verfügen möglicherweise über eine URL-Kodierungsfunktion, daher müssen Sie darauf achten.

Die chinesische PHP-Website bietet eine große Anzahl kostenloser Golang-Einführungs-Tutorials, die jeder gerne lernen kann!

Das obige ist der detaillierte Inhalt vonWas ist eine Golang-Behauptung?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!