Ir notas de estudio de desarrollo básico (B) - constante y variable

constante

1. El uso constante const modificado C-como el lenguaje definir.

2. Las constantes deben ser inicializados cuando se define, la sintaxis: const <nombre de constante> [tipo] = xxx

3. Las constantes no se pueden modificar.

4. Las constantes sólo se pueden asignar bool, numéricos, de cadena.

5. Tipo de asignación de computación constante inferencia es posible: const num = 4/2

6. medios de escritura B:
   const (
   A = 0 A = Itoa //
   . B // A + 1. 1 =
   C = 2. 1 // B +
   D, E
   )

   Sobre la descripción ápice:

   package main
   
   import "fmt"
   
   func main() {
   	const (
   		a = iota
   		b
   		c
   		d,e = iota,iota  //每一行增加1，同行所有数据一致，不++
   	)
   	fmt.Println(a,b,c,d,e)
   }
   

7. Las constantes con nombre es controlar el acceso por la primera letra del alcance del caso.

Variables:

1. La unidad básica del programa.
2. corresponde variable a un espacio de memoria de datos en la memoria, el valor de una variable para ser accedidos por el nombre de la variable.
3. Variables: & instrucción de asignación utilizando ----> var <var_name> <var_type > [= xxx],
   por ejemplo: var num int = 200 o var num int; num = 200 de los dos niños es una cosa.

Observe el uso de variables (importante):

1. Todo el código debe ser cargado en la memoria para funcionar, variable representa un área de almacenamiento de memoria.

2. La región tiene su propio nombre y tipo.

3. proceso de asignación de variable, var num int: define un nombre de variable int, num, el valor predeterminado es 0, num = 200: 200 0 reemplaza la memoria después de la asignación, completando de esta manera la asignación.
   Detrás fmt.Println (num) se imprime en el valor de la variable de la consola

4. Tipo de asignación de variables, observado por el segmento de código abajo y comentarios, en particular tercera forma:

   package main
   
   import "fmt"
   
   func main() {
   
   //如果i不赋值，那么int默认值就是0
   var i int
   fmt.Println(i)
   
   //不指定num的变量类型，通过赋值则Go做出了类型推导int
   var num = 200
   fmt.Println(num)
   //同理，num1如果是赋予小数，那么就是float了
   var num1 = 10.5
   fmt.Println(num1)
   
   //var都不写，变量这种方式都不写，使用"<var_name> := xx"，这样也叫作声明变量
   name := "durant"
   fmt.Println(name)
   }
   

5. declarar desechable de múltiples variables:

   package main
   
   import "fmt"
   
   func main() {
   //一次性声明多个变量传统写法
   var st1 int
   var st2 int
   var st3 int
   fmt.Println(st1,st2,st3)
   
   //简化1
   var st4,st5,st6 int
   fmt.Println(st4,st5,st6)
   
   //上述两种方法都只能定义一种类型，所以做如下类型推导
   var st7,st8 = "xiaoming",11
   fmt.Println(st7,st8)
   
   //类型推导2
   st9,st10,st11 := "alibaba","tencent",666
   fmt.Println(st9,st10,st11)
   }
   

6. Las variables globales:

   package main
   
   import "fmt"
   //全局变量定义传统
   var name1 = "james"
   var age1 = 34
   var gender1 = "male"
   
   //全局变量定义美观版本
   var(
   name2 = "durant"
   age2 = 32
   gender2 = "male"
   )
   //尝试使用 name3,age3,gender3 := "adtkb",24,"male" 是不可以的，所以定义全局变量只有两种
   
   func main() {
   fmt.Println(name1,age1,gender1)
   fmt.Println(name2,age2,gender2)
   }
   

7. Sólo los valores de datos variables cambiantes dentro de la gama del mismo tipo, no pueden ser cambiados por el str int

   package main
   
   import "fmt"
   
   func main() {
   //变量一定以最后一次赋值为基准
   var num int
   num = 20
   num = 30
   num = 40
   fmt.Println(num)
   
   //不可以改变数据类型，num=1.5这个也是不合规的
   //var num int
   //num = 20
   //var num = "alibaba"
   //fmt.Println(num)
   //这种肯定不可取
   
   }
   

8. Variable en el mismo ámbito de aplicación debe ser único, no hace falta decir, no puede el mismo ámbito hay dos variables del mismo nombre y diferentes valores de la variable.

9. Variable tres elementos: nombre de la variable, valor de la variable, tipos de datos variables

10. Si única variable, ninguna copia, el compilador Ir usará el valor por defecto,
    el valor por defecto int es 0, número entero.
    El valor de cadena por defecto "cadena vacía.
    Valor por defecto es 0 float32, la precisión decimal sola.

conocimientos adicionales:

Común DOS comando:
operaciones de directorio:
el directorio // comprobar el directorio actual de todos los archivos
cd / dd: // d interruptor para la unidad
de cd d: \ test // cambie al directorio prueba d del disco, donde los caminos relativos y absolutos dirigidas a
cd ... // cambiar a la matriz directorio
md d: \ test1 // crea un nuevo directorio
md d: \ test3 D: \ test2 // Crea múltiples directorios
rd d: \ test2 D: \ test3 // eliminar varios directorios (dir vacío)
RD d: \ test1 // borrar directorios individuales (dir vacío)
s // test1 directorio RD / q / y eliminar un solo contenido interno, / q: modo silencioso no pregunta / s: el nivel (de forma recursiva) eliminar todos similar a la -r Linux

Las operaciones de archivo:
eco xxx> d: \ test.txt d // crear un disco de archivo txt, xxx escritura interna, no xxx descrito como un tipo de cadena "xxx", entrar en lo que es lo que el texto
de la copia test.txt d: \ mierda \ test1.txt // copiar el archivo test.txt en el directorio raíz d a d : \ virtud de mierda, y test1.txt de cambio de nombre, a condición de que la carpeta de destino debe existir
movimiento test.txt d: \ mierda // mover el archivo test.txt en el directorio raíz d (corte) en d: \ virtud de mierda, a condición de que debe existir la carpeta de destino o cambiar el nombre
del test.txt // eliminar un archivo

Otras operaciones:
CLS // pantalla clara, similar al puente de borrado
de salida // cmd salida

Programa "+" se utiliza:

1. Ambas partes son numéricos, hacer víbora.
2. A ambos lados de la cuerda, hacer la concatenación de cadenas.

Piezas Ejemplo de código:

package main

import "fmt"

func main() {
	//整数类型
	i,j := 10,20
	var res = i + j
	fmt.Println(res)

	//小数类型
	k,l := 10.6,20.3
	var res1  = k + l
	fmt.Println(res1)

	//整数加小数类型没法做，会报错，告诉mismatch int float64 待解决

	//字符串类型
	str1,str2 := "very","good"
	var res3 = str1 + str2
	fmt.Println(res3)
}