Estrazione di sottostringhe in Go

Sto cercando di leggere un'intera riga dalla console (compresi gli spazi bianchi), quindi elaborarla. Usando bufio.ReadString, il carattere di nuova riga viene letto insieme all'input, quindi ho trovato il seguente codice per tagliare il carattere di nuova riga:

input,_:=src.ReadString('\n')
inputFmt:=input[0:len(input)-2]+"" //Need to manually add end of string

C'è un modo più idiomatico per farlo? Cioè, esiste già una libreria che si prende cura del byte nullo finale durante l'estrazione delle sottostringhe?

(Sì, so che esiste già un modo per leggere una riga senza il carattere di nuova riga in go readline -> string ma cerco di più un'elegante manipolazione delle stringhe.)

Sembra che tu sia confuso dal funzionamento delle sezioni e dal formato di archiviazione delle stringhe, che è diverso da quello che hai in C.

• qualsiasi slice in Go memorizza la lunghezza (in byte), quindi non devi preoccuparti del costo lendell'operazione: non c'è bisogno di contare
• Le stringhe Go non hanno terminazione null, quindi non è necessario rimuovere un byte null e non è necessario aggiungerlo 1dopo lo slicing aggiungendo una stringa vuota.

Per rimuovere l'ultimo carattere (se è un carattere di un byte), fallo semplicemente

inputFmt:=input[:len(input)-1]

Le stringhe di Go non sono terminate da null e per rimuovere l'ultimo carattere di una stringa puoi semplicemente fare:

s = s[:len(s)-1]

Per evitare il panico su un input di lunghezza zero, racchiudere l'operazione truncate in un if

input, _ := src.ReadString('\n')
var inputFmt string
if len(input) > 0 {
    inputFmt = input[:len(input)-1]
}
// Do something with inputFmt

Questo è quello più semplice per eseguire la sottostringa in Go

package main

import "fmt"

var p = fmt.Println

func main() {

  value := "address;bar"

  // Take substring from index 2 to length of string
  substring := value[2:len(value)]
  p(substring)

}

ATTENZIONE: operare solo su stringhe funzionerà solo con ASCII e conterà in modo errato quando l'input è un carattere non ASCII con codifica UTF-8 e probabilmente corromperà anche i caratteri poiché taglia i caratteri multibyte a metà sequenza.

Ecco una versione compatibile con UTF-8:

func substr(input string, start int, length int) string {
    asRunes := []rune(input)

    if start >= len(asRunes) {
        return ""
    }

    if start+length > len(asRunes) {
        length = len(asRunes) - start
    }

    return string(asRunes[start : start+length])
}

Per ottenere la sottostringa

1. trova la posizione di "sp"

2. taglia la stringa con array logico

https://play.golang.org/p/0Redd_qiZM

8 anni dopo mi sono imbattuto in questa gemma, eppure non credo che la domanda originale di OP abbia davvero avuto risposta:

quindi ho creato il seguente codice per tagliare il carattere di nuova riga

Mentre il bufio.Readertipo supporta un ReadLine() metodo che rimuove sia \r\ned \nè inteso come una funzione di basso livello che è scomodo da usare perché sono necessari controlli ripetuti.

IMO un modo idiomatico per rimuovere gli spazi bianchi è usare la libreria di stringhe di Golang :

input, _ = src.ReadString('\n')

// more specific to the problem of trailing newlines
actual = strings.TrimRight(input, "\r\n")

// or if you don't mind to trim leading and trailing whitespaces 
actual := strings.TrimSpace(input)

Guarda questo esempio in azione nel parco giochi Golang: https://play.golang.org/p/HrOWH0kl3Ww