Tutorial Golang

Vom învăța toate elementele de bază ale Golang în acest tutorial Learn Go Language.

Cum să descărcați și să instalați GO

Pas 1) Accesează https://golang.org/dl/. Descărcați binarul pentru sistemul dvs. de operare.

Pas 2) Double faceți clic pe programul de instalare și faceți clic pe Run.

Pas 3) Faceți clic pe Următorul

Pas 4) Selectați folderul de instalare și faceți clic pe Următorul.

Pas 5) Faceți clic pe Terminare odată ce instalarea este finalizată.

Pas 6) Odată ce instalarea este finalizată, o puteți verifica deschizând terminalul și tastând

go version

Aceasta va afișa versiunea go instalată

Programul First Go – Go Hello World!

Creați un folder numit studyGo. În acest tutorial în limba Go, vom crea programele noastre go în interiorul acestui folder. Fișierele Go sunt create cu extensia .merge. Puteți rula programe Go folosind sintaxa

go run <filename>

Creați un fișier numit first.go și adăugați codul de mai jos în el și salvați

package main
import ("fmt")

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

Navigați la acest folder din terminalul dvs. Rulați programul folosind comanda

du-te fugi mai întâi.du-te

Puteți vedea imprimarea de ieșire

Hello World! This is my first Go program

Acum să discutăm despre programul de mai sus.

pachet principal – Fiecare program Go Language ar trebui să înceapă cu un nume de pachet. Go ne permite să folosim pachete în alte programe go și, prin urmare, acceptă reutilizarea codului. Execuția unui program Go începe cu codul din interiorul pachetului numit main.

import fmt – importă pachetul fmt. Acest pachet implementează funcțiile I/O.

func main() – Aceasta este funcția de la care începe execuția programului. Funcția principală ar trebui să fie întotdeauna plasată în pachetul principal. Sub main(), puteți scrie codul în { }.

fmt.Println – Aceasta va imprima textul pe ecran prin funcția Println a fmt.

Notă: În secțiunile de mai jos ale acestui tutorial Go, când menționați executarea/executarea codului, înseamnă să salvați codul într-un fișier cu extensia .go și să îl rulați folosind sintaxa

    go run <filename>

Tipuri de date

Tipurile (tipurile de date) reprezintă tipul valorii stocate într-o variabilă, tipul valorii returnate de o funcție etc.

Există trei tipuri de bază în Go Language

Tipuri numerice – Reprezintă valori numerice care includ valori întregi, virgulă mobilă și complexe. Diferite tipuri numerice sunt:

int8 – numere întregi cu semn pe 8 biți.

int16 – numere întregi cu semn pe 16 biți.

int32 – numere întregi cu semn pe 32 biți.

int64 – numere întregi cu semn pe 64 biți.

uint8 – numere întregi fără semn pe 8 biți.

uint16 – numere întregi fără semn pe 16 biți.

uint32 – numere întregi fără semn pe 32 biți.

uint64 – numere întregi fără semn pe 64 biți.

float32 – numere în virgulă mobilă pe 32 de biți.

float64 – numere în virgulă mobilă pe 64 de biți.

complex64 – are float32 părți reale și imaginare.

complex128 – are float32 părți reale și imaginare.

Tipuri de șiruri – Reprezintă o secvență de octeți (caractere). Puteți face diverse operații pe șiruri, cum ar fi concatenarea șirurilor, extragerea subșirurilor etc

Tipuri booleene – Reprezintă 2 valori, fie adevărate fie false.

Variabile

Variabilele indică o locație de memorie care stochează un fel de valoare. Parametrul tip (în sintaxa de mai jos) reprezintă tipul de valoare care poate fi stocată în locația de memorie.

Variabila poate fi declarată folosind sintaxa

    var <variable_name> <type>

Odată ce declarați o variabilă de tip, puteți atribui variabila oricărei valori de tipul respectiv.

De asemenea, puteți da o valoare inițială unei variabile în timpul declarației în sine folosind

    var <variable_name> <type> = <value>

