So ersetzen Sie einen Brief zu einem bestimmten index in einem string-in Gehen?

Möchte ich ersetzen einen Brief zu einem bestimmten index in einem string: aaaaaaa -> aaabaaa. Gibt es eine eingebaute Möglichkeit, dies zu tun? Ich schrieb die folgende Hilfsprogramm-Funktion zu verwenden, in der Zwischenzeit:

func main() {
    input := "aaaaaaa"
    output := replaceAtIndex(input, 'b', 3)
}

func replaceAtIndex(input string, replacement byte, index int) string {
    return strings.Join([]string{input[:index], string(replacement), input[index+1:]}, "")
}

InformationsquelleAutor Ferguzz | 2014-07-22

go string

19

Strings sind unveränderlich in zu Gehen, müssen Sie es zu konvertieren, um Runen dann modifizieren, konvertieren Sie es dann zurück in einen string.

@chendesheng die Lösung ist halb-richtig, außer Sie verwenden können rune statt byte, so wird es funktionieren auf unicode als gut.
```
func replaceAtIndex(in string, r rune, i int) string {
    out := []rune(in)
    out[i] = r
    return string(out)
}
```
Spielplatz

InformationsquelleAutor OneOfOne

Beide Antworten (OneOfOne und Denys Séguret) korrekt sind. Ich wollte nur zeigen den Unterschied in der Leistung zwischen Ihnen (das ist wirklich Auffällig, wenn der string groß ist).

Es stellt sich heraus, dass die Verwendung str[:index] + string(Ersatz) + str[index+1:] ist schneller.

Also der benchmark:

package main
import (
    "testing"
)

func replaceAtIndex1(str string, replacement rune, index int) string {
    out := []rune(str)
    out[index] = replacement
    return string(out)
}

func replaceAtIndex2(str string, replacement rune, index int) string {
    return str[:index] + string(replacement) + str[index+1:]
}

func generateString(n int) string{
    s := ""
    for i := 0; i < n; i++{
        s += "a"
    }
    return s
}

func BenchmarkSmall1(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex1(str, replacement, index)
    }
}

func BenchmarkSmall2(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkMedium1(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex1(str, replacement, index)
    }
}

func BenchmarkMedium2(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkBig1(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex1(str, replacement, index)
    }
}

func BenchmarkBig2(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func main(){}

zeigt die folgende Ergebnisse (Dank Thomasz für das Auffinden einer copypasting Fehler):

BenchmarkSmall1-4   10000000           228 ns/op
BenchmarkSmall2-4   10000000           126 ns/op
BenchmarkMedium1-4    500000          2091 ns/op
BenchmarkMedium2-4  10000000           190 ns/op
BenchmarkBig1-4        10000        209232 ns/op
BenchmarkBig2-4       500000          3629 ns/op

Das ist kein fairer Vergleich. Slicing-str ohne Konvertierung in die rune ist nutzlos.
Warum ist es nutzlos @Amos?? Es funktioniert...
str[:index], wie agieren die byte, es ist ganz anders mit der rune, die Sie vielleicht beschädigt eine rune in dieser Art.. Zum Beispiel, können Sie "很好, " hello world" als Zeichenkette.

InformationsquelleAutor Salvador Dali

7

Können Sie verketten von strings mit dem + - operator :
```
return input[:index] + string(replacement) + input[index+1:]
```
Vorsichtig sein, dass der index nicht die index von einem "Brief", aber der byte.
- gibt es einen nutzen in diesem über strings.Join ?
- Hier interessiert der Vergleich mit strings.Join
- str[:index], wie agieren die byte, es ist ganz anders mit der rune, die Sie vielleicht beschädigt eine rune in dieser Art.. Zum Beispiel, können Sie "很好, " hello world" als Zeichenkette.
InformationsquelleAutor Denys Séguret

Just for fun:

package main                                                                                                                                                                                                

import (                                                                                                                                                                                                    
    "fmt"                                                                                                                                                                                                   
    "reflect"                                                                                                                                                                                               
    "syscall"                                                                                                                                                                                               
    "unsafe"                                                                                                                                                                                                
)                                                                                                                                                                                                           

//We should do this because by default strings in Go are read-only.                                                                                                                                                                                                                                                                                                                                                                                                                  
func mprotect(ptr uintptr, w bool) {                                                                                                                                                                        
    //Need to avoid "EINVAL addr is not a valid pointer,
    //or not a multiple of PAGESIZE."                                                                                                                   
    start := ptr & ^(uintptr(syscall.Getpagesize() - 1))                                                                                                                                                    

    prot := syscall.PROT_READ                                                                                                                                                                               
    if w {                                                                                                                                                                                                  
        prot |= syscall.PROT_WRITE                                                                                                                                                                          
    }                                                                                                                                                                                                       

    _, _, err := syscall.Syscall(                                                                                                                                                                           
        syscall.SYS_MPROTECT,                                                                                                                                                                               
        start, uintptr(syscall.Getpagesize()),                                                                                                                                                              
        uintptr(prot),                                                                                                                                                                                      
    )                                                                                                                                                                                                       
    if err != 0 {                                                                                                                                                                                           
        panic(err.Error())                                                                                                                                                                                  
    }                                                                                                                                                                                                       
}                                                                                                                                                                                                           

//This function is very, very very very unsafe.                                                                                                                                                            
//Nowhere and never use it!                                                                                                                                                                                
func replaceAtIndex(s string, b byte, i int) {                                                                                                                                                              
    h := *(*reflect.StringHeader)(unsafe.Pointer(&s))                                                                                                                                                       

    mprotect(h.Data, true)                                                                                                                                                                                  
    defer mprotect(h.Data, false)                                                                                                                                                                           

    *(*byte)(unsafe.Pointer(h.Data + uintptr(i))) = b                                                                                                                                                       
}                                                                                                                                                                                                           

func main() {                                                                                                                                                                                               
    h := "Hello, playground"                                                                                                                                                                                
    replaceAtIndex(h, 'x', 0)                                                                                                                                                                               
    fmt.Println(h)                                                                                                                                                                                          
}

Nie versuchen, es zu benutzen, die irgendwo in Ihrem code.
Es ist langsamer als jede standard-Lösungen oder in oben genannten Beispielen und vieles mehr unsicher. =)

