Golang opetusohjelma

Opimme kaikki Golangin perusteet tässä Learn Go Language -opetusohjelmassa.

Kuinka ladata ja asentaa GO

Vaihe 1) Mene https://golang.org/dl/. Lataa binaari käyttöjärjestelmällesi.

Vaihe 2) Double napsauta asennusohjelmaa ja napsauta Suorita.

Vaihe 3) Napsauta Seuraava

Vaihe 4) Valitse asennuskansio ja napsauta Seuraava.

Vaihe 5) Napsauta Valmis, kun asennus on valmis.

Vaihe 6) Kun asennus on valmis, voit tarkistaa sen avaamalla päätelaitteen ja kirjoittamalla

go version

Tämä näyttää go asennetun version

Ensimmäinen Go -ohjelmasi – Go Hello World!

Luo kansio nimeltä studyGo. Tässä Go-kielen opetusohjelmassa luomme go-ohjelmamme tähän kansioon. Go-tiedostot luodaan laajennuksella .mennä. Voit ajaa Go-ohjelmia syntaksin avulla

go run <filename>

Luo tiedosto nimeltä first.go ja lisää siihen alla oleva koodi ja tallenna

package main
import ("fmt")

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

Siirry tähän kansioon terminaalissasi. Suorita ohjelma komennolla

juokse ensin. Mene

Voit nähdä tulosteen tulostuksen

Hello World! This is my first Go program

Keskustellaan nyt yllä olevasta ohjelmasta.

paketin pää – Jokaisen Go Language -ohjelman tulee alkaa paketin nimellä. Go antaa meille mahdollisuuden käyttää paketteja toisissa go -ohjelmissa ja tukee siten koodin uudelleenkäytettävyyttä. Go-ohjelman suorittaminen alkaa koodilla paketin sisällä nimeltä main.

import fmt – tuo paketin fmt. Tämä paketti toteuttaa I/O-toiminnot.

func main() – Tämä on funktio, josta ohjelman suoritus alkaa. Päätoiminto tulee aina sijoittaa pääpakkaukseen. Main():n alle voit kirjoittaa koodin { } -kohtaan.

fmt.Println – Tämä tulostaa tekstin näytölle fmt:n Println-toiminnolla.

Huomautus: Kun mainitset tämän Go-opetusohjelman alla olevissa osissa suorita/suorita koodi, se tarkoittaa koodin tallentamista tiedostoon, jonka tunniste on .go ja sen suorittamista käyttämällä syntaksia.

    go run <filename>

Tietotyypit

Tyypit (tietotyypit) edustavat muuttujaan tallennetun arvon tyyppiä, funktion palauttaman arvon tyyppiä jne.

Go Languagessa on kolme perustyyppiä

Numeeriset tyypit – Edustavat numeerisia arvoja, jotka sisältävät kokonaisluvun, liukuluku- ja kompleksiarvot. Erilaisia ​​numeerisia tyyppejä ovat:

int8 – 8 bitin etumerkilliset kokonaisluvut.

int16 – 16 bitin etumerkilliset kokonaisluvut.

int32 – 32 bitin etumerkilliset kokonaisluvut.

int64 – 64 bitin etumerkilliset kokonaisluvut.

uint8 – 8-bittiset etumerkittömät kokonaisluvut.

uint16 – 16-bittiset etumerkittömät kokonaisluvut.

uint32 – 32-bittiset etumerkittömät kokonaisluvut.

uint64 – 64-bittiset etumerkittömät kokonaisluvut.

float32 – 32-bittiset liukulukuluvut.

float64 – 64-bittiset liukulukuluvut.

complex64 – sisältää float32 todellisia ja kuvitteellisia osia.

complex128 – sisältää float32 todellisia ja kuvitteellisia osia.

Merkkijonotyypit – Edustaa tavujen (merkkien) sarjaa. Voit tehdä merkkijonoille erilaisia ​​toimintoja, kuten merkkijonojen yhdistämisen, alimerkkijonon purkamisen jne

Boolen tyypit – Edustaa kahta arvoa, joko tosi tai epätosi.

Muuttujat

Muuttujat osoittavat muistipaikkaa, joka tallentaa jonkinlaisen arvon. Tyyppiparametri (alla olevassa syntaksissa) edustaa arvon tyyppiä, joka voidaan tallentaa muistipaikkaan.

Muuttuja voidaan ilmoittaa syntaksin avulla

    var <variable_name> <type>

Kun olet ilmoittanut tyypin muuttujan, voit määrittää muuttujan mille tahansa kyseisen tyypin arvolle.

Voit myös antaa muuttujalle alkuarvon itse ilmoituksen aikana

    var <variable_name> <type> = <value>

