Como atribuir valores padrão para campos struct em Golang?

Como Atribuir Valores Padrao Para Campos Struct Em Golang



Golang é uma linguagem de programação moderna que ganhou popularidade nos últimos anos. Um dos recursos poderosos do Golang é sua capacidade de definir e manipular structs. Estruturas são tipos de dados definidos pelo usuário que permitem aos desenvolvedores agrupar campos de dados relacionados em um único objeto. Em Go, estruturas pode ter valores padrão atribuídos aos seus campos, o que torna a inicialização muito mais fácil.

Neste ensaio, vamos explorar como atribuir um valor padrão para um campo struct em Golang.

O que são campos struct?

Em primeiro lugar, é fundamental compreender o conceito de campos de estrutura . O campos de estrutura são variáveis ​​que são agrupadas para formar um estrutura objeto. Cada campo de estrutura tem um nome e um tipo de dados. Por exemplo, uma estrutura que representa uma pessoa pode ter campos como nome, idade e sexo.







Como atribuir valores padrão para campos Struct em Golang?

Valores padrão pode ser atribuído a campos struct em Go usando:



  • Valores zero padrão
  • Construtores
  • Literais Estruturais
  • Valores de campo padrão

1: Valores Zero Padrão

Em Go, atribuir valores padrão a campos struct pode ser obtido com o comando “ valor zero ' recurso. Esse recurso atribui automaticamente um valor padrão de “ 0 ' ou ' falso ” para cada campo não inicializado, dependendo do tipo de dados. Isso significa que você não precisa definir explicitamente os valores padrão para cada campo na estrutura, pois o Go fará isso por você.



Esse recurso pode ser útil ao lidar com grandes structs com muitos campos, pois economiza tempo e esforço de definir manualmente os valores padrão para cada campo.





Aqui está um exemplo que usa o valor zero para atribuir valores padrão para campos struct:

pacote principal

importar 'fmt'

tipo Estrutura da pessoa {
Nome   string
Idade    int
flutuação de altura64
IsMale booleano
}

função principal ( ) {
p1 := Pessoa { Nome: 'John' , Idade: 30 }
fmt.Println ( p1.Name )
fmt.Println ( p1.Idade )
fmt.Println ( p1. Altura )
fmt.Println ( p1.IsMale )
}

O código acima define uma Pessoa estrutura com quatro campos: Name, Age, Height e IsMale, todos do tipo de dados bool. Em seguida, criamos uma nova instância da classe Person, p1, e inicializamos alguns de seus campos usando struct literais para especificar os nomes e valores dos campos. O valores zero padrão para os campos que não foram definidos explicitamente durante a inicialização são exibidos quando você imprime os valores dos campos usando fmt.Println .



Saída

2: Construtores

Ao escrever um construtor função para struct, você também pode fornecer valores padrão para campos struct em Golang. O construtor A função cria uma nova instância da struct e define os valores padrão para seus campos. Esse método economiza esforço e tempo, principalmente ao interagir com estruturas enormes com vários campos.

Aqui está um exemplo de como definir um construtor função com valores de campo padrão para uma estrutura:

pacote principal

importar 'fmt'

tipo Estrutura da pessoa {
Nome    string
Idade     int
String de endereço
}
função NovaPessoa ( ) * Pessoa {
retornar & Pessoa {
Nome: 'John Doe' ,
Idade: 30 ,
Endereço: 'Rua Principal 123' ,
}
}
função principal ( ) {
p := NovaPessoa ( )
fmt.Println ( p.Nome, p.Idade, p.Endereço )
}

No código acima, um Pessoa struct é definido, bem como o nova pessoa() função, que produz uma nova instância do Pessoa struct com padrões predeterminados. Nós chamamos nova pessoa() em principal() para criar uma nova instância de Person com valores de campo padrão , e então imprimimos os valores dos campos dessa instância.

Saída

3: Literais Estruturais

Em Golang, você pode definir valores padrão para campos struct usando literais de estrutura também. Simplesmente construa uma nova instância da estrutura e defina os valores para cada campo que precisa ser inicializado. Se desejar definir valores padrão para campos que não inicializar explicitamente, você pode usar o recurso de valor zero.

Aqui está um exemplo de como usar literais de estrutura para definir valores de campo padrão para uma estrutura:

pacote principal

importar 'fmt'

tipo Estrutura da pessoa {
Nome    string
Idade     int
String de endereço
}
função principal ( ) {
p := Pessoa {
Nome: 'John Doe' ,
Idade: 30 ,
}
fmt.Println ( p.Nome, p.Idade, p.Endereço )
}

No código acima, definimos um Pessoa struct neste exemplo e crie uma nova instância dele usando um struct literal e valores padrão para seus campos. Um novo Pessoa instância é criada em main() com alguns valores de campo preenchidos e outros deixados em branco. Desde o Endereço campo não é inicializado, ele recebe a string vazia que é o valor padrão para este campo. Por fim, imprimimos os valores de campo da instância Person.

Saída

4: Valores de campo padrão

Atribuindo valores padrão para campos de estrutura em Go é um processo direto. O valor padrão para um campo struct pode ser definido usando a sintaxe fieldName:defaultValue . Por exemplo, considere a seguinte definição de struct:

tipo Estrutura da pessoa {
Cadeia de nomes
idade int
Sequência de gênero
}

Atribuir valores padrão aos campos desta struct, podemos usar a seguinte sintaxe:

p := Pessoa {
Nome: 'John Doe' ,
Idade: 30 ,
Gênero: 'Macho' ,
}

No exemplo acima, atribuímos valores padrão aos campos da estrutura Person. Se omitirmos algum dos valores durante a inicialização, o valor padrão será usado em seu lugar. Por exemplo, se inicializarmos um objeto Person assim:

p := Pessoa {
Nome: 'Jane Doe' ,
}

O objeto Person resultante terá o valores padrão para os campos Idade e Sexo, que são 0 e uma string vazia, respectivamente.

Aqui está um código completo que ilustra o processo acima:

pacote principal
importar 'fmt'

tipo Estrutura da pessoa {
Nome   string
Idade    int
Sequência de gênero
}
função principal ( ) {
p1 := Pessoa {
Nome: 'John Doe' ,
Idade: 30 ,
Gênero: 'Macho' ,
}
fmt.Println ( p1 )

p2 := Pessoa {
Nome: 'Jeremy' ,
}
fmt.Println ( p2 )
}

No exemplo acima, construímos uma estrutura Person que possui três campos: Name, um int que representa a idade e Gender, uma string que representa o sexo. A sintaxe de inicialização struct é então usada para construir duas instâncias de Person, p1 e p2. p1 é inicializado com os valores “John Doe” para Name, “30” para Age e “Male” para Gender, que são todos valores expressamente fornecidos. Como não fornecemos valores para Idade e Sexo, os valores padrão de 0 e uma string vazia, respectivamente, serão atribuídos a eles. p2 é inicialmente inicializado apenas com o campo Nome fornecido.

Saída

Conclusão

Atribuindo valores padrão em Go é um aspecto essencial da programação com esta linguagem. Isso ajuda a garantir que cada instância de struct criada tenha dados padrão atribuídos a ela. Ao usar qualquer um dos métodos explicados acima, os desenvolvedores podem definir o valores padrão de campos struct de forma eficiente.