(Es ist nicht die Arbeit in Spielplatz, da syscall dort nicht definiert ist).

InformationsquelleAutor gobwas

Ich nahm Salvador benchmark und Hinzugefügt strings.Join() zu. Seine Antwort bleibt korrekt - str[:index] + string(replacement) + str[index+1:] ist die Schnellste option für große Zeichenfolgen angenommen, Sie möchten Ihre original-string erhalten. strings.Join() ist ziemlich nah für kleine Streicher-und sehr, sehr eng für große Zeichenfolgen. Ich habe auch tests mit noch größeren strings, um zu sehen, wenn strings.Join() wird schneller an jedem Punkt - es scheint nicht.

Ich auch, nur für funsies, gehackt zusammen mit zwei anderen Implementierungen mit unsafe und reflect

Macht man eine Kopie, so dass es ändert nicht die ursprüngliche Zeichenfolge, und hat eine sehr interessante performance-Ergebnisse - schneller für kleine Streicher, viel schneller für mittlere Saiten, viel, viel langsamer für große Zeichenfolgen
Die anderen nicht einfach eine veränderliche Zeichenfolge und ist, wenig überraschend, drastisch schneller für alle Zwecke und läuft in konstanter Zeit, mit dem VORBEHALT, dass Sie Ihre ursprüngliche string wird modifiziert.

Musste ich auch ändern generateString() so würde es die größte strings erzeugen würde, in einem vernünftigen Zeitrahmen 😉

Jedenfalls der code:

package main
import (
    "reflect"
    "strings"
    "testing"
    "unsafe"
)

func replaceAtIndex1(str string, replacement rune, index int) string {
    out := []rune(str)
    out[index] = replacement
    return string(out)
}

func replaceAtIndex2(str string, replacement rune, index int) string {
    return str[:index] + string(replacement) + str[index+1:]
}

func replaceAtIndex3(str string, replacement rune, index int) string {
    return strings.Join([]string{str[:index], str[index + 1:]}, string(replacement))
}

func strToBytes(str string) []byte {
    string_header := (*reflect.StringHeader)(unsafe.Pointer(&str))
    bytes_header := &reflect.SliceHeader{
        Data : string_header.Data,
        Len : string_header.Len,
        Cap : string_header.Len,
    }
    return *(*[]byte)(unsafe.Pointer(bytes_header))
}

func strToBytesCopy(str string) []byte {
    bytes_unsafe := strToBytes(str)
    bytes := make([]byte, len(bytes_unsafe))
    copy(bytes, bytes_unsafe)
    return bytes
}