Jos määrität muuttujan alkuarvolla, päättele muuttujan tyyppi määritetyn arvon perusteella. Joten voit jättää tyypin pois ilmoituksen aikana syntaksin avulla

    var <variable_name> = <value>

Voit myös ilmoittaa useita muuttujia syntaksilla

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

Tämän Go-opetusohjelman alla olevassa ohjelmassa on joitain Golang-esimerkkejä muuttujamäärityksistä

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

Tulos tulee olemaan

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

Go Language tarjoaa myös helpon tavan ilmoittaa muuttujat arvolla jättämällä pois avainsanan var using

    <variable_name> := <value>

Huomaa, että käytit := sijasta =. Et voi käyttää :=:ää vain arvon määrittämiseen jo määritetylle muuttujalle. := käytetään arvon ilmoittamiseen ja määrittämiseen.

Luo tiedosto nimeltä assign.go seuraavalla koodilla

package main
import ("fmt")

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

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

Suorita mene ja suorita assign.go nähdäksesi tuloksen muodossa

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

Ilman alkuarvoa ilmoitetuilla muuttujilla on 0 numeerisille tyypeille, false Boolen ja tyhjä merkkijono merkkijonoille

vakiot

Vakiomuuttujat ovat muuttujia, joiden arvoa ei voi muuttaa kerran määritettynä. Go-ohjelmointikielen vakio ilmoitetaan käyttämällä avainsanaa "const"

Luo tiedosto nimeltä állandó.go ja seuraava koodi

package main
import ("fmt")

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

Suorita mene ajaa konstantti.go nähdäksesi tuloksen muodossa

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

Silmukkaesimerkkejä varten

Silmukoita käytetään lausekkeiden lohkon suorittamiseen toistuvasti ehdon perusteella. Useimmat ohjelmointikielet tarjoavat 3 tyyppisiä silmukoita – for, while, do while. Mutta Go-ohjelmointikieli tukee vain silmukkaa.

Golang for -silmukan syntaksi on

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

Alustuslauseke suoritetaan ensin (ja vain kerran) Golang for -silmukassa.

Sitten arviointi_lauseke arvioidaan ja jos se on totta, lohkon sisällä oleva koodi suoritetaan.

Iteration_expression id suoritetaan ja arviointi_lauseke arvioidaan uudelleen. Jos se on totta, lausekelohko suoritetaan uudelleen. Tämä jatkuu, kunnes arviointi_lauseke muuttuu epätosi.

Kopioi alla oleva ohjelma tiedostoon ja suorita se nähdäksesi Golang for loop -tulostusnumerot 1-5

package main
import "fmt"

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

Lähtö on

1
2
3
4
5

Tai muuten

Jos muuten on ehdollinen lausunto. Synaksi on

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

Tässä ehto arvioidaan ja jos se on tosi, lausekkeet_1 suoritetaan muuten lausekkeet_2 suoritetaan.

Voit käyttää if-lausetta myös ilman muuta. Voit myös olla ketjutettuja jos else -lauseita. Alla olevat ohjelmat selittävät enemmän, jos muuta.

Suorita alla oleva ohjelma. Se tarkistaa, onko luku x pienempi kuin 10. Jos on, se tulostaa "x on pienempi kuin 10".

package main
import "fmt"

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

Koska x:n arvo on suurempi kuin 10, tässä if block -ehtoa ei suoriteta.

Katso nyt alla oleva ohjelma. Tässä Go-ohjelmointikielen opetusohjelmassa meillä on else-lohko, joka suoritetaan jos-arvioinnin epäonnistuessa.

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

Tämä ohjelma antaa sinulle tulosteen

x is greater than or equals 10

Nyt tässä Go-opetusohjelmassa näemme ohjelman, jossa on useita if else -lohkoja (ketjutettu jos else). Suorita alla oleva Go-esimerkki. Se tarkistaa, onko luku pienempi kuin 10 tai välillä 10-90 vai suurempi kuin 90.

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

Tässä ensin if-ehto tarkistaa, onko x pienempi kuin 10 ja se ei ole. Joten se tarkistaa seuraavan ehdon (muuten jos), onko se 10 ja 90 välillä, mikä on myös epätosi. Joten se sitten suorittaa lohkon else-osion alla, joka antaa tulosteen

x is greater than 90

Vaihtaa

Switch on toinen ehdollinen lause. Switch-käskyt arvioivat lausekkeen ja tulosta verrataan käytettävissä oleviin arvoihin (tapauksiin). Kun vastaavuus on löydetty, kyseiseen osumaan (tapaukseen) liittyvät lausunnot suoritetaan. Jos vastaavuutta ei löydy, mitään ei suoriteta. Voit myös lisätä oletustapauksen vaihtaaksesi, joka suoritetaan, jos muita osumia ei löydy. Kytkimen syntaksi on

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

