Buceo Profundo En el Go Type System

Spanish (Español) translation by Jean Perez (you can also view the original English article)

Go tiene un sistema de tipo muy interesante. Evita las clases y la herencia a favor de interfaces y composición, pero por otro lado no tiene plantillas o genéricos. La manera que maneja colecciones también es única.

En este tutorial usted aprenderá sobre los entresijos de la Go type system y cómo utilizarlo eficazmente para escribir código Go claro e idiomático.

El Panorama del Go type system

El sistema de tipo Go soporta los paradigmas procesales, orientado a objetos y funcionales. Tiene muy limitado soporte para programación genérica. Mientras que el Go es un lenguaje decididamente estático, proporciona suficiente flexibilidad para técnicas de dinámica a través de interfaces, funciones de primera clase y la reflexión. Sistema de tipo de ir carece de capacidades que son comunes en las lenguas más modernas:

No hay ningún tipo de excepción desde el error de ir manejo se basa en la interfaz de error y códigos de retorno.
No hay ninguna sobrecarga de operadores.
No hay ninguna función de sobrecarga (mismo nombre de función con parámetros diferentes).
Hay no opcional o por defecto de parámetros de la función.

Esas omisiones son todos de diseño con el fin de hacer más sencillo posible.

Tipos de Alias

Usted puede tipos de alias en ir y crear tipos distintos. Se puede asignar un valor del tipo subyacente a un tipo de alias sin conversión. Por ejemplo, la asignación var b int = a el siguiente programa produce un error de compilación porque el tipo de Age es un alias de int, pero no es un int:

package main


type Age int

func main() {
    var a Age = 5
    var b int = a
}


Output:

tmp/sandbox547268737/main.go:8: cannot use a (type Age) as
type int in assignment

Puede agrupar las declaraciones de tipo o utilizar una declaración por línea:

type IntIntMap map[int]int
StringSlice []string

type (
    Size   uint64
    Text  string
    CoolFunc func(a int, b bool)(int, error)
)

Tipos Básicos

Todos los sospechosos de siempre están aquí: bool, cadenas, enteros y enteros sin signo con tamaños poco explícita, complejo números (64-bit y 128-bit) y números de coma flotante (32 bits y 64 bits).

bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32, represents a Unicode code point
float32 float64
complex64 complex128

Cadenas

Cadenas en GO son UTF8 codificada y por lo tanto pueden representar cualquier carácter Unicode. El paquete de cadenas proporciona una serie de operaciones de cadena. Aquí está un ejemplo tomando un conjunto de palabras, convertir al caso correcto y junto a ellos a una oración.

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := []string{"i", "LikE", "the ColORS:", "RED,", 
                      "bLuE,", "AnD", "GrEEn"}
    properCase := []string{}
    
    for i, w := range words {
        if i == 0 {
            properCase = append(properCase, strings.Title(w))
        } else {
            properCase = append(properCase, strings.ToLower(w))
        }
    }
    
    sentence := strings.Join(properCase, " ") + "."
    fmt.Println(sentence)
}

Punteros

Go tiene punteros. El puntero nulo (ver más adelante valores cero) es nulo. Usted puede obtener un puntero a un valor con el & operador y obtener de nuevo usando el * operador. Puede tener punteros a punteros también.

package main

import (
    "fmt"
)


type S struct {
    a float64
    b string
}

func main() {
    x := 5
    px := &x
    *px = 6
    fmt.Println(x)
    ppx := &px
    **ppx = 7
    fmt.Println(x)
}

Programación Orientada a Objetos

Go soporta programación orientada a objetos a través de interfaces y estructuras. Hay no hay clases y no hay jerarquía de clases, aunque puede integrar estructuras anónimas dentro de estructuras, que ofrecen a una especie de herencia simple.

Para una exploración detallada de la programación orientada a objetos en ir, echa un vistazo Let's Go: Golang Programación Orientado a Objetos.

Interfaces

Las interfaces son la piedra angular del sistema de tipo de Go. Una interfaz es simplemente una colección de firmas de método. Cada tipo que implementa todos los métodos es compatible con la interfaz. Aquí está un ejemplo rápido. La interfaz de Shape define dos métodos: GetPerimeter() y GetArea(). El objeto Square implementa la interfaz.

