Go n'avait pas d'opérateur logique pour l'évaluation sans court-circuit

Je n'y ai pas prêté beaucoup d'attention, mais j'ai trébuché, alors j'ai pris note. Puisque le package et les instructions d'importation sont omis, veuillez vérifier le lien pour le code complet.

La version Go du code ci-dessous est «go1.14.9».

TL;DR ** Go n'a pas d'opérateur logique pour l'évaluation sans court-circuit, donc si vous incluez une fonction **

• ** Évaluer à l'avance ou **
• ** La fonction doit être écrite sur le côté gauche **

Point de trébuchement

Supposons que vous ayez un code comme celui-ci:

https://play.golang.org/p/en49-fRSNLU

func main() {
	funcCalled := true
	funcCalled = funcCalled || returnFalse()
	fmt.Println(funcCalled)
}

func returnFalse() bool {
	fmt.Println("returnFalse() called")
	return false
}

true

Program exited.

Je voulais appeler returnFalse () à chaque fois, mais je n'ai jamais eu " returnFalse () appelé ".

c'est**||Est-ce que l'évaluation du court-circuit et le côté gauche esttrueDans le cas de, le côté droit n'est pas évalué et le processus est terminé.**est.

DoncfuncCalled = funcCalled || returnFalse()Est

--À cause de funcCalled: = true --Le traitement est terminé sans évaluer returnFalse () sur le côté droit.

Solution

Pour appeler returnFalse (), c'est généralement

1. ** Appelez la fonction à l'avance et évaluez-la **
2. funcCalled = returnFalse() || funcCalledÉcrivez d'abord l'appel de fonction, comme
3. ** Utilisez l'opérateur logique «|» qui n'est pas une évaluation de court-circuit **

Modifiez à l'un des.

Premièrement, lorsque la fonction est appelée et évaluée à l'avance.

https://play.golang.org/p/EKTl6cQqsmx

func main() {
	funcCalled := true
	result := returnFalse() //Évaluer à l'avance
	funcCalled = result || funcCalled
	fmt.Println(funcCalled)
}

func returnFalse() bool {
	fmt.Println("returnFalse() called")
	return false
}

returnFalse() called
true

Program exited.

C'est bon.

Ensuite, lorsque l'appel de fonction de 2, est décrit en premier.

https://play.golang.org/p/Iq2jqGVE1j7

func main() {
	funcCalled := true
	funcCalled = returnFalse() || funcCalled //Écrivez d'abord l'appel de fonction
	fmt.Println(funcCalled)
}

func returnFalse() bool {
	fmt.Println("returnFalse() called")
	return false
}

returnFalse() called
true

Program exited.

Cela semble bon.

Enfin, si vous utilisez l'opérateur logique «|» qui n'est pas une évaluation de court-circuit de 3.

https://play.golang.org/p/aNMVkYBw7LI

func main() {
	funcCalled := true
	funcCalled = funcCalled | returnFalse() //Utilisez des opérateurs qui ne sont pas une évaluation de court-circuit
	fmt.Println(funcCalled)
}

func returnFalse() bool {
	fmt.Println("returnFalse() called")
	return false
}

./prog.go:9:26: invalid operation: funcCalled | returnFalse() (operator | not defined on bool)

Go build failed.

J'ai une erreur. N'est-il pas défini?

Jetons un coup d'œil aux spécifications du langage.

https://golang.org/ref/spec#Logical_operators

Logical operators apply to boolean values and yield a result of the same type as the operands. The right operand is evaluated conditionally.

&&    conditional AND    p && q  is  "if p then q else false"
||    conditional OR     p || q  is  "if p then true else q"
!     NOT                !p      is  "not p"

Cela ne semblait pas défini.

Conclusion

** Go n'a pas d'opérateur logique pour l'évaluation sans court-circuit, donc si vous incluez une fonction **

• ** Évaluer à l'avance ou **
• ** La fonction doit être écrite sur le côté gauche **