Tässä lausekkeen arvoa verrataan kunkin tapauksen arvoihin. Kun vastaavuus on löydetty, kyseiseen tapaukseen liittyvät lausunnot suoritetaan. Jos vastaavuutta ei löydy, oletusosion alaiset käskyt suoritetaan.

Suorita alla oleva ohjelma

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

Saat tulosteen muodossa

Sum is 3		

Muuta a:n ja b:n arvot 3:ksi ja tulos on

Printing default

Tapauksessa voi olla myös useita arvoja erottamalla ne pilkulla.

taulukot

Taulukko edustaa kiinteän kokoista, nimettyä sarjaa samantyyppisiä elementtejä. Sinulla ei voi olla taulukkoa, joka sisältää sekä kokonaislukua että merkkejä. Et voi muuttaa taulukon kokoa, kun olet määrittänyt koon.

Taulukon ilmoittamisen syntaksi on

var arrayname [size] type

Jokaiselle taulukon elementille voidaan antaa arvo syntaksin avulla

arrayname [index] = value

Array-indeksi alkaa 0 kokoon-1.

Voit määrittää taulukon elementeille arvoja määrityksen aikana syntaksin avulla

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

Voit myös jättää koko-parametrin huomioimatta, kun määrität taulukon arvoilla korvaamalla koon arvolla ... ja kääntäjä löytää pituuden arvojen lukumäärästä. Syntaksi on

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

Voit selvittää taulukon pituuden käyttämällä syntaksia

len(arrayname)

Suorita alla oleva Go-esimerkki ymmärtääksesi taulukon

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

ulostulo

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

Golang Slice and Append Function

Viipale on taulukon osa tai segmentti. Tai se on näkymä tai osittainen näkymä taustalla olevasta taulukosta, johon se osoittaa. Voit käyttää viipaleen elementtejä käyttämällä viipaleen nimeä ja indeksinumeroa aivan kuten taulukossa. Et voi muuttaa taulukon pituutta, mutta voit muuttaa viipaleen kokoa.

Viipaleen sisältö on itse asiassa osoittimia taulukon elementteihin. Se tarkoittaa jos muutat mitä tahansa osion elementtiä, se vaikuttaa myös alla olevan taulukon sisältöön.

Viipaleen luomisen syntaksi on

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

Tämä luo lohkon nimeltä viipaleen_nimi taulukosta, jonka nimi on taulukon_nimi, ja indeksin elementit ovat alusta loppuun-1.

Nyt tässä Golang-opetusohjelmassa suoritamme alla olevan ohjelman. Ohjelma luo lohkon taulukosta ja tulostaa sen. Voit myös nähdä, että osion sisällön muokkaaminen muuttaa todellista taulukkoa.

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

Tämä tulostaa tuloksen muodossa

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]

On olemassa tiettyjä toimintoja, kuten Golang len, Golang append, joita voit käyttää viipaleille

len(slice_name) – palauttaa viipaleen pituuden

liittää(viipaleen_nimi, arvo_1, arvo_2) – Golang append käytetään arvon_1 ja arvon_2 lisäämiseen olemassa olevaan osaan.

append(slice_nale1,slice_name2…) – liittää viipaleen_nimi2 lohkon_nimi1:een

Suorita seuraava ohjelma.

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

Tulos tulee olemaan

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]

Ohjelma luo ensin 2 viipaletta ja tulostaa sen pituuden. Sitten se lisäsi yhden viipaleen toiseen ja sitten lisäsi merkkijonon tuloksena olevaan viipaleeseen.

Tehtävät

Funktio edustaa lausekkeiden lohkoa, joka suorittaa tietyn tehtävän. Funktiomääritys kertoo meille funktion nimen, palautustyypin ja syöttöparametrit. Funktiomäärittely edustaa funktion sisältämää koodia. Funktion ilmoittamisen syntaksi on

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

Parametrit ja palautustyypit ovat valinnaisia. Voit myös palauttaa useita arvoja funktiosta.

Tässä Golang-opetusohjelmassa suoritetaan seuraava Golang-esimerkki. Tässä funktio nimeltä calc hyväksyy 2 numeroa ja suorittaa yhteen- ja vähennyslaskun ja palauttaa molemmat arvot.

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

Tulos tulee olemaan

Sum 25
Diff 5

Jäsenyydet

