Golang-zelfstudie: leer Go-programmeertaal voor beginners

Wat is Go?

Go (ook bekend als Golang) is een open source programmeertaal ontwikkeld door Google. Het is een statisch getypeerde gecompileerde taal. Go ondersteunt gelijktijdig programmeren, dwz het maakt het mogelijk meerdere processen gelijktijdig uit te voerenneonuttig. Dit wordt bereikt met behulp van kanalen, goroutines, enz. Go Language beschikt over garbagecollection die zelf het geheugenbeheer doet en de uitgestelde uitvoering van functies mogelijk maakt.

We zullen alle basisprincipes van Golang leren in deze Learn Go Language Tutorial.

GO downloaden en installeren

Stap 1) Ga naar https://golang.org/dl/. Download het binaire bestand voor uw besturingssysteem.

Stap 2) Double klik op het installatieprogramma en klik op Uitvoeren.

Stap 3) Klik op Volgende

Stap 4) Selecteer de installatiemap en klik op Volgende.

Stap 5) Klik op Voltooien zodra de installatie is voltooid.

Stap 6) Zodra de installatie is voltooid, kunt u deze verifiëren door de terminal te openen en te typen

go version

Hierdoor wordt de geïnstalleerde versie van go weergegeven

Je First Go-programma – Go Hello World!

Maak een map met de naam studyGo. In deze Go-taaltutorial maken we onze go-programma's in deze map. Go-bestanden worden gemaakt met de extensie .Gaan. U kunt Go-programma's uitvoeren met behulp van de syntaxis

go run <filename>

Maak een bestand met de naam first.go, voeg de onderstaande code eraan toe en sla het op

package main
import ("fmt")

func main() {
	fmt.Println("Hello World! This is my first Go program\n")
}

Navigeer naar deze map in uw terminal. Voer het programma uit met behulp van de opdracht

ga eerst rennen.go

U kunt de uitvoerafdruk zien

Hello World! This is my first Go program

Laten we nu het bovenstaande programma bespreken.

package main – Elk Go Language-programma moet beginnen met een pakketnaam. Met Go kunnen we pakketten in andere go-programma's gebruiken en wordt daarmee de herbruikbaarheid van code ondersteund. De uitvoering van een Go-programma begint met de code in het pakket genaamd main.

import fmt – importeert het pakket fmt. Dit pakket implementeert de I/O-functies.

func main() – Dit is de functie van waaruit de uitvoering van het programma begint. De hoofdfunctie moet altijd in het hoofdpakket worden geplaatst. Onder main() kunt u de code in { } schrijven.

fmt.Println – Hiermee wordt de tekst op het scherm afgedrukt via de Println-functie van fmt.

Opmerking: wanneer u in de onderstaande secties van deze Go-tutorial de code uitvoeren/uitvoeren vermeldt, betekent dit dat u de code opslaat in een bestand met de extensie .go en deze uitvoert met behulp van de syntaxis

    go run <filename>

Gegevenstypen

Typen (gegevenstypen) vertegenwoordigen het type waarde dat is opgeslagen in een variabele, het type waarde dat een functie retourneert, enz.

Er zijn drie basistypen in Go Language

Numerieke typen – Vertegenwoordig numerieke waarden, waaronder geheel getal, drijvende komma en complex waarden. Verschillende numerieke typen zijn:

int8 – 8 bit gehele getallen met teken.

int16 – 16 bit gehele getallen met teken.

int32 – 32 bit gehele getallen met teken.

int64 – 64 bit gehele getallen met teken.

uint8 – 8 bit gehele getallen zonder teken.

uint16 – 16 bit gehele getallen zonder teken.

uint32 – 32 bit gehele getallen zonder teken.

uint64 – 64 bit gehele getallen zonder teken.

float32 – 32 bit drijvende-kommagetallen.

float64 – 64 bit drijvende-kommagetallen.

complex64 – heeft float32 echte en denkbeeldige delen.

complex128 – heeft float32 echte en denkbeeldige delen.

Soorten tekenreeksen – Vertegenwoordigt een reeks bytes (tekens). U kunt verschillende bewerkingen uitvoeren op tekenreeksen, zoals het aaneenschakelen van tekenreeksen, het extraheren van subtekenreeksen, enz

Booleaanse typen – Vertegenwoordigt 2 waarden, waar of onwaar.

Golang-interface

Golang-interface is een verzameling methodehandtekeningen die door een type worden gebruikt om het gedrag van objecten te implementeren. Het belangrijkste doel van de Golang-interface is om methodehandtekeningen te voorzien van namen, argumenten en retourtypen. Het is aan een Type om de methode te declareren en te implementeren. Een interface in Golang kan worden gedeclareerd met het trefwoord ‘interface’.

Variabelen

Variabelen verwijzen naar een geheugenlocatie waarin een bepaalde waarde is opgeslagen. De parameter type (in de onderstaande syntaxis) vertegenwoordigt het type waarde dat op de geheugenlocatie kan worden opgeslagen.

Variabele kan worden gedeclareerd met behulp van de syntaxis

    var <variable_name> <type>

Zodra u een variabele van een bepaald type declareert, kunt u de variabele aan elke waarde van dat type toewijzen.

U kunt ook tijdens de declaratie zelf een initiële waarde aan een variabele geven met behulp van

    var <variable_name> <type> = <value>

Als u de variabele met een beginwaarde declareert, leidt u het type variabele af uit het toegewezen type waarde. U kunt het type dus weglaten tijdens de declaratie met behulp van de syntaxis

    var <variable_name> = <value>

U kunt ook meerdere variabelen declareren met de syntaxis

    var <variable_name1>, <variable_name2>  = <value1>, <value2>

Het onderstaande programma in deze Go-tutorial bevat enkele Golang-voorbeelden van variabele declaraties

 
package main
import "fmt"

func main() {
    //declaring a integer variable x
    var x int
    x=3 //assigning x the value 3 
    fmt.Println("x:", x) //prints 3
    
    //declaring a integer variable y with value 20 in a single statement and prints it
    var y int=20
    fmt.Println("y:", y)
    
    //declaring a variable z with value 50 and prints it
    //Here type int is not explicitly mentioned 
    var z=50
    fmt.Println("z:", z)
    
    //Multiple variables are assigned in single line- i with an integer and j with a string
    var i, j = 100,"hello"
    fmt.Println("i and j:", i,j)
}

De uitvoer zal zijn:

x: 3
y: 20
z: 50
i and j: 100 hello

Go Language biedt ook een gemakkelijke manier om de variabelen met waarde te declareren door het trefwoord var met behulp van weg te laten

    <variable_name> := <value>

