El lenguaje Go es un lenguaje de programación estáticamente fuertemente tipado, compilado, concurrente y de recolección de basura desarrollado por Google. El lenguaje Go consigue reducir la complejidad del código sin comprometer el rendimiento de la aplicación.
La gramática del lenguaje Go es sencilla, con sólo 25 palabras clave, por lo que no necesitamos dedicar mucho tiempo a aprender y memorizar;
Los tipos de datos del lenguaje G incluyen tipos booleanos, numéricos (entero, punto flotante, complejo), cadena, segmento (matriz), mapa de diccionario, canalización, etc.
El lenguaje Go naturalmente tiene características de concurrencia. Basado en la palabra clave go, es fácil crear una rutina para realizar algunas tareas concurrentes. El modelo de programación concurrente CSP basado en la tubería de rutina, en comparación con el complejo esquema tradicional de sincronización de múltiples subprocesos, ¿Es demasiado fácil de decir?
El lenguaje Go también tiene capacidades de recolección de basura, lo que evita que la capa de aplicación preste atención a la asignación y liberación de memoria. Debe saber que en el lenguaje C / C ++, la administración de la memoria es muy problemática.
El lenguaje Go también proporciona una biblioteca estándar relativamente completa: por ejemplo, solo necesitamos unas pocas líneas de código para crear e iniciar un servicio HTTP.
Artículos de construcción ambiental:
Podemos optar por descargar el código fuente para compilar e instalar, descargar el paquete de instalación para instalar y descargar el archivo ejecutable compilado, la dirección de descarga es:
https://golang.google.cn/dl/
El autor instaló localmente:
go1.19.darwin-amd64.tar.gz, este es el archivo ejecutable compilado, solo necesita descomprimirlo.
Descomprimir al directorio:
$HOME/Documentos/go1.18
Finalmente, configure las variables de entorno:
export GOROOT=$HOME/Documents/go1.18export PATH=$PATH:$GOROOT/binexport GOPATH=$HOME/Documents/gopath
GOROOT es el directorio de instalación de Go; PATH es para permitirnos ejecutar el comando go en cualquier directorio; el directorio de trabajo de GOPATH, los paquetes dependientes descargados a través del comando go get, etc. se colocan en el directorio GOPATH, y los archivos dependientes Basado en la gestión de gomod también se colocará en este directorio, bajo contenidos.
Una vez completada la configuración de la instalación, ejecute go version para verificar si la instalación se realizó correctamente.
Un editor adecuado es indispensable para el desarrollo de proyectos Go. Se recomienda utilizar Goland. La dirección de descarga es: https://www.jetbrains.com/go/
Una vez completada la instalación, abra el nuevo proyecto de Goland, cree un nuevo archivo main.go y escriba el clásico hola mundo:
paquete principal
import "fmt"func main()
{
fmt.Println("hello world")
}
Todos los archivos en el idioma Go deben especificar el paquete en el que se encuentran. Como arriba "paquete principal", lo llamamos paquete principal. Por supuesto, el nombre del paquete también puede tener otros nombres (generalmente el nombre del paquete es consistente con el nombre del directorio/carpeta actual), la función principal en el paquete principal es la función de entrada del programa.
Nuestro código definitivamente permanecerá en otros archivos, ¿cómo importarlo? Introducidas por "importar nombre del paquete", solo se puede acceder a las funciones/variables del paquete después de la introducción. Como se muestra en el código anterior, el paquete fmt es un paquete de formato/IO proporcionado por la capa inferior del lenguaje Go, y la función Println imprime variables en la salida estándar.
Artículos de tipo de datos:
Los tipos de datos del lenguaje Go incluyen tipos booleanos, numéricos (entero, punto flotante, complejo), cadena, segmento (matriz), mapa de diccionario, canalización, etc. La declaración y el uso simple de las variables de cada tipo son los siguientes:
package mainimport "fmt"func main() {//变量声明var a int = 1 //var 声明并初始化变量, 类型int可以省略b := 1 //:= 声明+初始化变量b = 3 //=只能针对已有变量重新赋值fmt.Println(a, b)//字符串str1 := "hello "str2 := "world"fmt.Println(len(str1), str1 + str2) //可以 +；len返回字符串长度//数组，容量固定arr := [5]int{1,2,3,4,5}arr[1] = 100 //数组元素访问fmt.Println(len(arr), arr) //len返回数组长度//切片，容量可以扩充，相当于动态数组slice := []int{1,2,3}slice[1] = 100 //切片元素访问slice = append(slice, 4, 5, 6) //append自动扩容fmt.Println(len(slice),cap(slice), slice) //len返回切片长度，cap返回切片容量//map，key-value结构score := map[string]int{"zhangsan":100,"lisi":99,"wangwu":98,}score["who"] = 90 //map赋值s, ok := score["who"] //map访问，s对应value值，ok标识该key是否存在（不存在返回空值）delete(score, "lisi") //删除map元素fmt.Println(s, ok, score)}
El ejemplo del canal de canalización no se proporciona aquí, que se presentará en detalle en el segundo capítulo del modelo de concurrencia. Por supuesto, además de estos tipos básicos proporcionados por el lenguaje Go, también podemos personalizar tipos, como interfaces, estructuras, etc., que también se presentarán en capítulos posteriores.
Artículos de estructura de sucursales:
Al igual que otros idiomas, el lenguaje Go también admite la estructura de rama if/switch y la estructura de bucle for, como se muestra a continuación:
package mainimport "fmt"func main() {//if分支condition := trueif condition {fmt.Println("true")}else{fmt.Println("false")}//wsith分支expr := "zhangsan"switch expr {case "zhangsan":fmt.Println("zhangsan")case "lisi":fmt.Println("lisi")default: //没有匹配到，默认执行fmt.Println("who")}//for循环for i := 0; i < 100; i ++ {if i /2 == 0 {fmt.Println("偶数")}}//无条件循环，死循环i := 0for {i ++fmt.Println("loop")if i > 100 { //检测条件，提前break退出循环break}}
Artículos funcionales:
La definición de funciones, como nombre, parámetros de entrada, valor de retorno y otros conceptos básicos, no se introducirá aquí. La diferencia entre el lenguaje Go y otros lenguajes es que admite múltiples valores de retorno (la mayoría de los lenguajes pueden solo devuelve un valor), y parámetros variables (la mayoría de los lenguajes realmente lo admiten). Además, el lenguaje Go también admite cierres (funciones anónimas). Los ejemplos son los siguientes:
package mainimport "fmt"func main() {add, sub := addSub(4, 3)fmt.Println(add, sub)sum(1, 2, 3)nums := []int{1, 2, 3, 4}sum(nums...) //切片转可变参数，通过...实现//变量f为函数类型f := func (in string) {fmt.Println(in)}f("hello world") //执行函数//声明匿名函数，注意与上面却别，加括号直接执行该匿名函数func (in string) {fmt.Println(in)}("hello world")}//返回两个int值func addSub(a, b int) (int, int){return a + b, a - b}//...表示参数数目可变func sum(nums ...int) {total := 0//nums其实是切片类型（[]int），for + range 可遍历切片元素for _, num := range nums {total += num}fmt.Println(total)}
Concurrencia de rutinas:
El lenguaje Go naturalmente tiene características de concurrencia: según la palabra clave go, se pueden crear fácilmente corrutinas para realizar algunas tareas concurrentes. El siguiente programa crea 10 corrutinas para ejecutar tareas simultáneamente, y la corrutina principal espera a que finalice la ejecución de cada subcorrutina y luego sale automáticamente:
package mainimport ("fmt""sync")func main() {wg := sync.WaitGroup{}//启动10个协程并发执行任务for i := 0; i < 10; i ++ {//任务开始wg.Add(1)go func(a int) {fmt.Println(fmt.Sprintf("work %d exec", a))//任务结束wg.Done()}(i)}//主协程等待任务结束wg.Wait()fmt.Println("main 结束")}
Resumir
Este artículo presenta brevemente la gramática básica del lenguaje Go, incluidos conceptos básicos como tipos de datos básicos, estructuras de ramas y funciones, para que los principiantes puedan tener una comprensión preliminar del lenguaje Go y sentar las bases para avances posteriores.