¿Cómo tener una función con un parámetro de cadena anulable en Go?

Question

Estoy acostumbrado a Java's String donde podemos pasar null en lugar de "" para significados especiales, como , use un valor predeterminado.

En Go, la cadena es un tipo primitivo, por lo que no puedo pasar nil (nulo) a un parámetro que requiere una cadena.

podría escribir la función utilizando un tipo de puntero, como esto:

func f(s *string) 

que realiza la llamada puede llamar a esa función, ya sea como

f(nil) 

o

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

pero el siguiente es desafortunadamente no permitido:

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

¿Cuál es la mejor manera de tener un parámetro que reciba una cadena o nulo?

Answer 1

Respuesta realmente no válida: pero el valor warping en una estructura puede proporcionar algún método genérico de utilidad. (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

pensé un poco más acerca de cómo iba a poner en práctica esta usando un struct. Esto es lo que ocurrió:

type MyString struct { 
    val string; 
} 

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

A continuación, puede llamar a f así:

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

Answer 3

suelta el Java-pensar y sólo tiene que pasar f (""). A continuación, prueba usando len():

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

O bien la cadena de está vacío y tiene un significado semántico de nil caso, o bien tiene algunos datos de cadena para procesar. No puedo ver el problema con eso.

Answer 4

Sé que estoy muy tarde para esta fiesta, pero encontré esto mientras buscaba un problema similar, y pensé en agregar mi solución para la posteridad.

Dependiendo de su caso de uso, utilizando un variadic function puede ser su amigo. Esto le permite ingresar cero o más argumentos del mismo tipo a una función, que se reciben dentro de la función como una matriz.

// 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! 

Esta solución requiere que usted sabe que va a estar pasando en un nulo en el tiempo de desarrollo; no puede simplemente llamar al f(nil) y hacer que funcione. Pero, si esto no es un problema en su caso de uso particular, podría ser una solución muy elegante que no requiera que defina ningún tipo de datos adicionales.