Estructura golang

Para abreviar, una estructura o estructura es una colección de campos con tipos de datos definidos. Las estructuras son muy útiles y mejoran la flexibilidad en los programas. Las estructuras son probablemente su mejor opción si tiene datos que se representan mejor como una unidad. Piense en ello como una versión liviana de la programación orientada a objetos.

GO le permite crear y usar estructuras utilizando tipos incorporados o definidos por el usuario.

Esta guía hará un viaje y explorará cómo funcionan las estructuras en el lenguaje de programación GO.

Declarando una estructura

La sintaxis a continuación muestra cómo crear estructura en Go:

typestruct_namestruct
Field_1 data_type
Field_2 data_type
…
campo_ndata_type

Comenzamos llamando a la palabra clave de tipo. Luego viene el nombre de la estructura. El nombre de la estructura puede ser cualquier cosa definida por el usuario (siempre que siga las reglas de nombrar en Go). Luego usamos la palabra clave struct, seguido de un par de aparatos ortopédicos rizados.

Dentro de los aparatos ortopédicos, definimos varios campos que componen la estructura. El nombre del campo es seguido por su tipo de datos.

Declarar estructura - ejemplo

El código de ejemplo a continuación define una estructura llamada empleado. Contiene 5 campos con varios tipos de datos.

estructura de typeEmployee
Cadena de nombre
Edad int
Bool retirado
Cadena de departamento
Flotación salarial64

Lo anterior crea una estructura de empleado que contiene campos de varios tipos.

Nota: Si desea exportar la estructura y sus campos a otros paquetes, asegúrese de que los nombres comiencen con letras mayúsculas. De lo contrario, el alcance se limita a ese paquete.

Instanciación de estructura

Definir una estructura significa que solo creamos un plan. Para crear un objeto fuera de la estructura, necesitamos crear una instancia de él.

Para crear una instancia de una clase en GO, comience con la palabra clave var seguida del nombre de la instancia.

El ejemplo a continuación crea una instancia de la estructura del empleado.

VAR EMP Empleado

Una vez que creamos una instancia de la estructura, podemos acceder a los campos utilizando la notación de puntos como se muestra:

VAR EMP Empleado
Embem.Nombre = "Thomas J"
Embem.Edad = 35
Embem.Retirado = falso
Embem.Departamento = "Ingeniero DevOps"
Embem.Salario = 130000.50

Una vez que establecemos los campos de la instancia, podemos imprimirlo como:

fmt.Println (EMP)

El fragmento anterior regresa:

$ Go Run Structs.ir
Thomas J 35 False DevOps Ingeniero 130000.5

Instanciación de estructura - literal

También puede crear una instancia de una estructura utilizando el método literal de struct. El ejemplo a continuación muestra usos struct literal para crear una instancia de una estructura.

var emp1 = empleado "Mary A", 26, False, "Game Developer", 150000.10
fmt.Println (emp1)

El ejemplo anterior crea una instancia de la clase y establece los campos sin usar la notación de puntos.

Instanciación de estructuras: nueva palabra clave

Si no desea establecer los valores durante la creación de instancias, puede usar la nueva palabra clave. Por ejemplo:

var emp2 = nuevo (empleado)

Una vez creado, podemos acceder a los campos de instancia y establecer valores como:

EMP2.Nombre = "Judy L"
EMP2.Edad = 60
EMP2.Retirado = verdadero
EMP2.Departamento = "Recursos humanos"
EMP2.Salario = 119000.99

Acceso a los campos de estructura

Para acceder a los campos de una estructura, vaya a proporcionarnos el operador DOT. Comenzamos con el nombre de la instancia de estructura y luego el nombre del campo.

Por ejemplo, para obtener el nombre del Emp2, podemos hacer:

fmt.Println (EMP2.Nombre)

Esto debería devolver el valor almacenado por el campo especificado.

Métodos de estructura

También podemos agregar un método a una estructura utilizando el receptor de métodos. Considere el ejemplo a continuación que crea un método para la estructura de los empleados.

func (e empleado) info () cadena
fmt.Printf ("Nombre: %S \ n Edad: %D \ n Retirado: %T \ n Departamento: %S \ n Salario: %f \ n", E.Nombre, E.Edad, E.Retirado, E.Departamento, E.Salario)
regresar "hecho"

Una vez que tengamos el método declarado, podemos crear una instancia y establecer los campos como:

empleado var e
mi.Nombre = "Thomas J"
mi.Edad = 35
mi.Retirado = falso
mi.Departamento = "Ingeniero DevOps"
mi.Salario = 130000.50

Finalmente, podemos llamar al método como:

fmt.Println (e.Info ())

Tras la llamada del método, debemos obtener una salida como:

Nombre: Thomas J
Edad: 35
Retirado: falso
Departamento: Ingeniero de DevOps
Salario: 130000.500000
Hecho

Tipo de campo struct

Puede averiguar el tipo de campo usando el paquete reflejar. Por ejemplo, para obtener el tipo de campo retirado, podemos hacer:

fmt.Println (reflejar.Typeof (e.Jubilado))

El código anterior devuelve el tipo de campo como:

::producción
bool

Comparación de estructura

Puede verificar si una estructura es igual a otra utilizando el operador de comparación. Tenga en cuenta que una estructura se define como igual si todos los campos tienen el mismo valor.

Nota: No todos los tipos de datos son comparables.

El ejemplo a continuación crea dos estructuras y las compara usando el operador ==.

…
empleado var e
mi.Nombre = "Thomas J"
mi.Edad = 35
mi.Retirado = falso
mi.Departamento = "Ingeniero DevOps"
mi.Salario = 130000.50
var emp2 = nuevo (empleado)
EMP2.Nombre = "Judy L"
EMP2.Edad = 60
EMP2.Retirado = verdadero
EMP2.Departamento = "Recursos humanos"
EMP2.Salario = 119000.99
Si e == *emp2
fmt.Println ("Las estructuras son iguales")
demás
fmt.Println ("Estructuras no iguales")

…

Dado que las estructuras no son iguales, el bloque de lo contrario se ejecuta.

PISTA: Los valores vacíos y cero se consideran iguales.

Conclusión

Uf!

Ese fue un tutorial excepcional sobre cómo trabajar con estructuras en Go Lang. Este tutorial, sin embargo, solo cubre lo básico. Hay muchas más operaciones que puede hacer con estructuras.

Sigue practicando y consulte nuestros tutoriales GO para obtener más información.