Hay muchos tipos de datos en el lenguaje Go. Además de los enteros básicos, los tipos de coma flotante, los booleanos y las cadenas, hay matrices, sectores, estructuras, funciones, mapas y canales. Los tipos básicos de Go son similares a otros idiomas.
Tipos de datos básicos
Entero
Los enteros se dividen en las siguientes dos categorías principales: Según la longitud: int8, int16, int32, int64 correspondientes enteros sin signo: uint8, uint16, uint32, uint64
¿Qué uint8es, sabemos que el bytetipo, int16el correspondiente lenguaje C shorttipo, int64que corresponde al lenguaje C longtipo.
| Tipo | Descripción |
|---|---|
| uint8 | Entero de 8 bits sin signo (0 a 255) |
| uint16 | Entero de 16 bits sin signo (0 a 65535) |
| uint32 | Entero de 32 bits sin signo (0 a 4294967295) |
| uint64 | Entero de 64 bits sin signo (0 a 18446744073709551615) |
| int8 | Entero de 8 bits firmado (-128 a 127) |
| Int16 | Entero de 16 bits firmado (-32768 a 32767) |
| int32 | Entero de 32 bits firmado (-2147483648 a 2147483647) |
| int64 | Entero de 64 bits firmado (-9223372036854775808 a 9223372036854775807) |
Entero especial
| Tipo | Descripción |
|---|---|
| Uint | En sistemas operativos de 32 bits, en sistemas operativos de uint3264 bitsuint64 |
| En t | En sistemas operativos de 32 bits, en sistemas operativos de int3264 bitsint64 |
| uintptr | Entero sin signo, utilizado para almacenar un puntero |
Nota: Al usar inty uintescribir, no puede suponer que es un número entero de 32 bits o 64 bits, pero considere inty uintpuede ser diferente en diferentes plataformas.
Nota La longitud len()devuelta por la función incorporada para obtener la longitud del objeto puede variar según la longitud de bytes de las diferentes plataformas. En el uso real, el número de elementos en el mapa rebanada o menos puede intser representado. Cuando se trata de la descripción de la estructura de transmisión binaria y lectura y escritura de archivos, para mantener la estructura del archivo no se verá afectado por la longitud de bytes de las diferentes plataformas de compilación de destino, no utilice inty uint.
Sintaxis de literales numéricos
Después de la versión Go1.13, se introdujo la sintaxis literal numérica, que es conveniente para que los desarrolladores definan números en formato de punto flotante binario, octal o hexadecimal, por ejemplo:
v: = 0b00101101, que representa 101101 en binario, que es equivalente a 45 en decimal. v: = 0o377, que representa 377 en octal, que es equivalente a 255 en decimal. v: = 0x1p-2, que representa el hexadecimal 1 dividido por 2², que es 0.25. También nos permite usar _ para separar números, por ejemplo:
v: = 123_456 es igual a 123456.
Podemos usar la función fmt para mostrar un número entero en diferentes formas base.
1 paquete main 2 3 import "fmt" 4 5 func main () { 6 // Decimal 7 var a int = 10 8 fmt.Printf ("% d \ n", a) // 10 9 fmt.Printf ("% b \ n ", a) // 1010 marcador de posición% b significa binario 10 11 // octal comienza con 0 12 var b int = 077 13 fmt.Printf ("% o \ n ", b) // 77 14 15 // Hexadecimal comienza con 0x 16 var c int= 0xff 17 fmt.Printf ("% x \ n", c) // ff 18 fmt.Printf ("% X \ n", c) // FF 19 }
Punto flotante
Go language admite dos números de coma flotante: float32y float64. El formato de datos de dos de punto flotante sigue la IEEE 754norma: float32 la más amplia gama de flotación se trata 3.4e38, puede utilizar las constantes definidas: math.MaxFloat32. float64 El alcance máximo del flotador aproximadamente 1.8e308, a las definiciones constantes se puede utilizar: math.MaxFloat64.
Al imprimir números de coma flotante, puede usar el fmtpaquete con verbos %f, el código es el siguiente:
1 paquete main 2 import ( 3 "fmt" 4 "math" 5 ) 6 func main () { 7 fmt.Printf ("% f \ n" , math.Pi) 8 fmt.Printf ("%. 2f \ n" , matemáticas.Pi) 9 }
Plural
complex64 y complex128
1 var c1 complex64 2 c1 = 1 + 2i 3 var c2 complex128 4 c2 = 2 + 3i 5 fmt.Println (c1) 6 fmt.Println (c2)
Los números complejos tienen partes reales e imaginarias. Las partes reales e imaginarias de complex64 son 32 bits, y las partes reales e imaginarias de complex128 son 64 bits.
Booleano
idioma ir a booldeclararse tipo de datos Boolean, los datos de Boole sólo true（真）y false（假）dos valores.
Nota:
- El valor predeterminado para las variables booleanas
false. - Go language no permite la coerción del entero a booleano.
- Los tipos booleanos no pueden participar en operaciones numéricas y no se pueden convertir con otros tipos.
Cadena
Las cadenas en Go aparecen como tipos de datos nativos. Usar cadenas es como usar otros tipos de datos nativos (int, bool, float32, float64, etc.) La implementación interna de cadenas en Go usa UTF-8codificación. El valor 双引号(")de la cadena está en el contenido, puede agregar directamente caracteres no ASCII al código fuente del idioma Go, por ejemplo:
1 s1: = "hola" 2 s2: = "你好"
Carácter de escape de cadena
Los caracteres de escape comunes para cadenas en Go incluyen retornos de carro, avances de línea, comillas simples y dobles, tabulaciones, etc., como se muestra en la siguiente tabla.
| Personaje de escape | Significado |
|---|---|
\r |
Retorno de carro (regreso al comienzo de la línea) |
\n |
Salto de línea (salta directamente a la misma posición de columna en la siguiente línea) |
\t |
Pestaña |
\' |
Cita simple |
\" |
Comillas dobles |
\\ |
Barra invertida |
Por ejemplo, queremos imprimir una ruta de archivo en una plataforma Windows:
1 paquete main 2 import ( 3 "fmt" 4 ) 5 func main () { 6 fmt.Println ("str: = \" c: \\ Code \\ lesson1 \\ go.exe \ "" ) 7 }
Cuerda multilínea
Para definir una cadena de varias líneas en Go, debe usar 反引号caracteres:
. 1 S1: = `una primera fila 2 de la segunda fila 3 de la tercera fila . 4 ` . 5 fmt.Println (S1)
Los saltos de línea entre backticks se tratarán como saltos de línea en la cadena, pero todos los caracteres de escape no son válidos y el texto se generará tal cual.
Operaciones comunes de cuerdas
| Método | Introduccion |
|---|---|
| len (str) | Encuentra la longitud |
| + O fmt.Sprintf | Concatenar cadenas |
| cuerdas. | Split |
| cadenas.contains | Determinar si contiene |
| strings.HasPrefix, strings.HasSuffix | Juicio de prefijo / sufijo |
| strings.Index (), strings.LastIndex () | Donde aparece la subcadena |
| strings.Join (una cadena [], cadena sep) | unirse a la operación |
tipos de byte y runas
Los elementos que forman cada cadena se denominan "caracteres", y los caracteres se pueden obtener atravesando o adquiriendo individualmente los elementos de la cadena. Los caracteres se incluyen entre comillas simples ('), como:
1 var a: = 'medio' 2 var b: = 'x'
Hay dos tipos de caracteres en el idioma Go:
uint8Tipo, o tipo de byte, representaASCII码un carácter.runeEscriba, representando unoUTF-8字符.
Cuando necesite tratar con caracteres chinos, japoneses u otros caracteres compuestos, debe usar el runetipo. runeEl tipo es en realidad uno int32.
Go utiliza un tipo de runa especial para manejar Unicode, lo que hace que el procesamiento de texto basado en Unicode sea más conveniente. También puede usar el tipo de byte para el procesamiento de cadena predeterminado, cuidando el rendimiento y la escalabilidad.
1 // 遍历 字符串 2 func traversalString () { 3 s: = "hola 沙河" 4 para i: = 0; i <len (s); i ++ { // byte 5 fmt.Printf ("% v (% c)" , s [i], s [i]) 6 } 7 fmt.Println () 8 para _, r: = rango s { // rune 9 fmt.Printf ("% v (% c)" , r, r) 10 } 11 fmt.Println () 12 }
Salida:
104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河)
Debido a que la codificación UTF8 del siguiente carácter chino consta de 3 a 4 bytes, no podemos atravesar simplemente una cadena que contiene byte chino, de lo contrario aparecerá el resultado de la primera línea en la salida anterior.
La parte inferior de la cadena es una matriz de bytes, por lo que se puede []byteconvertir con el tipo. La cadena no se puede modificar. La cadena está compuesta de bytes de bytes, por lo que la longitud de la cadena es la longitud de bytes de bytes. El tipo de runa se usa para representar caracteres utf8. Un carácter de runa consta de uno o más bytes.
Modificar la cadena
Para modificar una cadena, debe convertirla []runeo primero []byte, y luego convertirla después de que se complete string. En cualquier caso, la memoria se reasigna y la matriz de bytes se copia.
1 func changeString () { 2 s1: = "big" 3 // Forzar conversión de tipo 4 byteS1: = [] byte (s1) 5 byteS1 [0] = 'p' 6 fmt.Println (string (byteS1)) 7 8 s2: = "rábano blanco" 9 runeS2: = [] rune (s2) 10 runeS2 [0] = 'red' 11 fmt.Println (string (runeS2)) 12 }
Conversión de tipo
Solo hay conversión de tipo obligatoria en Go, no hay conversión de tipo implícita. Esta sintaxis solo se puede usar cuando dos tipos admiten la conversión entre ellos.
La sintaxis básica de la conversión de tipo obligatoria es la siguiente:
T (expresión)
Entre ellos, T representa el tipo a convertir. Las expresiones incluyen variables, operadores complejos y valores de retorno de funciones.
Por ejemplo, cuando se calcula la longitud de la hipotenusa de un triángulo rectángulo, se utiliza la función Sqrt () del paquete matemático. La función recibe un parámetro de tipo float64, y las variables a y b son ambos tipos int. En este momento, es necesario lanzar ayb Es de tipo float64.
1 func sqrtDemo () { 2 var a, b = 3, 4 3 var c int 4 // El parámetro recibido por math.Sqrt () es de tipo float64, que necesita ser lanzado 5 c = int (math.Sqrt (float64 (a * a + b * b))) 6 fmt.Println (c) 7 }
Materiales de referencia: https://www.liwenzhou.com/posts/Go/go_menu/