Qu'est-ce que l'affirmation Golang ?

Il existe une grammaire dans le langage Go qui permet de déterminer directement s'il s'agit d'une variable de ce type : valeur, ok = élément.(T), où valeur est la valeur du variable, et ok est un type booléen, element est la variable d'interface et T est le type affirmé.

Si l'élément stocke une valeur de type T, alors ok renvoie vrai, sinon il renvoie faux.

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)
}

Sortie :

The value is  {456 56 <nil>}

Il est également courant d'utiliser switch pour affirmer :

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")
    }
}

Sortie :

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

Le langage golang fournit la fonction d'assertion. Tous les programmes de Golang implémentent l'interface{}, ce qui signifie que tous les types tels que les types string, int, int64 et même les types de structure personnalisés ont l'interface{}. Cette approche est similaire à celle de Java. Le type Object est relativement similaire. Ensuite, lorsqu'une donnée est transmise via func funcName(interface{}), cela signifie que le paramètre est automatiquement converti en type d'interface{}.

Par exemple, le code suivant :

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

Le compilateur retournera :

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

À ce stade, cela signifie que l'ensemble du processus de conversion nécessite une assertion de type. Les assertions de type ont les formes suivantes :

L'assertion directe utilise

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

, mais si l'assertion échoue, la panique se produira généralement. Ainsi, afin d’éviter la panique, nous devons porter certains jugements avant d’affirmer.

value, ok := a.(string)

Si l'assertion échoue, la valeur de ok sera fausse, mais si l'assertion réussit, la valeur de ok sera vraie et la valeur obtiendra la valeur correcte attendue. Exemple :

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

De plus, vous pouvez également utiliser l'instruction switch pour porter un jugement :

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
}

De plus, ajoutez quelques conseils pour la programmation en langage Go :

( 1) Si cela ne répond pas aux exigences, vous pouvez revenir aussi vite que possible et réduire l'utilisation des instructions else, qui peuvent être plus intuitives.

(2) Lors de la conversion du type, s'il s'agit d'une chaîne, il n'est pas nécessaire d'affirmer. Utilisez la fonction fmt.Sprint() pour obtenir l'effet souhaité.

(3) Les variables peuvent être définies et déclarées en groupes, tels que :

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

(4) La logique de la fonction est relativement complexe et une partie de la logique peut être encapsulée dans une fonction pour améliorer la lisibilité. .

(5) Les fonctions qui utilisent le package net/http et le package net/url peuvent avoir une fonction d'encodage d'URL, vous devez donc y faire attention.

Le site Web PHP chinois propose un grand nombre de tutoriels d'introduction à Golang gratuits, tout le monde est invité à apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!