func bytesToStr(bytes []byte) string {
    bytes_header := (*reflect.SliceHeader)(unsafe.Pointer(&bytes))
    string_header := &reflect.StringHeader{
        Data : bytes_header.Data,
        Len : bytes_header.Len,
    }
    return *(*string)(unsafe.Pointer(string_header))
}

func replaceAtIndex4(str string, replacement rune, index int) string {
    bytes := strToBytesCopy(str)
    bytes[index] = byte(replacement)
    return bytesToStr(bytes)
}

func replaceAtIndex5(str string, replacement rune, index int) string {
    bytes := strToBytes(str)
    bytes[index] = byte(replacement)
    return bytesToStr(bytes)
}

func generateString(n int) string{
    var b strings.Builder
    b.Grow(n)
    for i := 0; i < n; i++ {
        b.WriteRune('a')
    }
    return b.String()
}

func BenchmarkSmall1(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex1(str, replacement, index)
    }
}

func BenchmarkSmall2(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkSmall3(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex3(str, replacement, index)
    }
}

func BenchmarkSmall4(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex4(str, replacement, index)
    }
}

func BenchmarkSmall5(b *testing.B) {
    n := 10
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex5(str, replacement, index)
    }
}

func BenchmarkMedium1(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex1(str, replacement, index)
    }
}

func BenchmarkMedium2(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkMedium3(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex3(str, replacement, index)
    }
}

func BenchmarkMedium4(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex4(str, replacement, index)
    }
}

func BenchmarkMedium5(b *testing.B) {
    n := 100
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex5(str, replacement, index)
    }
}

func BenchmarkBig1(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex1(str, replacement, index)
    }
}

func BenchmarkBig2(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkBig3(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex3(str, replacement, index)
    }
}

func BenchmarkBig4(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex4(str, replacement, index)
    }
}

func BenchmarkBig5(b *testing.B) {
    n := 10000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex5(str, replacement, index)
    }
}

func BenchmarkHuge2(b *testing.B) {
    n := 100000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkHuge3(b *testing.B) {
    n := 100000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex3(str, replacement, index)
    }
}

func BenchmarkHuge4(b *testing.B) {
    n := 100000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex4(str, replacement, index)
    }
}

func BenchmarkHuge5(b *testing.B) {
    n := 100000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex5(str, replacement, index)
    }
}

func BenchmarkGargantuan2(b *testing.B) {
    n := 10000000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex2(str, replacement, index)
    }
}

func BenchmarkGargantuan3(b *testing.B) {
    n := 10000000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex3(str, replacement, index)
    }
}

func BenchmarkGargantuan4(b *testing.B) {
    n := 10000000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex4(str, replacement, index)
    }
}

func BenchmarkGargantuan5(b *testing.B) {
    n := 10000000
    str, index, replacement := generateString(n), n / 2, 'B'

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        replaceAtIndex5(str, replacement, index)
    }
}

func main(){}

Und die Ergebnisse:

BenchmarkSmall1-8           20000000            99.9 ns/op
BenchmarkSmall2-8           50000000            29.5 ns/op
BenchmarkSmall3-8           20000000            58.1 ns/op
BenchmarkSmall4-8           50000000            32.0 ns/op
BenchmarkSmall5-8           1000000000           2.93 ns/op
BenchmarkMedium1-8           1000000          1034 ns/op
BenchmarkMedium2-8          20000000            68.4 ns/op
BenchmarkMedium3-8          20000000            78.8 ns/op
BenchmarkMedium4-8          30000000            49.3 ns/op
BenchmarkMedium5-8          1000000000           3.02 ns/op
BenchmarkBig1-8                20000         89557 ns/op
BenchmarkBig2-8              1000000          1204 ns/op
BenchmarkBig3-8              1000000          1257 ns/op
BenchmarkBig4-8              1000000          1200 ns/op
BenchmarkBig5-8             1000000000           2.93 ns/op
BenchmarkHuge2-8              200000         10260 ns/op
BenchmarkHuge3-8              200000          9908 ns/op
BenchmarkHuge4-8              100000         13628 ns/op
BenchmarkHuge5-8            1000000000           2.99 ns/op
BenchmarkGargantuan2-8          2000        822881 ns/op
BenchmarkGargantuan3-8          2000        807522 ns/op
BenchmarkGargantuan4-8          1000       2148387 ns/op
BenchmarkGargantuan5-8      1000000000           2.96 ns/op

InformationsquelleAutor Mike Cronce

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.