type Shape interface {
    GetPerimeter() uint
    GetArea() uint
}

type Square struct {
   side  uint
}

func (s *Square) GetPerimeter() uint {
    return s.side * 4
}

func (s *Square) GetArea() uint {
    return s.side * s.side
}

La interfaz vacío interface{} es compatible con cualquier tipo, porque no existen métodos que se requieren. La interfaz vacíela entonces puede apuntar a cualquier objeto (similar a Java del objeto o puntero void C y C++) y a menudo se utiliza para mecanografiar dinámico. Interfaces siempre son punteros y apuntan a un objeto concreto.

Para un artículo entero sobre interfaces ir, echa un vistazo: Cómo Definir e Implementar una Interfaz de GO.

Estructuras

Las estructuras son tipos definidos por el usuario de Go. Una estructura contiene los campos nombre, que pueden ser tipos básicos, los tipos de puntero u otros tipos de estructura. También puede integrar estructuras de forma anónima en otras estructuras como una forma de herencia de implementación.

En el ejemplo siguiente, las estructuras de S1 y S2 están incrustadas en la estructura S3, que también tiene su propio campo de int y un puntero a su tipo:

package main

import (
    "fmt"
)


type S1 struct {
    f1 int
}

type S2 struct {
    f2 int
}

type S3 struct {
    S1
    S2
    f3 int
    f4 *S3
}


func main() {
    s := &S3{S1{5}, S2{6}, 7, nil}
    
    fmt.Println(s)
}

Output:

&{{5} {6} 7 <nil>}

Tipo de Afirmaciones

Tipo de afirmaciones le permiten convertir una interfaz a su tipo concreto. Si ya sabes el tipo subyacente, sólo puede afirmarla. Si no está seguro, puede tratar de varias afirmaciones de tipo hasta que descubres el tipo correcto.

En el ejemplo siguiente, hay una lista de cosas que contiene cadenas y valores de cadena no representados como un segmento de interfaces vacías. El código recorre en iteración todas las cosas, tratando de convertir cada elemento en una cadena y almacenar todas las cadenas en un segmento independiente que finalmente se imprime.

package main

import "fmt"

func main() {
    things := []interface{}{"hi", 5, 3.8, "there", nil, "!"}
    strings := []string{}
    
    for _, t := range things {
        s, ok := t.(string)
        if ok {
            strings = append(strings, s)
        }
    }
    
    fmt.Println(strings)
    
}

Output:

[hi there !]

Reflexión

El paquete de reflect Go le permite comprobar directamente el tipo de una interfaz sin afirmaciones de tipo. También puede extraer el valor de una interfaz y convertirlo en una interfaz si desea (no tan útil).

Aquí hay un ejemplo similar al ejemplo anterior, pero en lugar de las cadenas de impresión sólo cuenta, por lo que no es necesario convertir de interfaz{} a cadena. La clave es llamar a reflect.Type() para obtener un objeto de tipo, que tiene un método Kind() que nos permite detectar si tratamos con una cadena o no.

package main

import (
    "fmt"
    "reflect"
)


func main() {
    things := []interface{}{"hi", 5, 3.8, "there", nil, "!"}
    stringCount := 0
    
    for _, t := range things {
        tt := reflect.TypeOf(t)
        if tt != nil && tt.Kind() == reflect.String {
            stringCount++
        }
    }
    
    fmt.Println("String count:", stringCount)
}

Funciones

Funciones son ciudadanos de primera clase en Go. Eso significa que puede asignar funciones a variables, pasar funciones como argumentos a otras funciones o devolver como resultados. Le permite utilizar el estilo de programación funcional con ir.

En el ejemplo siguiente se muestra un par de funciones, GetUnaryOp() y GetBinaryOp(), que devuelven funciones anónimas seleccionadas al azar. El programa principal decide si necesita una operación unaria o una operación binaria basada en el número de argumentos. Almacena la función seleccionada en una variable local llamada "op" y entonces invoca con el número correcto de argumentos.

package main

import (
    "fmt"
    "math/rand"
)

type UnaryOp func(a int) int
type BinaryOp func(a, b int) int