Dacă declarați variabila cu o valoare inițială, mergeți și deduceți tipul variabilei din tipul valorii atribuite. Deci, puteți omite tipul în timpul declarației folosind sintaxa

    var <variable_name> = <value>

De asemenea, puteți declara mai multe variabile cu sintaxa

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

Programul de mai jos din acest tutorial Go are câteva exemple Golang de declarații de variabile

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

Ieșirea va fi

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

Go Language oferă, de asemenea, o modalitate ușoară de a declara variabilele cu valoare prin omiterea cuvântului cheie var folosind

    <variable_name> := <value>

Rețineți că ați folosit := în loc de =. Nu puteți folosi := doar pentru a atribui o valoare unei variabile care este deja declarată. := este folosit pentru a declara și a atribui valoare.

Creați un fișier numit assign.go cu următorul cod

package main
import ("fmt")

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

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

Executați go run assign.go pentru a vedea rezultatul ca

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

Variabilele declarate fără valoare inițială vor avea 0 pentru tipurile numerice, false pentru boolean și șir gol pentru șiruri

constante

Variabilele constante sunt acele variabile a căror valoare nu poate fi modificată odată ce au fost atribuite. O constantă în limbajul de programare Go este declarată prin utilizarea cuvântului cheie „const”

Creați un fișier numit constant.go și cu următorul cod

package main
import ("fmt")

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

Executați go run constant.go pentru a vedea rezultatul ca

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

Pentru exemple de buclă

Buclele sunt folosite pentru a executa un bloc de instrucțiuni în mod repetat pe baza unei condiții. Majoritatea limbajelor de programare oferă 3 tipuri de bucle - for, while, do while. Dar limbajul de programare Go acceptă doar bucla for.

Sintaxa unei bucle pentru Golang este

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

Expresia_inițializare este executată mai întâi (și doar o dată) în Golang pentru bucla.

Apoi evaluation_expression este evaluată și dacă este adevărat, codul din interiorul blocului este executat.

Id-ul expresiei_iterație este executat, iar expresia_evaluării este evaluat din nou. Dacă este adevărat, blocul de instrucțiuni este executat din nou. Aceasta va continua până când expresia_evaluare devine falsă.

Copiați programul de mai jos într-un fișier și executați-l pentru a vedea Golang pentru numere de tipărire în buclă de la 1 la 5

package main
import "fmt"

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

Ieșirea este

1
2
3
4
5

Dacă altceva

Dacă else este o declarație condiționată. Sinaxa este

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

Aici condiția este evaluată și dacă este adevărată instrucțiunile_1 vor fi executate, altfel vor fi executate instrucțiunile_2.

Puteți folosi declarația if și fără else. De asemenea, puteți avea declarații if else înlănțuite. Programele de mai jos vor explica mai multe despre dacă altfel.

Executați programul de mai jos. Verifică dacă un număr, x, este mai mic de 10. Dacă da, va afișa „x este mai mic de 10”

package main
import "fmt"

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

Aici, deoarece valoarea lui x este mai mare decât 10, instrucțiunea din interiorul dacă condiția blocului nu va fi executată.

Acum vedeți programul de mai jos. În acest tutorial despre limbajul de programare Go, avem un bloc else care va fi executat la eșecul evaluării if.

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

Acest program vă va oferi rezultate

x is greater than or equals 10

Acum, în acest tutorial Go, vom vedea un program cu mai multe blocuri if else (înlănțuite dacă else). Executați exemplul Go de mai jos. Verifică dacă un număr este mai mic de 10 sau este între 10-90 sau mai mare de 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")
    }
}

Aici, mai întâi, condiția if verifică dacă x este mai mic de 10 și nu este. Deci verifică următoarea condiție (altfel dacă) dacă este între 10 și 90, ceea ce este, de asemenea, fals. Deci apoi execută blocul din secțiunea else care dă rezultatul

x is greater than 90

Intrerupator

