Vetor é um tipo de dados derivado estático que armazenam dados, de diferentes tipos, de forma sequencial em memória. Em Go: Tipos de Dados e Go: Variáveis vimos o básico sobre o o tipo. Nesta parte do tutorial vamos estudar as operações sobre vetores.

Vetor de ponteiros pode ser visto em Vetor de Ponteiro.

Ponteiro para Vetor pode ser visto em Ponteiro para Vetor.

O tipo de dado Vetor armazenam dados de forma justaposta. O nome vetor não é uma palavras reconhecida pela linguagem Go sendo um apelido para array. Um vetor é um tipo de dado derivados de outros tipos de dados primitivos ou não.

Tab. 1: Vetor de int

índice	0	1	2	3	4	5	(...)
elemento	0	10	20	30	40	50	?

Para cada elemento de um determinado tipo de dado contido em um vetor, temos um índice associado ao qual utilizamos para acessá-lo.

Vetores em Go, armazenam dados de forma estática. Sendo assim, não podemos aumentar ou dimimuir sua dimensão após a declaração.

A declaração de um vetor na linguagem Go é feita utilizando um tipo de dado desejado, sendo primitivo ou complexo, e sua dimensão entre [ e ].

Sintaxe A

var nome_vetor[dimensao] tipo_dado

Sintaxe B

var nome_vetor = [dimensao] tipo_dado { elemento1, elemento2, elementoN}

Onde

dimensao: número de elementos
tipo_dado: Tipo de dado dos elementos armazenados
elemento1...N: Elementos do tipo tipo_dado que iniciam nome_vetor

Um vetor com valores iniciados devem ter seus valores, baseados no tipo de dado utilizado, delimitados por { e } e separados por (,).

A linguagem Go não permite utilizar uma variáveis como dimensão ao declarar um vetor. Apenas constantes são aceitas.

Os vetores quando não iniciados manualmente, são iniciados automaticamente utilizando seus valores padrão aceitos.

Exemplo 1

package main
import "fmt"

func main() {
	var vint [3]int 
	vint = [3]int{1, 2, 3}
}

Saída

-

Quando precisamos declarar um vetor, que será iniciado, sem nos preocuparmos com a quantidade de elementos, utilizamos "…" como tamanho.

Sintaxe C

var nome_vetor = [...] tipo_dado { elemento1, elemento2, elementoN}

Exemplo 2

package main
import "fmt"

func main() {
  
  var vetor_int = [...] int {1,2,3}
  fmt.Println(vetor_int)
}

Saída

[1 2 3]

O acesso aos elementos de vetor é feita utilizando o seus índices utilizando o indexador "[]", assim como em várias outras linguagens como C, C++, Java e etc.

Sintaxe

nome_vetor[indice] = valor;
nome_vetor[indice];

Onde

indice: Índice do elemento desejado

Exemplo 3

package main
import "fmt"

func main() {
	var vint [3]int
	vint = [3]int{1, 2, 3}

	vint[0] = 777
	fmt.Printf("%d", vint[0])
}
            

Saída

777

Para verificarmos o número de elementos de nossos vetores utilizamos a função len:

Sintaxe D

len(nome_vetor)

Exemplo 4

package main
import "fmt"

func main() {
  
  var vetor_int = [...] int {1,2,3,4,5,6,7,8,9,10}

  fmt.Println(len(vetor_int))
}

Saída

10

Para percorrermos ou iterarmos vetores na linguagem Go, podemos utilizar o comando for ou for + comando range que foram vistos em Go: Comandos de repetição.

Exemplo 5: for + range

package main
import "fmt"

func main() {
  
  var vetor_int = [3] int {1,2,3}

  for indice,valor := range vetor_int {
    fmt.Println(indice, valor)
  }
}

Saída

1
2
3

Exemplo 6: for

package main
import "fmt"

func main() {
	var vstr = [3]string{"1", "2", "3"}

	for i := 0; i < len(vstr); i++ {
		fmt.Printf(vstr[i])
	}
}

Saída

123