func GetBinaryOp() BinaryOp {
    if rand.Intn(2) == 0 {
        return func(a, b int) int { return a + b }
    } else {
        return func(a, b int) int { return a - b }
    }
}

func GetUnaryOp() UnaryOp {
    if rand.Intn(2) == 0 {
        return func(a int) int { return -a }
    } else {
        return func(a int) int { return a * a }
    }
}


func main() {
    arguments := [][]int{{4,5},{6},{9},{7,18},{33}}
    var result int
    for _, a := range arguments {
        if len(a) == 1 {
            op := GetUnaryOp()
            result = op(a[0])            
        } else {
            op := GetBinaryOp()
            result = op(a[0], a[1])                    
        }
        fmt.Println(result)                
    }
}

Canales

Los canales son un tipo de datos inusuales. Usted puede pensar en ellos como mensaje colas utilizadas para pasar mensajes entre goroutines. Los canales son fuertemente tipados. Se sincronizan y han dedicado soporte de sintaxis para enviar y recibir mensajes. Cada canal puede recibir sólo, sólo enviar o bidireccional.

Canales también pueden ser opcionalmente protegidos. Se puede iterar sobre los mensajes en un canal con variedad e ir rutinas pueden bloquear en varios canales al mismo tiempo con la operación de selección versátil.

Aquí está un ejemplo típico donde se calcula la suma de los cuadrados de una lista de enteros en paralelo por las rutinas de ir dos, cada uno responsable de la mitad de la lista. La función principal espera por el resultado de ambas rutinas irás y luego se suma las sumas parciales para el total. Nota cómo el canal c se crea utilizando la función incorporada de make() y cómo el código Lee y escribe en el canal mediante el especial <- operador.

package main

import "fmt"

func sum_of_squares(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v * v
    }
    c <- sum // send sum to c
}

func main() {
    s := []int{11, 32, 81, -9, -14}

    c := make(chan int)
    go sum_of_squares(s[:len(s)/2], c)
    go sum_of_squares(s[len(s)/2:], c)
    sum1, sum2 := <-c, <-c // receive from c
    total := sum1 + sum2

    fmt.Println(sum1, sum2, total)
}

Esto es apenas raspando la superficie. Para una revisión detallada de los canales, echa un vistazo:

Ir

Let's Go: Concurrencia de Golang, Parte 2

Gigi Sayfan

Colecciones

Go tiene varias colecciones genéricas incorporados que pueden almacenar cualquier tipo. Estas colecciones son especiales, y no se pueden definir sus propio colecciones genéricas. Las colecciones son matrices, cortes y mapas. Canales también son genéricos y pueden ser considerados colecciones demasiado, pero tienen algunas propiedades bastante únicas, por lo que prefiero discutir por separado.

Matrices

Las matrices son colecciones de tamaño fijo de elementos del mismo tipo. Estos son algunos arreglos:

package main
import "fmt"


func main() {
    a1 := [3]int{1, 2, 3}
    var a2 [3]int
    a2 = a1 

    fmt.Println(a1)
    fmt.Println(a2)
    
    a1[1] = 7

    fmt.Println(a1)
    fmt.Println(a2)
    
    a3 := [2]interface{}{3, "hello"}
    fmt.Println(a3)
}

Tamaño de la matriz es parte de su tipo. Puede copiar matrices del mismo tipo y tamaño. La copia es por valor. Si desea almacenar elementos de tipo diferente, puede utilizar la escotilla de escape de una gran variedad de interfaces de vacías.

Rebanadas

Las matrices son muy limitadas debido a su tamaño fijo. Rebanadas son mucho más interesantes. Usted puede pensar de rebanadas como matrices dinámicas. Bajo las sábanas, rebanadas de utilizan una matriz para almacenar sus elementos. Usted puede comprobar la longitud de un segmento, añadir elementos y otros sectores, y más divertido de todos que se puede extraer las rodajas similar a Python rebanar:

package main

import "fmt"



func main() {
    s1 := []int{1, 2, 3}
    var s2 []int
    s2 = s1 

    fmt.Println(s1)
    fmt.Println(s2)

    // Modify s1    
    s1[1] = 7

    // Both s1 and s2 point to the same underlying array
    fmt.Println(s1)
    fmt.Println(s2)
    
    fmt.Println(len(s1))
    
    // Slice s1
    s3 := s1[1:len(s1)]
    
    fmt.Println(s3)
}