Merk op dat u gebruikte := in plaats van =. Je kunt := niet alleen gebruiken om een ​​waarde toe te wijzen aan een variabele die al is gedeclareerd. := wordt gebruikt om waarde te declareren en toe te wijzen.

Maak een bestand met de naam Assign.go met de following code

package main
import ("fmt")

func main() {
	a := 20
	fmt.Println(a)

	//gives error since a is already declared
	a := 30
	fmt.Println(a)
}

Voer go run Assign.go uit om het resultaat te zien als

./assign.go:7:4: no new variables on left side of :=		

Variabelen die zonder initiële waarde zijn gedeclareerd, hebben de waarde 0 voor numerieke typen, false voor Booleaanse waarden en een lege tekenreeks voor tekenreeksen

constanten

Constante variabelen zijn die variabelen waarvan de waarde niet kan worden gewijzigd nadat deze is toegewezen. Een constante in de Go-programmeertaal wordt gedeclareerd met behulp van het trefwoord “const”

Maak een bestand met de naam constant.go en met de following code

package main
import ("fmt")

func main() {
	const b =10
	fmt.Println(b)
	b = 30
	fmt.Println(b)
}

Voer go run constant.go uit om het resultaat te zien als

.constant.go:7:4: cannot assign to b

Voor lusvoorbeelden

Lussen worden gebruikt om een ​​blok met instructies herhaaldelijk uit te voeren op basis van een voorwaarde. De meeste programmeertalen bieden drie soorten lussen: for, while, do while. Maar de programmeertaal Go ondersteunt alleen for loop.

De syntaxis van een Golang for-lus is

for initialisation_expression; evaluation_expression; iteration_expression{
   // one or more statement
}

De initialisatie_expressie wordt eerst (en slechts één keer) uitgevoerd in Golang for loop.

Vervolgens wordt de evaluatie_expressie geëvalueerd en als deze waar is, wordt de code in het blok uitgevoerd.

De iteratie_expressie-ID wordt uitgevoerd en de evaluatie_expressie wordt opnieuw geëvalueerd. Als dit waar is, wordt het instructieblok opnieuw uitgevoerd. Dit gaat door totdat de evaluatie_expressie onwaar wordt.

Kopieer het onderstaande programma naar een bestand en voer het uit om de Golang voor lusafdruknummers van 1 tot 5 te zien

package main
import "fmt"

func main() {  
var i int
for i = 1; i <= 5; i++ {
fmt.Println(i)
    }
}

Uitgang is

1
2
3
4
5

Als anders

If else is een voorwaardelijke verklaring. De synax is

if condition{
// statements_1
}else{
// statements_2
}

Hier wordt de voorwaarde geëvalueerd en als het waar is, wordt statement_1 uitgevoerd, anders wordt statement_2 uitgevoerd.

Je kunt de if-instructie ook zonder else gebruiken. Je kunt ook if else-verklaringen hebben geketend. De onderstaande programma's leggen meer uit over if else.

Voer het onderstaande programma uit. Er wordt gecontroleerd of een getal, x, kleiner is dan 10. Als dat het geval is, wordt 'x is kleiner dan 10' weergegeven.

package main
import "fmt"

func main() {  
    var x = 50
    if x < 10 {
        //Executes if x < 10
        fmt.Println("x is less than 10")
    } 
}

Omdat de waarde van x groter is dan 10, wordt de instructie binnen de if-blokvoorwaarde niet uitgevoerd.

Zie nu het onderstaande programma. In deze Go-programmeertaaltutorial hebben we een else-blok dat wordt uitgevoerd als de if-evaluatie mislukt.

package main
import "fmt"

func main() {  
    var x = 50
    if x < 10 {
        //Executes if x is less than 10
        fmt.Println("x is less than 10")
    } else {
        //Executes if x >= 10
        fmt.Println("x is greater than or equals 10")
    }
}

Dit programma geeft je output

x is greater than or equals 10

In deze Go-tutorial zien we een programma met meerdere if else-blokken (aan elkaar gekoppeld if else). Voer het onderstaande Go-voorbeeld uit. Er wordt gecontroleerd of een getal kleiner is dan 10, tussen 10-90 of groter dan 90 ligt.

package main
import "fmt"

func main() {  
    var x = 100
    if x < 10 {
        //Executes if x is less than 10
        fmt.Println("x is less than 10")
    } else if x >= 10 && x <= 90 {
        //Executes if x >= 10 and x<=90
        fmt.Println("x is between 10 and 90")
    } else {
        //Executes if both above cases fail i.e x>90
        fmt.Println("x is greater than 90")
    }
}

Hier controleert eerst de if-voorwaarde of x kleiner is dan 10 en dat is niet het geval. Het controleert dus de volgende voorwaarde (else if) of deze tussen 10 en 90 ligt, wat ook onwaar is. Dus voert het vervolgens het blok uit onder de else-sectie die de uitvoer geeft

x is greater than 90

Stap over voor slechts

Switch is een andere voorwaardelijke verklaring. Switch-instructies evalueren een expressie en het resultaat wordt vergeleken met een reeks beschikbare waarden (cases). Zodra er een match is gevonden, worden de instructies die bij die match(case) horen, uitgevoerd. Als er geen match wordt gevonden, wordt er niets uitgevoerd. U kunt ook een standaardgeval toevoegen aan de overstap, dat wordt uitgevoerd als er geen andere overeenkomsten worden gevonden. De syntaxis van de schakelaar is

switch expression {
    case value_1:
        statements_1
    case value_2:
        statements_2
    case value_n:
        statements_n
    default:
        statements_default
    }

Hier wordt de waarde van de uitdrukking vergeleken met de waarden in elk geval. Zodra er een match is gevonden, worden de uitspraken die bij die casus horen, uitgevoerd. Als er geen overeenkomst wordt gevonden, worden de instructies onder de standaardsectie uitgevoerd.

Voer het onderstaande programma uit

package main
import "fmt"

func main() {  
    a,b := 2,1
    switch a+b {
    case 1:
        fmt.Println("Sum is 1")
    case 2:
        fmt.Println("Sum is 2")
    case 3:
        fmt.Println("Sum is 3")
    default:
        fmt.Println("Printing default")
    }
}

U krijgt de uitvoer als

Sum is 3		

Verander de waarde van a en b in 3 en het resultaat zal zijn

Printing default

U kunt ook meerdere waarden in een hoofdlettergebruik hebben door ze te scheiden met een komma.

arrays