Switch este o altă declarație condiționată. Instrucțiunile Switch evaluează o expresie și rezultatul este comparat cu un set de valori disponibile (cazuri). Odată ce o potrivire este găsită, instrucțiunile asociate cu acea potrivire (caz) sunt executate. Dacă nu se găsește nicio potrivire, nimic nu va fi executat. De asemenea, puteți adăuga un caz implicit pentru comutare, care va fi executat dacă nu sunt găsite alte potriviri. Sintaxa comutatorului este

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

Aici valoarea expresiei este comparată cu valorile din fiecare caz. Odată ce este găsită o potrivire, instrucțiunile asociate cu acel caz sunt executate. Dacă nu se găsește nicio potrivire, instrucțiunile din secțiunea implicită sunt executate.

Executați programul de mai jos

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

Veți obține rezultatul ca

Sum is 3		

Schimbați valoarea lui a și b la 3 și rezultatul va fi

Printing default

De asemenea, puteți avea mai multe valori într-un caz, separându-le cu virgulă.

Arrays

Array reprezintă o dimensiune fixă, numită secvență de elemente de același tip. Nu puteți avea o matrice care conține atât numere întregi, cât și caractere. Nu puteți modifica dimensiunea unei matrice odată ce ați definit dimensiunea.

Sintaxa pentru declararea unui tablou este

var arrayname [size] type

Fiecărui element de matrice i se poate atribui o valoare folosind sintaxa

arrayname [index] = value

Indexul matricei începe de la 0 la mărimea-1.

Puteți atribui valori elementelor de matrice în timpul declarației folosind sintaxa

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

De asemenea, puteți ignora parametrul dimensiune în timp ce declarați matricea cu valori, înlocuind dimensiunea cu ... iar compilatorul va găsi lungimea din numărul de valori. Sintaxa este

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

Puteți găsi lungimea matricei folosind sintaxa

len(arrayname)

Executați exemplul Go de mai jos pentru a înțelege matricea

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

producție

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

Golang Slice și funcție de adăugare

O felie este o porțiune sau un segment dintr-o matrice. Sau este o vedere sau o vedere parțială a unui tablou subiacent către care indică. Puteți accesa elementele unei secțiuni folosind numele și numărul de index la fel ca într-o matrice. Nu puteți modifica lungimea unei matrice, dar puteți modifica dimensiunea unei felii.

Conținutul unei felii sunt de fapt pointerii către elementele unui tablou. Inseamna dacă modificați orice element dintr-o felie, conținutul matricei de bază va fi de asemenea afectat.

Sintaxa pentru crearea unei felii este

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

Aceasta va crea o porțiune numită slice_name dintr-o matrice numită array_name cu elementele de la index de la început la sfârșit-1.

Acum, în acest tutorial Golang, vom executa programul de mai jos. Programul va crea o porțiune din matrice și o va imprima. De asemenea, puteți vedea că modificarea conținutului din felie va modifica matricea reală.

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

Acesta va imprima rezultatul ca

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]

Există anumite funcții precum Golang len, Golang append pe care le puteți aplica pe felii

len(nume_slice) – returnează lungimea feliei

append(nume_slice, valoare_1, valoare_2) – Golang append este folosit pentru a adăuga value_1 și value_2 la o porțiune existentă.

append(slice_nale1,slice_name2...) – adaugă slice_name2 la slice_name1

Executați următorul program.

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

Ieșirea va fi

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]

Programul creează mai întâi 2 felii și i-a imprimat lungimea. Apoi a atașat o felie la alta și apoi a atașat un șir la felia rezultată.

funcţii

O funcție reprezintă un bloc de instrucțiuni care îndeplinește o anumită sarcină. O declarație de funcție ne spune numele funcției, tipul de returnare și parametrii de intrare. Definiția funcției reprezintă codul conținut în funcție. Sintaxa pentru declararea funcției este

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

Parametrii și tipurile de returnare sunt opționale. De asemenea, puteți returna mai multe valori dintr-o funcție.

Acum, în acest tutorial Golang, să rulăm următorul exemplu Golang. Aici funcția numită calc va accepta 2 numere și efectuează adunarea și scăderea și returnează ambele valori.

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

