Erkundung der Variablen und Bezeichner der Go-Sprache: Flexible Speicherung von Daten

Inhaltsverzeichnis

Identifikator

Benennungsregeln

Namenskonvention

Beispiele für die Verwendung von Identifikatoren

Variable

Gängige Variablentypen

Variablendeklaration und -zuweisung

Initialisierung von Variablen

Bild

Für weitere verwandte technische Punkte zu Go achten Sie bitte auf das öffentliche Konto: Die nachfolgenden Beiträge von CTO Plus . Wenn Sie Fragen haben, hinterlassen Sie bitte eine Nachricht im Hintergrund zur Kommunikation.

Originaltext: Erkundung der Variablen und Bezeichner der Go-Sprache: Flexible Speicherung von Daten

Da viele Fans im Hintergrund Nachrichten hinterlassen haben, um sich nach technischen Informationen zur Go-Entwicklung zu erkundigen, habe ich mir an Wochenenden und spät in der Nacht schnell etwas Zeit genommen, um den Inhalt von Artikeln über die Go-Serie zu planen. Ich denke, es kann in drei Phasen unterteilt werden. Die erste Bühne ist die gesamte Syntax von Go. Die zweite Stufe ist der fortgeschrittene Inhalt von Go, der eine verteilte hohe Parallelität beinhaltet. Die dritte Stufe umfasst die Back-End-Entwicklung, das Web-Framework und den Datenbankbetriebsteil.

In früheren Artikeln haben wir auch eine allgemeine Einführung in Go gegeben, einschließlich einiger Open-Source-Projekte und Lernmaterialien. Weitere Informationen finden Sie in der empfohlenen Lektüre am Ende des Artikels.

In der ersten Phase gibt es fast 60 Artikel und der allgemeine Inhalt ist wie folgt:

【Gehe zur ersten Stufe】

