Comment avoir une fonction avec un paramètre de chaîne Nullable dans Go?

Question

Je suis habitué à Java's String où nous pouvons passer null plutôt que "" pour des significations spéciales, comme utiliser une valeur par défaut.

Dans Go, chaîne est un type primitif, donc je ne peux pas passer nil (null) à un paramètre qui nécessite une chaîne.

Je pourrais écrire la fonction en utilisant le type de pointeur, comme ceci:

func f(s *string) 

si l'appelant peut appeler cette fonction soit comme

f(nil) 

ou

// not so elegant 
temp := "hello"; 
f(&temp) 

mais ce qui suit malheureusement pas permis:

// elegant but disallowed 
f(&"hello"); 

Quelle est la meilleure façon d'avoir un paramètre qui reçoit soit une chaîne ou nil?

Answer 1

N'attendez pas vraiment la réponse: mais la valeur de déformation dans une structure peut fournir une méthode d'utilité générique. (Haskell Maybe?)

//#maybe.go 
package maybe 

import "log" 

type MayHaveValue struct { 
IsValue bool; 
} 

func (this MayHaveValue) IsJust() bool { 
return this.IsValue 
} 

type AString struct { 
MayHaveValue; 
Value string; 
} 

func String(aString string) AString { 
return AString{MayHaveValue{true}, aString} 
} 

var NoString AString = AString{MayHaveValue{false}, ""} 

func (this AString) String() (value string) { 
if this.IsJust() == true { 
    value = this.Value; 
} else { 
    log.Crash("Access to non existent maybeString value"); 
} 
return; 
} 

func (this AString) OrDefault(defaultString string) (value string) { 
if this.IsJust() { 
    value = this.Value; 
} else { 
    value = defaultString; 
} 
return; 
} 

//#main.go 
package main 

import "fmt" 
import "maybe" 

func say(canBeString maybe.AString) { 
if canBeString.IsJust() { 
    fmt.Printf("Say : %v\n", canBeString.String()); 
} else { 
    fmt.Print("Nothing to say !\n"); 
} 
} 

func sayMaybeNothing (canBeString maybe.AString) { 
fmt.Printf("Say : %v\n", canBeString.OrDefault("nothing")); 
} 

func main() { 
aString := maybe.String("hello"); 
say(aString); 
sayMaybeNothing(aString); 
noString := maybe.NoString; 
say(noString); 
sayMaybeNothing(noString); 
} 

Answer 2

Je pensais un peu plus sur la façon dont je mettre en œuvre cette aide d'un struct. Voici ce que je suis venu avec:

type MyString struct { 
    val string; 
} 

func f(s MyString) { 
    if s == nil { 
     s = MyString{"some default"}; 
    } 
    //do something with s.val 
} 

Ensuite, vous pouvez appeler f comme ceci:

f(nil); 
f(MyString{"not a default"}); 

Answer 3

lâche Java-penser et passer juste f (""). Ensuite, test à l'aide len():

func f (string str) { si len (str)> 0 {... } else { ...} }

Soit la chaîne est vide et a une signification sémantique de votre cas, ou bien a des données de chaîne à traiter. Je ne vois pas le problème avec ça.

Answer 4

Je sais que je suis super en retard pour cette fête, mais je l'ai trouvé en cherchant un problème similaire, et j'ai pensé que j'ajouterais ma solution pour la postérité.

En fonction de votre utilisation, l'utilisation d'un variadic function peut être votre ami. Cela vous permet d'entrer zéro ou plusieurs arguments du même type à une fonction, qui sont reçus dans la fonction en tant que tableau.

// My variadic function 
func f(s string...) { 
    if length(s) == 0 { 
    // We got a NULL 
    fmt.Println("default value") 
    } else { 
    // We got a value 
    fmt.Println(s[0]) 
    } 
} 

f() // works! 
f("has a value") // works! 

Cette solution nécessite que vous sachiez que vous allez passer à zéro au moment du développement; vous ne pouvez pas simplement appeler f(nil) et le faire fonctionner. Mais, si ce n'est pas un problème dans votre cas d'utilisation particulier, cela pourrait être une solution très élégante qui ne nécessite pas de définir des types de données supplémentaires.