Golang Introducción - Tipos básicos y artículos de definición de funciones

Acerca de la configuración y de salida en el artículo anterior, a continuación, entrar en el siguiente paso del aprendizaje

Prefacio: idioma Ir cuenta

idioma Ir Google es una estática desarrollado, compilado y recolección de basura concurrente y entra en el lenguaje.
estilo de lenguaje Go es similar al lenguaje C, la sintaxis se ha optimizado en gran medida sobre la base de la lengua C, retire la expresión no deseada entre paréntesis, y sólo por la forma ciclo de decir, se puede adaptar el valor clave de recorrido, etc. por lo tanto, el lenguaje Go es muy fácil para empezar.
idioma Ir característica más distintiva de goroutine. Ir idioma puede ser implementado en el lenguaje de la capa de función por paralelo concurrente goroutine. rosca similares goroutine, pero no thread goroutine será programado automáticamente en el tiempo de ejecución de lenguaje Go. por lo tanto, el lenguaje Go es muy adecuado para la preparación de los servicios de red altamente concurrentes.

A, Go y el uso de la gramática básica

1, tipo entero

Go对类型的长度有极大要求
长度类型：int8 int16 int32 int64
对应无符号类型：uint8 uint16 uint32 uint64

2, flotador

Go语言支持两种浮点整数:
float32:最大范围约为 3.4e38,可以使用常量定义:math.MaxFloat32
float64:最大范围约为 1.8e308,可以使用常量定义:math.MaxFloat64

3, Boolean

布尔型数据只有true和false
Go语言中不允许将整型强制转换为布尔型,代码如下:
fmt.Println(int(n) * 2)
编译错误,输出如下:
cannot convert n (type bool) to type int
布尔型无法参与数值运算,也无法与其他类型进行转换

4, cuerda

Por tipo de cadena, entre comillas dobles es más amplio que tipo de cadena en vivo, se puede colocar en un carácter no ASCII

str := "hello world"
ch  := "中文"

5, en rodajas

A continuación, sobre las secciones de idioma ir (puede ser asignado dinámicamente espacio) con el mismo tipo de elementos es una secuencia de longitud variable

var arr[]类型    // 初始化的时候定义，后面追加上类型 如int string float等
例：var arr[]int

Los elementos de la rebanada utilizando "[]" de acceso, que proporcionan un índice numérico en [] pueden ser adquiridos valor correspondiente valor de acceso predeterminado índice de rebanada es cero, no hay ningún valor predeterminado a partir del correspondiente principio figura de tal asignación se define como 0, el siguiente código se fija

// 创建切片
item := make([]int, 3)	//创建一个容量为3的整型切片 ps：其实就是创建一个容量只能为3的切片，但是value都只能为int
item[0] = 0		//为切片元素赋值
item[1] = 1
item[2] = 2

fmt.Println(item)
输出：[0 1 2]

La asignación de secuencia para

// 创建切片
item := make([]int, 10)	//创建一个容量为10的整型切片 ps：其实就是创建一个容量只能为10的切片，但是value都只能为int
item[7] = 77
item[8] = 88

fmt.Println(item)
输出：[0 0 0 0 0 0 0 77 88 0]  // 未定义的索引值则默认为0

También se puede rebanar adicional (agregar)

info := append(item, 99)

fmt.Println(item, info)
输出： [0 0 0 0 0 0 0 77 88 0 99]  // 在原来的基础上追加了99

Alternativamente cubre (copia)

test := []int{1,2,3,4,5}
copy(info, test)

fmt.Println(info)
输出：[1 2 3 4 5 0 0 77 88 0 99]

Cadena también puede seguir la forma en rodajas (función de intercepción de cuerdas, número de bit 1 desde el principio)

str := "hello world"
fmt.Println(str[6:])// 输出截取，这里注意的是截取只能截取字符串类型的，其他类型截不了
输出：world

Estos son simplemente algunos casos pequeños, hay algunos consejos más función gramatical, disponible en el documento oficial de visualización Ir http://docscn.studygolang.com/doc/

En segundo lugar, la variable

1, declaración de variables

var a int//声明一个整型类型的变量,可以保存整数数值
var b string//声明一个字符串类型的变量
var c []float32//声明一个32位浮点切片类型的变量,浮点切片表示由多个浮点类型组成的数据结构
var d func() bool//声明一个返回值为布尔类型的函数变量,这种形式一般用于回调函数,即将函数以变量的形式保存下来,在需要的时候重新调用这个函数
var e struct{//声明一个结构体变量,拥有一个整型的x字段
    x int
}

Las definiciones estándar: tipo de parámetros var

Declaración por lotes

var (
a int 
b string
c []float32
d func() bool
e struct{
    x int
    }
)

la variable inicializada (formato estándar)

var 变量名 类型 = 表达式
例：小明考试考了100分
var score int = 100

las variables de inicialización (declaración de variables corta)