„Erweiterte Funktionen, Entwicklungstrends und empfohlene beliebteste Open-Source-Projekte der Go-Sprache“
„Go 1.21 stabile Version und neue Funktionen, detaillierte Erklärung“
„Detaillierte Erläuterung der Multi-Terminal-Entwicklungsumgebung und des Compiler-Aufbaus von Go (Bilder und Text)“
„Gehen Sie zum Codieren, Standards zuerst“
„Detaillierte Einführung in die Entwicklung von Go-Code-Paketen und benutzerdefinierten Paketen“
„Tutorial zur Zusammenfassung der Go-Befehlsoperation“
„Zusammenfassung der Druckausgabemethoden in der Go-Sprache“
„Go-Sprachvariablen erkunden: Flexible Speicherung von Daten“
„Entschlüsselung von Go-Sprachkonstanten: Konstante Werte“
„Umfassendes Verständnis der Datentypen in der Go-Sprache“
„Das Geheimnis der String-Operationen in der Go-Sprache: Effiziente Textverarbeitung“
„Umfassende Analyse und Analyse der Prozesssteuerung von Go (if, for, switch, goto)“
„String-Traversal-Techniken in Go: Text einfach bearbeiten“
„Go Language Gconv-Typkonvertierung: nahtlose Konvertierung von Daten“
„Verwenden von strconv zum Konvertieren der Int-, Float- und String-Typen von Go ineinander: Flexible Konvertierung von Datentypen“
„Gos Operator-Entschlüsselung: Erkundung der Geheimnisse der Berechnung“
„Ausdrucksanalyse in Go: Den Kern des Codes verstehen“
„Go's Slice-Technik: Flexibler Betrieb geordneter Sammlungen“
„Umfassendes Verständnis und eingehende Analyse von Go-Sprachabschnitten (Slice): Erkundung des zugrunde liegenden Mechanismus“
„Go's Slice-Tipps: Verbesserung der Code-Effizienz“
„Gos Range Traversal enthüllt: Iterationsfähigkeiten beherrschen und Datensammlungen effizient verarbeiten“
„Gos Runenanalyse: tiefgreifendes Verständnis der Charakterverarbeitung“
„Das Geheimnis des Karten-(Sammel-)Betriebs in der Go-Sprache: Effiziente Mapping-Fähigkeiten beherrschen“
„ Go-Language-Keyword-Analyse: Schlüsselelemente des Codes verstehen “
„Go Language Mapping Skills: Flexibler Betrieb von Datensammlungen“
„Go-Sprachzuweisung und (tiefe) Kopieranalyse: eingehende Analyse der Datenverarbeitung“
„Parsen von Arrays in der Go-Sprache: Effiziente Verarbeitung geordneter Daten“
„Gos anfängliche Verwendung von Arrays und wie man sie als Funktionsparameter verwendet“
„Vergleich der Unterschiede und Merkmale der in Go integrierten Datenstrukturen Array, Slice und Map“
„Die Kunst der Fehlerbehandlung in Go: Eine eingehende Untersuchung des Fehlerbehandlungsmechanismus der Go-Sprache“
„Eine kurze Diskussion über Golangs umstrittenen Fehler: Erörterung seiner Vor- und Nachteile und Anwendungsszenarien“
„Die wunderbare Welt der Go-Zeiger: Analyse der Zeigerverwendung in der Go-Sprache“
„Der Charme von Go-Methoden: Die Fähigkeiten zur Verwendung von Methoden in der Go-Sprache beherrschen“
„Erkunden Sie die modulare Go-Programmierung: Das Design und die Verwendung von Modulen in der Go-Sprache“
„Die wunderbare Reise der Go-Funktionen: Vertiefendes Verständnis der Funktionsmerkmale in der Go-Sprache“
„Der Unterschied zwischen Go-Funktionen und -Methoden: Ihre Gemeinsamkeiten und Unterschiede aufdecken“
„Der Charme rekursiver Go-Funktionen: Erkundung der magischen Verwendung von Rekursion in der Go-Sprache“
„Das Geheimnis der effizienten integrierten Funktionen von Go: Integrierte Funktionen der Go-Sprache, die häufig in der Entwicklung verwendet werden“
„Erkundung der Go-Funktionsprogrammierung: Vorteile, Nachteile und praktische Erklärung der Modulanwendung“
„Der Charme der Funktionen höherer Ordnung von Go: Beherrschung der funktionalen Programmierung in der Go-Sprache“
„Detaillierte Einführung in die Rolle und Verwendung der übergeordneten Funktionen von Go“
„Die wunderbare Welt der Go-Schnittstellen: Vertiefendes Verständnis der Schnittstellenfunktionen in der Go-Sprache“
„Black-Box-Analyse der Go-Garbage-Collection: Erkundung des Garbage-Collection-Mechanismus in der Go-Sprache“
„Go Log-Modul schnell integrieren: Leitfaden zur Protokollmodul-Integration im Go Language Framework“
„Go-Strukturanalyse (Struktur): Beherrschen Sie die Verwendungsfähigkeiten von Strukturen in der Go-Sprache“
„Go-Leistungstesttechniken enthüllt: Optimierung der Leistung von Go-Sprachprogrammen“
„Go Debugging & Unit Testing: Debugging- und Testfähigkeiten in der Go-Sprachentwicklung“
„Umfassende Analyse von Go-Time-Operationen: Beherrschen Sie die Fähigkeiten der Zeitverarbeitung“
„Die zugrunde liegende Implementierung von Go-Funktionsabschlüssen: eine ausführliche Diskussion der Prinzipien von Abschlüssen in der Go-Sprache“
„Das Geheimnis der Go-Parallelitätssicherheit: Vertiefendes Verständnis des Implementierungsprinzips von sync.Map, der Parallelitätssicherheit in der Go-Sprache“
„Die wunderbare Welt des Kontexts: Grundlagen der gleichzeitigen Go-Programmierung: Was ist Kontext und Erforschung der Anwendung und Praxis des Kontexts in der Go-Sprache“
„Go-Paketmanager-Tool-Mod“
„Vergleich der Paketverwaltungstools in der Go-Sprache: Go-Module und dep“
„Gehen Sie zum Dependency-Management-Tool dep“
„Analyse des Go-Speichermanagements und des Garbage-Collection-Mechanismus“
„So verwenden Sie das Protokollierungspaket in Go“
„Kommunikation zwischen Go-Executoren“
„Go Coroutines: Parallel Computing“