Ieșirea va fi

Sum 25
Diff 5

Pachete

Pachetele sunt folosite pentru a organiza codul. Într-un proiect mare, nu este fezabil să scrieți cod într-un singur fișier. Limbajul de programare Go ne permite să organizăm codul în diferite pachete. Acest lucru crește lizibilitatea și reutilizarea codului. Un program Go executabil ar trebui să conțină un pachet numit main și execuția programului începe de la funcția numită main. Puteți importa alte pachete în programul nostru folosind sintaxa

import package_name

Vom vedea și discuta în acest tutorial Golang, cum să creați și să utilizați pachete în următorul exemplu Golang.

Pas 1) Creați un fișier numit package_example.go și adăugați codul de mai jos

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

În programul de mai sus, fmt este un pachet pe care limbajul de programare Go ni-l oferă în principal pentru scopuri I/O. De asemenea, puteți vedea un pachet numit calcul. În interiorul main() puteți vedea o sumă pasă := calcul.Do_add(x,y). Înseamnă că invocați funcția Do_add din calculul pachetului.

Pas 2) În primul rând, ar trebui să creați calculul pachetului într-un folder cu același nume sub folderul src din go. Calea instalată a go poate fi găsită din variabila PATH.

Pentru Mac, găsiți calea executând echo $PATH

Deci calea este /usr/local/go

Pentru Windows, găsiți calea executând echo %GOROOT%

Aici calea este C:\Go\

Pas 3) Navigați la folderul src (/usr/local/go/src pentru Mac și C:\Go\src pentru Windows). Acum, din cod, numele pachetului este de calcul. Go necesită ca pachetul să fie plasat într-un director cu același nume sub directorul src. Creați un director numit calcul în folderul src.

Pas 4) Creați un fișier numit calc.go (puteți da orice nume, dar numele pachetului din cod contează. Aici ar trebui să fie calcul) în directorul de calcul și adăugați codul de mai jos

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

Pas 5) Rulați comanda go install din directorul de calcul care va compila calc.go.

Pas 6) Acum reveniți la package_example.go și rulați go run package_example.go. Ieșirea va fi Suma 25.

Rețineți că numele funcției Do_add începe cu o literă majusculă. Acest lucru se datorează faptului că în Go, dacă numele funcției începe cu o literă majusculă, înseamnă că alte programe îl pot vedea (accesa), altfel alte programe nu îl pot accesa. Dacă numele funcției a fost do_add , atunci ați fi primit eroarea

nu se poate face referire la calculul numelui neexportat.calc..

Amânare și stivuire amână

Instrucțiunile Defer sunt folosite pentru a amâna execuția unui apel de funcție până când funcția care conține instrucțiunea defer finalizează execuția.

Să învățăm asta cu un exemplu:

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

Ieșirea va fi

Inside the main()
Inside the sample()

Aici execuția sample() este amânată până când se finalizează execuția funcției incluse(main()).

Stacking defer folosește mai multe instrucțiuni defer. Să presupunem că aveți mai multe instrucțiuni defer în interiorul unei funcții. Go plasează toate apelurile de funcții amânate într-o stivă și, odată ce funcția de încadrare revine, funcțiile stivuite sunt executate în Comanda Last In First Out (LIFO). Puteți vedea acest lucru în exemplul de mai jos.

Executați codul de mai jos

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

Ieșirea va fi

4
3
2
1			

Aici codul din main() se execută mai întâi, iar apoi apelurile de funcții amânate sunt executate în ordine inversă, adică 4, 3,2,1.

Pointeri

Înainte de a explica indicatorii, să discutăm mai întâi despre operatorul „&”. Operatorul „&” este folosit pentru a obține adresa unei variabile. Înseamnă că „&a” va tipări adresa de memorie a variabilei a.

În acest tutorial Golang, vom executa programul de mai jos pentru a afișa valoarea unei variabile și adresa acelei variabile

package main
import "fmt"

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

Rezultatul va fi

Address: 0xc000078008
Value: 20

