Go (lenguaje de programación)

La mascota de la ardilla terrestre se introdujo en 2009 para el lanzamiento de código abierto del lenguaje. Renée French , quien había diseñado la mascota del conejo para Plan 9 , adaptó la ardilla terrestre de un diseño anterior de camiseta de WFMU . ^{[ 34 ]}

En noviembre de 2016, los diseñadores tipográficos Charles Bigelow y Kris Holmes lanzaron las fuentes Go y Go Mono específicamente para su uso en el proyecto Go. Go es una sans-serif humanista similar a Lucida Grande , pero con una compatibilidad métrica casi completa (aunque no total) con Helvetica y Arial , y Go Mono es monoespaciada . Ambas fuentes se adhieren al conjunto de caracteres WGL4 y fueron diseñadas para ser legibles con una altura de x grande y formas de letra distintivas . Tanto Go como Go Mono se adhieren al estándar DIN 1450 al tener un cero tachado, minúsculas lcon cola y mayúsculas Icon serifa. ^{[ 35 ] [ 36 ]}

En abril de 2018, el diseñador de marca Adam Smith rediseñó el logotipo original. El nuevo logotipo es una letra GO moderna y estilizada que se inclina hacia la derecha con líneas aerodinámicas que la siguen. La mascota, la ardilla terrestre, se mantuvo igual. ^{[ 37 ]}

La falta de soporte para la programación genérica en las versiones iniciales de Go generó críticas considerables. ^{[ 38 ]} Los diseñadores expresaron una apertura a la programación genérica y señalaron que las funciones integradas eran de hecho genéricas en cuanto a tipos, pero se trataban como casos especiales; Pike calificó esto como una debilidad que podría corregirse en algún momento. ^{[ 39 ]} El equipo de Google creó al menos un compilador para un dialecto experimental de Go con genéricos, pero no lo publicó. ^{[ 40 ]}

En agosto de 2018, los principales colaboradores de Go publicaron diseños preliminares para la programación genérica y el manejo de errores , y solicitaron a los usuarios que enviaran comentarios. ^{[ 41 ] [ 42 ]} Sin embargo, la propuesta de manejo de errores finalmente se abandonó. ^{[ 43 ]}

En junio de 2020, se publicó un nuevo borrador de documento de diseño ^{[ 44 ]} que añadiría la sintaxis necesaria a Go para declarar funciones y tipos genéricos. Se proporcionó una herramienta de traducción de código, go2go , para que los usuarios pudieran probar la nueva sintaxis, junto con una versión habilitada para genéricos del Go Playground en línea. ^{[ 45 ]}

Los genéricos finalmente se agregaron a Go en la versión 1.18 el 15 de marzo de 2022. ^{[ 46 ]}

Go 1 garantiza la compatibilidad ^{[ 47 ]} para la especificación del lenguaje y las partes principales de la biblioteca estándar. Todas las versiones hasta la versión actual Go 1.26 ^{[ 48 ]} han mantenido esta promesa.

Go utiliza un go1.[major].[patch]formato de versionado, como go1.26.0y cada versión principal de Go es compatible hasta que haya dos versiones principales más recientes. A diferencia de la mayoría del software, Go llama al segundo número de una versión la versión principal, es decir, en go1.26.0es 26la versión principal. ^{[ 49 ]} Esto se debe a que Go planea no llegar nunca a la versión 2.0, priorizando la compatibilidad con versiones anteriores sobre posibles cambios incompatibles. ^{[ 50 ]}