Bild

Die Go-Sprache ist eine statisch typisierte Programmiersprache und Variablen werden zum Speichern und Bearbeiten von Daten in Go verwendet. In Go müssen Variablen vor ihrer Verwendung deklariert werden, und jede Variable hat einen bestimmten Typ.

Die Daten während der Programmausführung werden im Speicher gespeichert. Wenn wir bestimmte Daten im Code bearbeiten möchten, müssen wir die Variable im Speicher finden. Wenn wir die Variable jedoch direkt über die Speicheradresse im Code bedienen, ist die Lesbarkeit von Der Code wird sehr schlecht und fehleranfällig sein, daher verwenden wir Variablen, um die Speicheradresse dieser Daten zu speichern. In Zukunft können wir die entsprechende Adresse und Daten im Speicher direkt über diese Variable finden.

Die Go-Sprache ist eine statisch typisierte Programmiersprache. Wenn Sie also Variablen verwenden, müssen Sie zuerst deren Typ deklarieren. Variablen stellen eine der grundlegendsten Komponenten eines Programms in der Go-Sprache dar. Sie werden zum Speichern von Daten im Programm verwendet.

Bild

In diesem Artikel werde ich die Bezeichner, Variablen und Variablenbenennungsregeln in der Go-Sprache ausführlich vorstellen, einschließlich Variablendeklaration, Zuweisung, Typableitung und allgemeine Variablentypen, und dies anhand von Codebeispielen demonstrieren.

Der nächste Artikel fasst den Umfang, den Lebenszyklus und die Typkonvertierung von Go zusammen und stellt sie vor.

Identifikator

In Programmiersprachen sind Bezeichner Wörter mit besonderer Bedeutung, die von Programmierern definiert werden, z. B. Variablennamen, Konstantennamen, Funktionsnamen usw. Bezeichner in der Go-Sprache bestehen aus alphanumerischen Zeichen und _ (Unterstrich) und können nur mit Buchstaben und _ beginnen. Um einige Beispiele zu nennen: abc, _, _123, a123.

Go-Sprachbezeichner sind Namen, die zur Benennung von Programmeinheiten wie Variablen, Konstanten, Funktionen und Typen verwendet werden. In der Go-Sprache gelten für Bezeichner einige Regeln und Konventionen. Nachfolgend erfahren Sie mehr darüber.

Benennungsregeln

In der Go-Sprache muss die Benennung von Bezeichnern (Variablen) einigen Regeln folgen. Die Regeln lauten wie folgt:

1. Ein Bezeichner (Variablenname) besteht aus einem oder mehreren Buchstaben, Zahlen oder Unterstrichen.

2. Das erste Zeichen des Bezeichners (Variablenname) muss ein Buchstabe oder Unterstrich sein, keine Zahl.

3. Bei Bezeichnern (Variablennamen) muss die Groß-/Kleinschreibung beachtet werden. Name und Name sind beispielsweise unterschiedliche Bezeichner (Variablen).

4. Schlüsselwörter der Go-Sprache können nicht als Bezeichner (Variablennamen) verwendet werden, z. B. if, for usw.

5. Der Bezeichner (Variablenname) sollte beschreibend sein und die Bedeutung der Variablen klar ausdrücken können (sehen Sie sich den Namen an, um die Bedeutung zu erfahren).