O variabilă pointer stochează adresa de memorie a altei variabile. Puteți defini un pointer folosind sintaxa

	var variable_name *type

Asteriscul(*) reprezintă variabila este un pointer. Veți înțelege mai multe executând programul de mai jos

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

Ieșirea va fi

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

Structuri

O structură este un tip de date definit de utilizator, care conține încă un element de același tip sau diferit.

Utilizarea unei structuri este un proces în 2 etape.

Mai întâi, creați (declarați) un tip de structură

În al doilea rând, creați variabile de acest tip pentru a stoca valori.

Structurile sunt utilizate în principal atunci când doriți să stocați împreună date asociate.

Luați în considerare o informație despre angajați care are numele, vârsta și adresa. Puteți gestiona asta în 2 moduri

Creați 3 matrice - o matrice stochează numele angajaților, una stochează vârsta și al treilea stochează vârsta.

Declarați un tip de structură cu 3 câmpuri - nume, adresă și vârstă. Creați o matrice de acel tip de structură în care fiecare element este un obiect de structură având nume, adresă și vârstă.

Prima abordare nu este eficientă. În astfel de scenarii, structurile sunt mai convenabile.

Sintaxa pentru declararea unei structuri este

type structname struct {
   variable_1 variable_1_type
   variable_2 variable_2_type
   variable_n variable_n_type
}

Un exemplu de declarație de structură este

type emp struct {
    name string
    address string
    age int
}

Aici este creat un nou tip definit de utilizator numit emp. Acum, puteți crea variabile de tip emp folosind sintaxa

	var variable_name struct_name

Un exemplu este

var empdata1 emp 

Puteți seta valori pentru empdata1 ca

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

De asemenea, puteți crea o variabilă de structură și aloca valori prin

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

Aici, trebuie să mențineți ordinea elementelor. Raj va fi mapat după nume, următorul element de adresat și ultimul pentru vârsta.

Executați codul de mai jos

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

producție

John
Raj

Metode (nu funcții)

O metodă este o funcție cu un argument receptor. Archidin punct de vedere tehnic, este între cuvântul cheie func și numele metodei. Sintaxa unei metode este

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

Să convertim exemplul de program de mai sus pentru a folosi metode în loc de funcție.

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 nu este un limbaj orientat pe obiecte și nu are conceptul de clasă. Metodele oferă o imagine a ceea ce faci în programele orientate pe obiecte în care funcțiile unei clase sunt invocate folosind sintaxa nume obiect.numefuncție()

Concurenta

Go acceptă executarea concomitentă a sarcinilor. Înseamnă că Go poate executa mai multe sarcini simultan. Este diferit de conceptul de paralelism. În paralelism, o sarcină este împărțită în subsarcini mici și sunt executate în paralel. Dar în concurență, mai multe sarcini sunt executate simultan. Concurența se realizează în Go folosind Goroutines și Canale.

Goroutine

O goroutine este o funcție care poate rula concomitent cu alte funcții. De obicei, atunci când o funcție este invocată, controlul este transferat în funcția apelată și, odată finalizată, controlul de execuție revine la funcția de apelare. Funcția de apelare își continuă apoi execuția. Funcția apelantă așteaptă ca funcția invocată să finalizeze execuția înainte de a continua cu restul instrucțiunilor.

Dar în cazul goroutine, funcția de apelare nu va aștepta finalizarea execuției funcției invocate. Va continua să se execute cu următoarele instrucțiuni. Puteți avea mai multe goroutine într-un program.

De asemenea, programul principal se va închide odată ce își încheie executarea instrucțiunilor și nu va aștepta finalizarea goroutinelor invocate.

Goroutine este invocată folosind cuvântul cheie go urmat de un apel de funcție.

Exemplu

go add(x,y)

Veți înțelege goroutine cu exemplele Golang de mai jos. Executați programul de mai jos

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

Ieșirea va fi

In main
In main
In main
In main
In main

Aici programul principal și-a încheiat execuția chiar înainte de a începe goroutine. Display() este o rutină care este invocată folosind sintaxa

