Ir notas de estudio de desarrollo básico (c) - los tipos de datos básicos

tipos de datos variables:

• tipos de datos básicos:

  • número entero {

    • int: plástico, sistema operativo de 32 bits ocupa 4 bytes, el sistema operativo 64-bit ocupa 8 bytes,
    • byte: igual INT8 sin firmar,
    • int8, Int16, int32, Int64: 8bit número entero, de 16 bits número entero ... (01 representa una primera positivo y negativo, por lo que los valores de la tabla INT8 sólo siete, por lo que el rango de valores de -2 ^{7 1-2.} 7-1),
    • uint8, uint16, uint32, uint64: unsigned 8bit número entero, de 16 bits entero sin signo (unsigned que no implica negativo, de modo uint8 0 a 2 ^ 8-1),
    • runa: Int32 igual a
      }

  • flotador {

    • float32: precisión simple,
    • float64: doble,
      }

  • Carácter: ningún carácter especial, tales como char, varchar, no! ! El uso de un solo byte para almacenar caracteres alfabéticos, caracteres no puede utilizar el tipo de bytes, ya que los caracteres chinos son 3 bytes +

  • Boolean BOOL: VERDADERO o FALSO

  • String cadena: cadena de atribución Go El lenguaje como los tipos de datos básicos

  • Plural: complex128 complex64 (actualmente no se utiliza)

• tipos de datos complejos:

1. del puntero
2. array
3. Estructura struct, alternativa de clase
4. canal de tuberías
5. Función (también un tipo de función)
6. rebanada rebanada
7. interfaz interfaz
8. mapa (HashMap similares, juego), relativamente simple y no complicada, el equivalente de otro mapa idioma, sólo esto.

• Los detalles de los números enteros:

1. tipos golang en un int número entero y uint, el rango de valores no es el mismo.
2. Ver un tipo y el tamaño de datos variables:

   package main
   
   import (
   	"fmt"
   	"unsafe"
   )
   
   func main() {
   	/*
   	printf用于做格式化输出,
   	unsafe.Sizeof()函数：用于输出一个变量所占字节大小
   	*/
   
   	var i = 100
   	fmt.Printf("i的数据类型为: %T\n",i)
   	fmt.Printf("i所占用的字节数为：%d",unsafe.Sizeof(i))
   }
   

3. Teniendo en cuenta las condiciones locales para verificar el tipo de datos de una variable, como la edad, la mayoría de las personas no serán más de 255 años de edad, por lo que el byte edad var en él, no hay necesidad de asignar un valor Int64 edad, desperdicia una gran cantidad de variables de bytes.
   También conocido como la Pequeña principio de seguro de caución, no estoy seguro si el número se utiliza un poco más grande, porque ahora no es el actuales cuellos de botella de capacidad de hardware de computadora.

• consejos de punto flotante:

1. datos de punto flotante almacenados en el ordenador en tres partes: un bit de signo, el exponente bits de mantisa bits.
2. Los procedimientos almacenados, mantisa parte se pueden perder, lo que resulta en pérdida de precisión.
3. Más preciso que un número de coma flotante de doble precisión sola típicamente utilizados float64 convención.
4. Golang tipo de punto flotante y tiene un rango de longitud de campo fijo, la influencia del sistema operativo, y int no es lo mismo, no hay ningún defecto, y sólo float32 float64.
5. Golang predeterminado flotador declarado float64.
6. un flotador debe tener un punto decimal, por ejemplo, 0.123 se puede escribir como num = 0,123.
7. Apoyar la notación científica: NUM: 5.1234e = (E) 2 // 512,34 realidad , e (E) de 10 ^ X X-ésima potencia, el caso no afecta a la notación científica e, X puede ser un número negativo, x ^ - es decir, un 1 / x.

• Carácter de recomendaciones:

1. Sin char y varchar concepto, si un solo carácter, entonces el ASCII, el tipo de bytes utilizados para representar todos los caracteres individuales, el carácter si el número está ligado cadena: c1 bytes var = 'a'.

2. Golang cadena de bytes.

3. Si el carácter almacenado en la tabla ASCII, se puede utilizar directamente la salida de bytes directamente al valor de código de salida, y la salida printf% c usando caracteres ASCII precisos.

4. Si el carácter almacenado es mayor que 255, el uso de tipo int guardar, véase, por ejemplo caracteres valor de código, el valor de código se puede usar printf% d caracteres de salida.

