Meer informatie over basisgegevenstypen

  • 8 minuten

Go is een sterk getypte taal. Elke variabele die u declareert, is gebonden aan een specifiek gegevenstype en accepteert alleen waarden die overeenkomen met dat type.

In Go hebt u vier categorieën gegevenstypen:

  • Basistypen: getallen, tekenreeksen en booleaanse waarden
  • Statistische typen: matrices en structs
  • Referentietypen: aanwijzers, segmenten, kaarten, functies en kanalen
  • Interfacetypen: interface

In deze module behandelen we alleen de basistypen. Maak u geen zorgen als u niet weet wat de andere typen zijn. We behandelen ze in de komende modules.

Laten we beginnen met het verkennen van de numerieke gegevenstypen.

Gehele getallen

In algemene termen is inthet trefwoord voor het definiëren van een geheel getaltype. Maar Go biedt ook de int8typen , int32int16en int64 typen, die respectievelijk ints zijn met een grootte van respectievelijk 8, 16, 32 of 64 bits. Wanneer u een 32-bits besturingssysteem gebruikt, is intde grootte meestal 32 bits. Op 64-bits systemen is de int grootte meestal 64 bits. Maar dit gedrag kan verschillen van de ene computer naar de andere. U kunt dit gebruiken uint. Maar gebruik dit type alleen als u een waarde wilt weergeven als een niet-ondertekend getal om een bepaalde reden. Go biedt uint8ook typen, uint16en uint32typen uint64 .

Hier volgt een voorbeeld van het gebruik van de verschillende typen gehele getallen in Go:

var integer8 int8 = 127
var integer16 int16 = 32767
var integer32 int32 = 2147483647
var integer64 int64 = 9223372036854775807
fmt.Println(integer8, integer16, integer32, integer64)

Meestal gebruikt intu , maar u moet weten wat de andere typen gehele getallen zijn, omdat in Go int niet hetzelfde is als int32, zelfs als de natuurlijke grootte van het gehele getal 32 bits is. Met andere woorden, u moet expliciet casten wanneer een cast vereist is. En als u een wiskundige bewerking tussen verschillende typen probeert uit te voeren, krijgt u een foutmelding. Stel dat u deze code hebt:

var integer16 int16 = 127
var integer32 int32 = 32767
fmt.Println(integer16 + integer32)

Wanneer u het programma uitvoert, krijgt u deze fout:

invalid operation: integer16 + integer32 (mismatched types int16 and int32)

Zoals u ziet, moet u het nieuwe type expliciet aangeven wanneer u een waarde van het ene type naar het andere in Go converteert. Aan het einde van deze module wordt uitgelegd hoe u typen correct kunt casten.

Wanneer u verdergaat met uw Go-training, hoort u mogelijk over runes. Een rune is gewoon een alias voor int32 het gegevenstype. Het wordt gebruikt om een Unicode-teken (of een Unicode-codepunt) weer te geven. Stel dat u de volgende code hebt:

rune := 'G'
fmt.Println(rune)

U kunt verwachten dat het programma wordt afgedrukt G in de opdrachtprompt wanneer u het voorgaande codefragment uitvoert. Maar u ziet het getal 71, dat het Unicode-teken voor Gvertegenwoordigt. In de komende modules bespreken we meer over runes.

U vindt meer informatie over de bereiken voor elk type door naar de Go-broncode te kijken. Als u de bereiken van elk type kent, kunt u het juiste gegevenstype kiezen en vermijdt u ook het verspillen van bits in het geheugen.

Uitdaging 1

Stel een andere variabele van het type int in en gebruik de waarde van de integer32 of integer64 variabele om de natuurlijke grootte van de variabele op uw systeem te bevestigen. Als u een 32-bits systeem gebruikt en een waarde gebruikt die hoger is dan 2.147.483.647, krijgt u een overloopfout die er als volgt uitziet: constant 9223372036854775807 overflows int

Oplossing voor uitdaging:

package main

import "fmt"

func main() {
   var integer32 int = 2147483648
   fmt.Println(integer32)
}

Uitdaging 2

Declareer een niet-ondertekende variabele zoals uint, en initialiseer deze met een negatieve waarde, zoals -10. Wanneer u het programma probeert uit te voeren, krijgt u een foutmelding zoals deze: constant -10 overflows uint.

Oplossing voor uitdaging:

package main

import "fmt"

func main() {
   var integer uint = -10
   fmt.Println(integer)
}

Getallen met drijvende komma

Go biedt gegevenstypen voor twee grootten van drijvendekommagetallen: float32 en float64. U kunt deze typen gebruiken wanneer u grote getallen wilt opslaan en ze niet passen in een van de eerder genoemde gehele getallen. Het verschil tussen deze twee typen is de maximale grootte van bits die ze kunnen bevatten. Bekijk de volgende regels voor meer informatie over het gebruik van deze twee typen:

var float32 float32 = 2147483647
var float64 float64 = 9223372036854775807
fmt.Println(float32, float64)

U kunt de limieten van deze twee typen vinden met behulp van de math.MaxFloat32 en math.MaxFloat64 constanten, die beschikbaar zijn in het math pakket. Gebruik de volgende code om de maximumwaarden voor drijvende komma af te drukken in de opdrachtprompt:

package main

import (
    "fmt"
    "math"
)    

func main() {
    fmt.Println(math.MaxFloat32, math.MaxFloat64)
}

Typen drijvende komma's zijn ook handig wanneer u decimale getallen moet gebruiken. U kunt bijvoorbeeld iets als deze code schrijven:

const e = 2.71828
const Avogadro = 6.02214129e23
const Planck = 6.62606957e-34

Zoals u ziet, worden met de vorige code de gegevenstypen afgeleid van de gebruikte waarden.

Booleaans

Een Booleaanse waarde heeft slechts twee mogelijke waarden: true en false. U declareert een Booleaanse waarde met behulp van het trefwoord bool. Go verschilt van andere programmeertalen. In Go kunt u een Booleaanse waarde niet impliciet converteren naar 0 of 1. U moet dit expliciet doen.

U kunt dus een booleaanse variabele als volgt declareren:

var featureFlag bool = true

We gebruiken booleaanse gegevenstypen in de komende module wanneer we het hebben over controlestroominstructies in Go. We gebruiken ze ook in latere modules.

Tekenreeksen

Laten we ten slotte kijken naar het meest voorkomende gegevenstype in elke programmeertaal: tekenreeks. In Go wordt het trefwoord string gebruikt om een tekenreeksgegevenstype weer te geven. Als u een tekenreeksvariabele wilt initialiseren, moet u de waarde tussen dubbele aanhalingstekens (") definiëren. Enkele aanhalingstekens (') worden gebruikt voor enkele tekens (en voor runes, zoals we in een vorige sectie hebben gezien).

In de volgende code ziet u bijvoorbeeld twee manieren om een tekenreeksvariabele te declareren en te initialiseren:

var firstName string = "John"
lastName := "Doe"
fmt.Println(firstName, lastName)

Soms moet u escapetekens maken. Hiervoor gebruikt u in Go een backslash (\) voor het teken. Hier volgen bijvoorbeeld de meest voorkomende voorbeelden van het gebruik van escape-tekens:

  • \n voor nieuwe regels
  • \r voor regelterugloop
  • \t voor tabbladen
  • \' voor enkele aanhalingstekens
  • \" voor dubbele aanhalingstekens
  • \\ voor backslashes

Gebruik het volgende codefragment om escape-tekens te testen:

fullName := "John Doe \t(alias \"Foo\")\n"
fmt.Println(fullName)

U ziet nu de volgende uitvoer (inclusief de nieuwe regel):

John Doe        (alias "Foo")

Standaardwaarden

Tot nu toe hebben we bijna elke keer dat we een variabele hebben gedeclareerd, deze geïnitialiseerd met een waarde. Maar in Go, in tegenstelling tot in andere programmeertalen, hebben alle gegevenstypen een standaardwaarde wanneer u een variabele niet initialiseert. Deze functie is handig omdat u niet hoeft te controleren of een variabele is geïnitialiseerd voordat u deze gebruikt.

Hier volgt een lijst met enkele standaardwaarden voor de typen die we tot nu toe hebben verkend:

  • 0 voor int typen (en alle subtypen, zoals int64)
  • +0.000000e+000 voor float32 en float64 typen
  • false voor bool typen
  • Een lege waarde voor string typen

Voer het volgende codefragment uit om de eerder vermelde standaardwaarden te bevestigen:

var defaultInt int
var defaultFloat32 float32
var defaultFloat64 float64
var defaultBool bool
var defaultString string
fmt.Println(defaultInt, defaultFloat32, defaultFloat64, defaultBool, defaultString)

U kunt code zoals deze code gebruiken om de standaardwaarde te bepalen voor een gegevenstype dat we hier niet hebben verkend.

Typeconversies

In een vorige sectie hebben we bevestigd dat impliciete cast-conversie niet werkt in Go. In Go moet het casten expliciet worden uitgevoerd. Go biedt een aantal systeemeigen manieren om één gegevenstype te converteren naar een ander gegevenstype. Een manier is bijvoorbeeld om de ingebouwde functie voor elk type te gebruiken, zoals:

var integer16 int16 = 127
var integer32 int32 = 32767
fmt.Println(int32(integer16) + integer32)

Een andere benadering voor casten in Go is om het strconv-pakket te gebruiken. Als u bijvoorbeeld een string naar een int, en omgekeerd wilt converteren, kunt u deze code gebruiken:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    i, _ := strconv.Atoi("-42")
    s := strconv.Itoa(-42)
    fmt.Println(i, s)
}

Voer de voorgaande code uit en controleer of deze twee keer wordt uitgevoerd en afgedrukt -42 .

U ziet dat er een onderstrepingsteken (_) wordt gebruikt als de naam van een variabele in de voorgaande code. In Go betekent dit _ dat we de waarde van die variabele niet gaan gebruiken en dat we deze willen negeren. Anders wordt het programma niet gecompileerd omdat we alle variabelen moeten gebruiken die we declareren. We komen terug naar dit onderwerp en u leert wat het _ meestal vertegenwoordigt in de komende modules.