Maneira correta de inicializar fatia vazia

Para declarar uma fatia vazia, com um tamanho não fixo, é melhor fazer:

mySlice1 := make([]int, 0)

ou:

mySlice2 := []int{}

Apenas querendo saber qual é o caminho correto.

As duas alternativas que você forneceu são semanticamente idênticas, mas o uso make([]int, 0)resultará em uma chamada interna para o tempo de execução.makeslice (Go 1.14).

Você também tem a opção de deixá-lo com um nilvalor:

var myslice []int

Conforme escrito no blog Golang.org :

uma fatia nula é funcionalmente equivalente a uma fatia de comprimento zero, mesmo que não aponte para nada. Tem comprimento zero e pode ser anexado a, com alocação.

A nilfatia vai, porém, json.Marshal()em"null" enquanto uma fatia vazia será inserida "[]", como apontado por @farwayer.

Nenhuma das opções acima causará alocação, como apontado por @ArmanOrdookhani.

Eles são equivalentes. Veja este código:

mySlice1 := make([]int, 0)
mySlice2 := []int{}
fmt.Println("mySlice1", cap(mySlice1))
fmt.Println("mySlice2", cap(mySlice2))

Resultado:

mySlice1 0
mySlice2 0

Ambas as fatias têm 0capacidade, o que implica que ambas as fatias tenham0 comprimento (não pode ser maior que a capacidade), o que implica que ambas as fatias não possuem elementos. Isso significa que as duas fatias são idênticas em todos os aspectos.

Veja perguntas semelhantes:

Qual é o sentido de ter fatia nula e fatia vazia em golang?

fatias nulas vs fatias não nulas vs fatias vazias no idioma Go

Como complemento ao @ANisus ' resposta do ...

abaixo estão algumas informações do "Entrar em ação" livro , que acho que vale a pena mencionar:

Diferença entre nil&empty fatias

Se pensarmos em uma fatia como esta:

[pointer] [length] [capacity]

então:

nil slice:   [nil][0][0]
empty slice: [addr][0][0] // points to an address

nenhuma fatia

Eles são úteis quando você deseja representar uma fatia que não existe, como quando ocorre uma exceção em uma função que retorna uma fatia.

// Create a nil slice of integers.
var slice []int

fatia vazia

Fatias vazias são úteis quando você deseja representar uma coleção vazia, como quando uma consulta ao banco de dados retorna zero resultados.

// Use make to create an empty slice of integers.
slice := make([]int, 0)

// Use a slice literal to create an empty slice of integers.
slice := []int{}

Independentemente de saber se você está usando uma fatia nulo ou uma fatia vazia, o built-in funções append, lene captrabalho da mesma.

Exemplo de playground :

package main

import (
    "fmt"
)

func main() {

    var nil_slice []int
    var empty_slice = []int{}

    fmt.Println(nil_slice == nil, len(nil_slice), cap(nil_slice))
    fmt.Println(empty_slice == nil, len(empty_slice), cap(empty_slice))

}

impressões:

true 0 0
false 0 0

Fatia vazia e nula são inicializadas de maneira diferente no Go:

var nilSlice []int 
emptySlice1 := make([]int, 0)
emptySlice2 := []int{}

fmt.Println(nilSlice == nil)    // true
fmt.Println(emptySlice1 == nil) // false
fmt.Println(emptySlice2 == nil) // false

Quanto às três fatias, len e cap são 0.