Comment utiliser iota dans Go

La colonne tutorielle suivante de golang vous présentera comment utiliser iota dans Go. J'espère qu'elle sera utile aux amis dans le besoin !

Introduction

Le langage Go ne prend en fait pas directement en charge le mot-clé d'énumération. Généralement, nous implémentons des capacités d'énumération via const + iota.

Quelqu’un se demandera peut-être pourquoi devons-nous utiliser des énumérations ? Il y a une réponse très appréciée sur stackoverflow, comme suit :

Vous devez toujours utiliser des énumérations lorsqu'une variable (en particulier un paramètre de méthode) ne peut en prendre qu'une sur un petit ensemble de valeurs possibles. Des exemples seraient des éléments tels que des constantes de type (statut du contrat : « permanent », « temporaire », « apprenti ») ou des indicateurs (« exécuter maintenant », « différer l'exécution ») si vous utilisez des énumérations au lieu d'entiers (ou de codes de chaîne). , vous augmentez la vérification au moment de la compilation et évitez les erreurs de transmission de constantes non valides, et vous documentez quelles valeurs sont légales à utiliser. BTW, la surutilisation des énumérations peut signifier que vos méthodes en font trop (il est souvent préférable d'en avoir plusieurs). méthodes distinctes, plutôt qu'une méthode qui prend plusieurs indicateurs qui modifient ce qu'elle fait), mais si vous devez utiliser des indicateurs ou saisir des codes, les énumérations sont la voie à suivre.

Une traduction simple, deux les points sont très importants.

• Lorsqu'une variable (en particulier un paramètre de méthode) ne peut prendre qu'une valeur parmi un petit nombre de valeurs possibles, une énumération doit être utilisée.
  Par exemple, saisissez des constantes (statut du contrat : permanent, intérimaire, apprenti) ou un indicateur d'exécution immédiate ou différée lors de l'exécution d'un programme de tâches.
• Si vous utilisez des énumérations au lieu d'entiers, des vérifications au moment de la compilation seront ajoutées pour éviter que des valeurs invalides incorrectes ne soient transmises et enregistrer quelles valeurs sont légales à utiliser.

Comment implémenter une énumération

iota est une constante spéciale prédéclarée dans Go. Il sera prédéclaré à 0, mais sa valeur n'est pas fixée au stade de la compilation. Lorsque le iota prédéclaré apparaît dans une déclaration de constante, sa valeur dans la nième description de la constante est n (commence à partir de 0). Cela n'a donc de sens que s'il existe plusieurs déclarations constantes du même type.

Par exemple, comme tout le monde le sait sur le commerce électronique, le système de commande impliquera certainement le flux de l'état des commandes. Donc à ce moment-là, nous pouvons généralement faire ceci :

package mainimport "fmt"type OrderStatus intconst (
  Cancelled OrderStatus = iota //订单已取消 0  NoPay OrderStatus = iota //未支付  1  PendIng OrderStatus = iota // 未发货 2  Delivered OrderStatus = iota // 已发货 3  Received OrderStatus = iota // 已收货 4)func main() {
  fmt.Println(Cancelled, NoPay) // 打印:0,1}

Bien sûr, cela semble très gênant. En fait, d'autres constantes peuvent répéter l'expression iota de la ligne précédente, et nous pouvons la remplacer par celle-ci.

package mainimport "fmt"type OrderStatus intconst (
  Cancelled OrderStatus = iota //订单已取消 0  NoPay //未支付 1  PendIng // 未发货 2  Delivered // 已发货 3  Received // 已收货 4)func main() {
  fmt.Println(Cancelled, NoPay) // 打印:0,1}

Quelqu'un peut-il utiliser une valeur de 0 pour représenter le statut ? Généralement non, si nous voulons commencer par 1, alors nous pouvons le faire.

package mainimport "fmt"type OrderStatus intconst (
  Cancelled OrderStatus = iota+1 //订单已取消 1
  NoPay //未支付 2  PendIng // 未发货 3  Delivered // 已发货 4  Received // 已收货 5)func main() {
  fmt.Println(Cancelled, NoPay) // 打印:1,2}

Nous voulons également sauter un nombre après Delivered pour être la valeur de Received, qui est Received=6, nous pouvons alors utiliser le symbole _.

package mainimport "fmt"type OrderStatus intconst (
  Cancelled OrderStatus = iota+1 //订单已取消 1
  NoPay //未支付 2  PendIng // 未发货 3  Delivered // 已发货 4  _
 Received // 已收货 6)func main() {
  fmt.Println(Received) // 打印:6}

C'est bien de le faire en cours de route, et bien sûr, c'est bien de le faire à l'envers.

package mainimport "fmt"type OrderStatus intconst (
  Max = 5)const (
  Received OrderStatus = Max - iota // 已收货  5  Delivered // 已发货 4  PendIng // 未发货 3  NoPay //未支付 2  Cancelled //订单已取消 1)func main() {
  fmt.Println(Received,Delivered) // 打印:5,4}

Vous pouvez également utiliser des opérations sur bits, par exemple, il y a un tel morceau de code sur la serrure dans le package sync dans le code source go.

const (
 mutexLocked = 1 << iota  //1<<0 mutexWoken               //1<<1 mutexStarving            //1<<2 mutexWaiterShift = iota  //3
)

func main() {
 fmt.Println("mutexLocked的值",mutexLocked) //打印：1 fmt.Println("mutexWoken的值",mutexWoken) //打印：2 fmt.Println("mutexStarving的值",mutexStarving) //打印：4 fmt.Println("mutexWaiterShift的值",mutexWaiterShift) // 打印：3}

Peut-être que certaines personnes définissent généralement des valeurs constantes directement ou utilisent des chaînes pour les représenter.

Par exemple, je peux utiliser string pour représenter ce qui précède. J'ai en fait vu des chaînes utilisées pour représenter le statut de la commande.

package main

import "fmt"

const (
  Cancelled = "cancelled"  NoPay = "noPay"  PendIng = "pendIng"  Delivered = "delivered"  Received = "received")

var OrderStatusMsg = map[string]string{
  Cancelled: "订单已取消",
  NoPay:     "未付款",
  PendIng:   "未发货",
  Delivered: "已发货",
  Received:  "已收货",
}

func main() {
  fmt.Println(OrderStatusMsg[Cancelled])
}

Ou définissez directement la valeur constante entière.

package main

import "fmt"

const (
  Cancelled = 1  NoPay = 2  PendIng = 3  Delivered = 4  Received = 5)

var OrderStatusMsg = map[int]string{
  Cancelled: "订单已取消",
  NoPay:     "未付款",
  PendIng:   "未发货",
  Delivered: "已发货",
  Received:  "已收货",
}

func main() {
  fmt.Println(OrderStatusMsg[Cancelled])
}

En fait, les deux choses ci-dessus sont possibles, mais utiliser iota présente plus d'avantages.

• peut garantir l'unicité d'un ensemble de constantes, mais pas la définition manuelle.
• Peut partager le même comportement pour un groupe d'actions.
• Évitez les valeurs invalides.
• Améliorez la lisibilité et la maintenance du code.

Extension

Suivez ce que nous avons démontré ci-dessus, et enfin nous pouvons le faire.

package main

import (
 "fmt")

type OrderStatus int

const (
  Cancelled OrderStatus = iota + 1 //订单已取消 1  NoPay //未支付 2  PendIng // 未发货 3  Delivered // 已发货 4  Received // 已收货 5)

//公共行为 赋予类型 String() 函数，方便打印值含义
func (order OrderStatus) String() string { return [...]string{"cancelled", "noPay", "pendIng", "delivered", "received"}[order-1]
}

//创建公共行为 赋予类型 int 函数 EnumIndex()
func (order OrderStatus) EnumIndex() int { return int(order)
}

func main() {
 var order OrderStatus = Received
  fmt.Println(order.String())    // 打印:received
  fmt.Println(order.EnumIndex()) // 打印:5
}

Résumé

Cet article présente principalement l'utilisation de Golang dans iota et pourquoi nous devrions l'utiliser.

Je ne sais pas quelles astuces vous utilisez habituellement pour ce genre de scène, merci de laisser un message ci-dessous pour échanger. ＜

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!