score := 100
// 如果score已经被var初始化过，则这个时候会报错,例如以下
var score int = 90
score := 80
// error : no new variables on left side of :=
// 报错提示的原因是左边没有新的变量名出现，则不允许重新赋值

// ps：也可以支持多个变量一直赋值
info, score, x = 0, 1, 2

2, la variable anónima (no es un nombre de variable y no necesitan usar, puede reducir el espacio de memoria)

Durante el desarrollo, el a veces llama a un método, encontraron que algunos de los parámetros no es necesaria, pero no quieren recoger los residuos de memoria recibir, se puede utilizar el "_" ser reemplazado por un guión

func item() (int,int) {
    return 100, 200
}
a, _ := item()
fmt.Println(a)

输出：100

// 当然，我们也可以在赋值的时候这么做

_, score := 0, 80
fmt.Println(score)

输出：80

Ir en la memoria que aún es muy fuerte, no hay nada que preocuparse por quedarse sin memoria, se puede aliviar con seguridad de uso

En tercer lugar, la función

función Convencionalmente definido

func 方法名(参数列表) 返回值 {
    定义
}

例：

func item(a) int {
    return 100
}

1, el valor de la función (cierre)

valor de la función no es sólo una serie de códigos, estado también grabada. cierres de uso Go tecnología (cierres) valor de la función, el valor de la función Go programador llaman el cierre. Nos fijamos en un ejemplo de cierres:

func f1(limit int) (func(v int) bool) {
    //编译器发现limit逃逸了，自动在堆上分配
    return func (v int) bool { return v > limit}
}
func main(){

    closure := f1(3)
    fmt.Printf("%v\n", closure(1)) //false
    fmt.Printf("%v\n", closure(3)) //false
    fmt.Printf("%v\n", closure(10)) //true
}

ps：程序执行流程

1、程序进入main后，发现调用了f1方法并带入了”3“，此时返回一个闭包
2、走到下面closure(1)时，程序发现有传入闭包值”1“
3、程序走进上面的方法内，此时limit = 3， 闭包内的v = 1
4、走到下面的逻辑判断中，引用闭包内的v，并且将v与limit做比较
5、最终得到结果，返回给下面的 fmt.Printf("%v\n", closure(1))进行输出
6、依次类推

En función de los parámetros variables

Los parámetros variables, es decir, el valor del parámetro no es una fija muerto, pueden tener un número ilimitado N, por ejemplo, como un fmt.Printf función, pero sólo el último parámetro se pueden ajustar con un parámetro variable

declaración

func 函数名(变量名...类型) 返回值

Por ejemplo:

func getData(str string, vals... int) (num int) {
    for  _,v := range vals {
	num += v
    }
    num += len(str)
    return
}

func main(){
    fmt.Printf("%d\n", getData("abc", 1,2,3,4,5 )) 
}

输出：18


将传入的1,2,3,4,5 循环追加给num值，最后再加上str的长度 15 + 3 = 18
注意：在for后面一点要加上匿名函数，否则始终不会循环追加最后一个值，如去掉加起来则为13
getData第二个参数即最后一个参数则为可变参数

2, la función de retardo se realiza Defer

Contiene frase Defer después (como el retorno, el pánico) la función ha terminado, antes de la liberación de las llamadas pila se declaran comunicado Defer , que se utiliza comúnmente en la liberación de recursos, funciones que requieren mucho tiempo, como la grabación, que tiene las siguientes características:

• Cuando se declara Defer, los parámetros serán resueltas en tiempo real
• Invertir orden y el orden de declaración
• El valor de retorno se puede leer Defer conoce

//演示defer的函数可以访问返回值
func f2() (v int) {
    defer func (){ v++}()
    return 1 //执行这个时,把v置为1
}

//演示defer声明即解释
func f3(i int) (v int) {
    defer func(j int) {
	v+= j
    } (i) 		//此时函数i已被解析为10,后面修改i的值无影响
    v = 9		// v = 9
    i = i*2		// i = 20
    return
}

//演示defer的执行顺序,与声明顺序相反
func f4() {
    defer func() {fmt.Printf("first\n")} ()
    defer func() {fmt.Printf("second\n")} ()
}

func main(){
    fmt.Printf("%d\n", f2()) // 13
    fmt.Printf("%d\n", f3(10)) // 19
    f4() //second\nfirst\n

最终输出：
        2
        19
        second
        first

执行过程：
1、首先调用了f2，由于defer是在return执行后再去执行的，所以当return 1时，附加v++ 所以最终返回值为2
2、调用了f3并传入值为10，进入到f3方法中，v = 9,i = 20,走到defer，此时i已经被解析成了10，所以后面的相乘无影响
3、接着进入defer后，设定了j值，此时j = i = 10，v是后面新赋的值，也没有被解析，所以v+=j 则等于 v = 9+10 = 19,最后返回19
4、最后一步f4是返回的顺序是相反的，则验明了defer是在声明的倒序执行的

ps：一般典型的用来计算耗时，资源关闭等，相关操作可按照业务逻辑编写

artículos de estudio Golang continuará actualizando, gracias