Scinde une chaîne en fonction de la longueur de Golang

Personne ne sait comment découper une chaîne en Golang en longueur?

Par exemple à diviser "helloworld" après tous les 3 personnages, donc idéalement, il devrait retourner un tableau de "hel" "faible" "orl" "d"?

Sinon, une solution possible serait d'ajouter un saut de ligne après chaque 3 caractères..

Toutes les idées sont grandement appréciés!

  • Eh bien, certains de programmation pourrait il m'aider? Comme s[n:n+3]+"\n"?
InformationsquelleAutor Fernando Parra | 2014-09-05
  1. 18

    Assurez-vous de convertir votre chaîne dans une tranche de rune: voir "Tranche chaîne en lettres"

    a := []rune(s)
for i, r := range a {
    fmt.Printf("i%d r %c\n", i, r)
    //every 3 i, do something
}

    a[n:n+3] fonctionne le mieux avec un être d'une tranche de rune.

    L'indice augmentera par un chaque rune, alors qu'il aurait augmenter de plus d'un pour chaque octet dans un tranche de chaîne: "世界": i 0 et 3: un personnage (rune) peut être formé de plusieurs octets.

    Par exemple, considérons s := "世a界世bcd界efg世": 12 runes. (voir play.golang.org)

    Si vous essayez d'analyser octet par octet, vous passerez à côté (dans un naïf split tous les 3 caractères de mise en œuvre) une partie de la "index modulo 3" (égal à 2, 5, 8 et 11), parce que l'indice augmentera au-delà de ces valeurs:

    for i, r := range s {
    res = res + string(r)
    fmt.Printf("i %d r %c\n", i, r)
    if i > 0 && (i+1)%3 == 0 {
        fmt.Printf("=>(%d) '%v'\n", i, res)
        res = ""
    }
}

    La sortie:

    i  0 r 世
i  3 r a   <== miss i==2
i  4 r 界
i  7 r 世  <== miss i==5
i 10 r b  <== miss i==8
i 11 r c  ===============> would print '世a界世bc', not exactly '3 chars'!
i 12 r d
i 13 r 界
i 16 r e  <== miss i==14
i 17 r f  ===============> would print 'd界ef'
i 18 r g
i 19 r 世 <== miss the rest of the string

    Mais si vous étiez à itérer sur les runes (a := []rune(s)), vous obtenez ce que vous attendez, comme l'index de l'augmentation d'une rune à un moment, le rendant facile pour agréger exactement 3 caractères:

    for i, r := range a {
    res = res + string(r)
    fmt.Printf("i%d r %c\n", i, r)
    if i > 0 && (i+1)%3 == 0 {
        fmt.Printf("=>(%d) '%v'\n", i, res)
        res = ""
    }
}

    De sortie:

    i 0 r 世
i 1 r a
i 2 r 界 ===============> would print '世a界'
i 3 r 世
i 4 r b
i 5 r c ===============> would print '世bc'
i 6 r d
i 7 r 界
i 8 r e ===============> would print 'd界e'
i 9 r f
i10 r g
i11 r 世 ===============> would print 'fg世'
    InformationsquelleAutor VonC
  2. 6

    Aussi besoin d'une fonction pour le faire récemment, voir exemple d'utilisation ici

    func SplitSubN(s string, n int) []string {
    sub := ""
    subs := []string{}

    runes := bytes.Runes([]byte(s))
    l := len(runes)
    for i, r := range runes {
        sub = sub + string(r)
        if (i + 1) % n == 0 {
            subs = append(subs, sub)
            sub = ""
        } else if (i + 1) == l {
            subs = append(subs, sub)
        }
    }

    return subs
}
    InformationsquelleAutor mozey
  3. 1

    Voici un autre exemple (vous pouvez l'essayer ici):

    package main

import (
    "fmt"
    "strings"
)

func ChunkString(s string, chunkSize int) []string {
    var chunks []string
    runes := []rune(s)

    if len(runes) == 0 {
        return []string{s}
    }

    for i := 0; i < len(runes); i += chunkSize {
        nn := i + chunkSize
        if nn > len(runes) {
            nn = len(runes)
        }
        chunks = append(chunks, string(runes[i:nn]))
    }
    return chunks
}

func main() {
    fmt.Println(ChunkString("helloworld", 3))
    fmt.Println(strings.Join(ChunkString("helloworld", 3), "\n"))
}
    InformationsquelleAutor rinat.io
  4. 1

    J'ai essayé la version 3 pour mettre en œuvre la fonction, la fonction nommée "splitByWidthMake" est la plus rapide.

    Ces fonctions ignorer l'unicode, mais seulement le code ascii.

    package main
import (
"fmt"
"strings"
"time"
"math"
)
func splitByWidthMake(str string, size int) []string {
strLength := len(str)
splitedLength := int(math.Ceil(float64(strLength) / float64(size)))
splited := make([]string, splitedLength)
var start, stop int
for i := 0; i < splitedLength; i += 1 {
start = i * size
stop = start + size
if stop > strLength {
stop = strLength
}
splited[i] = str[start : stop]
}
return splited
}
func splitByWidth(str string, size int) []string {
strLength := len(str)
var splited []string
var stop int
for i := 0; i < strLength; i += size {
stop = i + size
if stop > strLength {
stop = strLength
}
splited = append(splited, str[i:stop])
}
return splited
}
func splitRecursive(str string, size int) []string {
if len(str) <= size {
return []string{str}
}
return append([]string{string(str[0:size])}, splitRecursive(str[size:], size)...)
}
func main() {
/*
testStrings := []string{
"hello world",
"",
"1",
}
*/
testStrings := make([]string, 10)
for i := range testStrings {
testStrings[i] = strings.Repeat("#", int(math.Pow(2, float64(i))))
}
//fmt.Println(testStrings)
t1 := time.Now()
for i := range testStrings {
_ = splitByWidthMake(testStrings[i], 2)
//fmt.Println(t)
}
elapsed := time.Since(t1)
fmt.Println("for loop version elapsed: ", elapsed)
t1 = time.Now()
for i := range testStrings {
_ = splitByWidth(testStrings[i], 2)
}
elapsed = time.Since(t1)
fmt.Println("for loop without make version elapsed: ", elapsed)
t1 = time.Now()
for i := range testStrings {
_ = splitRecursive(testStrings[i], 2)
}
elapsed = time.Since(t1)
fmt.Println("recursive version elapsed: ", elapsed)
}
    InformationsquelleAutor ryan
  5. 0

    Une solution facile en utilisant les regex

    re := regexp.MustCompile((\S{3}))
    x := re.FindAllStringSubmatch("HelloWorld", -1)
    fmt.Println(x)

    https://play.golang.org/p/mfmaQlSRkHe

    • Didi u l'exécuter dans Le feu de l'aire de Jeux? Pourriez-vous pls laissez-moi savoir wht u na pas comprendre?
    • devrait être FindAllString au lieu de FindAllStringSubmatch, non?
    InformationsquelleAutor rahul