Directorio de artículos
Definición y uso de variables
Sintaxis de definición de var 变量名 数据类型
variable: variables locales: variables definidas en el bloque de instrucciones (como métodos)
variables globales: variables definidas fuera del bloque de instrucciones
Método de declaración de variable:
- Especifique el tipo de variable y use el valor predeterminado si no se asigna ningún valor después de la declaración
- Juzgar el tipo de variable según el valor
- Omitir var y usar: = asignación, la variable de la izquierda no puede estar ya declarada, de lo contrario se informará un error
- Admite la declaración de múltiples variables (se admiten tanto las variables locales como las globales), consulte el código de muestra
Código de muestra
//全局变量声明
var gn1 = 100
var gn2 = "jack"
//一次声明多个全局变量
var (
gn3 = 200
gn4 = "mary"
)
func test(){
//变量使用方式1：指定变量类型，声明后如果不赋值则使用默认值
var i int
fmt.Println("i1=",i)
//变量使用方式2：根据值自行判断变量类型
var i2 = 2
fmt.Println("i2=",i2)
//变量使用方式3：省略var 使用 := 赋值，左侧变量不能是已经声明过的，否则报错
i3 := "4"
fmt.Println("i3=",i3)
//一次声明多个变量 方式1
var n1, n2, n3 int
fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)
//一次声明多个变量 方式2
var n12, n22, n32 = 100, "tom", 200
fmt.Println("n1=",n12,"n2=",n22,"n3=",n32)
//一次声明多个变量 方式3
n13, n23, n33 := 200, "tom", 300
fmt.Println("n1=",n13,"n2=",n23,"n3=",n33)
//输出全局变量
fmt.Println("全局变量：gn1=",gn1,"gn2=",gn2,"gn3=",gn3,"gn4",gn4)
n13 = 133
//n13 = n23; 该行报错，不能改变变量的类型
}
Tipo de datos básico
Tipos de datos básicos, incluido
1) Tipo numérico: entero: int, int8, int16, int32, int64 Tipo de punto flotante: float32, float64
2) Tipo de carácter: no hay un tipo de carácter especial, utilice byte para almacenar caracteres alfabéticos individuales
3) Tipo booleano: verdadero falso
4) Cadena: la cadena se define oficialmente como un tipo básico
derivado / tipo de datos complejos, que incluye:
1) puntero
2) matriz
3) estructura estructura
4) canal
5) función
6) rebanada
7) Interfaz
8) mapa
Entero
Variables que almacenan enteros, incluidos enteros con signo, enteros sin signo y otros tipos de enteros. El valor predeterminado es 0.
Enteros con
signo: enteros sin signo:
otros tipos de enteros:
código de muestra:
func test2(){
var i int
fmt.Println("i=",i);
//有符号整型测试
//var i2 int8 = 128 // 报错超过 constant 128 overflows int8
var i2 int8 = 127 //正常
fmt.Println("i2=",i2);
//无符号整型测试
//var i3 uint8 = 256 // 报错超过 constant 256 overflows uint8
//var i3 uint8 = -1 //报错 constant -1 overflows uint8
var i3 uint8 = 255 //正常
fmt.Println("i23=",i3);
//其他类型整型
var a int = 999
fmt.Println("a=",a);
var b unit = 1
var c byte = 255
fmt.Println("a=",a,"b=",b,"c=",c);
}
punto importante
- El tamaño de int y uint está relacionado con el sistema, y el rango de otros tipos no tiene nada que ver con el sistema.
- El tipo predeterminado de declaración de enteros es entero
- Verifique el tamaño de la variable y el número de bytes ocupados por el siguiente método:
fmt.Printf ("El número de bytes ocupados por el tipo% T de i3 es% d", i3, unsafe.Sizeof (i3)) - Al utilizar variables enteras en un programa Golang, intente utilizar tipos de datos que ocupen un pequeño espacio bajo la premisa de satisfacer el funcionamiento normal del programa.
Punto flotante
El tipo de datos utilizado para almacenar los decimales
. El formato de almacenamiento del tipo de coma flotante en la máquina: número de coma flotante = bit de signo + bit de exponente + bit de mantisa
Valor predeterminado 0
clasificación
Código de muestra
func test3(){
var price float32 =12.13
fmt.Println("price=",price);
var price2 float32 =-0.000098
var price3 float64 =-8999.09
fmt.Println("price2=",price2,"price3=",price3)
//精度丢失测试
var price4 float32 =12.130000901
var price5 float64 =12.130000901
//输出 price4= 12.130001 price5 12.130000901 float32 发生精度丢失
//float64 精度比 float32 精度高
fmt.Println("price4=",price4,"price5",price5)
var num float64 = 5.12334423e2
var num2 float64 = 5.123344233E-2
}
punto importante
- Los números de coma flotante están firmados
- Es posible que se pierda el número de bits, lo que da como resultado una pérdida de precisión. La precisión de float64 no es superior a float32
- El tipo de punto flotante se declara como float64 de forma predeterminada
- Dos representaciones de coma flotante de uso común:
Decimal: 5.12 .512 debe tener un punto decimal.
Notación científica: 5.123e2 = 5.12 * 10 elevado a la segunda potencia 5.123E-2 = 5.12 / 10 elevado a la segunda potencia E puede ser mayúscula o minúscula
Tipo de caracter
No hay un tipo de carácter especial en Golang. Si desea almacenar un carácter, generalmente usa byte para guardarlo. Una cadena es una secuencia de caracteres conectados por una cadena de caracteres de longitud fija. Los compañeros de habitación de la cadena de Go están concatenados con un solo byte.
Código de muestra
func test01(){
var c1 byte = 'a'
var c2 byte = '0'
fmt.Println("c1=",c1);
fmt.Println("c2=",c2);
//c1= 97 c2= 48 tyte输出时默认输出码值 如果希望输出字符串 需要格式化输出
fmt.Printf("c2= %c c1= %c",c2,c1) //c2= 0 c1= a
//var c3 byte = '北' // 报错 constant 21271 overflows byte
var c3 = '北' // 字符被默认成int32 类型
fmt.Println("c3 =",c3);
fmt.Printf("c3的类型 %T 占用的字节数是 %d", c3, unsafe.Sizeof(c3))
//输出：c3的类型 int32 占用的字节数是 4
var num = 10 + 'a'
fmt.Println("num = ", num )//输出 107
}
punto importante
- Si el carácter que guardamos está en la tabla ascii, se puede guardar directamente en byte, y si el código correspondiente del carácter es mayor que 255, se puede guardar en el tipo int.
- Los caracteres en el idioma go usan codificación UTF-8 (inglés 1 byte caracteres chinos 3 bytes), si desea consultar el valor del código utf-8 correspondiente al carácter, visite: http://www.mytju.com/classcode / herramientas / encode_utf8. asp
- Un carácter en go es esencialmente un número entero, y cuando se emite directamente, genera el valor del código UTF-8 correspondiente al carácter. Los caracteres de salida deben formatearse y salir fmt.Printf ("c2 =% c c1 =% c", c2, c1)
- Puede asignar directamente números enteros a las variables y formatear los caracteres correspondientes
- El tipo de carácter es equivalente a un número entero con el que se puede operar.
- Para almacenar el tipo de carácter en la computadora, es necesario convertir el valor del código correspondiente al carácter en un sistema binario para su almacenamiento.
Almacenamiento: Carácter -> Valor de código -> Binario -> Lectura de almacenamiento: Justo lo opuesto al almacenamiento - La relación entre los caracteres y los valores del código está determinada por la tabla de códigos de caracteres (preestablecida)
- La codificación de idiomas Go utiliza uniformemente utf-8, que es muy conveniente sin el problema de los códigos confusos
Tipo booleano
El tipo bool solo permite dos valores, verdadero y falso, que ocupa un byte, el
valor predeterminado: falso
Código de muestra
func test02(){
var b = false
fmt.Println(b)
//b的类型 bool 占用的字节数是 1
fmt.Printf("b的类型 %T 占用的字节数是 %d",b , unsafe.Sizeof(b))
}
tipo de cadena
Una cadena es una secuencia de caracteres concatenados con caracteres de longitud fija. Las cadenas de Go están conectadas por bytes individuales. Byte usa codificación UTF-8 para identificar texto Unicode.
Valor predeterminado: ""
Código de muestra
func test03(){
var str string = "北京欢迎你1"
//str ="haha "
fmt.Println(str[0])//229
//str[0] = 1 报错 字符串内容无法修改
//str的类型 string 占用的字节数是 16
fmt.Printf("str的类型 %T 占用的字节数是 %d",str , unsafe.Sizeof(str))
var str2 string =`adasdfa\n \t`
var str3 string ="adasdfa\n \t"
fmt.Println(str2)//输出 16adasdfa\n \t 不会通过 \转义字符
fmt.Println(str3)//输出 16adasdfa
str = str + "123"
fmt.Println(str)
str += "haha"
fmt.Println(str)
//当一个字符串很长时，可以通过加号分行写 但是加号要写在上一行
var str5 = "haha" +
"hah123" + " test "+
"asdfas"
fmt.Println(str5)
}
punto importante
- El contenido de la cadena no se puede modificar después de que se asigna el valor (el contenido de uno de los bytes)
- Dos métodos de definición de cadenas "123 \ n"
123\n(los caracteres no se escaparán)
Conversión de tipos de datos básicos
La conversión automática de tipos de variables no es compatible con Golang, y la
sintaxis básica debe convertirse explícitamente : la expresión T (v) convierte el valor v al tipo T
Código de muestra
func test04(){
var i int32 = 100
var f float32 = float32(i)
fmt.Println(f)//100
//i的类型 int32 占用的字节数是 4
fmt.Printf("i的类型 %T 占用的字节数是 %d",i , unsafe.Sizeof(i))
var n1 int32 = 10
var n2 int64
//n2 = n1 +10 会报错 因为类型不符
n2 = int64(n1)+10
fmt.Println("n2 = ",n2)//20
var n4 = 200
var n3 int8 =10
n3 = int8(n4)+10
fmt.Println("n3 = ",n3)//-46 由于类型范围问题 导致计算结果不准
//--------------基本类型 转string
var i1 int =99
var f1 float32 =32.23
var b bool = true
var c1 byte = 'a'
var str string
str = fmt.Sprintf("%d",i1)
fmt.Println("str = ",str)
fmt.Printf("str的类型 %T 占用的字节数是 %d \n",str , unsafe.Sizeof(str))
str = fmt.Sprintf("%f",f1)
fmt.Println("str = ",str)
fmt.Printf("str的类型 %T 占用的字节数是 %d \n",str , unsafe.Sizeof(str))
str = fmt.Sprintf("%t",b)
fmt.Println("str = ",str)
fmt.Printf("str的类型 %T 占用的字节数是 %d \n",str , unsafe.Sizeof(str))
str = fmt.Sprintf("%c",c1)
fmt.Println("str = ",str)
fmt.Printf("str的类型 %T 占用的字节数是 %d \n",str , unsafe.Sizeof(str))
str = strconv.FormatInt(int64(i1),10)
str = strconv.FormatBool(b)
str = strconv.FormatFloat(float64(f1),'f',10,64)
//-----------string转基本类型
var ss string = "123"
var ss2 string = "true"
var ss3 string ="123.123"
var in1,_ = strconv.ParseInt(ss,10,64)
fmt.Println(in1)
var bo,_ = strconv.ParseBool(ss2)
fmt.Println(bo)
var fl,_ = strconv.ParseFloat(ss3,64)
fmt.Println(fl)
}
punto importante
- Dos formas
de convertir tipos comunes en cadenas: llamar a fmt.Sprintf ("% t", b)
llamar a strconv.FormatBool (b) - Para convertir una cadena en un tipo común, use directamente el método del paquete strconv, como: strconv.ParseInt (ss, 10,64)
- Al convertir una cadena en un tipo básico, asegúrese de que el formato de la cadena sea correcto. Si no puede convertir hello en tipo int, otros tipos son similares a float en 0 y boolean en falso
Tipo de puntero
La variable de tipo de datos básicos almacena el valor, también llamado tipo de valor. La variable de puntero almacena una dirección y el espacio al que apunta esta dirección almacena el valor.
var ptr *int = &num //表示用ptr 变量保存 num变量的值的地址
Código de muestra
func test4(){
var i int = 10
fmt.Println("i的地址=",&i)
var ptr = &i
fmt.Println("i的地址=",ptr)
fmt.Println("ptr的地址=",&ptr)
fmt.Println("ptr指针地址保存的值=",*ptr)
//ptr的类型 *int 占用的字节数是 8
fmt.Printf("ptr的类型 %T 占用的字节数是 %d", ptr, unsafe.Sizeof(ptr))
}
punto importante
- Obtenga la dirección de la variable con el ampersand, como: & num es la dirección donde se guarda el valor de la variable num
- El tipo de puntero representa una dirección de memoria. Las variables de todos los tipos de valor (incluidos: entero, punto flotante, bool, matriz de cadenas, estructura) tienen los tipos de puntero correspondientes, en la forma: * tipo de variable, como: * int * int8 * int32 * int64 * float32
- Obtenga el valor de la dirección guardada por la variable de puntero usando *, como: * ptr Obtiene el puntero ptr apunta al valor guardado en la dirección
Tipo de valor y tipo de referencia
Tipo de valor: Incluyendo: entero, punto flotante, bool, matriz de cadenas, dirección de variable de estructura guarde directamente el valor, la memoria generalmente se asigna en la pila, el diagrama de memoria es el siguiente:
Tipo de referencia: La variable almacena una dirección y el espacio correspondiente a esta dirección almacena el valor real, cuando no existe una variable que haga referencia a esta dirección, el valor se reciclará como una hora. El espacio generalmente se asigna en el área del montón. El diagrama de memoria es el siguiente:
Convención de identificación y nomenclatura
Identificador
La cadena utilizada por Golang para nombrar diversas variables, métodos, funciones, etc. se convierte en la regla de denominación del identificador.
- Consta de letras mayúsculas y minúsculas, 0-9 y _
- Los números no pueden comenzar
- Estrictamente sensible a mayúsculas y minúsculas
- No puede contener espacios
- Un guión bajo "_" es un identificador especial en Go, llamado identificador vacío. Puede representar cualquier identificador y solo se usa como marcador de posición. No se pueden llamar variables o métodos a través de este identificador (representa El valor nunca se llamará) Por ejemplo: el método devuelve varios valores y algunos valores se pueden usar para ocupar el lugar cuando no se necesitan. Solo como marcador de posición, no como identificador
Convenciones de nombres
- Mantenga el nombre del paquete coherente con el directorio, intente utilizar nombres de paquete cortos y significativos y no entre en conflicto con los paquetes estándar
- Funciones variables, etc.utilizan la nomenclatura de caso camel
- En Go, si la primera letra de la variable, la función y el nombre de la constante está en mayúscula, significa que otros paquetes pueden acceder a ella (equivalente a public en java). De lo contrario, solo se puede usar en este paquete (equivalente a privado protegido, etc.)
- No utilice palabras clave reservadas e identificadores predefinidos
Palabras clave reservadas
Identificador predefinido
