Teilzeichenfolgen in Go extrahieren

Ich versuche, eine ganze Zeile von der Konsole zu lesen (einschließlich Leerzeichen) und sie dann zu verarbeiten. Mit bufio.ReadString wird das Zeilenumbruchzeichen zusammen mit der Eingabe gelesen, sodass ich den folgenden Code zum Trimmen des Zeilenumbruchzeichens gefunden habe:

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

Gibt es einen idiomatischeren Weg, dies zu tun? Gibt es bereits eine Bibliothek, die sich beim Extrahieren von Teilzeichenfolgen um das End-Null-Byte kümmert?

(Ja, ich weiß, dass es bereits eine Möglichkeit gibt, eine Zeile ohne das Zeilenumbruchzeichen in go readline -> string zu lesen, aber ich suche eher nach einer eleganten String-Manipulation.)

Es sieht so aus, als wären Sie verwirrt von der Arbeit mit Slices und dem String-Speicherformat, das sich von dem in C unterscheidet.

• Jedes Slice in Go speichert die Länge (in Bytes), sodass Sie sich nicht um die Kosten der lenOperation kümmern müssen: Sie müssen nicht zählen
• Go-Zeichenfolgen sind nicht nullterminiert, sodass Sie kein Nullbyte entfernen und 1nach dem Schneiden keine leere Zeichenfolge hinzufügen müssen.

Um das letzte Zeichen zu entfernen (wenn es sich um ein 1-Byte-Zeichen handelt), tun Sie dies einfach

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

Go-Zeichenfolgen sind nicht nullterminiert. Um das letzte Zeichen einer Zeichenfolge zu entfernen, können Sie einfach Folgendes tun:

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

Um eine Panik bei einer Eingabe mit der Länge Null zu vermeiden, schließen Sie die Kürzungsoperation in ein if ein

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

Dies ist die einfache Möglichkeit, Teilzeichenfolgen in Go auszuführen

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)

}

WARNUNG: Die alleinige Bearbeitung von Zeichenfolgen funktioniert nur mit ASCII und zählt falsch, wenn die Eingabe ein nicht ASCII-UTF-8-codiertes Zeichen ist. Wahrscheinlich werden sogar Zeichen beschädigt, da Multibyte-Zeichen in der Mitte der Sequenz geschnitten werden.

Hier ist eine UTF-8-fähige Version:

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])
}

Um Teilzeichenfolge zu erhalten

1. finde die Position von "sp"

2. String mit Array-Logik schneiden

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

8 Jahre später bin ich auf dieses Juwel gestoßen, und dennoch glaube ich nicht, dass die ursprüngliche Frage von OP wirklich beantwortet wurde:

Deshalb habe ich mir den folgenden Code ausgedacht, um das Zeilenumbruchzeichen zu kürzen

Während die bufio.ReaderArt unterstützt eine ReadLine() Methode , die beide entfernt \r\nund \nes wird als eine Low-Level - Funktion zu verstehen , die zur Benutzung umständlich ist , weil wiederholte Kontrollen notwendig sind.

IMO ist eine idiomatische Möglichkeit, Leerzeichen zu entfernen, die Verwendung der Strings- Bibliothek von 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)

Sehen Sie dieses Beispiel in Aktion auf dem Golang-Spielplatz: https://play.golang.org/p/HrOWH0kl3Ww