Informationen zur Einführung und Verwendung von Schlüsselwörtern finden Sie im CTO Plus-Artikel zum öffentlichen Konto. „ Lesen Sie einfach diesen Artikel, um die Funktionen, Merkmale und Verwendung von Go-Schlüsselwörtern im Detail zusammenzufassen .“

Im Allgemeinen verwendet der Benennungsstil der Go-Sprache die Kamelfall-Benennungsmethode, d. h. der erste Buchstabe ist ein Kleinbuchstabe und der erste Buchstabe nachfolgender Wörter wird großgeschrieben, z.

Namenskonvention

Zusätzlich zu den Namensregeln verfügt die Go-Sprache auch über einige Namenskonventionen, die zur Verbesserung der Lesbarkeit und Wartbarkeit des Codes dienen.

1. Benennung in Kamel-Schreibweise verwenden: Go Language empfiehlt die Benennung in Kamel-Schreibweise, um Bezeichner zu benennen. Die CamelCase-Nomenklatur ist in zwei Formen unterteilt: Die CamelCase-Nomenklatur mit dem ersten Buchstaben in Kleinbuchstaben (z. B. myVariable) wird für private Variablen und lokale Variablen verwendet, und die CamelCase-Nomenklatur mit dem ersten Buchstaben in Großbuchstaben (z. B. MyVariable) wird für öffentliche Variablen und verwendet globale Variablen.

2. Verwenden Sie aussagekräftige Namen: Bezeichnernamen sollten beschreibend sein und ihren Zweck und ihre Bedeutung klar zum Ausdruck bringen. Vermeiden Sie die Verwendung einzelner Buchstaben oder bedeutungsloser Namen.

3. Befolgen Sie die Namenskonventionen: Die Go-Sprache hat einige Namenskonventionen, z. B. die Verwendung von Einzelzeichennamen für Iterationsvariablen (wie i, j, k), die Verwendung von err als Namen von Fehlervariablen usw. Das Befolgen dieser Konventionen kann die Lesbarkeit Ihres Codes verbessern.

4. Vermeiden Sie die Verwendung von Abkürzungen: Vermeiden Sie die Verwendung von Abkürzungen zur Benennung von Bezeichnern, es sei denn, die Abkürzung ist allgemein bekannt. Die Verwendung vollständiger Wörter verbessert die Lesbarkeit Ihres Codes.

Beispiele für die Verwendung von Identifikatoren

Hier sind einige Beispiele für die Verwendung von Go-Sprachbezeichnern:

package main

import "fmt"

func myFunction(age int) int {
  var count int
  return count + age
}

func simple_variable() {
  var age int = 28
  var name string = "SteveRocket"

  fmt.Println("name:", name, "age:", age) // name: SteveRocket age: 28
  fmt.Println(myFunction(age))            // 28
}

func main() {
  simple_variable()
}

Im obigen Beispiel haben wir einige Bezeichner wie Alter, Name, myFunction und Anzahl verwendet. Diese Bezeichner folgen den Namensregeln und -konventionen der Go-Sprache, sind beschreibend und leicht zu verstehen und zu verwalten.

Als nächstes stellen wir die Deklarations-, Zuweisungs- und Benennungsregeln von Variablen vor.

Variable

Die Go-Sprache ist statisch typisiert. Go-Variablen müssen zuerst deklariert und dann verwendet werden. Der Typ der Variablen muss beim Deklarieren der Variablen klar sein. Ein wesentlicher Unterschied zwischen der Go-Sprache und anderen Sprachen besteht darin, dass die Typen der Go-Sprache hinter den Variablen stehen. Beispielsweise wird in C/C++ und Java die Deklaration eines Ganzen im Allgemeinen als int a = 1 geschrieben. In der Go-Sprache muss es so geschrieben werden, wie im folgenden Codebeispiel gezeigt:

func main() {
  var num int      // // 声明一个保存整型的变量num，如果没有赋值，默认为0
  fmt.Println(num) // 0

  var num2 int = 123 // 声明时赋值
  fmt.Println(num2)  // 123

  //因为 456 是 int 类型，所以赋值时，num3 自动被确定为 int 类型，所以类型名可以省略不写
  var num3 = 456    // 声明时赋值
  fmt.Println(num3) // 456

  var nick_name string  // 声明一个保存字符串类型的变量nick_name
  fmt.Println(nick_name) // 空字符串
  // 更简单的声明赋值
  name := "SteveRocket"
  fmt.Println(name) // SteveRocket

  var isNull bool  // 声明一个保存布尔类型的变量isNull，默认为false
  fmt.Println(isNull)
}

Bild

Gängige Variablentypen

Die Funktion von Variablen (Variable) besteht darin, Daten zu speichern. Verschiedene Arten von Variablen können unterschiedliche Datentypen speichern. Die Go-Sprache bietet mehrere Datentypen zum Speichern verschiedener Datentypen. Zu den gängigen Variablentypen (Datentypen) gehören:

Ganzzahltypen: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64 usw.
Gleitkommazahlentypen: float32, float64.
Boolescher Typ: bool, der Wert ist wahr oder falsch.
String-Typ: String.
Zeichentyp: Byte, wird zur Darstellung von ASCII-Zeichen verwendet.

Eine detaillierte Einführung in Datentypen finden Sie im Artikel „Detailliertes Verständnis der Datentypen der Go-Sprache“ hinter dem öffentlichen Konto CTO Plus

Zusätzlich zu den oben genannten Grunddatentypen bietet die Go-Sprache auch zusammengesetzte Typen wie Arrays, Slices, Karten, Strukturen usw. zum Speichern mehrerer Werte oder Werte unterschiedlichen Typs.

Für eine detaillierte Einführung in zusammengesetzte Datentypen beachten Sie bitte den Artikel hinter dem offiziellen Konto CTO Plus:

„Das Geheimnis des Karten-(Sammel-)Betriebs in der Go-Sprache: Effiziente Mapping-Fähigkeiten beherrschen“
„Go's Slice-Technik: Flexibler Betrieb geordneter Sammlungen“
„Umfassendes Verständnis und eingehende Analyse von Go-Sprachabschnitten (Slice): Erkundung des zugrunde liegenden Mechanismus“
„Go's Slice-Tipps: Verbesserung der Code-Effizienz“
„Go Language Mapping Skills: Flexibler Betrieb von Datensammlungen“
„Parsen von Arrays in der Go-Sprache: Effiziente Verarbeitung geordneter Daten“
„Gos anfängliche Verwendung von Arrays und wie man sie als Funktionsparameter verwendet“
„Vergleich der Unterschiede und Merkmale der in Go integrierten Datenstrukturen Array, Slice und Map“

Jede Variable in der Go-Sprache hat ihren eigenen Typ und die Variable muss deklariert werden, bevor sie verwendet werden kann. Als Nächstes führen wir die Deklaration und Zuweisung von Variablen ein.

Variablendeklaration und -zuweisung

In der Go-Sprache wird das Schlüsselwort var zum Deklarieren einer Variablen verwendet. Wenn Sie das Schlüsselwort var zum Deklarieren einer Variablen verwenden, müssen Sie den Namen und den Typ der Variablen angeben. Die Syntax lautet wie folgt:

var-Variablennamentyp

Deklarieren Sie beispielsweise eine Variable age vom Typ Integer:

var Alter int

Nachdem eine Variable deklariert wurde, kann der Variablen durch eine Zuweisungsoperation ein Anfangswert zugewiesen werden. Die Zuweisung verwendet das Gleichheitszeichen =, zum Beispiel:

Alter = 25

Sie können beim Deklarieren einer Variablen auch einen Wert zuweisen, was als Initialisierung der Variablen bezeichnet wird, zum Beispiel:

var name string = „John“

Innerhalb der Funktion kann es verwendet werden.

In der Go-Sprache kann die Deklaration von Variablen mit dem Schlüsselwort var oder mit dem einfacheren Symbol := zum Deklarieren und Initialisieren von Variablen (kurze Variablendeklaration) vereinfacht werden. Bei Verwendung der Kurzdeklarationsmethode (:=) können das Schlüsselwort var und die Typdeklaration weggelassen werden, zum Beispiel:

Alter := 25

Name := „SteveRocket“

Bei Verwendung der :=-Notation zur Vereinfachung wird der Typ der Variablen automatisch aus dem zugewiesenen Wert (dem Wert auf der rechten Seite) abgeleitet.

Variablen in der Go-Sprache müssen deklariert werden, bevor sie verwendet werden können, und wiederholte Deklarationen werden im selben Bereich nicht unterstützt. Und Go-Sprachvariablen müssen nach ihrer Deklaration verwendet werden.

In der Go-Sprache kann die Variablenzuweisung mithilfe des =-Symbols durchgeführt werden, zum Beispiel:

Alter := 18

Alter = 20

Bitte beachten Sie bei der Zuweisung von Werten, dass der Typ der Variablen mit dem Typ des zugewiesenen Werts übereinstimmen muss, da es sonst zu einem Kompilierungsfehler kommt.

Gleichzeitig unterstützt die Go-Sprache auch mehrere Zuweisungen, wie zum Beispiel:

a, b := 1, 2

a, b = b, a

Im obigen Code verwenden wir Mehrfachzuweisungen, um die Werte von a und b auszutauschen.

Vollständiges Codebeispiel:

package main

import "fmt"

// go语言中推荐使用驼峰命名
var studentName string

func variable() {
  Age := 30        // 变量区分大小写
  fmt.Println(Age) // 30

  age := 28
  fmt.Println(age) // 28
  age = 30         // 赋值
  fmt.Println(age) //30
  age = 25.0       // 重新赋值
  fmt.Println(age) // 25

  //在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。
  //age = 25.55  // cannot use 25.55 (untyped float constant) as int value in assignment (truncated)

  fmt.Println(age, Age) // 25 30
  age, Age = Age, age
  fmt.Println(age, Age) // 25 30
}

func main() {
  variable()
}

Bild

Initialisierung von Variablen

Wenn die Go-Sprache eine Variable deklariert, initialisiert sie automatisch den der Variablen entsprechenden Speicherbereich. Jede Variable wird mit dem Standardwert ihres Typs initialisiert, zum Beispiel:

Der Standardwert von Ganzzahlvariablen ist 0.
Der Standardwert von Gleitkommavariablen ist 0,0.
Der Standardwert einer String-Variablen ist der leere String „“.
Der Standardwert boolescher Variablen ist falsch.
Der Standardwert von Slices, Funktionen und Zeigervariablen ist Null.

func variable_default_value() {
  var name string
  var age int
  var isNull bool
  var salary float64
  // 切片
  var slice []int
  // 函数
  var fn func()
  // 指针变量
  var ptr *int
  fmt.Println(name, age, isNull, salary, slice, fn, ptr) // 输出结果："" 0 false 0 [] <nil> <nil>
}

Beachten Sie, dass diese Standardwerte nur gelten, wenn der Variablen bei der Deklaration nicht explizit ein Wert zugewiesen wird. Wenn beim Deklarieren einer Variablen explizit ein Anfangswert zugewiesen wird, wird die Variable auf diesen Anfangswert initialisiert. Das Standardformat für die Initialisierung von Stapelvariablen lautet wie folgt:

var-Variablenname Typ = Ausdruck

var name2, age2, wechat = „SteveRocket“, 28, „CTO Plus“

Standardaussage

Das Variablendeklarationsformat der Go-Sprache ist:

var Variablenname Variablentyp

Die Variablendeklaration beginnt mit dem Schlüsselwort var, der Variablentyp wird nach der Variablen platziert und es ist kein Semikolon am Ende der Zeile erforderlich. Zum Beispiel:

Var-Namenszeichenfolge

var Alter int

var isNull bool

Chargendeklaration

Es wäre umständlich, das Schlüsselwort var jedes Mal zu schreiben, wenn Sie eine Variable deklarieren. Die Go-Sprache unterstützt auch die Deklaration von Batch-Variablen:

//Variablen stapelweise deklarieren

War (

num1 int

Namenszeichenfolge

Alter int32

isNull bool

Gehaltsflotte32

)

Typinferenz

Manchmal lassen wir den Typ der Variablen weg. In diesem Fall leitet der Compiler den Typ der Variablen basierend auf dem Wert auf der rechten Seite des Gleichheitszeichens ab, um die Initialisierung abzuschließen.

var name = „SteveRocket“

war Alter = 18

anonyme Variable

Wenn Sie bei Mehrfachzuweisungen einen bestimmten Wert ignorieren möchten, können Sie eine anonyme Variable verwenden. Anonyme Variablen werden durch einen Unterstrich _ dargestellt, zum Beispiel:

func annoymous_variable(salary float64) (int, string, bool, float64) {
  return 28, "SteveRocket", true, salary
}
func main() {
  age, _, sex, _ := annoymous_variable(0)
  fmt.Println(age, sex) // 28 true
  //_, _, _, _ := annoymous_variable(0)  // no new variables on left side of :=
  _, _, _, salary := annoymous_variable(0)
  fmt.Println(salary)
}

Anonyme Variablen belegen keinen Namespace und weisen keinen Speicher zu, sodass keine wiederholten Deklarationen zwischen anonymen Variablen erfolgen. Sie können auch als Platzhalter in Python verwendet werden.

Beispielcode

Hier ist ein Beispielcode, der Variablen wie folgt verwendet:

package main

import "fmt"

// 全局变量studentName  go语言中推荐使用驼峰命名
var studentName string

// 批量声明全局变量
// 声明全局变量建议使用批量声明，方便追加
var (
  num1   int
  name   string
  age    int32
  isNull bool
  salary float32
)

// 声明变量
var myName string
var myAge int
var isSex bool

// 批量初始化变量(一次初始化多个变量)
var name2, age2, wechat = "SteveRocket", 28, "CTO Plus"

func variable() {
  Age := 30        // 变量区分大小写
  fmt.Println(Age) // 30

  age := 28
  fmt.Println(age) // 28
  age = 30         // 赋值
  fmt.Println(age) //30
  age = 25.0       // 重新赋值
  fmt.Println(age) // 25

  //在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。
  //age = 25.55  // cannot use 25.55 (untyped float constant) as int value in assignment (truncated)

  fmt.Println(age, Age) // 25 30
  age, Age = Age, age
  fmt.Println(age, Age) // 25 30
}

func variable02() {
  // 非全局变量（局部变量）声明了就必须使用，不使用就无法编译通过（全局变量声明或初始化了不使用也可以编译通过）
  // 不使用报错：blog declared and not used
  var blog = "https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q"
  fmt.Println(blog)

  //同一个作用域，不能重复声明同名变量
  //blog := "" // no new variables on left side of :=
  blog = "" // 但可以重新赋值
  fmt.Println(blog)

}
func variable_default_value() {
  var name string
  var age int
  var isNull bool
  var salary float64
  // 切片
  var slice []int
  // 函数
  var fn func()
  // 指针变量
  var ptr *int
  fmt.Println(name, age, isNull, salary, slice, fn, ptr) // "" 0 false 0 [] <nil> <nil>
}