Paketteja käytetään koodin järjestämiseen. Isossa projektissa ei ole mahdollista kirjoittaa koodia yhteen tiedostoon. Go-ohjelmointikielen avulla voimme järjestää koodin eri pakettien alle. Tämä lisää koodin luettavuutta ja uudelleenkäytettävyyttä. Suoritettavan Go-ohjelman tulee sisältää paketti nimeltä main ja ohjelman suoritus alkaa funktiosta, jonka nimi on main. Voit tuoda muita paketteja ohjelmaamme käyttämällä syntaksia

import package_name

Näemme ja keskustelemme tässä Golang-opetusohjelmassa pakettien luomisesta ja käyttämisestä seuraavassa Golang-esimerkissä.

Vaihe 1) Luo tiedosto nimeltä package_example.go ja lisää alla oleva koodi

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

Yllä olevassa ohjelmassa fmt on paketti, jonka Go-ohjelmointikieli tarjoaa meille pääasiassa I/O-tarkoituksiin. Näet myös paketin nimeltä laskenta. Main():n sisällä näet askelsumman := laskenta. Do_add(x,y). Se tarkoittaa, että kutsut funktiota Do_add paketin laskemisesta.

Vaihe 2) Ensin sinun tulee luoda pakettilaskenta samannimiseen kansioon src-kansioon go. Asennettu polku go löytyy PATH-muuttujasta.

Macissa etsi polku suorittamalla echo $PATH

Polku on siis /usr/local/go

Windowsissa etsi polku suorittamalla echo %GOROOT%

Tässä polku on C:\Go\

Vaihe 3) Siirry src-kansioon (/usr/local/go/src (mac) ja C:\Go\src (Windows). Nyt koodista paketin nimi on laskenta. Go edellyttää, että paketti on sijoitettava samannimiseen hakemistoon src-hakemiston alla. Luo src-kansioon laskenta nimeltä hakemisto.

Vaihe 4) Luo laskentahakemistoon tiedosto nimeltä calc.go (Voit antaa minkä tahansa nimen, mutta koodissa oleva paketin nimi ratkaisee. Tässä sen pitäisi olla laskenta) laskentahakemistoon ja lisää alla oleva koodi

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

Vaihe 5) Suorita komento go install laskentahakemistosta, joka kääntää calc.go-tiedoston.

Vaihe 6) Palaa nyt osoitteeseen package_example.go ja suorita go ja suorita package_example.go. Tulos on summa 25.

Huomaa, että funktion Do_add nimi alkaa isolla kirjaimella. Tämä johtuu siitä, että Go:ssa jos funktion nimi alkaa isolla kirjaimella, se tarkoittaa, että muut ohjelmat voivat nähdä (pääsyä) siihen, muut ohjelmat eivät voi käyttää sitä. Jos funktion nimi olisi do_add, olisit saanut virheen

ei voi viitata viemättömään nimilaskentaan.calc..

Lykkää ja pinoa lykkäyksiä

Defer-lauseita käytetään lykkäämään funktiokutsun suorittamista, kunnes lykkäyskäskyn sisältävä funktio suorittaa suorituksen loppuun.

Opitaan tämä esimerkin avulla:

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

Tulos tulee olemaan

Inside the main()
Inside the sample()

Tässä sample():n suoritusta lykätään, kunnes sulkeva funktio (main()) on suoritettu loppuun.

Pinoamisen lykkäys käyttää useita lykkäyslausekkeita. Oletetaan, että funktion sisällä on useita lykkäyslausekkeita. Go sijoittaa kaikki lykätyt funktiokutsut pinoon, ja kun sulkeva funktio palaa, pinotut funktiot suoritetaan Last In First Out (LIFO) -tilaus. Voit nähdä tämän alla olevassa esimerkissä.

Suorita alla oleva koodi

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

Tulos tulee olemaan

4
3
2
1			

Tässä suoritetaan ensin main():n sisällä oleva koodi ja sitten lykätyt funktiokutsut käänteisessä järjestyksessä eli 4, 3,2,1.

Osoittimet

Ennen kuin selitämme osoittimia, keskustellaan ensin '&'-operaattorista. &-operaattoria käytetään muuttujan osoitteen saamiseksi. Se tarkoittaa, että '&a' tulostaa muuttujan a muistiosoitteen.

Tässä Golang-opetusohjelmassa suoritamme alla olevan ohjelman näyttääksesi muuttujan arvon ja muuttujan osoitteen

package main
import "fmt"

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

Tuloksena on

Address: 0xc000078008
Value: 20

Osoitinmuuttuja tallentaa toisen muuttujan muistiosoitteen. Voit määrittää osoittimen syntaksin avulla

	var variable_name *type

Tähti(*) tarkoittaa, että muuttuja on osoitin. Ymmärrät enemmän suorittamalla alla olevan ohjelman

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

