Golang Mise en route - Types de base et articles de définition de fonction

A propos de la configuration et de sortie dans l'article précédent, nous entrons dans l'étape suivante de l'apprentissage

Avant-propos: langue Go propose

Go langue Google est statique développé, compilé et la collecte des ordures en même temps et entre en langue.
Style de langage Go est similaire à la langue C, la syntaxe a été grandement optimisée sur la base de la langue C, supprimer expression non désirée entre parenthèses, et seulement pour la piste cyclable de dire, vous pouvez adapter la valeur traversal, clé, etc. par conséquent, la langue Go est très facile de démarrer.
langue Go caractéristique la plus distinctive que goroutine. Go langue peut être mis en œuvre dans la langue de la couche de fonction en parallèle simultanée goroutine. goroutine fil similaire, mais pas thread goroutine sera automatiquement programmée dans le temps d' exécution de langue Go. par conséquent, la langue Go est bien adapté à la préparation des services de réseau hautement concurrents.

A, Go et l'utilisation de la grammaire de base

1, de type entier

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

2, flotteur

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, ficelle

Pour le type de chaîne, des guillemets doubles est agrandie par rapport au type de chaîne en direct, il peut être placé dans un caractère non-ASCII

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

5, en tranches

Ensuite, sur les sections de langue Go (peut être alloué dynamiquement l'espace) avec le même type d'éléments est une séquence de longueur variable

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

Les éléments de la tranche à l'aide « [] » à l'accès, en fournissant un index numérique dans [] peuvent acquérir la valeur de valeur correspondante accès par défaut d'index de tranche est égal à zéro, il n'y a pas de valeur par défaut depuis le début de chiffre correspondant de la cession est défini comme 0, le code suivant est apposé

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

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

L'affectation de séquence à

// 创建切片
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

Nous pouvons également être découpés en tranches supplémentaires (append)

info := append(item, 99)

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

En variante de recouvrement (copie)

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

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

Chaîne peut également suivre la manière tranchée (fonction d'interception de chaîne, le nombre de bits 1 depuis le début)

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

Ce sont simplement quelques petits cas, il y a quelques conseils fonction grammaticale, disponible sur le document officiel de visualisation Go http://docscn.studygolang.com/doc/

En second lieu, la variable

1, déclaration de variable

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

définitions standard: le type de paramètres var

lot Déclaration

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

variables initialisées (format standard)

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

les variables initialize (déclaration courte variable)

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 anonyme (pas un nom de variable et pas besoin d'utiliser, peut réduire l'espace mémoire)

Au cours du développement, l'appel parfois une méthode, a constaté que certains des paramètres n'est pas nécessaire, mais ne veulent pas ramasser la mémoire des déchets recevoir, vous pouvez utiliser le « _ » remplacé par un trait de soulignement

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

输出：100

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

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

输出：80

Allez dans la mémoire qui est encore très forte, rien à craindre de manquer de mémoire, il peut en toute sécurité la facilité d'utilisation

En troisième lieu, la fonction

Classiquement fonction définie

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

例：

func item(a) int {
    return 100
}

1, la valeur de la fonction (fermeture)

Valeur de la fonction est non seulement une chaîne de codes, l'état a également enregistré. Utilisez l'outil de fermeture valeur de la fonction technologique (Closures), la valeur de la fonction Go programmeur appelé la fermeture. Nous regardons un exemple de fermeture:

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、依次类推

Fonction des paramètres variables

Les paramètres variables, à savoir la valeur du paramètre n'a pas une mort fixe, peuvent avoir un nombre illimité N, par exemple, en tant que fmt.Printf de fonction, mais seul le dernier paramètre peut être réglé à un paramètre variable

déclaration

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

Par exemple:

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 fonction de retard est effectuée defer

Il contient peine defer après (comme le retour, la panique) fonction est terminée, avant la sortie des appels de la pile sont déclarés déclaration defer , couramment utilisé dans la libération des ressources, des fonctions chronophages telles que l' enregistrement, il présente les caractéristiques suivantes:

• Lorsque defer est déclarée, les paramètres seront résolus en temps réel
• Inverser l'ordre et l'ordre de déclaration
• La valeur de retour peut être lu defer connu

//演示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：一般典型的用来计算耗时，资源关闭等，相关操作可按照业务逻辑编写

articles d'étude golang continueront à jour, je vous remercie