Ir lengua primitiva tipos de datos conocidos

tipos de datos básicos de uso común, en Go son los siguientes:

• entero
• flotador
• Boole
• plural
• cadena

entero

• firmado
  • INT8
  • Int16
  • int32
  • Int64
• no firmado
  • uint8
  • uint16
  • uint32
  • uint64
• Entero especial
  • uint, el sistema operativo de 32 bits es uint32,64 bit del sistema operativo es uint64
  • int, el sistema operativo de 32 bits del sistema operativo es poco int32,64 es Int64
  • UIntPtr, entero sin signo, para almacenar un puntero

NOTA: El uso inty uintcuando el tipo, no puede suponerse que es de 32 bits o de 64 bits número entero, pero debe tener en cuenta inty uintpuede diferir en diferentes plataformas.

ary

// 程序入口
func main() {
    // age = "17"
    // fmt.Println("Hello World")
    // fmt.Print("isOK")
    // fmt.Printf("Age: %s", age)\n
    var a1 = 10
    fmt.Printf("十进制：%d\n", a1)
    fmt.Printf("二进制：%b\n", a1)
    fmt.Printf("八进制：%o\n", a1)
    fmt.Printf("十六进制：%x\n", a1)

    // 直接定义八进制
    a2 := 077
    fmt.Printf("直接声明八进制：%d\n", a2)
    // 直接定义十六进制
    a3 := 0x12321
    fmt.Printf("直接声明十六进制：%d\n", a3)
}

flotador

Ir lenguaje soporta dos tipos de punto flotante:

• float32, math.MaxFloat32 define utilizando constantes;
• float64, math.MaxFloat64 define utilizando constantes;

impresión de flotador, se puede utilizar con el paquete de FMT %f, de la siguiente manera:

package main
import (
        "fmt"
        "math"
)
func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi)
}

Boole

idioma ir a booldeclararse tipo de datos Boolean, los datos de Boole sólo true（真）y false（假）dos valores.

nota:

1. El valor por defecto de la variable booleana false.
2. Ir idioma no está permitido en el elenco entero de Boole.
3. operaciones booleanas no pueden participar en valor no se pueden convertir a otros tipos.

plural

Hay una pluralidad de partes real e imaginaria, las partes real e imaginaria de complex64 32, complex128 la parte real e imaginaria 64. De la siguiente manera:

func main(){
    var c1 complex64
    c1 = 1 + 2i
    var c2 complex128
    c2 = 2 + 3i
    fmt.Println(c1)
    fmt.Println(c2)
}

Subcadena