Tulos tulee olemaan

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

rakenteet

Rakenne on käyttäjän määrittelemä tietotyyppi, joka itsessään sisältää yhden saman tai eri tyyppisen elementin lisää.

Rakenteen käyttäminen on 2-vaiheinen prosessi.

Ensin luo (ilmoita) rakennetyyppi

Toiseksi luo tämän tyyppiset muuttujat arvojen tallentamiseksi.

Rakenteita käytetään pääasiassa silloin, kun halutaan tallentaa toisiinsa liittyviä tietoja yhdessä.

Harkitse työntekijän tietoja, joissa on nimi, ikä ja osoite. Voit käsitellä tämän kahdella tavalla

Luo 3 taulukkoa – yksi taulukko tallentaa työntekijöiden nimet, yksi ikä ja kolmas ikä.

Ilmoita rakennetyyppi, jossa on 3 kenttää - nimi, osoite ja ikä. Luo kyseisen rakennetyypin taulukko, jossa jokainen elementti on rakenneobjekti, jolla on nimi, osoite ja ikä.

Ensimmäinen lähestymistapa ei ole tehokas. Tällaisissa skenaarioissa rakenteet ovat kätevämpiä.

Rakenteen ilmoittamisen syntaksi on

type structname struct {
   variable_1 variable_1_type
   variable_2 variable_2_type
   variable_n variable_n_type
}

Esimerkki rakenneilmoituksesta on

type emp struct {
    name string
    address string
    age int
}

Täällä luodaan uusi käyttäjän määrittelemä tyyppi nimeltä emp. Nyt voit luoda emp-tyypin muuttujia syntaksin avulla

	var variable_name struct_name

Esimerkki on

var empdata1 emp 

Voit asettaa arvot empdata1:lle as

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

Voit myös luoda rakennemuuttujan ja määrittää arvot

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

Tässä sinun on säilytettävä elementtien järjestys. Raj kartoitetaan nimeen, seuraava elementti osoitteeseen ja viimeinen ikään.

Suorita alla oleva koodi

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

ulostulo

John
Raj

Menetelmät (ei toiminnot)

Metodi on funktio, jolla on vastaanottimen argumentti. Archirakenteellisesti se on func-avainsanan ja menetelmän nimen välissä. Metodin syntaksi on

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

Muunnetaan yllä oleva esimerkkiohjelma käyttämään menetelmiä funktion sijaan.

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 ei ole oliokieli, eikä siinä ole luokan käsitettä. Menetelmät antavat vaikutelman siitä, mitä teet olioohjelmissa, joissa luokan funktioita kutsutaan käyttämällä syntaksia objektinnimi.funktionnimi()

samanaikaisuuden

Go tukee tehtävien samanaikaista suorittamista. Se tarkoittaa, että Go voi suorittaa useita tehtäviä samanaikaisesti. Se eroaa rinnakkaisuuden käsitteestä. Rinnakkaisuudessa tehtävä jaetaan pieniin alitehtäviin ja suoritetaan rinnakkain. Mutta samanaikaisesti, useita tehtäviä suoritetaan samanaikaisesti. Samanaikaisuus saavutetaan Go-sovelluksessa Goroutine- ja kanavien avulla.

Gorutiinit

Gorutiini on toiminto, joka voi toimia samanaikaisesti muiden funktioiden kanssa. Yleensä kun toimintoa vedetään, ohjaus siirtyy kutsuttuun funktioon ja sen suorituksen jälkeen ohjaus palaa kutsuvaan funktioon. Kutsutoiminto jatkaa sitten suoritustaan. Kutsuva funktio odottaa, että kutsuttu funktio saattaa suorituksen loppuun, ennen kuin se jatkaa muiden käskyjen kanssa.

Mutta gorutiinin tapauksessa kutsutoiminto ei odota kutsutun funktion suorittamisen valmistumista. Sen suorittamista jatketaan seuraavilla lauseilla. Ohjelmassa voi olla useita gorutiineja.

Myös pääohjelma poistuu, kun se on suorittanut käskynsä, eikä se odota kutsuttujen gorutiinien valmistumista.

Goroutine kutsutaan käyttämällä avainsanaa go, jota seuraa funktiokutsu.

esimerkki

go add(x,y)

Ymmärrät gorutiinit alla olevien Golang-esimerkkien avulla. Suorita alla oleva ohjelma

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

Tulos tulee olemaan

In main
In main
In main
In main
In main

Täällä pääohjelma suoritti suorituksen jo ennen gorutiinin alkamista. Display() on gorutiini, joka kutsutaan syntaksin avulla

go function_name(parameter list)