go function_name(parameter list)

În codul de mai sus, main() nu așteaptă ca display() să se finalizeze, iar main() și-a încheiat execuția înainte ca display() să-și execute codul. Deci declarația print din display() nu a fost tipărită.

Acum modificăm programul pentru a imprima instrucțiunile și din display(). Adăugăm o întârziere de 2 secunde în bucla for a main() și o întârziere de 1 secundă în bucla for a afișajului().

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

Ieșirea va fi oarecum similară cu

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

Aici puteți vedea că ambele bucle sunt executate într-un mod suprapus din cauza execuției concurente.

Canale

Canalele sunt o modalitate prin care funcțiile pot comunica între ele. Poate fi considerat ca un mediu în care o rutină plasează date și este accesată de o altă rutină pe serverul Golang.

Un canal poate fi declarat cu sintaxa

channel_variable := make(chan datatype)

Exemplu:

	ch := make(chan int)

Puteți trimite date către un canal folosind sintaxa

channel_variable <- variable_name

Exemplu

    ch <- x

Puteți primi date de la un canal folosind sintaxa

    variable_name := <- channel_variable

Exemplu

   y := <- ch

În exemplele de limbă Go de mai sus de goroutine, ați văzut că programul principal nu așteaptă goroutine. Dar nu este cazul când sunt implicate canale. Să presupunem că dacă o rutină împinge date către canal, main() va aștepta instrucțiunea care primește datele canalului până când primește datele.

Veți vedea acest lucru în exemplele de limbă Go de mai jos. Mai întâi, scrieți o rutină normală și vedeți comportamentul. Apoi modificați programul pentru a utiliza canale și a vedea comportamentul.

Executați programul de mai jos

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

Ieșirea va fi

Inside main()

Main() a terminat execuția și a ieșit înainte ca goroutine să se execute. Deci tipărirea din interiorul display() nu a fost executată.

Acum modificați programul de mai sus pentru a utiliza canalele și a vedea comportamentul.

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

Ieșirea va fi

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

Aici ceea ce se întâmplă este main() la atingerea x := <-ch va aștepta date pe canalul ch. Display-ul () are o așteptare de 5 secunde și apoi împinge datele către canalul de canal. Main() la primirea datelor de la canal este deblocat și își continuă execuția.

Expeditorul care transmite date pe canal poate informa receptorii că nu vor mai fi adăugate date la canal prin închiderea canalului. Acesta este folosit în principal atunci când utilizați o buclă pentru a împinge date către un canal. Un canal poate fi închis folosind

close(channel_name)

Și la capătul receptorului, este posibil să verificați dacă canalul este închis folosind o variabilă suplimentară în timp ce preluați date de pe canal folosind

variable_name, status := <- channel_variable

Dacă starea este True înseamnă că ați primit date de la canal. Dacă este fals, înseamnă că încercați să citiți de pe un canal închis

De asemenea, puteți utiliza canale pentru comunicarea între goroutine. Trebuie să utilizați 2 goroutine - unul împinge datele către canal, iar celălalt primește datele de la canal. Vezi programul de mai jos

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

Aici există 2 subrutine, una împinge datele către canal și cealaltă imprimă datele către canal. Funcția add_to_channel adaugă numerele de la 0 la 9 și închide canalul. Simultan, funcția fetch_from_channel așteaptă la

x, flag := <- ch și odată ce datele devin disponibile, se tipărește datele. Iese odată ce steagul este fals, ceea ce înseamnă că canalul este închis.

Așteptarea în main() este dată pentru a preveni ieșirea din main() până când goroutines termină execuția.

Executați codul și vedeți rezultatul ca

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

Selectați

Select poate fi văzut ca o declarație de comutare care funcționează pe canale. Aici declarațiile de caz vor fi o operațiune de canal. De obicei, fiecare declarație de caz va fi citită încercare de pe canal. Când oricare dintre cazuri este gata (canalul este citit), atunci instrucțiunea asociată cu acel caz este executată. Dacă sunt pregătite mai multe cazuri, va alege unul aleatoriu. Puteți avea un caz implicit care este executat dacă niciunul dintre cazuri nu este pregătit.

