string - reales - libro de android studio en español pdf

¿Cuál es la mejor manera de probar una cadena vacía en Go?

Question

¿Qué método es el mejor (más idóneo) para probar cadenas no vacías (en Go)?

if len(mystring) > 0 { }

O:

if mystring != "" { }

¿O algo mas?

Answer 1

Ambos estilos se usan dentro de las bibliotecas estándar de Go.

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

se puede encontrar en el paquete strconv : http://golang.org/src/pkg/strconv/atoi.go

if s != "" { ... }

se puede encontrar en el paquete de encoding/json : http://golang.org/src/pkg/encoding/json/encode.go

Ambos son idiomáticos y claros. Es más una cuestión de gusto personal y de claridad.

Russ Cox escribe en un hilo de golang-nuts :

El que hace que el código sea claro.
Si estoy a punto de mirar el elemento x, normalmente escribo
len (s)> x, incluso para x == 0, pero si me importa
"¿Es esta cadena específica? Tiendo a escribir s ==" ".

Es razonable suponer que un compilador maduro compilará
len (s) == 0 y s == "" en el mismo código eficiente.
En este momento 6g, etc., compila s == "" en una llamada de función
mientras len (s) == 0 no, pero eso ha estado en mi lista de tareas pendientes para arreglarlo.

Haga el código claro.

Answer 2

Esto parece ser una microoptimización prematura. El compilador es libre de producir el mismo código para ambos casos o al menos para estos dos

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

y

if s != "" { ... }

porque la semántica es claramente igual.

Answer 3

Esto sería más eficaz que recortar toda la cadena, ya que solo necesita comprobar si existe al menos un carácter no espacial

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

Answer 4

Sería más limpio y menos propenso a errores para usar una función como la siguiente:

func empty(s string) bool {
    return len(strings.TrimSpace(s)) == 0
}

Answer 5

Suponiendo que los espacios vacíos y todos los espacios en blanco iniciales y finales deben eliminarse:

import "strings"
if len(strings.TrimSpace(s)) == 0 { ... }

Answer 6

Verificar la longitud es una buena respuesta, pero también podría representar una cadena "vacía" que también es solo un espacio en blanco. No está "técnicamente" vacío, pero si desea 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!")
  }
}