Quelles sont les méthodes de déclaration de variables en langage Go ?

Les méthodes de déclaration de variable sont : 1. Utilisez var pour déclarer une variable et indiquez le type de données de la variable. La syntaxe est "var variable name type = expression" ; 2. Utilisez le caractère ":=" pour créer une variable courte ; déclaration. La syntaxe est "nom de la variable :=expression". Lorsque vous utilisez une déclaration de variable courte, vous pouvez omettre le mot-clé var et les informations de type. Le type par défaut de la variable est bool, rune, int, float64, complex128 ou string.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Une caractéristique importante de l'apprentissage des langages statiques est différente des langages dynamiques : la déclaration de variables.

Comment le compilateur ou l'interprète d'un langage de programmation connaît-il les limites de la zone mémoire qu'une variable peut référencer ?

Les langages dynamiques et les langages statiques ont des méthodes de traitement différentes :

• L'interpréteur des langages dynamiques (tels que Python, Ruby, etc.) peut déterminer automatiquement les limites des variables en analysant les affectations de variables au moment de l'exécution. . Et dans les langages dynamiques, une variable peut se voir attribuer des limites de différentes tailles au moment de l'exécution.

• Les langages de programmation statiques ont une "expérience légèrement pire" à cet égard. Le compilateur de langage statiquement typé doit clairement connaître les limites d'une variable avant d'être autorisé à utiliser cette variable, mais le compilateur de langage statique n'a pas la capacité de fournir automatiquement ces informations. Ces informations de limite doivent être fournies par l'utilisateur du langage. , il y a donc une instruction "variable"". Grâce à la déclaration de variable, les utilisateurs du langage peuvent indiquer explicitement au compilateur les informations de limite d'une variable. Au niveau d'implémentation spécifique, ces informations de limite sont fournies par l'attribut type de la variable.

En tant que langage Go dans le camp des langages de programmation statiques, il suit cette exigence des langages statiques : les variables doivent être déclarées avant de les utiliser.

[golang] Déclaration et initialisation de variables var, :=, new() et make()

Le langage Go fournit une variété de méthodes de déclaration et d'initialisation de variables. Ici, nous nous concentrons sur leur explication un par un. Et fournissez un guide simple.

Guide

• Utilisez make() pour initialiser slice, map et channel . make()，来初始化slice，map 和channel 。
• 大多数场合，类型明确的场合下，使用短变量声明方式:=。
• 当使用文字方式初始化一个变量，并且需要指明类型时，使用var变量声明方式。
• 避免使用new()，除非你需要一个指针变量。

变量声明方式

