Variablen und Konstanten sind grundlegende Konzepte in den meisten Programmiersprachen. Sie sind die Bausteine für die Speicherung und Verwaltung von Daten.
In diesem Artikel werden wir uns anschauen, wie Variablen und Konstanten in Go funktionieren.
Inhaltsverzeichnis:
Was sind Variablen?
Eine Variable ist ein Speicherort, der durch einen Namen (oder Identifikator) identifiziert wird und einen Wert aufnimmt. Dieser Wert kann während der Ausführung eines Programms geändert (oder verändert) werden. Daher heißt esVariable.
Zum Beispiel:
myName := “temitope”
fmt.Println(myName)
myName:= ”oyedele”
fmt.Println(myName)
Wir haben eine Variable mit dem Identifikator myName erstellt, die eine Zeichenfolgenwert aufnimmt.
Wenn du bemerkt hast, änderten wir den Wert auf eine andere Zeichenfolge und könnten das mehrmals tun, weil Variablen dies zulassen.
Variablen ermöglichen es Ihnen, Daten zu speichern, die unterschiedliche Typen haben können, wie z.B. Integer, Fließkommazahlen, Zeichenfolgen oder Objekte.
Wie man in Go eine Variable erstellt
Es gibt zwei primäre Möglichkeiten, eine Variable in Go zu erzeugen, die explizite Deklaration und die Kurz-Deklaration.
Explizite Deklaration
Dies ist die traditionelle Methode zur Erstellung einer Variable in Go. Es funktioniert, indem Sie den Schlüsselwort var verwenden und den Typ der Variable deklarieren, was Ihren Code lesbarer und klar macht.
package main
import "fmt"
func main() {
var age int = 25
var name string = "Temitope"
var height float64 = 5.7
fmt.Println(age, name, height)
}
Du kannst sehen, dass wir für jede Variable ihren Datentyp vor der Zuweisung eines Werts deklariert haben.
output:
25 Temitope 5.7
Das Schlüsselwort var und der Datentyp können auch ohne einen initialen Wert verwendet werden:
package main
import "fmt"
func main() {
var age int
var name string
var height float64
age = 25
name = "Temitope"
height = 5.7
fmt.Println(age, name, height)
}
Auf diese Weise werden die Variablen zunächst ohne einen initialen Wert deklariert. Sie werden später im Code zugewiesen. Du erhälst die gleiche Ausgabe wie beim ersten.
Kurz-Deklaration einer Variable
Die Kurzschreibweise für die Variablen Deklaration (:=) ist eine knappere Methode, um Variablen zu deklarieren. Diese Methode ermöglicht es Ihnen, eine Variable gleichzeitig zu deklarieren und zu initialisieren, ohne ihren Typ explizit anzugeben, da der Typ aus dem zugewiesenen Wert abgeleitet wird.
package main
import "fmt"
func main() {
age := 25
name := "Temitope"
height := 5.7
fmt.Println(age, name, height)
}
Hier wurde jeder Variablenname neben seinem Wert deklariert, wobei Go den Typ aus dem zugewiesenen Wert ableitet. Zum Beispiel wurde die Variable age mit dem Wert 25 deklariert und Go schloss ab, dass sie vom Typ int ist. name wurde mit dem Wert „Temitope“ deklariert, und Go schloss ab, dass sie vom Typ string ist. Schließlich wurde height mit 5,7 deklariert, und Go schloss ab, dass sie vom Typ float64 ist.
output:
25 Temitope 5.7
Eine der Nachteile der Kurzschreibweise für die Variablen deklaration ist, dass Sie sie nur innerhalb einer Funktion verwenden können.
Mehrfache Variablen Deklarationen
Sie können mehrere Variablen auf einer Zeile deklarieren und initialisieren, indem Sie jeden Variablennamen mit einem Komma trennen. Diese Methode ist einfach und direkt. Sie wird häufig verwendet, wenn die Variablen miteinander in Beziehung stehen oder wenn Sie sie gemeinsam initialisieren möchten. Zum Beispiel:
package main
import "fmt"
func main() {
var age, height int = 25, 180
var name, city string = "Temitope", "New York"
fmt.Println(age, height)
fmt.Println(name, city)
}
Hier sind die Variablen age und height sowohl als Integer deklariert als auch mit den Werten 25 und 180 initialisiert. Die Variablen name und city werden ebenfalls als Strings deklariert und mit „Temitope“ und „New York“ initialisiert:
Output:
25 180
Temitope New York
Sie können auch mehrere Variablen auf einer Zeile deklarieren:
package main
import "fmt"
func main() {
var (
age int = 25
name string = "Temitope"
height int = 180
city string = "New York"
)
fmt.Println(age, name, height, city)
}
Hier werden die Variablen age, name, height und city innerhalb eines einzigen Var-Blocks deklariert, wobei jederVariable ihre eigene Zeile hat.
Output:
25 Temitope 180 New York
Nullwerte
Wenn Variablen deklariert werden, aber nicht initialisiert, erhalten sie standardmäßig Nullwerte. Diese Werte unterscheiden sich je nach dem Typ der Variable. Folgender ist ein Beispiel dafür, wie Sie Standardwerte deklarieren können:
package main
import "fmt"
func main() {
var intValue int
var floatValue float64
var boolValue bool
var stringValue string
var ptrValue *int
var sliceValue []int
var mapValue map[string]int
fmt.Println("Zero values:")
fmt.Println("int:", intValue)
fmt.Println("float64:", floatValue)
fmt.Println("bool:", boolValue)
fmt.Println("string:", stringValue)
fmt.Println("pointer:", ptrValue)
fmt.Println("slice:", sliceValue)
fmt.Println("map:", mapValue)
}
In dem obenstehenden Code wird folgendes passieren:
-
Die ganze Zahl
intValuewird den Nullwert 0 zugewiesen. -
Das Fließkommawert
floatValuewird den Nullwert 0 zugewiesen. -
Das Logische
boolValuewird den Nullwertfalsezugewiesen. -
Der String
stringValuewird den Nullwert „“ (leere Zeichenkette) zugewiesen. -
Der Zeiger
ptrValue, der SlicesliceValueund die MapmapValuewerden alle den Nullwertnilzugewiesen.
Ausgabe:
Output:
Zero values:
int: 0
float64: 0
bool: false
string:
pointer: <nil>
slice: []
map: map[]
Was ist der Variablenbereich?
Variablen können global oder lokal deklariert werden. Der Bereich einer Variable bestimmt, wo sie innerhalb Ihrer Datei zugänglich und veränderbar ist.
Globale Variablen werden außerhalb jeglicher Funktion deklariert, normalerweise am Anfang eines Dateis, und sie können von jeglicher Funktion innerhalb des gleichen Pakets aufgerufen werden. Hier ist ein Beispiel:
package main
import "fmt"
var globalCounter int = 0
func incrementCounter() {
globalCounter++
}
func main() {
fmt.Println("Initial Counter:", globalCounter)
incrementCounter()
fmt.Println("After Increment:", globalCounter)
}
In dem obigen Beispiel ist globalCounter die globale Variable und zugänglich für sowohl die incrementCounter-Funktion als auch die main-Funktion.
Außerdem behält das globalCounter-Wert seine Beschaffenheit über Funktionsaufrufe hinweg. Dies bedeutet, dass jeder Änderung, die in einer Funktion vorgenommen wird, sich ihre Wert in anderen Teilen des Programms auswirkt.
Lokale Variablen hingegen werden innerhalb einer Funktion oder einem Block deklariert und sind nur innerhalb dieser speziellen Funktion oder Block zugänglich. Sie werden erstellt, wenn die Funktion oder der Block ausgeführt wird und gelöscht, sobald er beendet ist. Zum Beispiel:
package main
import "fmt"
func incrementCounter() {
localCounter := 0
localCounter++
fmt.Println("Local Counter:", localCounter)
}
func main() {
incrementCounter()
incrementCounter()
}
In dem obigen Code haben wir localCounter als lokale Variable innerhalb der incrementCounter-Funktion. Jedes Mal, wenn incrementCounter aufgerufen wird, wird eine neue localCounter erstellt, initialisiert auf 0 und inkrementiert.
Der Wert von localCounter behält seine Beschaffenheit nicht zwischen Funktionsaufrufen, also kann er keinen anderen Teil des Programms beeinflussen, wenn ein Änderung in der Funktion vorgenommen wird.
Benennung Konventionen in Go
Der richtige Name von Variablen ist entscheidend, um sauberen, lesbaren und maintainbaren Code zu schreiben. Go hat spezifische Konventionen und Regeln für die Namensgebung von Variablen. Hier sind einige davon:
-
Bitte verwenden Sie deskriptive Namen:
Verwenden Sie Namen, die eindeutig den Zweck oder den Inhalt der Variable beschreiben. Zum Beispiel sollten Sie keine abstrakten Namen wie x oder y verwenden, sondern Namen wie
age,totalPriceoderuserName, die klar vermitteln, was die Variable repräsentiert. -
Verwenden Sie CamelCase für Namen mit mehreren Worten: In Go ist es eine gängige Praxis, camelCase für Variable Namen zu verwenden, die aus mehreren Worten bestehen. Der erste Wortanfang ist klein geschrieben, und der erste Buchstabe jedes folgenden Wortes ist Groß geschrieben.
-
Verwenden Sie kein Unterstrich: Im Gegensatz zu anderen Sprachen bevorzugt Go camelCase statt das Verwenden von Unterstrichen, um Wörter in Variable Namen zu trennen. Halten Sie sich an camelCase, um der idiomatischen Stil von Go zu folgen.
-
Verwende kurze Namen für kurzlebige Variablen: Für kurzlebige Variablen wie z.B. Schleifenzähler oder Indizes ist es akzeptabel, kurze Namen wie i, j oder k zu verwenden.
Was sind Konstanten in Go?
Konstanten sind Werte, die bei der Kompilierung festgelegt und während der Laufzeit des Programms nicht verändert werden können. Sie sind nützlich für Werte, die vorher bekannt sind und während der Laufzeit des Programms unveränderlich bleiben.
Stellen Sie sich vor, Sie bauen eine Online-Shop-Website, wo die Standardversandkosten immer $10 sind. Sie können diese als Konstante deklarieren, sodass Sie sie überall im Programm verwenden können, wann immer Versandkosten angewendet werden müssen. Wenn die Versandraten sich ändern, müssen Sie die Werte nur an einem einzigen Ort aktualisieren.
Wie können Konstanten in Go deklariert werden?
Sie können Konstanten mithilfe des Schlüsselworts const deklarieren, gefolgt von dem Namen, dem Typ (optional, falls der Wert den Typ impliziert) und dem Wert der Konstante. Hier ist ein Beispiel:
package main
import "fmt"
func main() {
const pi float64 = 3.14159
const greeting string = "Hello, World!"
fmt.Println("Pi:", pi)
fmt.Println("Greeting:", greeting)
}
Wenn Sie versuchen, eine Konstante nach der Deklaration zu ändern, erhalten Sie einen Kompilierungsfehler.
Arten von Konstanten in Go
Konstanten können als typpiert oder untyppiert kategorisiert werden. Beide Arten von Konstanten erfüllen das gleiche Ziel. Sie stellen im gesamten Programm fixe, unveränderliche Werte bereit. Allerdings unterscheiden sie sich in der Art und Weise, wie Go mit ihren Typs behandelt und wie flexibel sie sind, wenn sie verwendet werden.
Untypte Konstanten erhalten kein festes Datentyp, solange sie in einem Kontext nicht verwendet werden, der einen bestimmten Typ erfordert. Wenn Sie eine untypte Konstante deklarieren, infert Go den Typ an der Stelle, an der die Konstante verwendet wird. Dies macht untypte Konstanten flexibler, da sie in einer Reihe von Szenarien ohne Typumwandlung verwendet werden können.
package main
import "fmt"
const gravity = 9.81
func main() {
var height int = 10
var acceleration float64 = gravity * float64(height)
fmt.Println("Acceleration:", acceleration)
}
Hier ist gravity die untypte Konstante. Dies bedeutet, dass Go ihren Typ basierend auf ihrer Verwendung ermitteln kann. Wenn gravity in einer Berechnung mit einer float64 verwendet wird, behandelt Go sie automatisch als float64.
Im Gegensatz zu untypten Konstanten haben typierte Konstanten einen explizit deklarierten Typ. Dies bedeutet, dass sie nur in Kontexten verwendet werden können, die diesen Typ oder in einen kompatiblen Typ umgewandelt werden können. Typierte Konstanten sind strenger, was sicherstellt, dass der Wert immer als der spezifische Typ behandelt wird, der bei der Deklaration angegeben wurde.
package main
import "fmt"
const speedOfLight int = 299792458
func main() {
var distance int = speedOfLight * 2
fmt.Println("Distance:", distance)
}
Hier ist speedOfLight die typierte Konstante mit dem Typ int.
Sie kann nur in Operationen mit anderen int-Werten verwendet werden oder explizit in eine andere Art umgewandelt werden.
Das ist’s
In diesem Artikel haben wir einen Blick auf was Variablen und Konstanten sind und wie Sie sie in Go deklarieren können.
Variablen und Konstanten sind wichtige Werkzeuge in der Programmierung. Sie ermöglichen Entwicklern eine effiziente Verwaltung und Verarbeitung von Daten. Wenn Sie verstehen, wie Sie sie verwenden können, können Sie die Qualität Ihrer Code verbessern.
Teile diesen Inhalt, wenn es Ihnen geholfen hat.
Source:
https://www.freecodecamp.org/news/variables-and-constants-in-go/