5. Carácter constante necesidad de utilizar 'cerrado.

6. Golang, la naturaleza del carácter es un número entero, cuando la salida directa, un valor de código correspondiente al carácter codificación UTF-8.

7. Del mismo modo en la sección 6, lo anterior se puede asignar directamente a un número entero variable de salida% c formateado, correspondiente a la salida digital de los caracteres de código de uni.

8. Las tiras 6, 7, se puede determinar, el cálculo pueden ser caracteres, el valor de código de carácter se añade por esta forma de realización, el formato de salida y% c, uni-código de los nuevos aparece de caracteres.
   Por ejemplo:

   package main
   
   import "fmt"
   
   func main() {
   //Golang里面没有字符类型数据，只能用byte表示，即ASCII代码.
   //如果单纯输出，则输出为码值，'a'=97,不会输出字符a，而'9'=57
   var c1 byte = 'a'
   var c2 byte = '9'
   fmt.Println(c1,c2)
   //如果我们希望正确输出字符，则需要格式化输出
   fmt.Printf("c1=%c\tc2=%c\n",c1,c2)
   
   //如果输出汉字，那么byte内的汉字可以输出，而超过255则不可以再使用byte作为数据类型
   //var c3 byte = '赵'
   //fmt.Printf("c3=%c",c3)
   //上述是行不通的，赵已经超越了byte的最大值溢出了，所以需要int类型
   var c3 int = '赵'
   fmt.Printf("c3=%d\n",c3)
   var c4 int = 10 + 'b'
   fmt.Printf("c4=%c",c4)
   //c4的结果为1
   }
   

9. El carácter almacenado en el ordenador, el código de carácter correspondiente a un valor (entero) requerido para averiguar.
Almacenamiento: Char -> busca el valor de código correspondiente -> a binario -> memoria
lee: lectura binaria -> correspondiente al valor de código -> convierte en un personaje -> Leer
valores de código de caracteres se indican con antelación y bueno, no modificaciones.
10. Ir lenguaje de codificación se unifican en UTF-8, ya no es gbk involucrados, GB2312 problema de la basura no vuelva a ocurrir.

bool booleano de recomendaciones:

1. Sólo dos valores: verdadero y falso, los valores nulos no pueden tomar nada.
2. un byte de Boole, el uso unsafe.Sizeof () Comprobar tamaño variable.
3. Principalmente para una operación lógica, que se utiliza generalmente para el control de procesos, si, por el estilo.

String cadena de recomendaciones:

1. Muchos de los personajes empalmados juntos como una cadena, cadena de lenguaje Golang es una secuencia de caracteres muchos personajes conectados.
2. Usando UTF-8 de codificación de texto representa Unicode, la distorsión no es un problema.
3. Golang cadenas son inmutables.
4. Cuerda en dos formas:
   comillas: "" identifica el carácter de escape, tales como \ n envolverá no se emite \ n este efecto cadena
   backquote: `` producción primaria a todos los personajes, el carácter de escape falla, Del mismo modo en pitón var1 = r ''

   package main
   
   import "fmt"
   
   func main() {
   //创建字符串，打印字符串
   var add string = "shit aaa!"
   fmt.Println(add)
   
   //Go中字符串不可变
   //var add1 string = "damn!"
   //add1[0] = 'a'
   //fmt.Println(add1)
   //这种切片改变字符串的方式不可以
   
   //字符串两种表现形式
   //双引号："" 会识别转义字符，例如\n就是会换行，不会输出\n这种字符串效果
   //反引号：`` 原生输出所有字符，转义字符失效，类似python中 var1=r''
   s1,s2 := "abc\nabc\n",`abc\tabc`
   fmt.Println(s1,s2)
   //s1是abc换行abc, s2就是abc\tabc
   }
   

5. Cadena de empalme:
   utiliza típicamente para empalme +.
   Multi-línea de costura + debe permanecer extremo de la línea, y luego girar a la línea siguiente, o sea el error
   `
   lista Tipo de datos predeterminado básica:
   Entero 0
   coma flotante 0
   cadena" "
   falso booleano

   package main
   
   import "fmt"
   
   func main() {
   var a int           //0
   var b int32         //0
   var c int64         //0
   var d bool          //false
   var e string        //""
   var f float32       //0
   var g float64       //0
   fmt.Println(a,b,c,d,e,f,g)
   //printf中%v表示按照变量值输出
   }