Variables en constanten zijn fundamentele concepten in de meeste programmeertalen. Ze zijn de bouwstenen voor het opslaan en beheren van gegevens.

In dit artikel kijken we naar hoe variabelen en constanten werken in Go.

Inhoudsopgave:

Wat zijn Variabelen ?

Een variabele is een opslaglocatie aangeduid met een naam (of identifier) die een waarde bevat. Deze waarde kan veranderen (of varieren) tijdens de uitvoering van een programma. Dit is waarom het een variabele wordt genoemd.

Bijvoorbeeld:

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

We hebben een variabele gemaakt met een identifier myName die een stringwaarde bevat.

Als je merkt, hebben we de waarde gewijzigd in een andere string, en we kunnen dat meerdere keren doen omdat variabelen dat mogen.

Variabelen stellen je in staat gegevens op te slaan, die van verschillende types kunnen zijn, zoals integers, floating-point getallen, strings of objecten.

Hoe maak je een Variabele aan in Go

Er zijn twee primaire manieren om een variabele aan te maken in Go, expliciete declaratie en kortere schrijfwijze.

Expliciete Declaratie

Dit is de traditionele manier om een variabele in Go aan te maken. Het werkt door gebruik te maken van het keyword var en de variabeletype te declareren, wat je code meer leesbaar en duidelijk maakt.

package main

import "fmt"

func main() {

    var age int = 25

    var name string = "Temitope"

    var height float64 = 5.7

    fmt.Println(age, name, height)

}

Je kunt zien dat we voor elke variabele het datatype hebben gedeclareerd voordat we er een waarde aan toekennen.

output:
25 Temitope 5.7

Het keyword var en het datatype kunnen ook zonder initiële waarde worden gebruikt:

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)
}

Op deze manier worden de variabelen eerst zonder initiële waarde gedeclareerd. Ze krijgen later in de code waarden toegekend. Je krijgt nog steeds hetzelfde resultaat als bij de eerste keer.

Korte Schrijfwijze voor Variabele declaratie

De syntaxis voor de verklaring van variabelen met verkorte notatie (:=) is een beknoptere manier om variabelen te verklaren. Met deze methode kun je een variabele in één regel declareren en initialiseren zonder expliciet het type te vermelden, aangezien het type wordt afgeleid van de toegewezen waarde.

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

Hier werd elke variabele samen met zijn waarde verklaard, waarbij Go het gegevenstype afleidde. Bijvoorbeeld, leeftijd werd verklaard en geïnitialiseerd met een waarde van 25, en Go leidde het type af als int. naam werd verklaard met de waarde “Temitope”, en Go leidde het type af als string. Ten slotte werd lengte verklaard met 5.7, en Go leidde het type af als float64.

output:
25 Temitope 5.7

Een van de nadelen van de verkorte variabeleverklaring is dat je deze alleen binnen een functie kunt gebruiken.

Meervoudige Variabele Verklaringen

Je kunt meerdere variabelen op dezelfde regel declareren en initialiseren door elke variabele te scheiden met een komma. Deze aanpak is eenvoudig en duidelijk. Het wordt vaak gebruikt wanneer de variabelen gerelateerd zijn of wanneer je ze samen wilt initialiseren. Bijvoorbeeld:

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 worden de variabelen leeftijd en lengte beide verklaard als gehele getallen en geïnitialiseerd met de waarden 25 en 180, respectievelijk. Variabele naam en stad worden ook beide verklaard als strings en geïnitialiseerd met “Temitope” en “New York”:

Output:
25 180
Temitope New York

Je kunt ook meerdere variabelen in een blok declareren zoals dit:

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 worden de variabelen leeftijd, naam, lengte en stad binnen een enkel var-blok verklaard, waarbij elke variabele zijn eigen regel krijgt.

Output:
25 Temitope 180 New York

Nulwaarden

Wanneer variabelen worden gedeclareerd zonder te worden geïnitialiseerd, worden ze standaard toegewezen aan nulwaarden. Deze waarden verschillen afhankelijk van het type variabele. Hieronder volgt een voorbeeld van hoe u standaardwaarden kunt declareren:

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 de bovenstaande code zal het volgende gebeuren:

  • De integer intValue krijgt de nulwaarde 0.

  • Het floating-point getal floatValue krijgt de nulwaarde 0.

  • De Booleaanse boolValue krijgt de nulwaarde false.

  • De string stringValue krijgt de nulwaarde “” (lege string).

  • De pointer ptrValue, slice sliceValue en map mapValue krijgen allemaal de nulwaarde nil.

Uitvoer:

Output:
Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: []
map: map[]

Wat is de reikwijdte van een variabele?

Variabelen kunnen zowel globaal als lokaal worden gedeclareerd. De reikwijdte van een variabele bepaalt waar het kan worden benaderd en gewijzigd binnen uw code.

Globale variabelen worden buiten elke functie gedeclareerd, meestal bovenaan een bestand, en zij kunnen door elke functie binnen hetzelfde pakket worden bereikt. Hier is een voorbeeld:

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 het bovenstaande voorbeeld is globalCounter de globale variabele, en is toegankelijk voor zowel de incrementCounter functie als de main functie.

Daarnaast blijft de waarde van globalCounter bestaan tijdens verschillende functieoproepen. Dit betekent dat elke wijziging die aan deze variabele wordt gemaakt in één functie invloed heeft op zijn waarde in andere delen van het programma.