Yllä olevassa koodissa main() ei odota, että display() on valmis, ja main() suoritti suorituksensa ennen kuin display() suoritti koodinsa. Joten display():n sisällä olevaa print-lausetta ei tulostettu.

Nyt muokkaamme ohjelmaa tulostamaan lausekkeet myös display():stä. Lisäämme 2 sekunnin viiveen main():n for-silmukkaan ja 1 sekunnin viiveen display() for-silmukkaan.

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

Tulos on jonkin verran samanlainen kuin

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

Tässä näet, että molemmat silmukat suoritetaan päällekkäin samanaikaisen suorituksen vuoksi.

Kanavat

Kanavat ovat toimintojen tapa kommunikoida keskenään. Sitä voidaan pitää välineenä, johon yksi rutiini sijoittaa tiedot ja johon toinen rutiini pääsee käsiksi Golang-palvelimella.

Kanava voidaan ilmoittaa syntaksilla

channel_variable := make(chan datatype)

Esimerkiksi:

	ch := make(chan int)

Voit lähettää dataa kanavalle syntaksin avulla

channel_variable <- variable_name

esimerkki

    ch <- x

Voit vastaanottaa dataa kanavalta syntaksin avulla

    variable_name := <- channel_variable

esimerkki

   y := <- ch

Yllä olevissa go-kieliesimerkeissä gorutiinista olet nähnyt, että pääohjelma ei odota gorutiinia. Mutta näin ei ole silloin, kun kanavat ovat mukana. Oletetaan, että jos gorutiini työntää dataa kanavalle, main() odottaa kanavatietoja vastaanottavaa käskyä, kunnes se saa tiedot.

Näet tämän alla olevissa Go-kieliesimerkeissä. Kirjoita ensin normaali gorutiini ja katso käyttäytymistä. Muokkaa sitten ohjelmaa käyttämään kanavia ja katsomaan käyttäytymistä.

Suorita alla oleva ohjelma

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

Tulos tulee olemaan

Inside main()

Main() lopetti suorituksen ja poistui ennen kuin gorutine suorittaa. Joten näytön() sisällä olevaa tulostusta ei suoritettu.

Muokkaa nyt yllä olevaa ohjelmaa käyttääksesi kanavia ja nähdäksesi toiminnan.

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

Tulos tulee olemaan

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

Tässä tapahtuu main(), kun saavutetaan x := <-ch odottaa dataa kanavalla ch. Näyttö() odottaa 5 sekuntia ja siirtää sitten tiedot kanavan ch. Main() vastaanottaessaan dataa kanavalta vapautuu ja jatkaa suoritustaan.

Lähettäjä, joka lähettää dataa kanavalle, voi sulkea kanavan ilmoittaa vastaanottajille, että kanavalle ei lisätä enää dataa. Tätä käytetään pääasiassa, kun käytät silmukkaa tiedon siirtämiseen kanavalle. Kanavan voi sulkea käyttämällä

close(channel_name)

Ja vastaanottimen päässä on mahdollista tarkistaa, onko kanava suljettu lisämuuttujan avulla, kun tietoja haetaan kanavalta käyttämällä

variable_name, status := <- channel_variable

Jos tila on True, se tarkoittaa, että olet vastaanottanut tietoja kanavalta. Jos epätosi, se tarkoittaa, että yrität lukea suljetulta kanavalta

Voit myös käyttää kanavia kommunikointiin gorutiinien välillä. Tarvitsee käyttää kahta gorutiinia – toinen työntää tiedot kanavalle ja toinen vastaanottaa tiedot kanavalta. Katso alla oleva ohjelma

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

Tässä on 2 aliohjelmaa, joista toinen työntää tiedot kanavalle ja toinen tulostaa dataa kanavalle. Funktio add_to_channel lisää numerot 0:sta 9:ään ja sulkee kanavan. Samanaikaisesti funktio fetch_from_channel odottaa klo

x, lippu := <- ch ja kun tiedot tulevat saataville, se tulostaa tiedot. Se poistuu, kun lippu on epätosi, mikä tarkoittaa, että kanava on suljettu.

Main():n odotusaika estetään main():n poistumisesta, kunnes gorutiinit lopettavat suorituksen.

Suorita koodi ja katso tulos muodossa

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

valita

Select voidaan katsoa kytkinlauseena, joka toimii kanavilla. Tässä tapauslausekkeet ovat kanavaoperaatio. Yleensä jokaisen tapauksen lausumat yritetään lukea kanavalta. Kun jokin tapauksista on valmis (kanava on luettu), kyseiseen tapaukseen liittyvä käsky suoritetaan. Jos useita tapauksia on valmiina, se valitsee satunnaisen. Sinulla voi olla oletustapaus, joka suoritetaan, jos mikään tapauksista ei ole valmis.

