¿Qué son las estructuras en Golang?

En el lenguaje GO, una estructura es una colección de variables (campos) agrupadas con un solo nombre. Es un tipo de datos compuesto que nos permite crear estructuras de datos personalizadas para mantener la información relacionada. Las estructuras en Go son como clases en programación orientada a objetos como C y C ++, pero no admiten la herencia. En cambio, confían en la composición para lograr la reutilización de código. Este artículo cubre las estructuras en Golang y cómo podemos declarar y acceder a los miembros de Struct.

¿Qué es una estructura en Golang?

En Golang, una estructura es un tipo de datos compuestos que consiste en cero o más campos con nombre, cada uno de los cuales tiene un tipo específico. Los campos de una estructura pueden ser de cualquier tipo, incluidas otras estructuras, matrices, funciones o interfaces.

Aquí hay un ejemplo de una estructura en Golang:

Tipo de persona estructura
Cadena de nombre completo
Años
Dirección del sitio

Tipo de estructura de dirección
StreetName String
Ciudad de nombre de nombre
Cadena de nombre de campo

Aquí hemos definido una estructura de persona que tiene tres campos: nombre completo, años y ubicación. El campo de la ubicación es en sí misma una estructura que tiene tres campos: streetname, ciudadname y nombre de campo.

Cómo declarar estructura en Golang

Podemos declarar una estructura en Golang utilizando el tipo palabra clave. El nombre de la estructura se define después del tipo palabra clave, y sus campos están encerrados en aparatos ortopédicos . Aquí está la sintaxis para declarar una estructura en Go:

tipo structName struct
FieldName1 fieldType1
FieldName2 fieldType2
…

A continuación se muestra un ejemplo de cómo declarar una estructura nombrada con el nombre de dos campos y la edad de la cadena de la edad de los tipos e int respectivamente:

Tipo de persona estructura
cadena de nombre
edad int

En el código anterior, hemos usado el tipo palabra clave para declarar una nueva estructura nombrada Persona con dos campos nombre de tipo cadena y edad de tipo int. Los campos están separados por un Nueva línea personaje pero un semicolon (;) También se puede usar para separarlos.

Cómo acceder al miembro de Struct en Golang

Para acceder a los campos de una instancia de estructura en el idioma GO punto (".") Se utiliza el operador. Este operador de puntos es seguido por un nombre de campo. Aquí hay un ejemplo de cómo acceder a los campos de nombre y edad de una instancia de estructura de persona:

// Crear una nueva instancia de estructura de 'persona' con el nombre de "kash" y 24 años
kash: = persona nombre: "kash", edad: 24
// acceder a los campos de la instancia de estructura 'kash'
fmt.Println (kash.nombre) // Salida: "Kash"
fmt.Println (kash.edad) // Salida: 24

En el código anterior, hemos creado una nueva instancia de Struct Struct llamada Kash con el nombre kash y edad 24. Luego accedemos a los campos de nombre y edad de la instancia de Kash Struct utilizando el (".") operador e imprimo en la consola.

Es importante tener en cuenta que se accede a los campos de una instancia de estructura utilizando notación de puntos y no la flecha notación (->) utilizado en otros lenguajes de programación. La notación del punto se usa de manera consistente a través de GO para acceder a los campos de las estructuras, así como a las propiedades y métodos de otros tipos.

Código de ejemplo de declarar y acceder al miembro de Struct en Golang

A continuación se muestra un ejemplo completo de declarar la estructura de la persona en Go e imprimir sus valores en la pantalla:

paquete principal
importar "fmt"
Tipo de persona estructura
cadena de nombre
edad int

func Main ()
// Crear una nueva instancia de estructura de 'persona' con el nombre de "kash" y 24 años
kash: = persona nombre: "kash", edad: 24
// imprime el 'nombre' y 'edad' de la instancia de estructura 'kash' en la consola
fmt.Printf ("Nombre: %s \ n", kash.nombre)
fmt.Printf ("edad: %d \ n", kash.edad)

En el código escrito anteriormente, primero declaramos el Persona estructura. Esta estructura contiene dos campos que son de nombre y edad. Después de eso, creamos una nueva instancia de Struct Struct llamada Kash con el nombre kash y edad 24.

Para mostrar el nombre y los campos de edad, usamos el fmt.Printf función con el %s y %d formatear especificadores para imprimir los campos de nombre y edad, respectivamente.

Después de ejecutar, el código siguiente aparece en la consola:

Cómo pasar la estructura como argumentos de función

Para pasar un argumento de estructura como una función en GO, simplemente tenemos que especificar el tipo de estructura como el tipo de parámetro en la firma de función, y luego pasar la instancia de struct como argumento al llamar a la función.

Código de ejemplo

El siguiente ejemplo muestra cómo pasar una instancia de Struct de persona como argumento a una función en el lenguaje GO e imprimir sus valores en la pantalla:

paquete principal
importar "fmt"
// declara una estructura llamada 'persona' con dos campos: 'nombre' y 'edad'
Tipo de persona estructura
cadena de nombre
edad int

// declarar una función llamada 'printperson' que toma una estructura de 'persona' como argumento
FUNC PrintPerson (P Person)
fmt.Printf ("Nombre: %S \ n", P.nombre)
fmt.Printf ("edad: %d \ n", p.edad)

func Main ()
// Crear una nueva instancia de estructura de 'persona' con el nombre de "kash" y 24 años
kash: = persona nombre: "kash", edad: 24
// pasar la instancia de estructura 'kash' a la función 'printperson'
Printperson (kash)

En el código anterior, primero declaramos la estructura de la persona con dos campos, nombre, y edad. Luego declaramos una función nombrada impreso Eso lleva a la estructura de una persona como argumento e imprime su nombre e campos de edad en la pantalla utilizando el FMT.Función printf.

En la función principal, creamos una nueva instancia de Struct Struct llamada Kash con el nombre kash y 24 años. Luego pasamos la instancia de Kash Struct a la función Printperson llamando a la función Printperson y pasando kash Como el argumento.

La siguiente salida se puede ver en la consola después de ejecutar el código anterior:

Conclusión

En Golang, las estructuras pueden representar tipos de datos complejos y encapsular datos relacionados. Una estructura es un tipo de datos compuesto por uno o más campos, cada uno de los cuales tiene un nombre y tipo específicos. Los campos de una estructura pueden ser de cualquier tipo, incluidas otras estructuras, matrices, funciones o interfaces. Este artículo discutido en detalle las estructuras de Go, para obtener más información sobre la declaración y el acceso a los elementos de estructura, lea el artículo.