Como Concatenar Eficientemente as String em Andamento

1. Com o operador Plus (+)
2. Com múltiplos argumentos em Print() Função
3. Com Join() Função
4. Sprintf() Método
5. bytes.Buffer Método
6. Método strings.Builder
7. Anexar com += Operador
8. Comparação de diferentes métodos

O ato de fundir duas ou mais strings em uma única nova strings é chamado de Concatenação de strings. A Concatenação de strings é uma das operações mais amplamente realizadas na programação. Neste artigo, discutiremos diferentes métodos para concatenar strings na linguagem de programação Go com seus prós e contras.

Com o operador Plus (+)

A utilização do + é o método mais simples e mais amplamente utilizado para a concatenação de strings. Às vezes o operador + também é chamado de operador de concatenação.

package main

import "fmt"

func main() {

    str_1 := "Welcome to "
    str_2 := "the Blog!!"
    fmt.Println("str_1: ", str_1)
    fmt.Println("str_2: ", str_2)
    fmt.Println("Combined String: ", str_1+str_2)
}

Resultado:

str_1:  Welcome to 
str_2:  the Blog!!
Combined String:  Welcome to the Blog!!

Com múltiplos argumentos em Print() Função

Podemos passar várias strings como argumentos para Print() em Go. As strings são automaticamente concatenadas pela adição de espaço branco entre as strings.

package main

import "fmt"

func main() {

    fmt.Println("String", "Concatenation!!")
}      

Resultado:

String Concatenation!!

Com Join() Função

Também podemos concatenar as strings utilizando a função join() apresentada em um pacote de strings que leva uma fatia de strings e um separador para juntá-las com a produção de uma única string.

Sintaxe:

func Join(str []string, sep string) string

onde str é a fatia de strings das quais concatenamos elementos e sep é o separador colocado entre as fatias.

   package main

import (
    "fmt"
    "strings" //for join() function
)

func main() {

    str_slices := []string{"This", "is",
        "String", "Concatenation!!"}

    str_concat := strings.Join(str_slices, "-")
    fmt.Println(str_concat)
}
  

Resultado:

This-is-String-Concatenation!!

Sprintf() Método

A utilização do Sprintf() método no pacote fmt é também um dos métodos mais simples para a concatenação de string.

package main

import "fmt"

func main() {
    str_1 := "We will"
    str_2 := " Rock"
    str_3 := " You!!"

    str_final := fmt.Sprintf("%s%s%s", str_1, str_2, str_3)

    fmt.Println(str_final)
} 

Resultado:

We will Rock You!!

bytes.Buffer Método

Uma maneira eficiente de concatenar as strings sem a geração do objeto de strings desnecessário é o método bytes.Buffer. Podemos escrever as strings em buffer de bytes utilizando o método WriteString() e depois transformá-lo em string.

package main

import (
    "bytes"
    "fmt"
)

func main() {
    var byte_buf bytes.Buffer

    byte_buf.WriteString("Hello ")
    byte_buf.WriteString("World!!")

    fmt.Println(byte_buf.String())
}

Resultado:

Hello World!!

Método strings.Builder

Este método permite a concatenação eficiente de strings, utilizando muito menos memória em comparação com outros.

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str_build strings.Builder
    str_build.WriteString("Hello ")
    str_build.WriteString("World!!")
    fmt.Println(str_build.String())
}

Resultado:

Hello World!!

Anexar com += Operador

É semelhante à concatenação de strings usando o operador plus, mas ligeiramente mais curto do que o anterior. O operador += anexa uma nova string à direita da string especificada.

package main

import "fmt"

func main() {
    str_1 := "Hello "

    str_1 += "World!!"
    fmt.Println("Final String:", str_1)

}

Resultado:

Final String: Hello World!!

Comparação de diferentes métodos

Os métodos bytes.Buffer e strings.Builder são bastante mais rápidos do que outros métodos de concatenação de strings. Assim, quando temos que executar a concatenação de strings em uma grande quantidade, preferimos os métodos bytes.Buffer e strings.Builder. Entretanto, quando o número de concatenações é pequeno, podemos utilizar operadores + ou +=.