Să vedem codul de mai jos

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

Executarea programului de mai sus va da rezultatul:

from data2()

Aici declarația select așteaptă ca datele să fie disponibile pe oricare dintre canale. Data2() adaugă date la canal după un somn de 2 secunde, ceea ce va determina executarea celui de-al doilea caz.

Adăugați un caz implicit la selectare în același program și vedeți rezultatul. Aici, la atingerea blocului select, dacă niciun caz nu are date pregătite pe canal, acesta va executa blocul implicit fără a aștepta ca datele să fie disponibile pe orice canal.

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

Acest program va da rezultatul:

Default case executed			

Acest lucru se datorează faptului că, atunci când a ajuns blocul de selectare, niciun canal nu avea date de citit. Deci, cazul implicit este executat.

mutex

Mutex este forma scurtă pentru excluderea reciprocă. Mutex este folosit atunci când nu doriți să permiteți accesarea unei resurse de mai multe subrutine în același timp. Mutex are 2 metode – Blocare și deblocare. Mutex este conținut în pachetul de sincronizare. Deci, trebuie să importați pachetul de sincronizare. Instrucțiunile care trebuie să fie executate reciproc exclusiv pot fi plasate în interiorul mutex.Lock() și mutex.Unlock().

Să învățăm mutex cu un exemplu care numără de câte ori este executată o buclă. În acest program ne așteptăm ca rutina să ruleze bucla de 10 ori și numărul este stocat în sumă. Apelați această rutină de 3 ori, astfel încât numărul total ar trebui să fie 30. Numărul este stocat într-un număr global de variabile.

În primul rând, rulați programul fără 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)
}

Vezi rezultatul

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

Rezultatul poate fi diferit atunci când îl executați, dar rezultatul final nu va fi 30.

Aici ceea ce se întâmplă este că 3 goroutine încearcă să mărească numărul de bucle stocat în numărul de variabile. Să presupunem că la un moment dat numărul este 5 și goroutine1 va crește numărul la 6. Pașii principali includ

Număr de copii la temp

Creșteți temperatura

Stocați temperatura înapoi pentru a număra

Să presupunem că la scurt timp după efectuarea pasului 3 de către goroutine1; o altă goroutină ar putea avea o valoare veche, să spunem că 3 face pașii de mai sus și stochează 4 înapoi, ceea ce este greșit. Acest lucru poate fi prevenit prin utilizarea mutex care face ca alte rutine să aștepte atunci când o rutină folosește deja variabila.

Acum veți rula programul cu mutex. Aici cei 3 pași menționați mai sus sunt executați într-un 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)
}

Acum ieșirea va fi

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

Aici obținem rezultatul așteptat ca rezultat final. Deoarece instrucțiunile de citire, creștere și rescriere a numărului sunt executate într-un mutex.

Eroare de manipulare

Erorile sunt condiții anormale, cum ar fi închiderea unui fișier care nu este deschis, deschiderea unui fișier care nu există, etc. Funcțiile returnează de obicei erori ca ultima valoare returnată.

Exemplul de mai jos explică mai multe despre eroare.

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

Ieșirea va fi:

open /invalid.txt: no such file or directory

Aici am încercat să deschidem un fișier inexistent și a returnat eroarea variabilei. Dacă fișierul este valid, atunci eroarea va fi nulă

Erori personalizate

Folosind această funcție, puteți crea erori personalizate. Acest lucru se face prin utilizarea New() a pachetului de erori. Vom rescrie programul de mai sus pentru a folosi erorile personalizate.

Rulați programul de mai jos

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

Ieșirea va fi:

Custom error message:File name is wrong

Aici area() returnează aria unui pătrat. Dacă intrarea este mai mică de 1, atunci area() returnează un mesaj de eroare.

Citirea fișierelor

Fișierele sunt folosite pentru stocarea datelor. Go ne permite să citim date din fișiere