Array vertegenwoordigt een vaste grootte, een zogenaamde reeks elementen van hetzelfde type. U kunt geen array hebben die zowel gehele getallen als tekens bevat. U kunt de grootte van een array niet wijzigen nadat u de grootte hebt gedefinieerd.

De syntaxis voor het declareren van een array is

var arrayname [size] type

Aan elk array-element kan een waarde worden toegewezen met behulp van de syntaxis

arrayname [index] = value

Array-index begint vanaf 0 tot maat 1.

U kunt tijdens de declaratie waarden toewijzen aan array-elementen met behulp van de syntaxis

arrayname := [size] type {value_0,value_1,…,value_size-1} 

U kunt de parameter size ook negeren terwijl u de array met waarden declareert door size te vervangen door ... en de compiler zal de lengte uit het aantal waarden vinden. Syntaxis is

arrayname :=  […] type {value_0,value_1,…,value_size-1}

U kunt de lengte van de array vinden met behulp van de syntaxis

len(arrayname)

Voer het onderstaande Go-voorbeeld uit om de array te begrijpen

package main
import "fmt"

func main() {  
    var numbers [3] string //Declaring a string array of size 3 and adding elements 
    numbers[0] = "One"
    numbers[1] = "Two"
    numbers[2] = "Three"
    fmt.Println(numbers[1]) //prints Two
    fmt.Println(len(numbers)) //prints 3
    fmt.Println(numbers) // prints [One Two Three]

    directions := [...] int {1,2,3,4,5} // creating an integer array and the size of the array is defined by the number of elements 
    fmt.Println(directions) //prints [1 2 3 4 5]
    fmt.Println(len(directions)) //prints 5

    //Executing the below commented statement prints invalid array index 5 (out of bounds for 5-element array)
    //fmt.Println(directions[5]) 
}

uitgang

Two
3
[One Two Three]
[1 2 3 4 5]
5

Golang Slice en Append-functie

Een slice is een gedeelte of segment van een array. Of het is een weergave of een gedeeltelijke weergave van een onderliggende array waarnaar deze verwijst. U kunt toegang krijgen tot de elementen van een segment met behulp van de segmentnaam en het indexnummer, net zoals u dat in een array doet. U kunt de lengte van een array niet wijzigen, maar u kunt wel de grootte van een segment wijzigen.

De inhoud van een segment zijn eigenlijk de verwijzingen naar de elementen van een array. Het betekent als u een element in een segment wijzigt, wordt de onderliggende array-inhoud ook beïnvloed.

De syntaxis voor het maken van een segment is

var slice_name [] type = array_name[start:end]

Hierdoor wordt een segment met de naam slice_name gemaakt van een array met de naam array_name, waarbij de elementen in de index van begin tot eind-1 beginnen.

In deze Golang-tutorial zullen we nu het onderstaande programma uitvoeren. Het programma maakt een segment van de array en drukt dit af. U kunt ook zien dat het wijzigen van de inhoud van het segment de daadwerkelijke array zal wijzigen.

package main
import "fmt"

func main() {  
    // declaring array
    a := [5] string {"one", "two", "three", "four", "five"}
    fmt.Println("Array after creation:",a)

    var b [] string = a[1:4] //created a slice named b
    fmt.Println("Slice after creation:",b)

    b[0]="changed" // changed the slice data
    fmt.Println("Slice after modifying:",b)
    fmt.Println("Array after slice modification:",a)
}

Hierdoor wordt het resultaat afgedrukt als

Array after creation: [one two three four five]
Slice after creation: [two three four]
Slice after modifying: [changed three four]
Array after slice modification: [one changed three four five]

Er zijn bepaalde functies zoals Golang len en Golang append die u op segmenten kunt toepassen

len(plaknaam) – geeft de lengte van het segment terug

append(segmentnaam, waarde_1, waarde_2) – Golang append wordt gebruikt om waarde_1 en waarde_2 aan een bestaand segment toe te voegen.

append(slice_nale1,slice_name2…) – voegt segmentnaam2 toe aan segmentnaam1

Voer het volgende uitwing programma.

package main
import "fmt"

func main() {  
	a := [5] string {"1","2","3","4","5"}
	slice_a := a[1:3]
	b := [5] string {"one","two","three","four","five"}
	slice_b := b[1:3]

    fmt.Println("Slice_a:", slice_a)
    fmt.Println("Slice_b:", slice_b)
    fmt.Println("Length of slice_a:", len(slice_a))
    fmt.Println("Length of slice_b:", len(slice_b))

    slice_a = append(slice_a,slice_b...) // appending slice
    fmt.Println("New Slice_a after appending slice_b :", slice_a)
    
    slice_a = append(slice_a,"text1") // appending value
    fmt.Println("New Slice_a after appending text1 :", slice_a)
}

De uitvoer zal zijn:

Slice_a: [2 3]
Slice_b: [two three]
Length of slice_a: 2
Length of slice_b: 2
New Slice_a after appending slice_b : [2 3 two three]
New Slice_a after appending text1 : [2 3 two three text1]

Het programma maakt eerst 2 plakjes en drukt de lengte ervan af. Vervolgens werd het ene segment aan het andere toegevoegd en vervolgens een tekenreeks aan het resulterende segment toegevoegd.

Functies

Een functie vertegenwoordigt een blok instructies dat een specifieke taak uitvoert. Een functiedeclaratie vertelt ons de functienaam, het retourtype en de invoerparameters. Functiedefinitie vertegenwoordigt de code in de functie. De syntaxis voor het declareren van de functie is

func function_name(parameter_1 type, parameter_n type) return_type {
//statements
}

De parameters en retourtypen zijn optioneel. U kunt ook meerdere waarden uit een functie retourneren.

Laten we nu in deze Golang-tutorial het volgende uitvoerenwing Golang-voorbeeld. Hier accepteert de functie calc 2 getallen, voert het optellen en aftrekken uit en retourneert beide waarden.

package main
import "fmt"

//calc is the function name which accepts two integers num1 and num2
//(int, int) says that the function returns two values, both of integer type.
func calc(num1 int, num2 int)(int, int) {  
    sum := num1 + num2
    diff := num1 - num2
    return sum, diff
}

func main() {  
    x,y := 15,10

    //calls the function calc with x and y an d gets sum, diff as output
    sum, diff := calc(x,y) 
    fmt.Println("Sum",sum)
    fmt.Println("Diff",diff) 
}

De uitvoer zal zijn:

Sum 25
Diff 5

Pakketten