Cuando copie rebanadas, solo copie la referencia a la misma matriz subyacente. Cuando rebana, el sub-segmento todavía señala el mismo arreglo de discos. Pero cuando usted agregar, un sector que apunta a una nueva matriz.

Puede iterar sobre matrices o rebanadas utilizando un lazo regular con índices o gamas. También puede crear divisiones en una capacidad determinada que se inicializará con el valor cero de su tipo de datos mediante la función make():

package main

import "fmt"



func main() {
    // Create a slice of 5 booleans initialized to false    
    s1 := make([]bool, 5)
    fmt.Println(s1)
    
    s1[3] = true
    s1[4] = true

    fmt.Println("Iterate using standard for loop with index")
    for i := 0; i < len(s1); i++ {
        fmt.Println(i, s1[i])
    }
    
    fmt.Println("Iterate using range")
    for i, x := range(s1) {
        fmt.Println(i, x)
    }
}

Output:

[false false false false false]
Iterate using standard for loop with index
0 false
1 false
2 false
3 true
4 true
Iterate using range
0 false
1 false
2 false
3 true
4 true

Mapas

Los mapas son colecciones de pares de clave y valor. Se pueden asignar literales de mapa u otros mapas. También puede crear mapas de vacíos utilizando la función incorporada de make. Usted tener acceso a elementos mediante corchetes. Mapas de apoyan iteración usando range, y puede comprobar si una clave existe tratando de acceder a él y comprobando el valor devuelto booleano opcional segunda.

package main

import (
    "fmt"
)

func main() {
    // Create map using a map literal
    m := map[int]string{1: "one", 2: "two", 3:"three"}
    
    // Assign to item by key
    m[5] = "five"
    // Access item by key
    fmt.Println(m[2])
    
    v, ok := m[4]
    if ok {
        fmt.Println(v)
    } else {
        fmt.Println("Missing key: 4")
    }
    
    
    for k, v := range m {
        fmt.Println(k, ":", v)
    }
}

Output:

two
Missing key: 4
5 : five
1 : one
2 : two
3 : three

Tenga en cuenta que la iteración no está en orden de creación o inserción.

Valores Cero

No hay ningún tipo sin inicializar en ir. Cada tipo tiene un predefinido cero valor. Si se declara una variable de un tipo sin asignarle un valor, que contiene su valor cero. Esta es una característica de seguridad importante.

Para cualquier tipo T, *new(T) devolverá un cero valor de T.

De tipo booleano, el valor cero es "falso". Para tipos numéricos, la cero valor es... cero. Láminas, mapas y punteros, es nulo. Para estructuras, es una estructura donde todos los campos se inicializan con su valor de cero.

package main

import (
    "fmt"
)


type S struct {
    a float64
    b string
}

func main() {
    fmt.Println(*new(bool))
    fmt.Println(*new(int))
    fmt.Println(*new([]string))
    fmt.Println(*new(map[int]string))
    x := *new([]string)
    if x == nil {
        fmt.Println("Uninitialized slices are nil")
    }

    y := *new(map[int]string)
    if y == nil {
        fmt.Println("Uninitialized maps are nil too")
    }
    fmt.Println(*new(S))
}

¿Plantillas o Genéricos?

Go no tiene ninguno. Esta es probablemente la queja más común sobre el sistema de ir. Los diseñadores van están abiertos a la idea, pero no sé todavía cómo implementar sin violar los principios de diseño subyacentes a la lengua. ¿Qué puede hacer si usted necesita gravemente algunos tipos de datos genéricos? Aquí están algunas sugerencias:

Si sólo tienes unas pocas instancias, considere a crear objetos concretos.
Utilice una interfaz vacía (usted necesitará tipo afirmar a su tipo concreto en algún momento).
Usar generación de código.

Conclusión

Go tiene un interesante sistema de tipo. Los diseñadores de Go decisiones explícitas para quedarse en el simple lado del espectro. Si eres serio sobre Go programación, debe invertir el tiempo y conocer su sistema y su idiosincrasia. Será bien vale la pena su tiempo.