La sintaxis de Go incluye cambios respecto a C, con el objetivo de mantener el código conciso y legible. Se introdujo un operador combinado de declaración/inicialización que permite al programador escribir `or` , sin especificar los tipos de variables utilizadas. Esto contrasta con ` and` de C (aunque desde C23 se admite la inferencia de tipos mediante ` , como en C++ ). Go también elimina la necesidad de usar paréntesis en las condiciones de las sentencias.i:=3s:="Hello, world!"inti=3;char*s="Hello, world!";autoif

Los puntos y coma siguen finalizando las sentencias; ^{[ a ]} ​​pero son implícitos cuando se produce el final de una línea. ^{[ b ]}

Los métodos pueden devolver múltiples valores, y devolver un par es la forma convencional en que un método indica un error a quien lo llama en Go. ^{[ c ]} Go agrega sintaxis literales para inicializar parámetros de struct por nombre y para inicializar mapas y slices . Como alternativa al bucle de tres instrucciones de C, las expresiones de Go permiten una iteración concisa sobre arreglos, slices, cadenas, mapas y canales. ^{[ 59 ]}result,errforrange

Go tiene varios tipos integrados, incluidos los numéricos ( byte, int64, float32, etc.), booleanos y cadenas de bytes ( string). Las cadenas son inmutables; los operadores integrados y las palabras clave (en lugar de funciones) proporcionan concatenación, comparación y codificación/decodificación UTF-8 . ^{[ 61 ]} Los tipos de registro se pueden definir con la structpalabra clave. ^{[ 62 ]}

Go contiene las siguientes primitivas: ^{[ 63 ]}

Tenga en cuenta que bytees un alias de uint8y runees un alias de int32.

Para cada tipo Ty cada constante entera no negativa n, existe un tipo de arreglo denotado [n]T; los arreglos de diferentes longitudes son, por lo tanto, de diferentes tipos. Los arreglos dinámicos están disponibles como "segmentos", denotados []Tpara algún tipo T(compárese con otros lenguajes como C/C++ y Java , donde en cambio los arreglos se denotan T[]). Estos tienen una longitud y una capacidad que especifican cuándo se necesita asignar nueva memoria para expandir el arreglo. Varios segmentos pueden compartir su memoria subyacente. ^{[ 39 ] [ 64 ] [ 65 ]}

Los punteros están disponibles para todos los tipos, y el puntero alTtipo se denota*T(similar a Rust ; compárese con otros lenguajes como C/C++ y C# , donde los punteros se denotanT*). La toma de direcciones y la indirección utilizan los&y*, como en C, o se producen implícitamente a través de la llamada al método o la sintaxis de acceso a atributos. ^{[ 66 ] [ 67 ]} No hay aritmética de punteros, ^{[ d ]} excepto a través delunsafe.Pointertipo especial en la biblioteca estándar. ^{[ 68 ]}

Para un par de tipos K, V, el tipo map[K]Ves el mapeo de claves de tipo Ka Vvalores de tipo , que puede considerarse equivalente a Map<K, V>en otros lenguajes. La especificación del lenguaje de programación Go no ofrece garantías de rendimiento ni requisitos de implementación para los tipos de mapeo, aunque generalmente se implementa como una tabla hash (equivalente a HashMap<K, V>en otros lenguajes). Las tablas hash están integradas en el lenguaje, con una sintaxis especial y funciones integradas. chan Tes un canal que permite enviar valores de tipo Tentre procesos Go concurrentes . ^{[ 69 ]}

Aparte de su soporte para interfaces , el sistema de tipos de Go es nominal : la typepalabra clave se puede usar para definir un nuevo tipo con nombre , que es distinto de otros tipos con nombre que tienen la misma disposición (en el caso de un struct, los mismos miembros en el mismo orden). Algunas conversiones entre tipos (por ejemplo, entre los distintos tipos enteros) están predefinidas y agregar un nuevo tipo puede definir conversiones adicionales, pero las conversiones entre tipos con nombre siempre deben invocarse explícitamente. ^{[ 70 ]} Por ejemplo, la typepalabra clave se puede usar para definir un tipo para direcciones IPv4 , basado en enteros sin signo de 32 bits de la siguiente manera:

tipo ipv4addr uint32

Con esta definición de tipo, ipv4addr(x)interpreta el uint32valor xcomo una dirección IP. Simplemente asignar xa una variable de tipo ipv4addres un error de tipo. ^{[ 71 ]}

Las expresiones constantes pueden ser tipadas o "sin tipo"; se les asigna un tipo cuando se les asigna a una variable tipada si el valor que representan pasa una comprobación en tiempo de compilación. ^{[ 72 ]}

Los tipos de función se indican mediante lafuncpalabra clave; toman cero o más parámetros y devuelven cero o más valores, todos ellos tipados. Los parámetros y los valores de retorno determinan el tipo de función; por lo tanto,func(string, int32) (int, error)es el tipo de funciones que toman unstringy un entero con signo de 32 bits, y devuelven un entero con signo (de ancho predeterminado) y un valor del tipo de interfaz integradoerror. ^{[ 73 ]}

Cada tipo con nombre tiene un conjunto de métodos asociado. El ejemplo de dirección IP anterior se puede ampliar con un método para comprobar si su valor es un estándar conocido:

// ZeroBroadcast informa si addr es 255.255.255.255. func ( addr ipv4addr ) ZeroBroadcast () bool { return addr == 0xFFFFFFFF }

Debido a la tipificación nominal, esta definición de método agrega un método a ipv4addr, pero no a uint32. Si bien los métodos tienen una definición y sintaxis de llamada especiales, no existe un tipo de método distinto. ^{[ 74 ]}

importar "matemáticas"tipo Shape interface { Área () float64 }// Nota: no hay declaración "implements" type Square struct { side float64 }func ( sq Cuadrado ) Área () float64 { return sq . lado * sq . lado }// No hay declaración "implements" aquí tampoco type Circle struct { radius float64 }func ( c Circle ) Area () float64 { return math . Pi * math . Pow ( c . radius , 2 ) }

var shp Shape = Square { 5 } square , ok := shp .( Square ) // Afirma que shp es de tipo Square, debería funcionar if ok { fmt . Printf ( "%#v\n" , square ) } else { fmt . Println ( "No se puede imprimir la forma como Square" ) ​​}

func ( sq Cuadrado ) Diagonal () float64 { return sq . lado * math . Sqrt2 } func ( c Círculo ) Diámetro () float64 { return 2 * c . radio }func LongestContainedLine ( shp Shape ) float64 { switch v := shp .( type ) { case Square : return v.Diagonal ( ) // O, con aserción de tipo, shp.(Square).Diagonal() case Circle : return v.Diameter ( ) // O , con aserción de tipo, shp.(Circle).Diameter() default : return 0 // En la práctica, esto debería manejarse con errores } }

tipo Number interface { ~ int | ~ float64 | ~ float32 | ~ int32 | ~ int64 }func Add [ T Number ]( nums ... T ) T { var sum T for _ , v := range nums { sum += v } return sum }func main () { add := Add [ int ] // Instanciación de tipo println ( add ( 1 , 2 , 3 , 4 , 5 )) // 15res := Add ( 1.1 , 2.2 , 3.3 , 4.4 , 5.5 ) // Inferencia de tipo println ( res ) // +1.650000e+001 }

tipo ByteSize intconst ( _ = iota // ignora el primer valor asignándolo a un identificador en blanco; 0 KB ByteSize = 1 << ( 10 * iota ) // 1 << (10 * 1) == 1 << 10 == 1024; en binario 10000000000 MB // 1 << (10 * 2) == 1048576; en binario 1000000000000000000000 GB // 1 << (10 * 3) == 1073741824; en binario 10000000000000000000000000000000 )

En el sistema de paquetes de Go, cada paquete tiene una ruta (por ejemplo, "compress/bzip2"o "golang.org/x/net/html") y un nombre (por ejemplo, bzip2o html). Por defecto, las definiciones de otros paquetes siempre deben ir precedidas del nombre del otro paquete. Sin embargo, el nombre utilizado puede cambiarse del nombre del paquete, y si se importa como _, no se requiere ningún prefijo de paquete. Solo son accesibles los nombres en mayúsculas de otros paquetes: io.Readeres público, pero bzip2.readerno lo es. ^{[ 94 ]} El go getcomando puede recuperar paquetes almacenados en un repositorio remoto ^{[ 95 ]} y se anima a los desarrolladores a desarrollar paquetes dentro de una ruta base que corresponda a un repositorio de origen (como example.com/user_name/package_name) para reducir la probabilidad de colisión de nombres con futuras adiciones a la biblioteca estándar u otras bibliotecas externas. ^{[ 96 ]}

El lenguaje Go cuenta con funcionalidades integradas, así como con soporte de bibliotecas, para escribir programas concurrentes . El entorno de ejecución es asíncrono : la ejecución de un programa que realiza, por ejemplo, una lectura de red, se suspenderá hasta que haya datos disponibles para su procesamiento, lo que permite que otras partes del programa realicen otras tareas. Esta funcionalidad está integrada en el entorno de ejecución y no requiere ningún cambio en el código del programa. El entorno de ejecución de Go también programa automáticamente operaciones concurrentes (goroutines) en múltiples CPU; esto puede lograr paralelismo para un programa bien escrito. ^{[ 97 ]}

La principal estructura de concurrencia es la goroutine , un tipo de hilo ligero . ^{[ 98 ] : 280–281} Una llamada a función con el prefijo de la gopalabra clave inicia una función en una nueva goroutine. La especificación del lenguaje no especifica cómo deben implementarse las goroutines, pero las implementaciones actuales multiplexan las goroutines de un proceso Go en un conjunto más pequeño de hilos del sistema operativo , de forma similar a la planificación realizada en la implementación del entorno de ejecución del compilador Glasgow Haskell (GHC) de Erlang y Haskell . ^{[ 99 ] : 10}

Aunque existe un paquete de biblioteca estándar que incluye la mayoría de las estructuras clásicas de control de concurrencia (bloqueos mutex , etc.), ^{[ 99 ] : 151–152} los programas concurrentes idiomáticos prefieren los canales , que envían mensajes entre goroutines. ^{[ 100 ]} Los búferes opcionales almacenan mensajes en orden FIFO ^{[ 101 ] : 43} y permiten que las goroutines emisoras procedan antes de que se reciban sus mensajes. ^{[ 98 ] : 233}

Los canales tienen un tipo, de modo que un canal de un tipo chan Tsolo puede usarse para transferir mensajes de ese tipo T. Se utiliza una sintaxis especial para operar con ellos; <-ches una expresión que hace que la goroutine en ejecución se bloquee hasta que llegue un valor a través del canal ch, mientras que ch <- xenvía el valor x(posiblemente bloqueándose hasta que otra goroutine reciba el valor). La instrucción integrada switchsimilar a selectse puede usar para implementar comunicación sin bloqueo en múltiples canales; vea a continuación un ejemplo. Go tiene un modelo de memoria que describe cómo las goroutines deben usar canales u otras operaciones para compartir datos de forma segura. ^{[ 102 ]}

La existencia de canales no distingue por sí sola a Go de los lenguajes concurrentes basados ​​en el modelo de actores, como Erlang, donde los mensajes se dirigen directamente a los actores (que corresponden a las goroutines). En el modelo de actores, los canales son actores en sí mismos; por lo tanto, dirigirse a un canal simplemente significa dirigirse a un actor. El estilo de actores se puede simular en Go manteniendo una correspondencia uno a uno entre goroutines y canales, pero el lenguaje permite que varias goroutines compartan un canal o que una sola goroutine envíe y reciba mensajes en múltiples canales. ^{[ 99 ] : 147}

A partir de estas herramientas se pueden construir estructuras concurrentes como grupos de trabajadores , tuberías (en las que, por ejemplo, un archivo se descomprime y analiza mientras se descarga), llamadas en segundo plano con tiempo de espera, llamadas paralelas "en abanico" a un conjunto de servicios y otras. ^{[ 103 ]} Los canales también han encontrado usos más allá de la noción habitual de comunicación entre procesos, como servir como una lista segura de concurrencia de búferes reciclados, ^{[ 104 ]} implementar corrutinas (que ayudaron a inspirar el nombre goroutine ), ^{[ 105 ]} e implementar iteradores . ^{[ 106 ]}

Las convenciones estructurales de Go relacionadas con la concurrencia ( canales y entradas de canal alternativas) se derivan del modelo de procesos secuenciales comunicantes de Tony Hoare . A diferencia de lenguajes de programación concurrentes anteriores como Occam o Limbo (un lenguaje en el que trabajó el codiseñador de Go, Rob Pike), ^{[ 107 ]} Go no proporciona ninguna noción integrada de concurrencia segura o verificable. ^{[ 108 ]} Si bien el modelo de procesos comunicantes es el preferido en Go, no es el único: todas las goroutines en un programa comparten un único espacio de direcciones. Esto significa que los objetos mutables y los punteros pueden ser compartidos entre goroutines; véase § Falta de seguridad de carrera de datos , más adelante. 

El enlazador en la cadena de herramientas gc crea binarios enlazados estáticamente por defecto; por lo tanto, todos los binarios de Go incluyen el entorno de ejecución de Go. ^{[ 116 ] [ 117 ]}

Go omite deliberadamente ciertas características comunes en otros lenguajes, incluyendo ^la herencia ( ^de implementación)  , las aserciones , ^la aritmética de punteros ^{, las} conversiones ^de tipo implícitas ^{, las} uniones sin etiquetar ^{y las} uniones ^etiquetadas . Los diseñadores agregaron solo aquellas funcionalidades en las que los tres ^estuvieron de acuerdo. ^{[ 120 ]}

De las características del lenguaje omitidas, los diseñadores argumentan explícitamente en contra de las aserciones y la aritmética de punteros, mientras defienden la elección de omitir la herencia de tipos como un lenguaje más útil, fomentando en cambio el uso de interfaces para lograr el despacho dinámico ^{[ h ]} y la composición para reutilizar código. La composición y la delegación , de hecho, se automatizan en gran medida mediante structla incrustación; según los investigadores Schmager et al. , esta característica "tiene muchos de los inconvenientes de la herencia: afecta la interfaz pública de los objetos, no es de grano fino (es decir, no hay control a nivel de método sobre la incrustación), los métodos de los objetos incrustados no se pueden ocultar y es estática", lo que hace que "no sea obvio" si los programadores la usarán en exceso en la medida en que se dice que los programadores en otros lenguajes abusan de la herencia. ^{[ 75 ]}

El manejo de excepciones se omitió inicialmente en Go debido a la falta de un "diseño que dé un valor proporcional a la complejidad". ^{[ 121 ]} Se propuso un mecanismo similar a una excepción panicque recoverevita la estructura de control habitual ^{[ 122 ]} y se publicó en la instantánea del 30 de marzo de 2010. ^{[ 123 ]} Los autores de Go recomiendan usarlo para errores irrecuperables, como aquellos que deberían detener un programa completo o una solicitud al servidor, o como un atajo para propagar errores hacia arriba en la pila dentro de un paquete. ^{[ 124 ] [ 125 ]} En todos los paquetes, Go incluye un tipo de error canónico, y las devoluciones de múltiples valores que usan este tipo son el modismo estándar. ^{[ 4 ]}try-catch

paquete principalimportar "fmt"func main () { fmt.Println ( " hola mundo " ) }

donde "fmt" es el paquete para E/S formateada , similar a <stdio.h> de C o <print> de C++ . ^{[ 135 ]}

El siguiente programa sencillo demuestra las características de concurrencia de Go para implementar un programa asíncrono. Inicia dos hilos ligeros ("goroutines"): uno espera a que el usuario escriba texto, mientras que el otro implementa un temporizador. La instrucción `select` espera a que cualquiera de estas gorutinas envíe un mensaje a la rutina principal y actúa sobre el primer mensaje que llega (ejemplo adaptado del libro de David Chisnall). ^{[ 99 ] : 152}

paquete principalimportar ( "fmt" "tiempo" )func readword ( ch chan string ) { fmt.Println ( " Escribe una palabra y pulsa Enter." ) var word string fmt.Scanf ( " % s" , & word ) ch <- word }func timeout ( t chan bool ) { time . Sleep ( 5 * time . Second ) t <- false }func main () { t := make ( chan bool ) go timeout ( t )ch := hacer ( cadena chan ) ir leer palabra ( ch )seleccionar { caso palabra := <- ch : fmt . Println ( "Recibido" , palabra ) caso <- t : fmt . Println ( "Tiempo de espera agotado." ) } }

El paquete de pruebas proporciona soporte para pruebas automatizadas de paquetes Go. ^{[ 136 ]} Ejemplo de función objetivo:

func ExtractUsername ( email string ) string { at := strings . Index ( email , "@" ) return email [: at ] }

Código de prueba (tenga en cuenta que la palabra clave assert no existe en Go; las pruebas se encuentran en <filename>_test.go en el mismo paquete):

importar ( "pruebas" )func TestExtractUsername ( t * testing.T ) { t.Run ( "withoutDot" , func ( t * testing.T ) { username := ExtractUsername ( " r@google.com" ) if username ! = "r" { t.Fatalf ( " Got : %v\ n " , username ) } } )t . Run ( "withDot" , func ( t * testing . T ) { username := ExtractUsername ( "jonh.smith@example.com" ) if username != "jonh.smith" { t . Fatalf ( "Got: %v\n" , username ) } }) }

Es posible ejecutar pruebas en paralelo.

El paquete net/http ^{[ 137 ]} proporciona soporte para la creación de aplicaciones web.

Este ejemplo mostraría "¡Hola mundo!" cuando se visite localhost:8080.

paquete principalimport ( "fmt" "log" "net/http" )func helloFunc ( w http . ResponseWriter , r * http . Request ) { fmt . Fprintf ( w , "¡Hola mundo!" ) }func main () { http.HandleFunc ( " / " , helloFunc ) log.Fatal ( http.ListenAndServe ( " : 8080 " , nil ) ) }