Datos
Variables y constantes
Declaración con tipado
var nombre tipo const nombre tipo var nombre tipo = valor const nombre tipo = valor var nombre1, nombre2, ... tipo const nombre1, nombre2, ... tipo var nombre1, nombre2, ... tipo = valor1, valor2, ... const nombre1, nombre2, ... tipo = valor1, valor2, ... var/const ( nombre1 tipo = valor1 nombre2 tipo = valor2 ... )
Declaración de variables por inferencia
nombre := valor nombre1, nombre2, ... := valor1, valor2, ...
Tipos de datos básicos
Cadena
string
Boolean o lógico
bool
Números
Enteros
Sin signo
byte 1 byte. 0..255 uint8 1 byte. 0..255 uint16 2 bytes. 0..65535 uint 4 bytes. 0..4294967295 uint32 4 bytes. 0..4294967295 uint 8 bytes. 0..18446744073709551615 uint64 8 bytes. 0..18446744073709551615
Con signo
int8 1 byte. -127..128 int16 2 bytes. -32768..32767 rune 4 bytes. -2147483648..2147483647 int 4 bytes. -2147483648..2147483647 int32 4 bytes. -2147483648..2147483647 int 8 bytes. -9223372036854775808..9223372036854775807 int64 8 bytes. -9223372036854775808..9223372036854775807
Reales o decimales
float32 4 bytes con signo float64 8 bytes con signo complex32 4 bytes con signo + parte imaginaria complex64 8 bytes con signo + parte imaginaria
Colecciones
Arrays
Los arrays son colecciones de datos del mismo tipo, con un tamaño fijo. Se referencian por un índice, que es la posición del elemento en el array, comenzando desde cero y terminando en su longitud - 1
// Declaracion y creacion
var variableArray[tamaño]tipoDato
variableArray := [tamaño]tipoData{valor1, valor2, ...}
// Asignacion de valor a un elemento
variableArray[indice] = valor
// Acceso a un elemento
variableArray[indice]
// Longitud de un array
len(variableArray)
// Capacidad de un array (igual a longitud)
cap(variableArray)
// Extraer un fragmento del array
variableArray[posicionInicio:posicionFinal]
// Extraer desde el inicio hasta posición-1
variableArray[:posicion]
// Extraer desde posición hasta el final
variableArray[posicion:]
// Arrays multidimensionales
var variableArray[tam1][tam2][...]tipoDato
// Asignacion multidimensional
variableArray[pos1][pos2][...] = valor
// Acceso multidimensional
variableArray[pos1][pos2][...]
Slices
Un slice (fragmento), es un tipo de array que puede ser dinámico, es decir que puede variar su tamaño. La forma de acceder o extraer fragmentos de un slice es igual que en un array.
// Declaracion y creacion
var variableSlice[]tipoDato
variableSlice := variableArray[posicionInicio, posicionFinal]
variableSlice := make([]tipoDato)
variableSlice := make([]tipoDato, longitud)
variableSlice := make([]tipoDato, longitud, capacidad)
// Asignacion de valores desde array
variableSlice = variableArray[posicionInicio, posicionFinal]
// Asignacion directa de valores
variableSlice = []tipoDato{valor1, valor2, ...}
// Agregar nuevos valores
variableSlice = append(variableSlice, valor1, valor2, ...)
// Copiar valores entre slices
copy(variableSlice1, variableSlice2)
Mapas
Un mapa es una colección de datos de tipo clave/valor. En lugar de acceder mediante un índice, se accede mediante un valor de clave.
// Declaracion y creacion
var variableMapa map[tipoClave]tipoValor
variableMapa := make(map[tipoClave]tipoValor
// Agregar o modificar elemento
variableMapa[clave] = valor
// Eliminar elemento
delete(variableMapa, clave)
// Verificar si existe un elemento
// var1 recoge la clave (si existe)
// var2 es un boolean: true si existe
var1, var2 = variableMapa[clave]
_, var = variableMapa[clave]
// Recorrer un mapa
for varClave, varValor := range variableMapa {
...
}
Operadores
Asignación
var/const nombre tipo = valor // Con tipado nombre := valor // Por inferencia
Aritméticos
expr1 + expr2 Suma expr1 - expr2 Resta expr1 * expr2 Multiplicación expr1 / expr2 División expr1 % expr2 Resto (de la división)
Incremento / decremento
valor++ // valor = valor + 1 valor-- // valor = valor - 1
Asignación aritmética
valor1 += valor2 // valor1 = valor1 + valor2 valor1 -= valor2 // valor1 = valor1 - valor2 valor1 *= valor2 // valor1 = valor1 * valor2 valor1 /= valor2 // valor1 = valor1 / valor2 valor1 %= valor2 // valor1 = valor1 % valor2
Concatenación
string1 + string2 // Concatenación variableString += string // Concatenación y asignación
Comparación
valor1 == valor2 igual a valor1 != valor2 distinto de (no igual a) valor1 < valor2 menor que valor1 <= valor2 menor o igual que valor1 > valor2 mayor que valor1 >= valor2 mayor o igual que
Lógicos o relacionales
valor1 && valor2 AND/Y valor2 || valor2 OR/O !valor NOT/NO (negación)
Estructuras de control
if y else
if condición {
// Código si condición es true
}
if condición {
// Código si condición es true
} else {
// Código si condición es false
}
if condición1 {
// Código si condición1 es true
} else if condición2 {
// Código si condición2 es true
} [else ... {
...
}]
switch, case y default
switch {
case condición1:
// código si condición1 es true
case condición2:
// código si condición2 es true
[case ...
...
]
[default:
// código si ninguna condición anterior es true
]
}
switch variable {
case valor1:
// código si variable == valor1
case valor2, valor3, ...:
// código si variable == valor2 o valor3...
[case ...
...
]
[default:
// código si ningún valor anterior
]
}
for
// Bucle controlador de iterador
for iterador:=valorInicio; condiciónIterador; incrementoIterador {
...
[break]
...
[continue]
...
}
// Bucle "while"
iterador := valorInicio
for condiciónIterador {
...
[break]
...
[continue]
...
incrementoIterador
}
// Bucle infinito
for {
...
[break]
...
[continue]
...
}
Rangos
// Bucle controlador de iterador for índice/clave, valor := range{ ... [break] ... [continue] ... }
Funciones
Conceptos básicos
// Funcion basica
func nombreFuncion() {
...
}
// Funcion con parametros
func nombreFuncion(param1 [, param2 ]) {
...
}
// Funcion con retorno
func nombre([params ]) {
...
return
}
// Funcion con retorno multiple
func nombre([params ]) (, ) {
...
return , valor2[...]
}
Funciones variádicas
// Funcion variadica func nombre(tipo, ... ) { ... for indice, valor := range { fmt.Printf("Indice %v > %v\n", indice, valor) } }
Funciones anónimas
... // La funcion anonima se asigna un identificador identificador := func([params]){ ... return } // Invocacion a la funcion anonima identificador([params]) ...
Closures
... // Declaracion del closure identificador := nombreFuncion() ... // Invocacion al closure identificador([params]) ... func nombreFuncion() func([params]){ // Inicializacion variables internas return func([params]) { ... return } }
No hay comentarios:
Publicar un comentario