Katsotaanpa alla olevaa koodia

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

Yllä olevan ohjelman suorittaminen antaa tuloksen:

from data2()

Tässä valintalause odottaa, että tiedot ovat saatavilla missä tahansa kanavassa. Data2() lisää dataa kanavaan 2 sekunnin lepotilan jälkeen, mikä saa toisen tapauksen suorittamaan.

Lisää oletuskoko samassa ohjelmassa olevaan valintaan ja katso tulos. Tässä valintalohkon saavuttaessa, jos missään tapauksessa kanavalla ei ole dataa valmiina, se suorittaa oletuslohkon odottamatta tietojen olevan saatavilla millekään kanavalle.

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

Tämä ohjelma antaa tulosteen:

Default case executed			

Tämä johtuu siitä, että kun valintalohko saavutettiin, millään kanavalla ei ollut luettavaa dataa. Joten oletustapaus suoritetaan.

muteksi

Mutex on keskinäisen poissulkemisen lyhyt muoto. Mutexia käytetään, kun et halua sallia useiden aliohjelmien pääsyn resurssiin samanaikaisesti. Mutexillä on 2 tapaa - Lukitse ja Avaa. Mutex sisältyy synkronointipakettiin. Joten sinun on tuotava synkronointipaketti. Käskyt, jotka on suoritettava toisensa poissulkevasti, voidaan sijoittaa mutex.Lock()- ja mutex.Unlock()-sisään.

Opetetaan mutex esimerkillä, joka laskee, kuinka monta kertaa silmukka suoritetaan. Tässä ohjelmassa odotamme rutiinin suorittavan silmukan 10 kertaa ja laskuri tallennetaan summana. Kutsut tätä rutiinia 3 kertaa, joten kokonaismäärän pitäisi olla 30. Luku tallennetaan globaaliin muuttujamäärään.

Ensin suoritat ohjelman ilman mutexia

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

Katso tulos

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

Tulos voi olla erilainen, kun suoritat sen, mutta lopputulos ei ole 30.

Tässä tapahtuu, että 3 gorutiinia yrittävät lisätä muuttujamäärään tallennettua silmukkamäärää. Oletetaan, että tällä hetkellä määrä on 5 ja gorotine1 kasvattaa määrää kuuteen.

Kopioi määrä lämpötilaan

Nosta lämpötilaa

Tallenna lämpötila takaisin laskeaksesi

Oletetaan pian sen jälkeen, kun olet suorittanut vaiheen 3 goroutine1:llä; toisella gorutiinilla voi olla vanha arvo, eli 3 tekee yllä olevat vaiheet ja tallentaa 4 takaisin, mikä on väärin. Tämä voidaan estää käyttämällä mutexia, joka saa muut rutiinit odottamaan, kun yksi rutiini jo käyttää muuttujaa.

Nyt suoritat ohjelman mutexilla. Tässä yllä mainitut 3 vaihetta suoritetaan mutexissa.

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

Nyt tulos tulee olemaan

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

Tästä saamme lopputulokseksi odotetun tuloksen. Koska lausekkeet, jotka lukevat, lisäävät ja kirjoittavat laskun takaisin, suoritetaan mutexissa.

Virheiden käsittely

Virheet ovat epänormaaleja olosuhteita, kuten tiedoston sulkeminen, jota ei avata, avaamaton tiedosto jne. Toiminnot palauttavat yleensä virheet viimeisenä palautusarvona.

Alla oleva esimerkki selittää enemmän virheestä.

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

Tuotos on:

open /invalid.txt: no such file or directory

Täällä yritimme avata tiedoston, jota ei ole olemassa, ja se palautti virheen muuttujaan er. Jos tiedosto on kelvollinen, virhe on tyhjä

Mukautetut virheet

Tämän ominaisuuden avulla voit luoda mukautettuja virheitä. Tämä tehdään käyttämällä virhepaketin New()-komentoa. Kirjoitamme yllä olevan ohjelman uudelleen hyödyntämään mukautettuja virheitä.

Suorita alla oleva ohjelma

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

Tuotos on:

Custom error message:File name is wrong

Tässä area() palauttaa neliön alueen. Jos syöte on pienempi kuin 1, alue() palauttaa virheilmoituksen.

Tiedostojen lukeminen

Tiedostoja käytetään tietojen tallentamiseen. Go antaa meille mahdollisuuden lukea tietoja tiedostoista

Luo ensin tiedosto data.txt nykyiseen hakemistoosi alla olevan sisällön kanssa.

Line one
Line two
Line three