Pakketten worden gebruikt om de code te ordenen. In een groot project is het niet haalbaar om code in één bestand te schrijven. Met Go-programmeertaal kunnen we de code onder verschillende pakketten ordenen. Dit vergroot de leesbaarheid en herbruikbaarheid van de code. Een uitvoerbaar Go-programma moet een pakket bevatten met de naam main en de uitvoering van het programma begint met de functie genaamd main. U kunt andere pakketten in ons programma importeren met behulp van de syntaxis

import package_name

In deze Golang-tutorial zullen we zien en bespreken hoe u pakketten kunt maken en gebruikenwing Golang-voorbeeld.

Stap 1) Maak een bestand met de naam package_example.go en voeg de onderstaande code toe

package main
import "fmt"
//the package to be created
import "calculation"

func main() {  
	x,y := 15,10
	//the package will have function Do_add()
sum := calculation.Do_add(x,y)
fmt.Println("Sum",sum) 
}

In het bovenstaande programma is fmt een pakket dat de programmeertaal Go ons levert, voornamelijk voor I/O-doeleinden. U kunt ook een pakket zien met de naam berekening. Binnen main() kun je een stapsom zien:= berekening.Do_add(x,y). Het betekent dat u de functie Do_add aanroept vanuit de pakketberekening.

Stap 2) Eerst moet u de pakketberekening maken in een map met dezelfde naam onder de src-map van onderweg. Het geïnstalleerde pad van go kan worden gevonden via de PATH-variabele.

Voor Mac: zoek het pad door echo $PATH uit te voeren

Het pad is dus /usr/local/go

Voor windows, zoek het pad door echo %GOROOT% uit te voeren

Hier is het pad C:\Go\

Stap 3) Navigeer naar de map src (/usr/local/go/src voor mac en C:\Go\src voor windows). Vanuit de code is de pakketnaam nu berekening. Go vereist dat het pakket in een map met dezelfde naam onder de map src wordt geplaatst. Maak een map met de naam berekening in de map src.

Stap 4) Maak een bestand met de naam calc.go (u kunt elke naam opgeven, maar de pakketnaam in de code is van belang. Hier zou het berekening moeten zijn) in de berekeningsmap en voeg de onderstaande code toe

package calculation
  
func Do_add(num1 int, num2 int)(int) {
    sum := num1 + num2
    return sum
}

Stap 5) Voer de opdracht go install uit vanuit de berekeningsmap die calc.go zal compileren.

Stap 6) Ga nu terug naar package_example.go en voer run package_example.go uit. De uitvoer is Som 25.

Merk op dat de naam van de functie Do_add begint met een hoofdletter. Dit komt omdat als de functienaam in Go met een hoofdletter begint, dit betekent dat andere programma's deze kunnen zien (toegang krijgen), anders hebben andere programma's er geen toegang toe. Als de functienaam do_add was, zou je de foutmelding hebben gekregen

kan niet verwijzen naar de niet-geëxporteerde naam computation.calc..

Uitstel en stapelen uitstel

Defer-instructies worden gebruikt om de uitvoering van een functieaanroep uit te stellen totdat de functie die de defer-instructie bevat, de uitvoering voltooit.

Laten we dit leren met een voorbeeld:

package main
import "fmt"

func sample() {  
    fmt.Println("Inside the sample()")
}
func main() {  
    //sample() will be invoked only after executing the statements of main()
    defer sample()
    fmt.Println("Inside the main()")
}

De uitvoer zal zijn:

Inside the main()
Inside the sample()

Hier wordt de uitvoering van sample() uitgesteld totdat de uitvoering van de omsluitende functie (main()) is voltooid.

Bij het stapelen van uitstel worden meerdere uitstelinstructies gebruikt. Stel dat u meerdere uitstelinstructies binnen een functie hebt. Go plaatst alle uitgestelde functieaanroepen in een stapel, en zodra de omsluitende functie terugkeert, worden de gestapelde functies uitgevoerd in de stapel. Last In First Out (LIFO)-bestelling. Je kunt dit zien in het onderstaande voorbeeld.

Voer de onderstaande code uit

package main
import "fmt"

func display(a int) {  
    fmt.Println(a)
}
func main() {  
    defer display(1)
    defer display(2)
    defer display(3)
    fmt.Println(4)
}

De uitvoer zal zijn:

4
3
2
1			

Hier wordt eerst de code in main() uitgevoerd, en vervolgens worden de uitgestelde functieaanroepen in de omgekeerde volgorde uitgevoerd, dat wil zeggen 4, 3,2,1.

Pointers

Voordat we de aanwijzingen uitleggen, bespreken we eerst de operator '&'. De operator '&' wordt gebruikt om het adres van een variabele op te halen. Het betekent dat '&a' het geheugenadres van variabele a zal afdrukken.

In deze Golang-tutorial zullen we het onderstaande programma uitvoeren om de waarde van een variabele en het adres van die variabele weer te geven

package main
import "fmt"

func main() {
	a := 20
	fmt.Println("Address:",&a)
	fmt.Println("Value:",a)
}

Het resultaat zal zijn

Address: 0xc000078008
Value: 20

Een pointervariabele slaat het geheugenadres van een andere variabele op. U kunt een pointer definiëren met behulp van de syntaxis

	var variable_name *type

Het sterretje (*) geeft aan dat de variabele een pointer is. U zult meer begrijpen door het onderstaande programma uit te voeren

package main
import "fmt"

func main() {
	//Create an integer variable a with value 20
	a := 20
	
	//Create a pointer variable b and assigned the address of a
	var b *int = &a

	//print address of a(&a) and value of a  
	fmt.Println("Address of a:",&a)
	fmt.Println("Value of a:",a)

	//print b which contains the memory address of a i.e. &a
	fmt.Println("Address of pointer b:",b)

	//*b prints the value in memory address which b contains i.e. the value of a
	fmt.Println("Value of pointer b",*b)

	//increment the value of variable a using the variable b
	*b = *b+1

	//prints the new value using a and *b
	fmt.Println("Value of pointer b",*b)
	fmt.Println("Value of a:",a)}

De uitvoer zal zijn:

Address of a: 0x416020
Value of a: 20
Address of pointer b: 0x416020
Value of pointer b 20
Value of pointer b 21
Value of a: 21

Structuren

Een structuur is een door de gebruiker gedefinieerd gegevenstype dat zelf nog een element van hetzelfde of een ander type bevat.

Het gebruik van een structuur bestaat uit twee stappen.

Maak (declareer) eerst een structuurtype

Ten tweede: maak variabelen van dat type om waarden op te slaan.

Structuren worden vooral gebruikt als je gerelateerde gegevens bij elkaar wilt opslaan.

Overweeg een stukje werknemersinformatie met naam, leeftijd en adres. Je kunt dit op 2 manieren aanpakken