func annoymous_variable(salary float64) (int, string, bool, float64) {
  // 匿名变量 是一个特殊的变量： _
  // 匿名变量使用_指定，用来作为一个占位符，匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明
  return 28, "SteveRocket", true, salary
}

func main() {
  variable()
  variable02()
  variable_default_value()
  age, _, sex, _ := annoymous_variable(0)
  fmt.Println(age, sex) // 28 true
  //_, _, _, _ := annoymous_variable(0)  // no new variables on left side of :=
  _, _, _, salary := annoymous_variable(0)
  fmt.Println(salary)
}

Im obigen Beispiel haben wir die Deklaration von Variablen, die Verwendung anonymer Variablen, die Initialisierung von Variablen, die Typableitung von Kurzvariablen usw. sowie die Zuweisung von Anfangswerten zu diesen Variablen durch Zuweisungsoperationen und die Verwendung von fmt vollständig demonstriert .Println() Die Funktion druckt den Wert einer Variablen auf der Standardausgabe.

Weitere Informationen zur Verwendung des Ausdrucks in der Go-Sprache finden Sie in diesem Artikel zum öffentlichen Konto CTO Plus: „Zusammenfassung der Ausdruckmethoden in der Go-Sprache“

Bild

Zusammenfassen

Nach der Einleitung des obigen Artikels werden im Folgenden einige Hinweise zur Verwendung von Variablen zusammengefasst:

Vorsichtsmaßnahmen

Jede Anweisung außerhalb einer Funktion muss mit einem Schlüsselwort (var, const, func usw.) beginnen.
:= kann nicht außerhalb einer Funktion verwendet werden.
_ wird hauptsächlich für Platzhalter verwendet und der Identifikationswert kann ignoriert werden.
In der Go-Sprache werden Variablen unterschiedlichen Typs bei der Deklaration Standardwerte zugewiesen. Der Standardwert von Ganzzahlvariablen ist 0, der Standardwert von Gleitkommavariablen ist 0,0 und der Standardwert von Zeichenfolgenvariablen ist die leere Zeichenfolge. ". Der Standardwert boolescher Variablen ist falsch und der Standardwert von Slice-, Funktions- und Zeigervariablen ist Null.
Wenn beim Deklarieren einer Variablen explizit ein Anfangswert zugewiesen wird, wird die Variable auf diesen Anfangswert initialisiert und muss im Code verwendet werden, andernfalls tritt ein Kompilierungsfehler auf.

Im Allgemeinen werden Variablen in der Go-Sprache zum Speichern und Bearbeiten von Daten verwendet und müssen vor der Verwendung deklariert werden. Die Variable wird mit dem Schlüsselwort var deklariert und durch eine Zuweisungsoperation kann der Variablen ein Anfangswert zugewiesen werden. Die Benennung von Variablen muss bestimmten Regeln folgen und sollte beschreibend sein. Die Go-Sprache bietet mehrere Datentypen zum Speichern verschiedener Datentypen. Durch den sinnvollen Einsatz von Variablen können Daten einfach verwaltet und manipuliert werden.

Gleichzeitig werden Go-Sprachbezeichner zur Benennung von Programmeinheiten wie Variablen, Konstanten, Funktionen und Typen verwendet. Für Bezeichner gelten einige Benennungsregeln und -konventionen, z. B. die Verwendung von Kamelbuchstaben, die Verwendung aussagekräftiger Namen, das Befolgen von Namenskonventionen usw. Das Befolgen dieser Regeln und Konventionen kann die Lesbarkeit und Wartbarkeit Ihres Codes verbessern.

Ich hoffe, dieser Artikel hilft Ihnen, die Bezeichner (Variablen) der Go-Sprache zu verstehen!

Kolumne „Cloud Native & Microservice“
https://blog.csdn.net/zhouruifu2015/category_5704941

Für weitere spannende Neuigkeiten folgen Sie meinem offiziellen Account und lernen und wachsen Sie gemeinsam.

Bild