go语言可以使用 var 来声明一个变量，并指明变量的数据类型。

	// 初始化整数变量，值为10。
	var v int = 10
	fmt.Println(v)
	// 输出: 10

	// 变量声明: 一个slice变量
	var vSlice []int = []int{1, 2, 3, 4}
	fmt.Println(vSlice, "type: ", reflect.TypeOf(vSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	var vMap map[string]int = map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(vMap)
	// 输出: map[a:1 b:2]

短变量声明方式

short variable declarations 符号: :=。

短变量声明时，变量的默认类型是: bool, rune, int, float64, complex128 or string

	// 短变量声明: 一个整数变量。
	sdvInt := 10
	fmt.Println(sdvInt, "type: ", reflect.TypeOf(sdvInt).Kind())
	// 输出: 10 type:  int

	// 短变量声明: 一个slice变量
	sdvSlice := []int{1, 2, 3, 4}
	fmt.Println(sdvSlice, "type: ", reflect.TypeOf(sdvSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	sdvMap := map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(sdvMap)
	// 输出: map[a:1 b:2]

new(T)

new(T)的特点：

• 根据类型T分配内存
• 设置内存为0
• 返回内存的指针

	// 初始化一个整数指针变量，指向的值为0
	var i3 *int = new(int)
	fmt.Println(*i3)

	// 初始化一个slice指针变量
	var i4 = new([10]int)[0:5]
	fmt.Println(i4, "type: ", reflect.TypeOf(i4).Kind())
	// 输出: [0 0 0 0 0] type: slice

	// 初始化一个map指针变量，指向的值为[]
	var i5 *map[string]int = new(map[string]int)
	fmt.Println(*i5)
	// 输出: map[]

	// 初始化一个chan指针变量，指向的值为nil
	var i6 *chan int = new(chan int)
	fmt.Println(*i6)
	// 输出: nil

make()

make只用于初始化 slice，map 和 channel

Dans la plupart des cas, lorsque le type est clair, utilisez la méthode

déclaration de variable courte :=. Lors de l'initialisation d'une variable à l'aide de méthodes littérales et que vous devez spécifier le type, utilisez la méthode vardéclaration de variable

.

Évitez d'utiliser new() sauf si vous avez besoin d'une variable de pointeur.

🎜Comment déclarer des variables🎜🎜🎜🎜Le langage Go peut utiliser var pour déclarer une variable et indiquer le type de données de la variable. 🎜

	// make只能用于创建slice, map, channel
	// 切片类型(slice)
	makeSlice := make([]int, 5, 10)
	fmt.Println(makeSlice)
	// 输出: [0 0 0 0 0]

	// Map 类型
	var makeMap map[string]int = make(map[string]int)
	fmt.Println(makeMap)
	// 输出: map[]

	// Channel 类型
	var makeChan chan int32 = make(chan int32, 100)
	fmt.Println(makeChan)
	// 输出: 0xc000112000

🎜🎜🎜Déclarations de variables courtes 🎜🎜🎜🎜Déclarations de variables courtes Symbole : :=. 🎜🎜Lors de la déclaration d'une variable courte, le type par défaut de la variable est : bool, rune, int, float64</code >, < code>complex128 ou string🎜

package main

import (
	"fmt"
	"reflect"
)

func main() {

	// 初始化整数变量，值为10。
	var v int = 10
	fmt.Println(v)
	// 输出: 10

	// 变量声明: 一个slice变量
	var vSlice []int = []int{1, 2, 3, 4}
	fmt.Println(vSlice, "type: ", reflect.TypeOf(vSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	var vMap map[string]int = map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(vMap)
	// 输出: map[a:1 b:2]

	// 短变量声明: 一个整数变量。
	sdvInt := 10
	fmt.Println(sdvInt, "type: ", reflect.TypeOf(sdvInt).Kind())
	// 输出: 10 type:  int

	// 短变量声明: 一个slice变量
	sdvSlice := []int{1, 2, 3, 4}
	fmt.Println(sdvSlice, "type: ", reflect.TypeOf(sdvSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	sdvMap := map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(sdvMap)
	// 输出: map[a:1 b:2]

	// 初始化一个整数指针变量，指向的值为0
	var newInt *int = new(int)
	fmt.Println(*newInt)

	// 初始化一个slice指针变量
	var newSlice = new([10]int)[0:5]
	fmt.Println(newSlice, "type: ", reflect.TypeOf(newSlice).Kind())
	// 输出: [0 0 0 0 0] type: slice

	// 初始化一个map指针变量，指向的值为[]
	var newMap *map[string]int = new(map[string]int)
	fmt.Println(*newMap)
	// 输出: map[]

	// 初始化一个chan指针变量，指向的值为nil
	var newChan *chan int = new(chan int)
	fmt.Println(*newChan)
	// 输出: nil

	// make只能用于创建slice, map, channel
	// 切片类型(slice)
	makeSlice := make([]int, 5, 10)
	fmt.Println(makeSlice)
	// 输出: [0 0 0 0 0]

	// Map 类型
	var makeMap map[string]int = make(map[string]int)
	fmt.Println(makeMap)
	// 输出: map[]

	// Channel 类型
	var makeChan chan int32 = make(chan int32, 100)
	fmt.Println(makeChan)
	// 输出: 0xc000112000

}

🎜🎜🎜new(T)🎜🎜🎜🎜new(T) Caractéristiques : 🎜🎜🎜Attribué selon pour taper T Memory 🎜🎜Réglez la mémoire sur 0🎜🎜Renvoyer le pointeur de mémoire🎜🎜rrreee🎜🎜🎜make()🎜🎜🎜🎜make n'est utilisé que pour initialiser slice, map et <code>canal. 🎜rrreee🎜🎜🎜Code source complet🎜🎜🎜rrreee🎜[Recommandations associées : 🎜Tutoriel vidéo Go🎜, 🎜Enseignement de la programmation🎜]🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!