Maak 3 arrays – één array slaat de namen van werknemers op, één slaat de leeftijd op en de derde slaat de leeftijd op.

Declareer een structuurtype met 3 velden: naam, adres en leeftijd. Maak een array van dat structuurtype waarbij elk element een structuurobject is met naam, adres en leeftijd.

De eerste aanpak is niet efficiënt. In dit soort scenario's zijn structuren handiger.

De syntaxis voor het declareren van een structuur is

type structname struct {
   variable_1 variable_1_type
   variable_2 variable_2_type
   variable_n variable_n_type
}

Een voorbeeld van een structuurdeclaratie is

type emp struct {
    name string
    address string
    age int
}

Hier wordt een nieuw door de gebruiker gedefinieerd type met de naam emp gemaakt. Nu kunt u variabelen van het type emp maken met behulp van de syntaxis

	var variable_name struct_name

Een voorbeeld is

var empdata1 emp 

U kunt waarden voor empdata1 instellen als

empdata1.name = "John"
	empdata1.address = "Street-1, Bangalore"
	empdata1.age = 30

U kunt ook een structuurvariabele maken en waarden toewijzen door

empdata2 := emp{"Raj", "Building-1, Delhi", 25}

Hier moet u de volgorde van de elementen behouden. Raj wordt toegewezen aan de naam, het volgende element dat moet worden aangepakt en het laatste aan de leeftijd.

Voer de onderstaande code uit

package main
import "fmt"

//declared the structure named emp
type emp struct {
        name string
        address string
        age int
}       

//function which accepts variable of emp type and prints name property
func display(e emp) {
          fmt.Println(e.name)
}

func main() {
// declares a variable, empdata1, of the type emp
var empdata1 emp
//assign values to members of empdata1
empdata1.name = "John"
empdata1.address = "Street-1, London"
empdata1.age = 30

//declares and assign values to variable empdata2 of type emp
empdata2 := emp{"Raj", "Building-1, Paris", 25}

//prints the member name of empdata1 and empdata2 using display function
display(empdata1)
display(empdata2)
}

uitgang

John
Raj

Methoden (geen functies)

Een methode is een functie met een receiver-argument. Architechnisch gezien bevindt het zich tussen het func-trefwoord en de methodenaam. De syntaxis van een methode is

func (variable variabletype) methodName(parameter1 paramether1type) {  
}

Laten we het bovenstaande voorbeeldprogramma converteren om methoden te gebruiken in plaats van functie.

package main
import "fmt"

//declared the structure named emp
type emp struct {
    name string
    address string
    age int
}

//Declaring a function with receiver of the type emp
func(e emp) display() {
    fmt.Println(e.name)
}

func main() {
    //declaring a variable of type emp
    var empdata1 emp
    
    //Assign values to members
    empdata1.name = "John"
    empdata1.address = "Street-1, Lodon"
    empdata1.age = 30

    //declaring a variable of type emp and assign values to members
    empdata2 := emp {
        "Raj", "Building-1, Paris", 25}

    //Invoking the method using the receiver of the type emp
   // syntax is variable.methodname()
    empdata1.display()
    empdata2.display()
}

Go is geen objectgeoriënteerde taal en kent niet het concept van klasse. Methoden geven een idee van wat u doet in objectgeoriënteerde programma's waarbij de functies van een klasse worden aangeroepen met behulp van de syntaxis objectnaam.functienaam()

samenloop

Go ondersteunt gelijktijdige uitvoering van taken. Het betekent dat Go meerdere taken tegelijkertijd kan uitvoerenneonuttig. Het verschilt van het concept van parallellisme. Bij parallellisme wordt een taak opgesplitst in kleine subtaken en parallel uitgevoerd. Maar bij gelijktijdigheid worden meerdere taken tegelijkertijd uitgevoerdneonuttig. Gelijktijdigheid wordt in Go bereikt met behulp van Goroutines en kanalen.

goroutines

Een goroutine is een functie die gelijktijdig met andere functies kan worden uitgevoerd. Wanneer een functie wordt aangeroepen, wordt de besturing gewoonlijk overgedragen naar de aangeroepen functie, en zodra de uitvoering ervan is voltooid, keert de besturing terug naar de aanroepende functie. De aanroepende functie vervolgt vervolgens de uitvoering ervan. De aanroepende functie wacht tot de aangeroepen functie de uitvoering heeft voltooid voordat deze verdergaat met de rest van de instructies.

Maar in het geval van goroutine wacht de aanroepende functie niet tot de uitvoering van de aangeroepen functie is voltooid. Het zal doorgaan met uitvoeren met de volgende instructies. U kunt meerdere goroutines in een programma hebben.

Bovendien wordt het hoofdprogramma afgesloten zodra het de instructies heeft uitgevoerd en wacht het niet op de voltooiing van de aangeroepen goroutines.

Goroutine wordt aangeroepen met het trefwoord go, gevolgd door een functieaanroep.

Voorbeeld

go add(x,y)

Je zult goroutines begrijpen met de onderstaande Golang-voorbeelden. Voer het onderstaande programma uit

package main
import "fmt"
    
func display() {
	for i:=0; i<5; i++ {
		fmt.Println("In display")
	}
}

func main() {
	//invoking the goroutine display()
	go display()
	//The main() continues without waiting for display()
	for i:=0; i<5; i++ {
		fmt.Println("In main")
	}
}

De uitvoer zal zijn:

In main
In main
In main
In main
In main

Hier voltooide het hoofdprogramma de uitvoering nog voordat de goroutine startte. De display() is een goroutine die wordt aangeroepen met behulp van de syntaxis

go function_name(parameter list)

In de bovenstaande code wacht main() niet tot display() is voltooid, en main() voltooide de uitvoering ervan voordat display() zijn code uitvoerde. Dus de print-instructie in display() werd niet afgedrukt.

Nu passen we het programma aan om ook de instructies van display() af te drukken. We voegen een vertraging van 2 sec toe in de for-lus van main() en een vertraging van 1 sec in de for-lus van display().

package main
import "fmt"
import "time"
    
func display() {
	for i:=0; i<5; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println("In display")
	}
}

func main() {
	//invoking the goroutine display()
	go display()
	for i:=0; i<5; i++ {
		time.Sleep(2 * time.Second)
		fmt.Println("In main")
	}
}

De uitvoer zal enigszins vergelijkbaar zijn met

In display
In main
In display
In display
In main
In display
In display
In main
In main
In main

Hier kunt u zien dat beide lussen overlappend worden uitgevoerd vanwege de gelijktijdige uitvoering.