Suorita nyt alla oleva ohjelma nähdäksesi, että se tulostaa koko tiedoston sisällön tulosteena

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

Tässä tiedot, err := ioutil.ReadFile("data.txt") lukee tiedot ja palauttaa tavusekvenssin. Tulostuksen aikana se muunnetaan merkkijonomuotoon.

Tiedostojen kirjoittaminen

Näet tämän ohjelman avulla

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

Täällä luodaan tiedosto, test.txt. Jos tiedosto on jo olemassa, tiedoston sisältö katkaistaan. Writeline()-funktiota käytetään tiedoston sisällön kirjoittamiseen. Sen jälkeen suljit tiedoston Close()-komennolla.

Cheat Sheet

Tässä Go-opetusohjelmassa käsittelimme

Aihe	Tuotetiedot	Syntaksi
Perustyypit	Numero, merkkijono, bool
Muuttujat	Ilmoita ja anna muuttujille arvoja	muuttujan_nimityyppi var muuttujan_nimi tyyppi = arvo muuttujan_nimi1, muuttujan_nimi2 = arvo1, arvo2 muuttujan_nimi := arvo
vakiot	Muuttujat, joiden arvoa ei voi muuttaa kerran määritettynä	const muuttuja = arvo
Loopille	Suorita lauseet silmukassa.	alustus_ilmaisua varten; arviointi_ilmaus; iteraatio_lauseke{ // yksi tai useampi lausunto }
Tai muuten	Se on ehdollinen lausunto	if condition{ // lausunnot_1 Else {} // lausunnot_2 }
kytkin	Ehdollinen lausunto, jossa on useita tapauksia	vaihtaa lauseke { case value_1: lausunnot_1 case value_2: lausunnot_2 case value_n: lausunnot_n default: lausunnot_oletus }
Ryhmä	Kiinteäkokoinen nimetty samantyyppisten elementtien sarja	arrayname := [koko] tyyppi {arvo_0,arvo_1,…,arvo_koko-1}
Viipale	Osa tai segmentti taulukosta	var slice_name [] type = taulukon_nimi[aloitus:loppu]
Tehtävät	Lausekkeiden lohko, joka suorittaa tietyn tehtävän	func funktion_nimi(parametrin_1 tyyppi, parametrin_n tyyppi) return_type { //lausunnot }
Jäsenyydet	Käytetään koodin järjestämiseen. Lisää koodin luettavuutta ja uudelleenkäytettävyyttä	tuo paketin_nimi
Lykätä	Lykkää funktion suorittamista, kunnes sisältävä funktio lopettaa suorituksen	lykkää funktion_nimi(parametriluettelo)
Osoittimet	Tallentaa toisen muuttujan muistiosoitteen.	muuttujan_nimi *tyyppi
Tuote mallit	Käyttäjän määrittämä tietotyyppi, joka itsessään sisältää yhden saman tai eri tyyppisen elementin lisää	kirjoita rakenteen nimi struct { muuttuja_1 muuttuja_1_tyyppi muuttuja_2 muuttuja_2_tyyppi muuttuja_n muuttujan_n_tyyppi }
Menetelmät	Metodi on funktio, jolla on vastaanottimen argumentti	func (muuttujatyyppi) methodName(parameter_list) { }
Gorutine	Toiminto, joka voi toimia samanaikaisesti muiden toimintojen kanssa.	go function_name(parameter_list)
Kanava	Toimintojen tapa kommunikoida keskenään. Tietoväline, johon yksi rutiini sijoittaa tietoja ja johon toinen rutiini pääsee käsiksi.	Julistaa: ch := make(chan int) Lähetä tiedot kanavalle: kanavamuuttuja <- muuttujan_nimi Vastaanota kanavalta: muuttujan_nimi := <- kanavamuuttuja
valita	Kanavilla toimiva vaihtoilmoitus. Tapauslausekkeet ovat kanavaoperaatio. Kun jokin kanava on valmis tietojen kanssa, kyseiseen tapaukseen liittyvä käsky suoritetaan	valitse { tapaus x := <-chan1: fmt.Println(x) tapaus y := <-chan2: fmt.Println(y) }
muteksi	Mutexia käytetään, kun et halua sallia useiden aliohjelmien pääsyn resurssiin samanaikaisesti. Mutexillä on 2 tapaa – Lock and Unlock	mutex.Lock() //lausunnot mutex.Unlock().
Lue tiedostoja	Lukee tiedot ja palauttaa tavusekvenssin.	Data, err := ioutil.ReadFile(tiedostonimi)
Kirjoita tiedosto	Kirjoittaa dataa tiedostoon	l, err := f.WriteString(kirjoitettava_teksti)