studio - Qual é a melhor maneira de testar uma string vazia no Go?




string vazia é null (5)

Qual método é melhor (mais idiomático) para testar strings não vazias (em Go)?

if len(mystring) > 0 { }

Ou:

if mystring != "" { }

Ou alguma outra coisa?


A partir de agora, o compilador Go gera código idêntico em ambos os casos, por isso é uma questão de gosto. O GCCGo gera código diferente, mas quase ninguém usa, então eu não me preocuparia com isso.

https://godbolt.org/z/fib1x1


Ambos os estilos são usados ​​nas bibliotecas padrão do Go.

if len(s) > 0 { ... }

pode ser encontrado no pacote strconv : http://golang.org/src/pkg/strconv/atoi.go

if s != "" { ... }

pode ser encontrado no pacote encoding/json : http://golang.org/src/pkg/encoding/json/encode.go

Ambos são idiomáticos e são suficientemente claros. É mais uma questão de gosto pessoal e de clareza.

Russ Cox escreve em um tópico de golang-nuts :

Aquele que faz o código claro.
Se eu estou prestes a olhar para o elemento x eu normalmente escrevo
len (s)> x, mesmo para x == 0, mas se eu me preocupo com
"é essa string específica" eu costumo escrever s == "".

É razoável supor que um compilador maduro irá compilar
len (s) == 0 e s == "" no mesmo código eficiente.
Agora mesmo 6g etc compile s == "" em uma chamada de função
enquanto len (s) == 0 não é, mas isso está na minha lista de tarefas a ser corrigida.

Faça o código claro.


Esta parece ser uma microoptimização prematura. O compilador está livre para produzir o mesmo código para ambos os casos ou pelo menos para esses dois

if len(s) != 0 { ... }

e

if s != "" { ... }

porque a semântica é claramente igual.


Isso teria mais desempenho do que aparar toda a string, já que você só precisa verificar pelo menos um único caractere não-espacial existente

// Strempty checks whether string contains only whitespace or not
func Strempty(s string) bool {
    if len(s) == 0 {
        return true
    }

    r := []rune(s)
    l := len(r)

    for l > 0 {
        l--
        if !unicode.IsSpace(r[l]) {
            return false
        }
    }

    return true
}

Verificar a duração é uma boa resposta, mas você também pode explicar uma string "vazia" que também é apenas espaço em branco. Não "tecnicamente" vazio, mas se você quiser verificar:

package main

import (
  "fmt"
  "strings"
)

func main() {
  stringOne := "merpflakes"
  stringTwo := "   "
  stringThree := ""

  if len(strings.TrimSpace(stringOne)) == 0 {
    fmt.Println("String is empty!")
  }

  if len(strings.TrimSpace(stringTwo)) == 0 {
    fmt.Println("String two is empty!")
  }

  if len(stringTwo) == 0 {
    fmt.Println("String two is still empty!")
  }

  if len(strings.TrimSpace(stringThree)) == 0 {
    fmt.Println("String three is empty!")
  }
}




is-empty