Kanalen

Kanalen zijn een manier waarop functies met elkaar kunnen communiceren. Het kan worden gezien als een medium waar de ene routine gegevens plaatst en toegankelijk is voor een andere routine op de Golang-server.

Een kanaal kan worden gedeclareerd met de syntaxis

channel_variable := make(chan datatype)

Voorbeeld:

	ch := make(chan int)

U kunt gegevens naar een kanaal verzenden met behulp van de syntaxis

channel_variable <- variable_name

Voorbeeld

    ch <- x

U kunt gegevens van een kanaal ontvangen met behulp van de syntaxis

    variable_name := <- channel_variable

Voorbeeld

   y := <- ch

In de bovenstaande Go-taalvoorbeelden van goroutine heb je gezien dat het hoofdprogramma niet op de goroutine wacht. Maar dat is niet het geval als het om kanalen gaat. Stel dat als een goroutine gegevens naar channel pusht, de main() zal wachten op de instructie die kanaalgegevens ontvangt totdat deze de gegevens ontvangt.

Je zult dit zien in onderstaande Go-taalvoorbeelden. Schrijf eerst een normale goroutine en bekijk het gedrag. Pas vervolgens het programma aan om kanalen te gebruiken en het gedrag te bekijken.

Voer het onderstaande programma uit

package main
import "fmt"
import "time"
    
func display() {
	time.Sleep(5 * time.Second)
	fmt.Println("Inside display()")
}

func main() {
	go display()
	fmt.Println("Inside main()")
}

De uitvoer zal zijn:

Inside main()

De main() beëindigde de uitvoering en werd afgesloten voordat de goroutine werd uitgevoerd. Dus de afdruk in display() werd niet uitgevoerd.

Pas nu het bovenstaande programma aan om kanalen te gebruiken en het gedrag te bekijken.

package main
import "fmt"
import "time"
    
func display(ch chan int) {
	time.Sleep(5 * time.Second)
	fmt.Println("Inside display()")
	ch <- 1234
}

func main() {
	ch := make(chan int) 
	go display(ch)
	x := <-ch
	fmt.Println("Inside main()")
	fmt.Println("Printing x in main() after taking from channel:",x)
}

De uitvoer zal zijn:

Inside display()
Inside main()
Printing x in main() after taking from channel: 1234

Wat hier gebeurt is de main() bij het bereiken van x := <-ch zal wachten op gegevens op kanaal ch. Het display() wacht 5 seconden en pusht vervolgens gegevens naar het kanaal ch. De main() bij het ontvangen van de gegevens van het kanaal wordt gedeblokkeerd en gaat door met de uitvoering ervan.

De afzender die gegevens naar het kanaal pusht, kan de ontvangers informeren dat er geen gegevens meer aan het kanaal worden toegevoegd door het kanaal te sluiten. Dit wordt voornamelijk gebruikt als u een lus gebruikt om gegevens naar een kanaal te pushen. Een kanaal kan worden gesloten met

close(channel_name)

En aan de ontvangerkant is het mogelijk om te controleren of het kanaal gesloten is met behulp van een extra variabele, terwijl gegevens van het kanaal worden opgehaald met behulp van

variable_name, status := <- channel_variable

Als de status True is, betekent dit dat u gegevens van het kanaal heeft ontvangen. Als dit niet waar is, betekent dit dat u probeert te lezen vanaf een gesloten kanaal

Je kunt ook kanalen gebruiken voor communicatie tussen goroutines. Er moeten twee goroutines worden gebruikt: de ene stuurt gegevens naar het kanaal en de andere ontvangt de gegevens van het kanaal. Zie onderstaand programma

package main
import "fmt"
import "time"

//This subroutine pushes numbers 0 to 9 to the channel and closes the channel
func add_to_channel(ch chan int) {	
	fmt.Println("Send data")
	for i:=0; i<10; i++ {
		ch <- i //pushing data to channel
	}
	close(ch) //closing the channel

}

//This subroutine fetches data from the channel and prints it.
func fetch_from_channel(ch chan int) {
	fmt.Println("Read data")
	for {
		//fetch data from channel
x, flag := <- ch

		//flag is true if data is received from the channel
//flag is false when the channel is closed
if flag == true {
			fmt.Println(x)
		}else{
			fmt.Println("Empty channel")
			break	
		}	
	}
}

func main() {
	//creating a channel variable to transport integer values
	ch := make(chan int)

	//invoking the subroutines to add and fetch from the channel
	//These routines execute simultaneously
	go add_to_channel(ch)
	go fetch_from_channel(ch)

	//delay is to prevent the exiting of main() before goroutines finish
	time.Sleep(5 * time.Second)
	fmt.Println("Inside main()")
}

Hier zijn er twee subroutines, de ene stuurt gegevens naar het kanaal en de andere drukt gegevens naar het kanaal af. De functie add_to_channel telt de getallen 2 tot en met 0 op en sluit het kanaal. GelijktijdigneoMeestal wacht de functie fetch_from_channel op

x, flag := <- ch en zodra de gegevens beschikbaar zijn, worden de gegevens afgedrukt. Het verdwijnt zodra de vlag vals is, wat betekent dat het kanaal gesloten is.

Er wordt gewacht in main() om te voorkomen dat main() wordt afgesloten totdat de goroutines de uitvoering hebben voltooid.

Voer de code uit en bekijk de uitvoer als

Read data
Send data
0
1
2
3
4
5
6
7
8
9
Empty channel
Inside main()

kies

Select kan worden gezien als een schakelinstructie die op kanalen werkt. Hier zullen de casusverklaringen een kanaaloperatie zijn. Normaal gesproken worden elke case-instructies gelezen door het kanaal. Wanneer een van de cases gereed is (het kanaal wordt gelezen), wordt de instructie die bij die case hoort, uitgevoerd. Als er meerdere cases klaar zijn, wordt er willekeurig een gekozen. U kunt een standaardcase instellen die wordt uitgevoerd als geen van de cases gereed is.

Laten we de onderstaande code bekijken

package main
import "fmt"
import "time"

//push data to channel with a 4 second delay
func data1(ch chan string) {  
    time.Sleep(4 * time.Second)
    ch <- "from data1()"
}

//push data to channel with a 2 second delay
func data2(ch chan string) {  
    time.Sleep(2 * time.Second)
    ch <- "from data2()"
}