Daarentegen zijn lokale variabelen binnen een functie of blok gedeclareerd en alleen toegankelijk binnen die specifieke functie of blok. Ze worden gemaakt wanneer de functie of blok wordt uitgevoerd en vernietigd zodra hij is voltooid. Bijvoorbeeld:

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

    fmt.Println("Local Counter:", localCounter)

}

func main() {

    incrementCounter()

    incrementCounter()

}

In de bovenstaande code hebben we de localCounter als lokale variabele binnen de incrementCounter functie. Elke keer dat incrementCounter wordt aangeroepen, wordt een nieuwe localCounter gemaakt, geïnitialiseerd op 0, en verhoogd.

De waarde van localCounter blijft niet tussen functieoproepen bestaan, dus kan hij geen deel van een programma beïnvloeden als er een wijziging aan de functie wordt gemaakt.

Naamgeving conventies in Go

De juiste naamgeving van variabelen is cruciaal voor het schrijven van schoon, leesbaar en onderhoudbaar code. Go heeft enkele specifieke conventies en regels voor het naamgeven van variabelen. Hieronder staan enkele ervan:

  • Gebruik beschrijvende namen:

    Gebruik namen die de doel of inhoud van de variable duidelijk beschrijven. Bijvoorbeeld, in plaats van vage namen als x of y, gebruik namen zoals age, totalPrice of userName die duidelijk aangeven wat de variable voorstelt.

  • Gebruik CamelCase voor Meerdere-Woorden-Namen: In Go is het gebruikelijk CamelCase te gebruiken voor variable namen die uit meerdere woorden bestaan. Het eerste woord is kleine letters, en de eerste letter van elk volgend woord wordt hoofdletters gemaakt.

  • Vermijd het Gebruik van Underscores: Anders dan in sommige andere talen, heeft Go camelCase voorrang boven het gebruik van underscores om woorden in variable namen te scheiden. Blijf bij camelCase om aan de stijl van Go te voldoen.

  • Gebruik korte namen voor kortlevende variabelen: Voor kortlevende variabelen, zoals loop-tellers of indices, is het acceptabel om korte namen zoals i, j of k te gebruiken.

Wat zijn constanten in Go?

Constanten zijn onveranderlijke waarden die bij het compileren worden gedefinieerd en gedurende de uitvoering van het programma niet kunnen worden gewijzigd. Ze zijn nuttig voor het definiëren van waarden die van tevoren bekend zijn en hetzelfde blijven.

Stel je voor dat je een online winkel bouwt waar de standaard verzendkosten altijd $10 zijn. Je kunt het als een constante declareren, zodat je het in je hele programma kunt gebruiken wanneer verzendkosten moeten worden toegepast. Als de verzendtarieven veranderen, hoef je alleen de waarde op één plaats bij te werken.

Hoe constanten in Go te declareren

Je kunt constanten declareren met het const-sleutelwoord, gevolgd door de naam, het type (optioneel als de waarde het type impliceert) en de waarde van de constante. Zo doe je dat:

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

Als je probeert een constante te wijzigen nadat deze is gedeclareerd, krijg je een compileerfout.

Soorten constanten in Go

Constanten kunnen worden gecategoriseerd als getypeerd of ongetypeerd. Beide soorten constanten hebben hetzelfde doel. Ze bieden vaste, onveranderlijke waarden gedurende het programma. Ze verschillen echter in hoe Go met hun types omgaat en hoe flexibel ze zijn bij gebruik.

Zonder typegebonden constante zijn niet toegewezen een type tenzij ze worden gebruikt in een context die een type vereist. Wanneer je een niet-typegebonden constante declareert, zal Go het type bij het gebruik van de constante afleiden. Dit maakt niet-typegebonden constanten flexibeler omdat ze kunnen worden gebruikt in diverse omgevingen zonder dat typeconversie nodig is.

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, gravity is de niet-typegebonden constante. Dit betekent dat Go zijn type kan afleiden gebaseerd op hoe hij wordt gebruikt. Wanneer gravity wordt gebruikt in een berekening met een float64, zal Go het automatisch als een float64 behandelen.

In tegenstelling tot niet-typegebonden constanten hebben de typegebonden constanten een expliciet gedeclareerd type. Dit betekent dat ze alleen kunnen worden gebruikt in contexten die overeenkomen met dat type of die kunnen worden geconverteerd naar een compatibel type. Typegebonden constanten zijn strikter, waarbij ervoor wordt gezorgd dat de waarde altijd wordt behandeld als het specifieke type waarvoor zij zijn gedeclareerd.

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

Here, speedOfLight is de typegebonden constante met het type int.

Ze kan alleen worden gebruikt in bewerkingen met andere int-waarden of expliciet worden geconverteerd naar een ander type.

That’s a Wrap

In dit artikel hebben we gekeken naar wat variabelen en constanten zijn en hoe je ze in Go kunt declareren.

Variabelen en constanten zijn essentiële tools in programmeren. Ze laten ontwikkelaars toe om efficiënt gegevens te beheren en te manipuleren. Wanneer je begrijpt hoe je ze moet gebruiken, kan je de kwaliteit van je code verbeteren.

Delen als je dit nuttig vond.