A linguagem Go, não fornece nativamente uma função para que seja possível realizar a cópia de vetores, mas podemos copiar os elemento de um vetor utilizando o operador (:=).

Sintaxe E

vetor_destino := vetor_origem

Exemplo 7

package main
import "fmt"

func main() {

	origem := [3]int{1, 2, 3}

	destino := origem

	fmt.Println("orig:", origem)
	fmt.Println("dest:", destino)

	origem[0] = 777

	fmt.Println("orig:", origem)
	fmt.Println("dest:", destino)
}

Saída

orig: [1 2 3]
dest: [1 2 3]
orig: [777 2 3]
dest: [1 2 3]

A forma mais básica de passarmos um vetor como argumento para uma função é por valor. Vale lembrar que quando essa abordagem é utilizada, alterando o valor de um elemento do vetor não irá refletir na variável que foi passada como argumento.

Sintaxe F

func nome_funcao(param [dimensao]tipo_dado,tamanho int) (tipo_retorno){ /*corpo*/}
func nome_funcao(param []tipo_dado) (tipo_retorno){ /*corpo*/}

Sintaxe G

nome_funcao(nome_vetor)

As sintaxe F e G acima mostram a declaração de um protótipo de uma função e a passagem de uma vetor como argumento respectivamente.

Exemplo 8

package main
import "fmt"

func funcao1(vstr []string) {
	for i := 0; i < len(vstr); i++ {
		fmt.Printf(vstr[i])
	}
}

func funcao2(vstr [3]string, tamanho int) {
	for i := 0; i < tamanho; i++ {
		fmt.Printf(vstr[i])
	}
}

func main() {

	vstr1 := []string{"1", "2", "3"}
	vstr2 := [3]string{"1", "2", "3"}
	funcao1(vstr1)
	funcao2(vstr2, 3)
}

Saída

123123

Para que seja possível a persistência de uma alteração feita em um vetor, sendo esse acessado dentro de uma função ou método, é necessário fazer a passagem do vetor, como argumento, por referência utilizando o operador (&).

Sintaxe H

func nome_funcao(param *[dimensao]tipo_dado, tamanho) (tipo_retorno){ /*corpo*/}
func nome_funcao(param *[dimensao]tipo_dado) (tipo_retorno){ /*corpo*/}

Sintaxe I

nome_funcao(&nome_vetor)

As sintaxe A e B acima mostram a declaração de um protótipo de uma função e a passagem de uma vetor como argumento respectivamente.

Exemplo 9

package main
import "fmt"

func funcao(param *[4]int) {
	for i := 0; i < len(param); i++ {
		param[i] *= 2
	}
}

func main() {
	var vint = [4]int{1, 2, 3, 4}
	fmt.Println("antes:", vint)
	funcao(&vint)
	fmt.Println("depois:", vint)
}

Saída

antes: [1 2 3 4]
depois: [2 4 6 8]

O retorno de vetores em funções é feito da mesma forma como qualquer outro tipo de dado já visto. Declaramos o tipo de retorno no protótipo da função como vetor com ou sem sua dimensão.

Sintaxe J

func nome_funcao(parametros) (nome_retorno [dimensao]tipo_dado)
func nome_funcao(parametros) ( [dimensao]tipo_dado)
func nome_funcao(parametros) (nome_retorno []tipo_dado)
func nome_funcao(parametros) ( []tipo_dado)

Exemplo 10

package main
import "fmt"

func funcao1() (vetor []int) {
	vetor = []int{1, 2, 3, 4}
	return
}
func funcao2() [4]int {
	vetor := [4]int{1, 2, 3, 4}
	return vetor
}

func main() {

	vint1 := funcao1()
	fmt.Println(vint1)
	vint2 := funcao2()
	fmt.Println(vint2)
}
            

1. 17/09/2024 - revisão 2 - Correção em nome de sintaxes/numéro de exemplos; ajustes gramaticais pontuais
2. 02/10/2023 - revisão 1 - Correção em referências, erros gramaticais
3. 21/08/2023 - versão inicial