Variables y Tipos

## Objetivos de Aprendizaje - Declarar e inicializar variables - Comprender los tipos básicos de Go - Dominar la inferencia de tipos - Trabajar con constantes - Valores cero y comportamiento predeterminado ## Variables ### Declaración ```go var name string = "Go" // Declaración con tipo var version = 1.20 // Declaración con inferencia name := "Golang" // Declaración corta (solo funciones) ``` ### Declarar Múltiples Variables ```go var ( name string = "Go" version float64 = 1.20 isAwesome bool = true ) ``` ### Declaración en Paralelo ```go var a, b, c int = 1, 2, 3 var name, age = "Alice", 30 ``` ## Reglas de Nomenclatura - Comenzar con letra o guión bajo - Pueden contener números (después del primer carácter) - Sensible a mayúsculas/minúsculas - No usar palabras reservadas ```go var name string // Válido var _count int // Válido (privado) var 2ndPlace int // Inválido var for int // Inválido (palabra reservada) ``` ## Tipos Básicos ### Tipos Enteros | Tipo | Rango | |------|-------| | int | Dependiente de la plataforma (32 o 64 bits) | | int8 | -128 a 127 | | int16 | -32,768 a 32,767 | | int32 | -2,147,483,648 a 2,147,483,647 | | int64 | -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 | | uint | Sin signo, dependiente de la plataforma | | uint8 | 0 a 255 | | uint16 | 0 a 65,535 | | uint32 | 0 a 4,294,967,295 | | uint64 | 0 a 18,446,744,073,709,551,615 | ```go var i int = 100 var ui uint = 100 ``` ### Tipos de Punto Flotante | Tipo | Rango | |------|-------| | float32 | ~1.4e-45 a ~3.4e38 | | float64 | ~4.9e-324 a ~1.8e308 | ```go var pi float64 = 3.14159265359 var e float32 = 2.71828 ``` ### Números Complejos ```go var c1 complex64 = 1 + 2i var c2 complex128 = 1 + 2i ``` ### Tipo Booleano ```go var isActive bool = true var hasPermission bool = false ``` ### Tipo String ```go var name string = "Go Programming" var empty string = "" ``` ### Tipo Rune ```go var grade rune = 'A' // Punto de código Unicode var emoji rune = '😀' ``` ### Tipo Byte ```go var b byte = 'A' // Alias para uint8 ``` ## Inferencia de Tipos ```go var version = 1.20 // Inferido como float64 var count = 100 // Inferido como int var name = "Go" // Inferido como string var isTrue = true // Inferido como bool ``` ## Valores Cero Las variables declaradas sin inicialización obtienen un valor cero. | Tipo | Valor Cero | |------|------------| | int | 0 | | float64 | 0.0 | | bool | false | | string | "" | | pointers | nil | ```go var i int // 0 var f float64 // 0.0 var b bool // false var s string // "" var arr []int // nil ``` ## Constantes ### Declaración de Constantes ```go const Pi = 3.14159 const MaxSize = 100 const AppName = "MyApp" ``` ### Múltiples Constantes ```go const ( StatusOK = 200 StatusError = 500 StatusRedirect = 300 ) ``` ### Enumerador iota ```go const ( Sunday = iota // 0 Monday // 1 Tuesday // 2 Wednesday // 3 ) const ( Flag1 = 1 << iota // 1 Flag2 // 2 Flag3 // 4 ) ``` ## Conversión de Tipos ### Conversión Explícita Requerida Go no permite conversión implícita de tipos. ```go var i int = 42 var f float64 = float64(i) var u uint = uint(f) ``` ### Entero a String ```go import "strconv" i := 42 s := strconv.Itoa(i) // "42" s := strconv.FormatInt(int64(i), 10) ``` ### String a Entero ```go import "strconv" s := "42" i, err := strconv.Atoi(s) // 42, nil ``` ### ParseFloat ```go import "strconv" s := "3.14159" f, err := strconv.ParseFloat(s, 64) // 3.14159 ``` ## Operaciones con Strings ### Longitud ```go import "unicode/utf8" s := "Hello" len(s) // 5 (bytes) utf8.RuneCountInString(s) // 5 (caracteres) ``` ### Concatenación ```go s1 := "Hello" s2 := "World" s3 := s1 + " " + s2 // "Hello World" ``` ### String Builder ```go import "strings" var sb strings.Builder sb.WriteString("Hello") sb.WriteString(" ") sb.WriteString("World") s := sb.String() // "Hello World" ``` ## Alcance de Variables ### Alcance de Función ```go func main() { x := 10 // Alcance de función if x > 5 { y := 20 // Alcance de bloque fmt.Println(x, y) } // fmt.Println(y) // Error: y no está definido } ``` ### Alcance de Paquete ```go var globalVar = "Soy global" func main() { fmt.Println(globalVar) } ``` ## Redeclaración La declaración corta puede redeclarar variables en el mismo alcance. ```go i, j := 1, 2 i, j := 3, 4 // Redeclara i y j ``` ## Identificador en Blanco Descartar valores usando `_`. ```go result, _ := someFunction() // Ignorar segundo valor de retorno ``` ## Resumen - Las variables se declaran con `var` o `:=` - Go tiene múltiples tipos enteros con diferentes rangos - Flotantes: `float32` y `float64` - Booleanos: `true` o `false` - Strings: caracteres UTF-8 - Valores cero: `0`, `0.0`, `false`, `""`, `nil` - Las constantes se declaran con `const` - La conversión de tipos debe ser explícita: `float64(i)` - Go no permite conversión implícita de tipos