func main() {
    //creating channel variables for transporting string values
    chan1 := make(chan string)
    chan2 := make(chan string)
    
    //invoking the subroutines with channel variables
    go data1(chan1)
    go data2(chan2)
    
    //Both case statements wait for data in the chan1 or chan2.
    //chan2 gets data first since the delay is only 2 sec in data2().
    //So the second case will execute and exits the select block
    select {
    case x := <-chan1:
        fmt.Println(x)
    case y := <-chan2:
        fmt.Println(y)
    }
}

Als u het bovenstaande programma uitvoert, krijgt u de uitvoer:

from data2()

Hier wacht de select-instructie tot er gegevens beschikbaar zijn in een van de kanalen. De data2() voegt gegevens toe aan het kanaal na een slaap van 2 seconden, waardoor het tweede geval wordt uitgevoerd.

Voeg een standaardgeval toe aan de selectie in hetzelfde programma en bekijk de uitvoer. Hier, bij het bereiken van het geselecteerde blok, en als geen enkel geval gegevens gereed heeft op het kanaal, zal het het standaardblok uitvoeren zonder te wachten tot gegevens beschikbaar zijn op welk kanaal dan ook.

package main
import "fmt"
import "time"

//push data to channel with a 4 second delay
func data1(ch chan string) {  
    time.Sleep(4 * time.Second)
    ch <- "from data1()"
}

//push data to channel with a 2 second delay
func data2(ch chan string) {  
    time.Sleep(2 * time.Second)
    ch <- "from data2()"
}

func main() {
    //creating channel variables for transporting string values  
    chan1 := make(chan string)
    chan2 := make(chan string)
    
    //invoking the subroutines with channel variables
    go data1(chan1)
    go data2(chan2)

    //Both case statements check for data in chan1 or chan2.
    //But data is not available (both routines have a delay of 2 and 4 sec)
    //So the default block will be executed without waiting for data in channels.
    select {
    case x := <-chan1:
        fmt.Println(x)
    case y := <-chan2:
        fmt.Println(y)
    default:
    	fmt.Println("Default case executed")
    }
}

Dit programma geeft de uitvoer:

Default case executed			

Dit komt omdat toen het geselecteerde blok werd bereikt, geen enkel kanaal gegevens had om te lezen. Het standaardgeval wordt dus uitgevoerd.

mutex

Mutex is de afkorting voor wederzijdse uitsluiting. Mutex wordt gebruikt als u niet wilt dat meerdere subroutines tegelijkertijd toegang hebben tot een bron. Mutex heeft 2 methoden: vergrendelen en ontgrendelen. Mutex is opgenomen in sync pakket. Je moet dus de sync pakket. De instructies die wederzijds uitsluitend moeten worden uitgevoerd, kunnen binnen mutex.Lock() en mutex.Unlock() worden geplaatst.

Laten we mutex leren met een voorbeeld waarin het aantal keren wordt geteld dat een lus wordt uitgevoerd. In dit programma verwachten we dat de routine 10 keer een lus uitvoert en dat de telling in som wordt opgeslagen. Je roept deze routine drie keer aan, zodat het totale aantal 3 moet zijn. Het aantal wordt opgeslagen in een globale variabele aantal.

Eerst voert u het programma uit zonder mutex

package main
import "fmt"
import "time"
import "strconv"
import "math/rand"
//declare count variable, which is accessed by all the routine instances
var count = 0

//copies count to temp, do some processing(increment) and store back to count
//random delay is added between reading and writing of count variable
func process(n int) {
	//loop incrementing the count by 10
	for i := 0; i < 10; i++ {
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		temp := count
		temp++
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		count = temp
	}
	fmt.Println("Count after i="+strconv.Itoa(n)+" Count:", strconv.Itoa(count))
}

func main() {
	//loop calling the process() 3 times
	for i := 1; i < 4; i++ {
		go process(i)
	}

	//delay to wait for the routines to complete
	time.Sleep(25 * time.Second)
	fmt.Println("Final Count:", count)
}

Bekijk het resultaat

 Count after i=1 Count: 11
Count after i=3 Count: 12
Count after i=2 Count: 13
Final Count: 13

Het resultaat kan anders zijn als u het uitvoert, maar het eindresultaat zal niet 30 zijn.

Wat er hier gebeurt, is dat 3 goroutines proberen het aantal lussen dat is opgeslagen in het aantal variabelen te verhogen. Stel dat de telling op een gegeven moment 5 is en goroutine1 de telling gaat verhogen naar 6. De belangrijkste stappen zijn onder meer

Kopieer telling naar temp

Verhoog de temperatuur

Bewaar de temperatuur terug naar de telling

Stel dat kort na het uitvoeren van stap 3 door goroutine1; een andere goroutine kan een oude waarde hebben, bijvoorbeeld 3, voert de bovenstaande stappen uit en slaat 4 terug, wat verkeerd is. Dit kan worden voorkomen door mutex te gebruiken, waardoor andere routines wachten wanneer een routine de variabele al gebruikt.

Nu voer je het programma uit met mutex. Hier worden de bovengenoemde 3 stappen uitgevoerd in een mutex.

package main
import "fmt"
import "time"
import "sync"
import "strconv"
import "math/rand"

//declare a mutex instance
var mu sync.Mutex

//declare count variable, which is accessed by all the routine instances
var count = 0

//copies count to temp, do some processing(increment) and store back to count
//random delay is added between reading and writing of count variable
func process(n int) {
	//loop incrementing the count by 10
	for i := 0; i < 10; i++ {
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		//lock starts here
		mu.Lock()
		temp := count
		temp++
		time.Sleep(time.Duration(rand.Int31n(2)) * time.Second)
		count = temp
		//lock ends here
		mu.Unlock()
	}
	fmt.Println("Count after i="+strconv.Itoa(n)+" Count:", strconv.Itoa(count))
}

func main() {
	//loop calling the process() 3 times
	for i := 1; i < 4; i++ {
		go process(i)
	}

	//delay to wait for the routines to complete
	time.Sleep(25 * time.Second)
	fmt.Println("Final Count:", count)
}

Nu zal de uitvoer zijn

 Count after i=3 Count: 21
Count after i=2 Count: 28
Count after i=1 Count: 30
Final Count: 30

Hier krijgen we het verwachte resultaat als uiteindelijke uitvoer. Omdat het lezen, ophogen en terugschrijven van de telling in een mutex wordt uitgevoerd.

Foutafhandeling

Fouten zijn abnormale omstandigheden, zoals het sluiten van een bestand dat niet is geopend, het openen van een bestand dat niet bestaat, enz. Functies retourneren doorgaans fouten als de laatste geretourneerde waarde.

In het onderstaande voorbeeld wordt meer uitgelegd over de fout.

package main
import "fmt"
import "os"