Mai întâi creați un fișier, data.txt, în directorul dvs. actual cu conținutul de mai jos.

Line one
Line two
Line three

Acum rulați programul de mai jos pentru a vedea că imprimă conținutul întregului fișier ca rezultat

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

Aici datele, err := ioutil.ReadFile(“data.txt”) citește datele și returnează o secvență de octeți. În timpul imprimării, acesta este convertit în format șir.

Scrierea fișierelor

Veți vedea asta cu un program

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

Aici este creat un fișier, test.txt. Dacă fișierul există deja, atunci conținutul fișierului este trunchiat. Writeline() este folosit pentru a scrie conținutul fișierului. După aceea, ați închis fișierul folosind Close().

Cheat Sheet

În acest tutorial Go, am acoperit,

Subiect	Descriere	Sintaxă
Tipuri de bază	Numeric, șir, bool
Variabile	Declarați și atribuiți valori variabilelor	var tipul nume_variabilă var nume_variabilă tip = valoare var nume_variabilă1, nume_variabilă2 = valoare1, valoare2 nume_variabilă := valoare
constante	Variabile a căror valoare nu poate fi modificată odată ce au fost atribuite	const variabilă = valoare
Pentru Loop	Executați instrucțiuni într-o buclă.	pentru initialisation_expression; expresie_evaluare; expresie_iterație{ // una sau mai multe declarații }
Dacă altceva	Este o declarație condiționată	dacă condiția{ // declarații_1 } else { // declarații_2 }
comuta	Declarație condiționată cu mai multe cazuri	schimba expresia { valoarea cazului_1: declarații_1 valoarea cazului_2: declarații_2 case value_n: declarații_n implicit: statements_default }
Mulțime	Secvență de nume de dimensiune fixă ​​a elementelor de același tip	arrayname := [dimensiune] tip {value_0,value_1,…,value_size-1}
Felie	Porțiune sau segment dintr-o matrice	var slice_name [] type = array_name[start:end]
funcţii	Bloc de declarații care îndeplinește o anumită sarcină	func function_name(parameter_1 type, parameter_n type) return_type { //instrucțiuni }
Pachete	Sunt folosite pentru a organiza codul. Mărește lizibilitatea și reutilizarea codului	import package_nam
Amâna	Amână execuția unei funcții până când funcția care o conține termină execuția	defer function_name(lista_parametri)
Pointeri	Stochează adresa de memorie a unei alte variabile.	var nume_variabilă *tip
Structure	Tip de date definit de utilizator, care conține încă un element de același tip sau diferit	tip structname struct { variabilă_1 variabilă_1_tip variabilă_2 variabilă_2_tip variabilă_n variabilă_n_tip }
Aplicate	O metodă este o funcție cu un argument receptor	func (variabilă tip variabilă) methodName(lista_parametri) { }
Goroutine	O funcție care poate rula concomitent cu alte funcții.	mergeți numele_funcției(lista_parametrilor)
Canal	Modul prin care funcțiile pot comunica între ele. Un mediu pe care o rutină plasează date și este accesată de o altă rutină.	Declara: ch := make(chan int) Trimiteți date către canal: variabilă_canal <- nume_variabilă Primiți de pe canal: nume_variabilă := <- variabilă_canal
Selectați	Declarație Switch care funcționează pe canale. Declarațiile de caz vor fi o operațiune de canal. Când oricare dintre canale este gata cu date, atunci instrucțiunea asociată cu acel caz este executată	Selectați { caz x := <-chan1: fmt.Println(x) cazul y := <-chan2: fmt.Println(y) }
mutex	Mutex este folosit atunci când nu doriți să permiteți accesarea unei resurse de mai multe subrutine în același timp. Mutex are 2 metode – Blocare și deblocare	mutex.Lock() //instrucțiuni mutex.Unlock().
Citiți fișiere	Citește datele și returnează o secvență de octeți.	Date, err := ioutil.ReadFile(nume fișier)
Scrieți fișierul	Scrie date într-un fișier	l, err := f.WriteString(text_to_write)