Ir cadenas de idioma para que aparezca Tipo de datos nativos, utilizar la cadena Al igual que con otros tipos de datos nativos (int, bool, float32, float64, etc.) de la misma. Ir dentro de la implementación del lenguaje usos cadena de UTF-8código. El valor es una cadena de 双引号(")contenido, se pueden añadir directamente a un caracteres no ASCII en el idioma fuente de Ir, por ejemplo:

s1 := "Joker"
s2 := "HelloWorld"

Si una cadena de múltiples líneas es acentos abiertos, dentro de su contenido es de salida, por ejemplo:

s1 := `
    你好，
    欢迎光临。
`

carácter

Elemento de composición de cada cadena se llama 字符, 字符con ''cerrado, de la siguiente manera:

s1 := 'H'
s2 := '你'

Ir caracteres de idiomas de dos maneras:

• Tipo uint8 o tipo de llamada de bytes, lo que representa ASCIIun código de signos;
• tipo runa, representativo de un UTF-8símbolo;

Cuando usted necesita para manejar chino, japonés u otros caracteres complejos, es necesario utilizar runeel tipo. runeEn realidad, es un tipo int32.

Go utiliza un tipo runa especial para manejar Unicode, el tratamiento más conveniente maquillaje de texto basado en Unicode, también se puede utilizar el tipo de bytes sea el manejo de cadenas por defecto, el rendimiento y la escalabilidad que cuidar.

package main

import "fmt"

func main() {
    s1 := "Hello World，你好啊！"
    // fmt.Printf(s1)
    // 遍历字符串,Byte类型
    for i := 0; i < len(s1); i++ {
        fmt.Printf("%v(%c)", s1[i], s1[i])
    }
    fmt.Println()
    // 遍历字符串，rune类型
    for _, r := range s1 {
        fmt.Printf("%v(%c)", r, r)
    }
}

Los resultados de salida son los siguientes:

72(H)101(e)108(l)108(l)111(o)32( )87(W)111(o)114(r)108(l)100(d)239(ï)188(¼)140()228(ä)189(½)160( )229(å)165(¥)189(½)229(å)149(
)138()239(ï)188(¼)129()
===============================================
72(H)101(e)108(l)108(l)111(o)32( )87(W)111(o)114(r)108(l)100(d)65292(，)20320(你)22909(好)21834(啊)65281(！)

Como puede verse, el primer método de recorrido es atravesada bytes, mientras que para las letras o números no están en inglés, que no está ocupada por un byte, como el chino UTF-8codificación que ocupa 3 bytes, al pulsar bytes para atravesar si vamos a obtener el primer resultado, este resultado no es lo que queremos. Necesitamos un segundo recorrido, el tipo de runa se utiliza para representar UTF-8un carácter, una runa de caracteres por uno o más bytes.

Escapar de cuerdas

cadena especial necesita mantener su sentido original, que necesita ser escapado, comúnmente utilizado en la siguiente tabla:

escape	significado
\ r	entrar
\norte	Wrap
\ t	tabulación
\'	Las comillas simples
\\	barra invertida
\"	Las comillas dobles

Por ejemplo:

package main

import "fmt"

func main() {
    s1 := "\"Hello World\""
    fmt.Printf(s1)
}

operación de cadena comunes

método	efecto
solamente (a)	Buscando longitud (longitud de bytes)
+ O fmt.Sprintf	La concatenación de cadenas
strings.Split	cuerdas de corte
strings.contains	La determinación de si la cadena de caracteres contiene
strings.HasPrefix, strings.HasSuffix	El análisis de la cadena de prefijo / sufijo (booleano)
strings.Index (), strings.LastIndex ()	Posición (índice) en la subcadena aparece de salida
strings.Join (una cadena [], cadena sep)	unirse a la operación

Ejemplos:

package main

import "fmt"
import "strings"

func main() {
    s := "Hello World 你好啊！"
    // 求长度
    fmt.Println(len(s))
    // 字符串拼接
    s1 := "Joker"
    s2 := "你好"
    fmt.Println(s1 + s2)
    s12 := fmt.Sprintf("%s%s", s1, s2)
    fmt.Println(s12)
    // 字符串切割
    sSplit := strings.Split(s, " ")
    fmt.Println(sSplit)
    // 判断字符串是否包含
    fmt.Println(strings.Contains(s, "H"))
    fmt.Println(strings.Contains(s, "L"))
    // 判断字符串的前缀
    fmt.Println(strings.HasPrefix(s, "H"))
    // 判断字符串的后缀
    fmt.Println(strings.HasSuffix(s, "啊"))
    // 判断字串出现的位置
    fmt.Println(strings.Index(s, "H"))
    // 判断子串最后出现的位置
    fmt.Println(strings.LastIndex(s, "o"))
    // join操作
    fmt.Println(strings.Join(sSplit, "-"))
}

Modificar la cadena de

Para modificar la necesidad cadena para convertir en primer lugar en []runeo []bytedespués de la finalización de la conversión en string. De cualquier conversión volverá a asignar memoria y copiar la matriz de bytes.

package main

import "fmt"

func main() {
    s1 := "hello"
    // 1、强制转换
    byteS1 := []byte(s1)
    // 2、进行修改
    byteS1[0] = 'H'
    // 3、强制转换成字符串并打印
    fmt.Println(string(byteS1))

    s2 := "我爱你中国"
    // 1、强制转换
    runeS2 := []rune(s2)
    // 2、修改
    runeS2[3] = '祖'
    // 3、强制转换成字符串并打印
    fmt.Println(string(runeS2))
}

tipo de conversión

idioma ir solamente arroja, sin conversión implícita. Esta sintaxis se utiliza sólo cuando la conversión mutua entre los dos tipos de apoyo.

Arroja sintaxis básica es la siguiente:

T(表达式)

En donde, T representa el tipo a ser convertido. Expresiones incluyen variables, operador y funciones complejas valores de retorno.