//function accepts a filename and tries to open it.
func fileopen(name string) {
    f, er := os.Open(name)

    //er will be nil if the file exists else it returns an error object  
    if er != nil {
        fmt.Println(er)
        return
    }else{
    	fmt.Println("file opened", f.Name())
    }
}

func main() {  
    fileopen("invalid.txt")
}

De output zal worden:

open /invalid.txt: no such file or directory

Hier probeerden we een niet-bestaand bestand te openen, en het retourneerde de fout naar de variabele er. Als het bestand geldig is, is de fout nul

Aangepaste fouten

Met deze functie kunt u aangepaste fouten maken. Dit wordt gedaan met behulp van New() van het foutpakket. We zullen het bovenstaande programma herschrijven om gebruik te maken van aangepaste fouten.

Voer het onderstaande programma uit

package main
import "fmt"
import "os"
import "errors"

//function accepts a filename and tries to open it.
func fileopen(name string) (string, error) {
    f, er := os.Open(name)

    //er will be nil if the file exists else it returns an error object  
    if er != nil {
        //created a new error object and returns it  
        return "", errors.New("Custom error message: File name is wrong")
    }else{
    	return f.Name(),nil
    }
}

func main() {  
    //receives custom error or nil after trying to open the file
    filename, error := fileopen("invalid.txt")
    if error != nil {
        fmt.Println(error)
    }else{
    	fmt.Println("file opened", filename)
    }  
}

De output zal worden:

Custom error message:File name is wrong

Hier retourneert area() de oppervlakte van een vierkant. Als de invoer kleiner is dan 1, retourneert area() een foutmelding.

Bestanden lezen

Bestanden worden gebruikt om gegevens op te slaan. Met Go kunnen we gegevens uit de bestanden lezen

Maak eerst een bestand, data.txt, in uw huidige map met de onderstaande inhoud.

Line one
Line two
Line three

Voer nu het onderstaande programma uit om te zien dat het de inhoud van het volledige bestand als uitvoer afdrukt

package main
import "fmt"
import "io/ioutil"

func main() {  
    data, err := ioutil.ReadFile("data.txt")
    if err != nil {
        fmt.Println("File reading error", err)
        return
    }
    fmt.Println("Contents of file:", string(data))
}

Hier lezen de gegevens, err := ioutil.ReadFile(“data.txt”) de gegevens en retourneert een bytereeks. Tijdens het afdrukken wordt het geconverteerd naar stringformaat.

Bestanden schrijven

Je zult dit zien met een programma

package main
import "fmt"
import "os"

func main() {  
    f, err := os.Create("file1.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    l, err := f.WriteString("Write Line one")
    if err != nil {
        fmt.Println(err)
        f.Close()
        return
    }
    fmt.Println(l, "bytes written")
    err = f.Close()
    if err != nil {
        fmt.Println(err)
        return
    }
}

Hier wordt een bestand gemaakt, test.txt. Als het bestand al bestaat, wordt de inhoud van het bestand afgekapt. Writeline() wordt gebruikt om de inhoud naar het bestand te schrijven. Daarna sloot u het bestand met Close().

Cheatsheet

In deze Go-tutorial hebben we besproken:

Thema Omschrijving Syntaxis
Basistypen Numeriek, tekenreeks, bool
Variabelen Waarden declareren en toewijzen aan variabelen var variabele_naam type
var variabele_naam type = waarde
var variabele_naam1, variabele_naam2 = waarde1, waarde2
variabele_naam:= waarde
constanten Variabelen waarvan de waarde niet kan worden gewijzigd nadat deze is toegewezen const variabele = waarde
For loop Voer instructies in een lus uit. voor initialisatie_expressie; evaluatie_expressie; iteratie_expressie{
// een of meer verklaringen
}
Als anders Het is een voorwaardelijke verklaring als voorwaarde{
// verklaringen_1
Else {}
// verklaringen_2
}
schakelaar Voorwaardelijke verklaring met meerdere gevallen schakel expressie {
casuswaarde_1:
verklaringen_1
casuswaarde_2:
verklaringen_2
hoofdletterwaarde_n:
verklaringen_n
default:
verklaringen_default
}
reeks Vaste grootte benoemde reeks elementen van hetzelfde type arraynaam:= [grootte] type {waarde_0,waarde_1,…,waarde_grootte-1}
Plak Gedeelte of segment van een array var slice_name [] type = array_name[start:eind]
Functies Blok met instructies dat een specifieke taak uitvoert func functienaam(parameter_1 type, parameter_n type) return_type {
//verklaringen
}
Pakketten Worden gebruikt om de code te ordenen. Verhoogt de leesbaarheid en herbruikbaarheid van code importeer pakketnaam
Uitstellen Stelt de uitvoering van een functie uit totdat de bevattende functie de uitvoering voltooit functie_naam uitstellen(parameterlijst)
Pointers Slaat het geheugenadres van een andere variabele op. var variabelenaam *type
Structuur Door de gebruiker gedefinieerd datatype dat zelf nog een element van hetzelfde of een ander type bevat type structnaam struct {
variabele_1 variabele_1_type
variabele_2 variabele_2_type
variabele_n variabele_n_type
}
Methoden Een methode is een functie met een receiver-argument func (variabele variabeletype) methodName(parameterlijst) {
}
Goroutine Een functie die gelijktijdig met andere functies kan worden uitgevoerd. ga naar functienaam(parameterlijst)
Kanaal Manier waarop functies met elkaar kunnen communiceren. Een medium waarop de ene routine gegevens plaatst en waartoe een andere routine toegang heeft. Verklaren:
ch := make(chan int)
Gegevens naar kanaal verzenden:
kanaalvariabele <- variabele_naam
Ontvangen van kanaal:
variabele_naam := <- kanaal_variabele
kies Schakelverklaring die werkt op kanalen. De casusverklaringen zullen een kanaaloperatie zijn. Wanneer een van de kanalen gereed is met gegevens, wordt de instructie die bij dat geval hoort, uitgevoerd selecteer {
geval x := <-chan1:
fmt.Println(x)
geval y := <-chan2:
fmt.Println(y)
}
mutex Mutex wordt gebruikt als u niet wilt dat meerdere subroutines tegelijkertijd toegang hebben tot een bron. Mutex heeft 2 methoden: vergrendelen en ontgrendelen mutex.Lock()
//verklaringen
mutex.Ontgrendelen().
Lees bestanden Leest de gegevens en retourneert een bytereeks. Gegevens, fout := ioutil.ReadFile(bestandsnaam)
Schrijf bestand Schrijft gegevens naar een bestand l, fout := f.WriteString(text_to_write)