Parathënie

Kontakti me autorin: tahir.hoxha@gmail.com
Linkedin: https://www.linkedin.com/in/tahirhoxha/

Ky libër shërben si material ndihmës gjatë mbajtjes së kursit të Go në AUK/TDI. Përmbajtja ndryshon në vazhdimësi sepse shtohen materiale të reja në mënyrë periodike.

Hyrje

Gjuha programore Go është gjuhë programore e re e krijuar nga Google, së pari e prezantuar në vitin 2009. Autorë të Go janë Robert Griesemer, Rob Pike dhe Ken Thompson.

Go është gjuhë programore me dedikim të përgjithshëm që karakterizohet me një sintaksë të pastër dhe të thjeshtë. Është i disponueshëm në sisteme operative të ndryshme, posedon dokumentacion të shkëlqyeshëm dhe komunitet në rritje e sipër.

Go adopton koncepte të ndryshme nga gjuhët e tjera programore, gjithnjë duke i ikur kompleksitetit të panevojshëm dhe krijimit të një kodi sa më efiçent dhe të menaxhueshëm. Implementon një koncept të veçantë të OOP (object oriented programming) dhe ofron menaxhim automatik të memorjes (garbage collection).

Duke qenë më i thjeshtë se shumica e gjuhëve të tjera, është lehtë i kuptueshëm nga ana e programuesve që njohin ndonjë gjuhë tjetër programore. Përdoret për programim procedural, ka karakteristika të programimit funksional, por siç u cek më sipër - edhe një variant të thjeshtuar të programimit të bazuar në objekte.

Go po tregohet i shkëlqyeshëm në veçanti në ndërtimin e Web aplikacioneve dhe mikroserviseve, ku karakterizohet me ekzekutim të shpejtë dhe procesim të një numri të madh të HTTP kërkesave (HTTP requests) dhe HTTP përgjigjeve (HTTP responses). Megjithatë, Go nuk është i kufizuar në aplikacione të këtij lloji - ai gjithsesi mund të tregohet shumë i mirë edhe me grafikë, mësim makinerik (machine learning), aplikacione mobile, etj.

Karakteristikë tjetër e Go është se ai është open source, kështu që të gjitha mjetet e nevojshme për punë u janë në dispozicion gjithkujt dhe janë pa pagesë.

Go si gjuhë e re progamore është krijuar në radhë të parë për të qenë gjuhë e thjeshtë edhe efiçente për ndërtimin e back-end sistemeve. Go në veçanti ka fituar popullaritet si gjuhë për shkrimin e Web aplikacioneve dhe mikroserviseve.

Go një set të begatshëm dhe gjithpërfshirës të librarive standarde.

Në sintaksë është i ngjashëm me C, por ka veti unike të cilat nuk i hasim në gjuhët e tjera. Ndonëse konsiderohet si trashëgimtar i C, Go në fakt trashëgon edhe karakteristika nga gjuhë të ndryshme programore. Është i ngjashëm me C për sa i përket strukturave kontrolluese (control-flow statements), tipeve bazike të të dhënave (basic data types), sintaksën e shprehjeve (expression syntax), etj.

Ndër objektivat primare të Go është që për nga performanca të jetë i krahasueshëm me C, gjë që nuk është arritur në tërësi. Megjithatë, Go tregon performancë superiore në krahasim me gjuhët e interpretuara, në veçanti kur kemi të bëjmë me ekzekutimin konkurrent të kodit nëpërmes goroutines, me anë të të cilave mundësohet procesimi i një numri të madh të kërkesave njëkohësisht. Kjo në veçanti është e rëndësishme për Web aplikacionet, të cilat duhet t’iu nënshtrohen kërkesave të shumëfishta në të njëjtën kohë.

Tri qëllime kryesore të dizajnuesve të Go kanë qenë:

• Tipizimi statik (static type) dhe efiçenca gjatë kohës së ekzekutimit (run-time effeciency)
• Lexueshmëria dhe përdorshmëria
• Performanca e lartë në operacionet rrjetor dhe multiprocesim

Është gjuhë statically typed, veti kjo që e diferencon nga gjuhët me tipe dinamike siç janë PHP, Python, Ruby, etj. Te gjuhët programore statically typed, variablat deklarohen në mënyrë eksplicite përfshirë këtu edhe tipin e variablit (nëse është numër i plotë, numër me presje dhjetore, tekst, etj). Këtij grupimi të gjuhëve programore i përkasin edhe gjuhët: Java, C, C#, C++, Scala, etj.

Programi në Go duhet të kompajlohet para se të ekzekutohet. Kjo nënkupton që kodi shkruhet në një tekst editor, më pas thirret kompajleri i cili nga kodi burimor (source code), e krijon kodin ekzekutues në gjuhën makinerike. Kjo procedurë duhet të ndiqet pas çdo ndryshimi në kodin burimor.

Ekzektimi i programit të shkruar në Go është shumë më i shpejtë se i atyre të shkruara në gjuhët e interpretuara siç janë PHP apo Python dhe për shkak se është statically typed, shumë më rrallë mund të paraqiten gabime gjatë ekzekutimit, sepse shumë prej gabimeve mund të detektohen gjatë fazës së kompajlimit, pra para ekzekutimit.

Go mundëson gjenerimin e kodit ekzekutues për sisteme operative të ndryshme: Windows, Linux apo macOS, pa marrë parasysh në cilin sistem operativ jeni duke e shkruar kodin burimor. Pa marrë parasysh sa fajlla me kod burimor keni krijuar, gjatë procesit të kompajlimit në Go do të krijohet një fajll me kod ekzekutues.

Kompanitë që e përdorin gjuhën programore Go në projektet e tyre:

https://github.com/golang/go/wiki/GoUsers

Instalimi

Go mund të instalohet nga adresa:

https://golang.org/dl/

ku e zgjedhni platformën e dëshiruar: Microsoft Windows, Apple macOS apo Linux. Rekomandohet të zgjedhet versioni i fundit, që në momentin e shkrimit është 1.12.1.

Për distribuimin binar të instaluesit për Windows 64 bitësh zgjedhet go1.12.1.windows-amd64.msi, ndërsa për versionin 32 bitësh zgjedhet go1.12.1.windows-386.msi.

Në mënyrë standarde, Go instalohet në folderin C:Go .

Për të kaluar në një version më të ri, shkarkohet instaluesi i versionit të ri dhe gjatë ekzekutimit ai automatikisht do ta largojë versionin ekzistues nga sistemi për ta instaluar versionin e ri, pa i prekur projektet ekzistuese. I njëjti instalues mund të përdoret edhe për deinstalimin e Go nga sistemi.

Pas instalimit, kujdesemi që variabli i ambientit GOPATH të tregojë lokacionin e dëshiruar për projektet tona. Në shembullin e më poshtëm është zgjedhur folderi go brenda folderit të përcaktuar me variablin %USERPROFILE%, që në shumicën e rasteve nënkupton C:UsersPerdoruesi , por mund ta zgjedhim cilindo folder, sipas preferencës tonë.

Editorët

Për ta shkruar kodin në Go, mund të përdoret cilido tekst editor. Megjithatë, ekzistojnë programe të cilat janë të specializuar për lehtësimin e programimit në këtë gjuhë, siç janë:

• GoLand nga JetBrains. Komercial.
• Visual Studio Code. Pa pagesë.
• Atom. Pa pagesë.

Në Visual Studio Code duhet të instalohet plugin-i për Go duke shkuar në File - Extensions - Go.

Për testimin e programeve të thjeshta, mund të përdoret Go Playground.

https://play.golang.org/

Hello World në Go

1 package main
2 import "fmt"
3 
4 func main() {
5    fmt.Println("Përshëndetje")
6 }

https://play.golang.org/p/vc4MvaHUPo2

Funksioni main() është pika hyrëse (entry point) e programit, respektivisht nga këtu fillon ekzekutimi i kodit, prej nga pastaj mund të thirren funksionet e tjera, me çka vazhdon rrjedha e ekzekutimit të programit.

Udhëzime

Nëse jeni të detyruar ta kopjoni kodin nga libri, dhe me atë rast ju dalin edhe numrat rendorë të rreshtave programorë, rreshtat mund t’i largoni automatikisht duke e kopjuar kodin dhe bartur në faqen:

http://remove-line-numbers.ruurtjan.com/

Variablat e ambientit

$GOROOT

$GOROOT_FINAL

$GOOS and $GOARCH

Sistemet operative dhe arkitekturat e kompajlimit.

$GOOS - $GOARCH kombinimet

• android / arm
• darwin / 386
• darwin / amd64
• darwin / arm
• darwin / arm64
• dragonfly / amd64
• freebsd / 386
• freebsd / amd64
• freebsd / arm
• linux / 386
• linux / amd64
• linux / arm
• linux / arm64
• linux / ppc64
• linux / ppc64le
• linux / mips
• linux / mipsle
• linux / mips64
• linux / mips64le
• linux / s390x
• netbsd / 386
• netbsd / amd64
• netbsd / arm
• openbsd / 386
• openbsd / amd64
• openbsd / arm
• plan9 / 386
• plan9 / amd64
• solaris / amd64
• windows / 386
• windows / amd64

$GOHOSTOS / $GOHOSTARCH

$GOBIN

Rregullat e përgjithshme

Sintaksa e Go kërkon përdorimin e pikëpresjes (semicolons ;) si statement terminator. Mirëpo vendosja e pikëpresjes nuk është e domosdoshme sepse këtë e bën kompajleri në mënyrë automatike në fund të rreshtave programorë.

Vendosja manuale e pikëpresjes është e domosdoshme kur dëshirojmë t’i vendosim disa statements në një rresht programor. Po ashtu edhe kur kemi të bëjmë me ciklet for, me atë ai rresht të përfundojë me {, shenjë që përdoret për hapjen e bllokut të ciklit. Në të kundërtën, kompajleri do të vendosë automatikisht pikëpresje në fund të inkrementit (i++), me çka vie deri te gabimi gjatë kompajlimit.

1 	for i := 0; i < 5; i++ {
2 		fmt.Println(i)
3 	}

https://play.golang.org/p/4sgL67gpCBh

Gabim:

1 	for i := 0; i < 5; i++ 
2 	{
3 		fmt.Println(i)
4 	}

Në këtë rast, lajmërohet gabimi: “syntax error: unexpected newline, expecting { after for clause”.

Në përgjithësi, kllapa hapëse e bllokut duhet të vendoset në fund të rreshtit dhe jo në rresht të ri. Nëse kllapat hapëse i kemi vendosur në rresht të ri, në editor mund ta bëjmë ri-formatimin e kodit për të qenë konform me rregullat e Go. Në GoLand kjo bëhet me Code - Reformat Code.

Emërtimet e fajllave dhe identifikatorëve

Programet përbëhen nga:

• Fjalët kyçe (keywords),
• Konstantat (constants),
• Variablat (variables),
• Operatorët (operators),
• Tipet (types), dhe
• Funksionet (functions).

Go i përket gjuhëve programore case-sensitive, pra është ka rëndësi nëse shkronjat janë të mëdha (uppercase) apo të vogla (lowercase).

Emërtimet e variablave fillojnë patjetër me shkronjë, ku si shkronjë konsiderohet cilido Unicode UTF-8 karakter. Në vazhdim të shkronjës së parë mund të përdorim shkronja të tjera apo numra.

Shenja _ e shënuar si e vetme ka kuptim të veçantë dhe quhet blank identifier. Përdoret në rastet kur ndonjë nga vlerat kthyese të funksionit nuk dëshirojmë t’i ruajmë si vlerë në ndonjë variabël, respektivisht kur dëshirojmë ta injorojmë një vlerë kthyese të funksionit.

Ka raste kur variablat, tipet dhe funksionet nuk kanë nevojë fare të kenë emra dhe këto quhen anonime (anonymous).

Në vijim janë të shënuara 25 fjalët kyçe (keywords) të Go:

• break
• case
• chan
• const
• continue
• default
• defer
• else
• fallthrough
• for
• func
• go
• goto
• if
• import
• interface
• map
• package
• range
• return
• select
• struct
• switch
• type
• var

Një fjalë kyçe nuk mund të përdoret si identifikator.

Përveç fjalëve kyçe, Go ka dhe 36 identifikatorë të paradefinuar, të cilët paraqesin emrat tipeve elementare dhe të funksioneve interne (built-in).

• append
• bool
• byte
• cap
• close
• complex
• complex64
• complex128
• uint16
• copy
• false
• float32
• float64
• imag
• int
• int8
• int16
• uint32
• int32
• int64
• iota
• len
• make
• new
• nil
• panic
• uint64
• print
• println
• real
• recover
• string
• true
• uint
• uint8
• uintptr

Delimiterët

Në Go përdoren delimiterët vijues:

• Kllapat (parentheses) ( ),
• Kllapat e mesme (brackets) [ ]
• Kllapat e mëdha (braces) { }.

Shenjat e pikësimit Si shenja të pikësimit përdoren:

• .
• ,
• ;
• …

Strukturimi i kodit

Kodi strukturohet në formë të formulimeve (statements). Formulimet nuk është e domosdoshme të përfundojnë me pikëpresje (;) si në disa gjuhë të tjera, sepse kompajeli i Go e bën futjen automatike të pikëpresjes në fund të çdo formulimi. Në rastet kur i vendosim disa formulime në të njëjtin rresht, atëherë formulimet patjetër duhet të ndahen me pikëpresje.

Struktura bazike dhe komponentet e një Go programi

1 package main
2 
3 import (
4 	"fmt"
5 )
6 
7 func main() {
8 	fmt.Println("Hello, playground")
9 }

Struktura e përgjithshme e një programi në Go

• Bëhet importimi i pakove
• Pas importimit, deklarohen konstantat, variablat dhe tipet
• Pastaj vie funksioni init() nëse është i nevojshëm dhe ky është një funksion special që e përmban çdo pako dhe që ekzekutohet i pari.
• Më pas vie funksioni main() dhe atë vetëm në kuadër të pakos main.
• Pastaj renditen të gjitha funksionet tjera. Metodat ndaj tipeve në fillim ose funksionet me atë renditje si thirren brenda funksionit main(), ose metodat dhe funksionet të renditura sipas alfabetit nëse numri i funksioneve është i madh.

Pakot

Me anë të pakove bëhet strukturimi i kodit. Programi ndërtohet si pako që mund t’i pakot tjetra për funksione të caktuara.

Çdo Go fajll i përket një pakoje, analogjikisht me bibliotekat apo namespace në gjuhët tjera.
Shumë Go fajlla të ndryshëm mund t’i përkasin një pakoje.

Emri i pakos shënohet të rreshtin e parë të programit, për shembull: package main.

Fajlli i pavarur ekzekutabil i përket pakos main. Çdo Go aplikacion përmban një pako të quajtu main.

Një aplikacion mund të përbëhet nga pako të ndryshme, por edhe në rastet kur përdoret pakoja main, nuk është e domosdoshme që i tërë kodi të vendoset brenda një fajlli të madh. Mund të krijohen disa fajlla të vegjël, ku secili duhet ta ketë package main në rreshtin e parë.

Variablat

Deklarimi dhe inicializimi i variablave

Variabli deklarohet me var, pas të cilit shënohet emri i variablit e pas emrit shënohet tipi i variablit.

var x int

Në këtë rast është deklaruar variabli x i tipit integer, pra numër i plotë.

Shohim se ka dallim prej gjuhëve të tjera siç është për shembull Java, ku njëherë ceket tipi e pastaj emri i variablit.

Variabli nuk mund të deklarohet me var pa e cekur tipin.

Variabli nuk është inicializuar, pra nuk i është dhënë një vlerë fillestare. Megjithatë, në Go, çdo tip i të dhënave kanë vlera iniciale standarde edhe kur nuk janë të inicializuara në mënyrë eksplicite, që për integer është 0.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x int
 9 	fmt.Println(x)
10 }

https://play.golang.org/p/EoS6ka-viIh

Rezultati:

1 0

Deklarimi dhe inicializimi i variablit mund të bëhet në një rresht:

var x int = 5

Në këtë rast, është deklaruar variabli x, i tipit integer, me vlerë 5.

Variabli mund të deklarohet në një rresht, e të inicializohet në një rresht tjetër më poshtë përgjatë rrjedhës së ekzekutimit të programit:

1 var x int
2 int = 5

Tipe int ka disa: int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64. Nuk mund të kryhen operacione ndërmjet tipeve të ndryshme, për shembull të kryhet operacioni i mbledhjes ndërmjet numrit të tipit int8 dhe një numri tjetër të tipit int16.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x int = 5
 9 	var y int8 = 9
10 
11 	fmt.Println(x + y)
12 }

https://play.golang.org/p/1SqAca5tPkC

Rezultati:

1 invalid operation: x + y (mismatched types int and int8)

Për ta mundësuar operacionin e mbledhjes në shembullin e mësipërm, duhet ta konvertojmë vlerën int8 në int, ashtu që të dy numrat t’i përkasin tipit të njëjtë. Kjo bëhet me funksionin int().

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x int = 5
 9 	var y int8 = 9
10 
11 	fmt.Println(x + int(y))
12 }

https://play.golang.org/p/TzThfTDL0YN

Rezultati:

1 14

Pra, Go jo vetëm që nuk lejon operacione ndërmjet tipeve të ndryshme (float dhe int), por nuk lejon as ndërmjet nëntipeve të tipit të njëjtë (int8, int16,…).

Ekziston edhe një formë e shkurtër e deklarimit dhe inicializimit të një variabli:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	x := 5
 9 	y := 9
10 
11 	fmt.Println(x + int(y))
12 }

https://play.golang.org/p/QzuRvnaXmfx

Rezultati:

1 14

Go do ta determinojë tipin e variablit në bazë të tipit të vlerës (type inference). Për shkak se 5 është tip int, edhe variabli x do të jetë i po atij tipi.

Kjo formë e deklarimit dhe inicializimit është e lejuar vetëm brenda funksioneve.

Me këtë sintaksë, Go do ta deklarojë variablin gjithmonë si int, nëse numri është i plotë dhe vlera e numrit është brenda intervalit: -2.147.483.648 deri 2.147.483.647, në platformat 32 bitëshe. Në platformat 64 bitëshe vlera duhet të jetë ndërmjet -9.223.372.036.854.775.808 dhe 9.223.372.036.854.775.807.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	x := 2147483647
 9 	fmt.Printf("%T", x)
10 }

https://play.golang.org/p/_UU6nZazVIF

Rezultati:

1 int

Me fmt.Printf("%T", x) kërkojmë të na tregohet tipi i vlerës së variablit x.

Nëse vlera e numrit është jashtë intervalit të cekur, në varësi të platformës (32 bit apo 64 bit), Go do ta shfaqë gabimin

constant 2147483648 overflows int

gjatë kompajlimit. Në vend të vlerës 2147483648 do të jetë cilado vlerë e shënuar si vlerë e variablit e që është jashtë intervalit të lejuar.

Pas deklarimit, variabli mund të marrë çfarëdo vlere të tipit përkatës dhe intervalit të lejuar të vlerave.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x := 5
 7 	x = 9
 8 
 9 	fmt.Println(x)
10 }

https://play.golang.org/p/MfgOksB1dHW

Rezultati:

1 9

Në Go është i lejuar deklarimi i disa variablave në rreshtin e njëjtë. Nëse është bërë inicializimi në të njëjtin rresht, mund të mos e shënojmë tipin sepse Go ia jep variablës tipin sipas vlerës (type inference).

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	var x, y int
 7 	x, y = 1, 3
 8 
 9 	var a, b, c = 5.0, 8.5, 3.8
10 	// Njëjtë sikur
11 	// var a, b, c float32 = 5.0, 8.5, 3.8
12 
13 	fmt.Println("x=", x, "y=", y, "a=", a, "b=", b, "c=", c)
14 }

https://play.golang.org/p/hc0WAre2L-E

Rezultati

1 x= 1 y= 3 a= 5 b= 8.5 c= 3.8

Variablat mund të deklarohen dhe inicializohen edhe në grupe, të paraprira me var, ndërsa brenda kllapave vendosen rreshtat me deklarime/inicializime.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	var (
 7 		a = 5
 8 		b = 3.2
 9 		c = 8
10 	)
11 	fmt.Println("a=", a, "b=", b, "c=", c)
12 }

https://play.golang.org/p/1eWPvTFQizm

Rezultati:

1 a= 5 b= 3.2 c= 8

Rideklarimi i variablave

Variabli nuk mund të deklarohet më shumë se njëherë brenda një blloku.

1 package main
2 
3 import "fmt"
4 
5 func main() {
6 	x := 5
7 	x := 9
8 	fmt.Println(x)
9 }

https://play.golang.org/p/E2jTAsCTBX-

Gjatë kompajlimit të këtij programi, lajmërohet gabimi:

no new variables on left side of :=

me çka na bën me dije se tashmë ekziston një variabël x i deklaruar dhe se nuk mund ta deklarojmë për së dyti.

Rideklarimi nuk mund të bëhet as me var.

1 package main
2 
3 import "fmt"
4 
5 func main() {
6 	var x int = 5
7 	var x int = 9
8 	fmt.Println(x)
9 }

https://play.golang.org/p/hZVXUR7Cw4d

Gjatë kompajlimit, lajmërohet gabimi:

1 ./prog.go:7:6: x redeclared in this block
2 previous declaration at ./prog.go:6:6

që na bën me dije se variabli x nuk mund të rideklarohet në bllokun e njëjtë.

Vizibiliteti

Nëse e zhvendosim deklarimin e parë jashtë bllokut të funksionit, atëherë nuk do të lajmërohet kurrfarë gabimi, sepse në këtë rast kemi 2 variabla x me vizibilitet (visibility, scope) të ndryshëm, i pari në zonën globale prej nga e “shohin” të gjitha funksionet, ndërsa i dyti vetëm brenda funsionit main().

 1 package main
 2 
 3 import "fmt"
 4 
 5 var x int = 5
 6 
 7 func main() {
 8 	var x int = 9
 9 	fmt.Println(x)
10 }

https://play.golang.org/p/b9lbFfLQZxg

Rezultati:

1 9

Nëse e fshijmë deklarimin e dytë (var x int = 9), atëherë funksioni main() do ta “shohë” vlerën e x që është deklaruar në rreshtin 5.

1 package main
2 
3 import "fmt"
4 
5 var x int = 5
6 
7 func main() {
8 	fmt.Println(x)
9 }

https://play.golang.org/p/TXzGGOHQIfr

Rezultati:

1 5

Variablat e deklaruara / rideklaruara brenda një blloku, nuk mund të “shihen” në blloqet që janë të nivelit më të lartë.

 1 package main
 2 
 3 import "fmt"
 4 
 5 var x int = 1
 6 
 7 func main() {
 8 	fmt.Println(x)
 9 	var x int = 2
10 	{
11 		var x int = 3
12 		fmt.Println(x)
13 	}
14 	fmt.Println(x)
15 }

https://play.golang.org/p/xzKC7ACUONj

Rezultati:

1 1
2 3
3 2

Në rreshtin 5 është bërë deklarimi i variablit x në nivel “global”, respektivisht brenda package main.
Nga rreshti 7 deri në rreshtin 15 është blloku i funksionit main(), brenda të cilit është rideklaruar variabli x.
Nga rreshti 10 deri në rreshtin 13 është një bllok në vete, brenda të cilit është rideklaruar variabli x. Ky bllok në rastin konkret nuk bën asgjë të veçantë, përveç që e ndërron vizibilitetin e variablave brenda saj.

Kur kemi blloqe të strukturave, siç është për shembull struktura for, variablat e deklaruara brenda atyre blloqeve, nuk do të shihen jashtë bllokut. Gjithçka që deklarohet brenda bllokut, ngelet brenda bllokut dhe vlerat e variablave të tillë nuk mund të lexohen pas mbylljes së bllokut.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	for i:= 1; i < 3; i++{
 7 		var x int = 3
 8 		fmt.Println(x)
 9 	}
10 	
11 	fmt.Println(x)
12 }

https://play.golang.org/p/_rjZMM8lJmx

Rezultati:

1 ./prog.go:11:14: undefined: x

Për rreshtin 11, variabli x asnjëherë nuk është deklaruar, sepse deklarimi ka ndodhur brenda bllokut të strukturës for.

E njëjta ndodh edhe me vetë inkrementin e strukturës for; variabli i nuk do të jetë i aksesueshëm jashtë bllokut.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	for i := 1; i < 3; i++ {
 7 		fmt.Println(i)
 8 	}
 9 
10 	fmt.Println(i)
11 }

https://play.golang.org/p/f8ngsHoWbpl

Rezultati:

1 ./prog.go:10:14: undefined: i

Ky gabim nuk do të lajmërohet nëse variablin i do ta kishim tashmë të deklaruar para bllokut të strukturës for.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	var i int = 8
 7 	for i := 1; i < 3; i++ {
 8 		fmt.Println(i)
 9 	}
10 
11 	fmt.Println(i)
12 }

https://play.golang.org/p/QSLdTzlW2h8

Rezultati:

1 1
2 2
3 8

Pra, Println në rreshtin 11 na e tregon vlerën e variablit i të deklaruar në rreshtin 6, ndërsa Println në rreshtin 8 tregon vlerat e variablit i që është iterator i ciklit të hapur në rreshtin 7.

Thënë ndryshe, variabli i në rreshtin 8 nuk është i njëjti variabël me atë në rreshtin 11, edhe pse kanë emër të njëjtë!

Nëse e ndryshojmë rreshtin 7 dhe në vend të:

for i := 1; i < 3; i++ {

shkruajmë:

for i = 1; i < 3; i++ {

atëherë rezultati do të ndryshojë, sepse variabli i i ciklit do të jetë tashmë i inicializuar dhe i padeklaruar për së dyti. Prandaj, Println(i) i rreshtit 11 do ta tregojë vlerën 3 (vlera e fundit e iteratorit), dhe jo 8.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	var i int = 8
 7 	for i = 1; i < 3; i++ {
 8 		fmt.Println(i)
 9 	}
10 
11 	fmt.Println(i)
12 }

https://play.golang.org/p/rgo1hvJDkBb

Rezultati:

1 1
2 2
3 3

Deklarimi i përsëritur brenda ciklit nuk konsiderohet rideklarim.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	for i := 1; i <= 5; i++ {
 9 		x := 5
10 		y := x + i
11 		fmt.Println(y)
12 	}
13 }

https://play.golang.org/p/YfjQ_0hrnWX

Rezultati:

1 6
2 7
3 8
4 9
5 10

Konvencionet mbi emërtimin e variablave

Konvertimet ndërmjet tipeve

Konstantat

Konstantat në Go emërtohen njëjtë sikurse edhe variablat, pra nuk bëhet si p.sh. në PHP ku për emërtimet e konstantave përdoret vetëm shkronjat kapitale dhe nënvizimi (sikurse që është FILTER_SANITIZE_STRING).

Duhet marrë parasysh se të gjitha variablat dhe konstantat që fillojnë me shkronjë kapitale, në Go e kanë kuptimin se ato variabla/konstanta do të eksportohen, ndërsa nëse janë me të vogla - do të jenë variabla/konstanta lokale në raport me pakon.

Kontantat deklarohen me fjalën const.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	// numriPi nuk eksportohet
 9 	const numriPi float64 = 3.141592653589793
10 	fmt.Println(numriPi)
11 	
12 	// NumriPi eksportohet
13 	const NumriPi float64 = 3.141592653589793
14 	fmt.Println(NumriPi)
15 }

https://play.golang.org/p/VK3ar1gF60i

Rezultati:

1 3.141592653589793
2 3.141592653589793

Programi vijues nuk do të kompajlohet, për shkak se në rreshtin 11 përpiqemi t’ia ndryshojmë vlerën konstantës, me ç’rast lajmërohet gabimi cannot assign to numriPi.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const numriPi float64 = 3.141592653589793
 9 	fmt.Println(numriPi)
10 
11 	numriPi = 3.14
12 	fmt.Println(numriPi)
13 }

https://play.golang.org/p/oUNUv_8-Sbr

Rezultati:

1 ./prog.go:11:10: cannot assign to numriPi

Karakteristikë e konstantave është se caktimi i vlerave të tyre duhet të jetë i verifikueshëm qysh në fazën e kompajlimit. Kjo do të thotë se konstantës nuk mundemi t’i japim vlerë që kthehet nga një funksion gjatë ekzekutimit të programit (runtime).

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"math"
 6 )
 7 
 8 func main() {
 9 	const n = math.Sqrt(9)
10 	fmt.Println(n)
11 }

https://play.golang.org/p/tvBSOxAdml4

Rezultati:

1 ./prog.go:9:8: const initializer math.Sqrt(9) is not a constant

Edhe pse e dijmë që vlera do të ishte 3, konstanta n nuk e merr atë vlerë dhe lajmërohet gabimi const initializer math.Sqrt(9) is not a constant, sepse ajo vlerë është rezultat kthyes i një funksioni gjatë ekzekutimit të programit dhe kompajleri nuk mund ta “dijë” paraprakisht atë vlerë.

Po ashtu, nuk lejohen as shprehjet, rezultati i të cilave mund të dihet vetëm gjatë kohës së ekzekutimit, siç është rasti me krahasimin e vlerave të dy variablave si në shembullin vijues:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var a, b = 5, 7
 9 	const n = a < b
10 	fmt.Println(n)
11 }

https://play.golang.org/p/WdCrkF70PIB

Rezultati:

1 ./prog.go:9:8: const initializer a < b is not a constant

Konstantave mund t’iu caktohen vetëm vlera primitive:

• int
• float
• boolean
• string

Nuk mund të përdoren tipet më komplekse siç janë:

• vargjet
• segmentet
• struktet
• mapat

sepse këto për nga natyra janë variabile.

E përbashkëta e variablave dhe konstantave është se me të dyja mund të zbatohet “shadowing”, që do të thotë ridefinimi i një vlere të re të variablit/konstantës brenda një blloku që është brenda një blloku tjetër ku tashmë është deklaruar po ai variabël apo konstantë. Blloku që është me hiearki më të ultë mund të bëjë “shadow” (t’i zëvendësojë vlerat) një variable/konstante tashmë të definuar në bllokun me hierarki më të lartë.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 const n = 7
 8 
 9 func main() {
10 	const n = 5
11 	fmt.Println(n)
12 }

https://play.golang.org/p/bv_obpquhTf

Rezultati:

1 5

E shohim që deklarimi i konstantës në rreshtin 10, “e mbulon” vlerën e konstantës së njëjtë të deklaruar në rreshtin 7. Kjo ndodh për shkak se blloku ku gjendet const n=7 me hierarki është më “sipër” prej bllokut ku gjendet const n = 5. Me fjalë të tjera, blloku i brendshëm ka prioritet më të lartë.

Megjithëse i mundur, ndryshimi i vlerës së konstantës në bllokun e brendshëm mund të jetë burim potencial i ndonjë “bug” , nëse rastësisht në ato dy blloqe kemi deklaruar dy konstanta me emër të njëjtë por me dedikime të ndryshme.

Për më tepër, “shadowing”, përveç vlerës lejon edhe ndryshimin e tipit të konstantës! Kjo potencialisht mund të shkaktojë probleme gjatë kompajlimit ose ekzekutimit të programit.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 const n int = 7
 8 
 9 func main() {
10 	const n string = "test"
11 	fmt.Println(n)
12 }

https://play.golang.org/p/W_HO2UUq-TF

Rezultati:

1 test

Vërejmë se konstanta n, në rreshtin 7 është integer, ndërsa në rreshtin 10 është string.

Lirisht mund të kryejmë operacione ndërmjet variablave dhe konstantave nëse janë të tipit të njëjtë.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"math"
 6 )
 7 
 8 func main() {
 9 	const a float64 = 7
10 	var b float64 = 9
11 
12 	// Teorema e Pitagorës
13 	fmt.Println(math.Sqrt(math.Pow(a, 2) + math.Pow(b, 2)))
14 }

https://play.golang.org/p/2e8cbW5l-UZ

Rezultati:

1 11.40175425099138

Në Go, nuk lejohen operacione ndërmjet dy tipeve të ndryshme, as ndërmjet dy nëntipeve, si për shembull operacioni i mbledhjes ndërmjet int8 dhe int16.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var a int8 = 7
 9 	var b int16 = 12
10 	fmt.Println(a + b)
11 }

https://play.golang.org/p/hx5eKdK0orw

Rezultati:

1 ./prog.go:10:16: invalid operation: a + b (mismatched types int8 and int16)

Gabim i ngjashëm paraqitet edhe kur lejojmë që Go ta konkludojë vetë tipin e një variabli, si në rreshtin 8 të shembullit vijues:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var a = 7
 9 	var b int16 = 12
10 	fmt.Println(a + b)
11 }

Rezultati:

1 ./prog.go:10:16: invalid operation: a + b (mismatched types int and int16)

Dy shembujt e fundit i dhamë me variabla, për të potencuar dallimin me rastin kur përdorim konkludimin e tipit (type inference) të konstantë, me ç’rast Go nuk do të “ankohet” për faktin që janë dy nëntipe të ndryshme dhe vetë do ta bëjë konvertimin e nëntipeve asisoj që të përputhen.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const a = 7
 9 	var b int8 = 12
10 	fmt.Printf("%T, %T\n", a, b)
11 
12 	c := a + b
13 	fmt.Printf("%T, %v\n", c, c)
14 }

https://play.golang.org/p/7cr_-7Exu7d

Rezultati:

1 int, int8
2 int8, 19

Pra, Go e sheh konstantën a si int, ndërsa variablin b si int8. Mirëpo, pas mbledhjes së vlerave të tyre, rezultati (19) është i tipit int8.

Pra, ndërmjet int dhe int8, për rezultat ka zgjedhur tipin int8, i cili ka diapazon më të ngushtë të vlerave. Kjo është në rregull për aq kohë sa vlera e rezultatit gjatë ekzekutimit të programit nuk e tejkalon vlerën 127, sa është vlera maksimale e tipit int8.

Nëse vlera e rezultatit e tejkalon vlerën maksimale të nëntipit të caktuar, ndodh overflow pa kurrfarë lajmërimi mbi tejkalimin e vlerës maksimale, që shpie drejt rezultateve të gabuara.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const a = 12
 9 	var b int8 = 120
10 	fmt.Printf("%T, %T\n", a, b)
11 
12 	c := a + b
13 	fmt.Printf("%T, %v\n", c, c)
14 }

https://play.golang.org/p/tAkX2-YhJln

Rezultati:

1 int, int8
2 int8, -124

Shohim se 120 + 12, në vend të 132 është -124. Kjo për shkak se është bërë një “rotacion” nëpër vlerat e int8 (-128 deri 127).

Enumerated constants

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const (
 9 		x = iota
10 		y = iota
11 		z = iota
12 	)
13 
14 	fmt.Printf("%T, %T, %T\n", x, y, z)
15 	fmt.Printf("%v, %v, %v\n", x, y, z)
16 }

https://play.golang.org/p/Kl5LHx9Uo0o

Rezultati:

1 int, int, int
2 0, 1, 2

Rezultat të njëjtë na jep edhe ky kod:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const (
 9 		x = iota
10 		y
11 		z
12 	)
13 
14 	fmt.Printf("%T, %T, %T\n", x, y, z)
15 	fmt.Printf("%v, %v, %v\n", x, y, z)
16 }

https://play.golang.org/p/aKN4PxzypFD

Kjo për shkak se kompajleri nënkupton se edhe konstantat në vijim marrin vlerën iota.

Vlera iota është vlerë speciale për numërim duke filluar nga 0 dhe është e tipit int. Çdo konstantë vijuese brenda bllokut, merr vlerë për 1 më të madhe se konstanta paraprake.

Vlen vetëm për blloqe konstantash të deklaruara me:

1 const (
2 
3 )

Por nuk vlen nëse konstantat janë deklaruar si vijon:

1 	const x = iota
2 	const y = iota
3 	const z = iota

Me këtë mënyrë te deklarimit, të tre konstantat (x, y dhe z) do të kenë vlerë 0.

Çdo bllok konstantash me vlerë iota, fillon prej zeros:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const (
 9 		x = iota
10 		y
11 		z
12 	)
13 
14 	const (
15 		a = iota
16 		b
17 	)
18 
19 	fmt.Printf("%v, %v, %v\n", x, y, z)
20 	fmt.Printf("%v, %v\n", a, b)
21 }

https://play.golang.org/p/ker4s4okHwW

Rezultati:

1 0, 1, 2
2 0, 1

Listë të tillë konstantash të paradefinuara me vlerë inkrementale mund të përdorim kur dëshirojmë në program të bëjmë krahasime.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const (
 9 		a = iota
10 		b
11 		c
12 	)
13 
14 	x := 2
15 
16 	fmt.Printf("%v\n", x == a)
17 	fmt.Printf("%v\n", x == b)
18 	fmt.Printf("%v\n", x == c)
19 }

https://play.golang.org/p/oYSJVpMUw1l

Rezultati:

1 false
2 false
3 true

Nëse fare s’na interson vlera 0, ndërsa këto konstanta gjithmonë fillojnë nga 0, atëherë vlerën e parë e vendosim në _, që është* write only variable*, pra variabël në të cilin mund të vendosim vlerë, por asaj vlere nuk mund t’i referohemi më pas, pra praktikisht ajo vlerë do të humbet.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const (
 9 		_ = iota
10 		a
11 		b
12 	)
13 
14 	x := 1
15 
16 	fmt.Printf("%v\n", x == a)
17 	fmt.Printf("%v\n", x == b)
18 }

https://play.golang.org/p/dsBbDsodtap

Rezultati:

1 true
2 false

Nëse numërimin dëshirojmë ta fillojmë nga një numër tjetër, atëherë konstantës së parë ia rrisim apo zvogëlojmë vlerën, në varësi prej vlerës së dëshiruar.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	const (
 9 		_ = iota - 4
10 		a
11 		b
12 	)
13 
14 	const (
15 		_ = iota + 4
16 		x
17 		y
18 	)
19 
20 	fmt.Printf("a=%v, b=%v\n", a, b)
21 	fmt.Printf("x=%v, y=%v\n", x, y)
22 }

https://play.golang.org/p/PZ51jnTUzp7

Rezultati:

1 a=-3, b=-2
2 x=5, y=6

Vërejmë se kontanta a fillon nga -3, ndërsa konstanta x nga 5.

Përveç mbledhjes dhe zbritjes, mund të përdorim të gjithë operatorët që janë në dispozicion për vlerat primitive.

Tipet e të dhënave

Janë 4 kategori të veçanta të tipeve të të dhënave në Go:

• Tipet bazike (Basic Types)
• Tipet agregate (Aggregate Types) - vargjejt (arrays) dhe strukturat (structs)
• Tipet referenciale (Reference Types) - Treguesit (pointers) dhe slices
• Tipet interface (Interface Types) - Interfejsat standard
• Tipet bazike të integruara në Go

Go përdor tipet bazike të integruara si vijon:

• Një tip logjik (boolean): bool.
• 11 tipe numerike: int8, uint8, int16, uint16, int32, uint32, int64, uint64, int, uint, dhe uintptr.
• Dy tipe numerike me presje dhjetore: float32 dhe float64.
• Dy tipe numerike komplekse: complex64 dhe complex128.
• Një tip tekstual: string.

Këto tipe mund të përdoren drejtpërsëdrejti në kod, pa pasur nevojë të importohet ndonjë pako.
Tipet numerike përfshijnë numrat e plotë, numrat me presje dhjetore dhe numrat kompleks.

Numrat

Numrat ndahen në dy lloje kryesore:

• Numra të plotë (integers), dhe
• Numra me presje dhjetore (floating-point numbers).

Numrat e plotë

Numrat e plotë janë numra pa komponentën decimale. Të gjithë numrat e plotë kanë madhësi të caktuar kur ruhen apo procesohen në kompjuter.

Për shembull, një bajt (byte) përbëhet nga 8 bita, ku secili bit mund ta ketë vlerën 0 ose 1.
Kështu, në një bajt (8 bit) mund të ruhen 256 (2⁸) vlera të ndryshme pozitive, prej 0 deri 255, respektivisht prej 00000000 deri 11111111 nëse e shprehim numrin në formë binare.

Nëse duhet ta ruajmë një numër pozitiv më të madh se 255, na nevojitet edhe një bajt tjetër, pra gjithsej 2 bajtë (16 bit). Në këtë rast, vlerat do të shkojnë nga 0000000000000000 deri në 1111111111111111, që në numra me bazë 10 do të jetë nga 0 deri në 65.535, pra gjithsej 65.536 vlera (2¹⁶).

Me katër bajtë (32 bit), diapazoni i vlerave pozitive është 0 deri në 4.294.967.295, gjithsej 4.294.967.296 vlera (232), e kështu me radhë, për çdo bajt të shtuar diapazoni i vlerave zgjerohet 256 herë.

Kur duhet të ruhen numrat e plotë negativë, biti i parë i bajtit të parë (most significant bit) shfrytëzohet si indikator: vlera 0 tregon se është vlerë pozitive, ndërsa vlera 1 se është vlerë negative, prandaj diapazoni i vlerave përgjysmohet, ashtu siç është paraqitur në tabelë.

Kur ruajmë vetëm vlera pozitive, kemi të bëjmë me unsigned integers, ndërsa për pozitive dhe negative – signed integers.
Tipet e numrave të plotë, emrat e të cilëve fillojnë me u janë tipe pa parashenjë (unsigned types), të cilat përmbajnë vetëm vlera jonegative.

Numri pas emrit tregon numrin e bitave binarë (8, 16, 32, 64) që nevojiten për ruajtjen e vlerës në memorje. Për shembull uint8 zbërthehet si: numër i plotë jonegativ që okupon 8 bit në memorje, me çka mund të reprezentohen vlerat prej 0 deri 255 (2⁸-1). Ndërsa tipi int8: numër i plotë që okupon 8 bit n memorje dhe merr vlera prej -128 (-2⁷) deri në 127 (2⁷-1).

Vlera jonegative (unsigned)

• Bit: 8, Bajt:1, Prej: 0, Deri: 255 (2⁸-1)
• Bit: 16, Bajt:2, Prej: 0, Deri: 65.535 (2¹⁶-1)
• Bit: 32, Bajt:4, Prej: 0, Deri: 4.294.967.295 (2³²-1)
• Bit: 64, Bajt:8, Prej: 0, Deri: 18.446.744.073.709.551.615 (2⁶⁴-1)

Vlera negative dhe jonegative (signed)

• Bit: 8, Bajt:1, Prej: -128 (-2⁷), Deri: 127 (2⁷-1)
• Bit: 16, Bajt:2, Prej: -32.768 (-2¹⁵), Deri: 32,767 (2¹⁵-1)
• Bit: 32, Bajt:4, Prej: -2.147.483.648 (-2³¹), Deri: 2.147.483.647 (2³¹-1)
• Bit: 64, Bajt:8, Prej: -9.223.372.036.854.775.808 (-2⁶³), Deri: 9,223,372,036,854,775,807 (2⁶³-1)

Go përdor tipet vijuese të numrave të plotë:

8 bitë unsigned

• uint8 (byte)

16 bitë unsigned

• uint16

32 bitë unsigned

• uint32
• uint
• uintptr

64 bitë unsigned

burim vështirë i detektueshëm
8 bitë signed

• int8

16 bitë signed

• int16

32 bitë signed

• int32 (rune)
• int

64 bitë signed

onjë gabim eventu
Tipi byte është alias i uint8, d.m.th. janë të njëjtë.

Tipi rune është alias i int32.

Madhësitë e tipeve uint, int dhe uintptr varen nga platforma, respektivisht arkitektura e procesorit; në platformat 32 bitëshe kanë madhësi 32 bitëshe, ndërsa në platformat 64 bitëshe - madhësi 64 bitëshe.
Madhësia e vlerës uintptr duhet të jetë mjaft e madhe që të ruajë bitat e painterpretuar të një adrese memorike.

Duhet të kemi parasysh që vlerat që ia japim një tipi t’i përgjigjen diapazonit të vlerave të lejuara për atë tip. Për shembull, tipi int8 mund të përmbajë vlera prej -128 deri 127. Nëse në program i japim një vlerë më të madhe se 127 apo më të vogël se -128, kompajleri do të lajmërojë gabim dhe programi nuk do të kompajlohet fare.

1 var muaji int8
2 muaji = 500

Mirëpo, nëse vlera e një tipi caktohet gjatë ekzekutimit të programit, me ç’rast kompajleri nuk e di paraprakisht vlerën, do të ndodhin situata konfuze, me ç’rast programi nuk lajmëron gabim por ndodh overflow. Për shembull, meqë vlera maksimale e int8 është 127 dhe nëse gjatë kohës së ekzekutimit merr vlerën 128, vlera rezultuese do të jetë -127! Kjo për shkak se pas arritjes së vlerës maksimale, programi fillon prej vlerës më të vogël për aq sa sa vlera e re dallon nga vlera maksimale.

Me fjalë të tjera, nëse int8 merr vlerën 150, në fakt ai do ta ketë vlerën -105 sepse 150-127=23 dhe -128+23 = -105. Ky mund të jetë burim vështirë i detektueshëm i gabimeve në rezultatet e programit sepse sistemi i kohës së ekzekutimit (runtime system) i Go nuk do të na lajmërojë për ndonjë gabim eventual.

Duhet të kemi parasysh edhe faktin që ndaj numrave të plotë të tipeve të ndryshme nuk mund të kryejmë operacione aritmetikore. Për shembull, nuk mund ta mbledhim një numër të tipit uint8 me një numër të tipit int16. Për ta realizuar operacionin e mbledhjes, të dy tipet duhet më parë t’i konvertojmë në një tip të njëjtë e më pas ta kryejmë veprimin aritmetikor. Në shembullin vijues, konvertimi bëhet në tipin int nëpërmes funksionit int(), i cili ka madhësinë 32 apo 64 bitë, në varësi prej arkitekturës, por gjithsesi është më i madh se 8 bitë (tipi uint8) dhe 16 bitë (int16).

 1 var m uint8
 2 m = 5
 3 var f int16
 4 f = 6
 5 
 6 var n int
 7 // kjo shkakton gabim kompajlimi
 8 n = m + f
 9 // prandaj variablat m dhe f duhet te konvertohen
10 // me funksionin int()
11 n = int(m) + int(f)

Numrat me presje dhjetore

Numrat me presje dhjetore (floating-point numbers) janë numra që përmbajnë komponentën decimale. Paraqitja e tyre në kompjuter është më e ndërlikuar se e numrave të plotë. Kjo bën që saktësia e këtyre numrave të jetë e kufizuar dhe rrjedhimisht edhe e llogaritjeve që bëhen me këto numra.

Në memorje, të gjitha vlerat e numrave me presje dhjetore ruhen në formatin IEEE-754.

Numrat me presje dhjetore kanë madhësi (numra bitash) të caktuar, 32 bitë (single precision) apo 64 bitë (double precision), sikurse edhe numrat e plotë.

Numrat më të mëdhenj kanë saktësi më të vogël, sepse duke qenë se kanë madhësi fikse (32/64 bitë), sa më e madhe pjesa e plotë, aq më pak shifra ngelen në dispozicion djathtas prej presjes dhjetore, me çka zvogëlohet saktësia e pjesës decimale.

Mund të përmbajnë edhe vlera jonumerike siç janë:

• NaN (not a number)
• Infinit pozitiv (+∞)
• Infininit negativ (−∞)

Shembull me infinit:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var c float32 = 0
 9 	var d float32 = 0
10 
11 
12 	var a float32 = 24
13 	d = a / c
14 	fmt.Printf("result = %.2f \n", d)
15 
16 	var b float32 = -15
17 	d = b / c
18 	fmt.Printf("result = %.2f \n", d)
19 }

https://play.golang.org/p/ZrzSGo-MnzA

Rezultati:

1 result = +Inf 
2 result = -Inf 

Go ka dy tipe për paraqitjen e numrave kompleksë:

• complex64, dhe
• complex128.

Pjesa reale dhe imagjinare e një vlere complex64 janë të dyja vlera float32, ndërsa pjesët reale dhe imagjinare të një vlere complex128 janë të dyja vlera float64.

Në Go përdoren operatorët standard vijues:

• Mbledhja +
• Zbritja -
• Shumëzimi *
• Pjestimi /
• Modulusi %

Numrat kompleks

Numrat kompleks përbëhen nga dy pjesë:

• pjesa reale, dhe
• pjesa imagjinare.

Go mundëson kryerjen e drejtpërsëdrejtë të operacioneve aritmetikore ndaj numrave kompleks. Numri kompleks është 128 bitësh, float64 për pjesën reale, float64 për pjesën imagjinare, apo 64 bitësh - float32 për pjesën reale, float32 për pjesën imagjinare.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	var a = 4 + 3i
 7 	var b = 6 + 2i
 8 
 9 	fmt.Println(a + b)
10 	fmt.Println(a - b)
11 	fmt.Println(a * b)
12 	fmt.Println(a / b)
13 }

https://play.golang.org/p/-qHz2eUw9B8

Rezultati:

1 (10+5i)
2 (-2+1i)
3 (18+26i)
4 (0.75+0.25i)

Me përdorimin e pakos “math/cmplx”, mund të kryejmë edhe veprime të tjera matematikore.

• Abs(x complex128) float64
• Acos(x complex128) complex128
• Acosh(x complex128) complex128
• Asin(x complex128) complex128
• Asinh(x complex128) complex128
• Atan(x complex128) complex128
• Atanh(x complex128) complex128
• Conj(x complex128) complex128
• Cos(x complex128) complex128
• Cosh(x complex128) complex128
• Cot(x complex128) complex128
• Exp(x complex128) complex128
• Inf() complex128
• IsInf(x complex128) bool
• IsNaN(x complex128) bool
• Log(x complex128) complex128
• Log10(x complex128) complex128
• NaN() complex128
• Phase(x complex128) float64
• Polar(x complex128) (r, θ float64)
• Pow(x, y complex128) complex128
• Rect(r, θ float64) complex128
• Sin(x complex128) complex128
• Sinh(x complex128) complex128
• Sqrt(x complex128) complex128
• Tan(x complex128) complex128
• Tanh(x complex128) complex128

Rrënja katrore e numri kompleks:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"math/cmplx"
 6 )
 7 
 8 func main() {
 9 	var a = 4 + 3i
10 	fmt.Println(cmplx.Sqrt(a))
11 }

https://play.golang.org/p/8aXVwGwWjW1

Rezultati:

1 (2.1213203435596424+0.7071067811865476i)

Po të përdorej funksioni Sqrt() nga pakoja math:

1 	var a = 4 + 3i
2 	fmt.Println(math.Sqrt(a))

do të lajmërohej gabimi:

1 cannot use a (type complex128) as type float64 in argument to math.Sqrt

Ngritja në fuqi e numrit kompleks

E marrim rezultatin e shembullit me rrënjë katrore të numrave kompleks, dhe e ngrisim në katror, për të verifikuar a e fitojmë rezultatin e pritur (4 + 3i).

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"math/cmplx"
 6 )
 7 
 8 func main() {
 9 	var a = 2.1213203435596424 + 0.7071067811865476i
10 	fmt.Println(cmplx.Pow(a,2 ))
11 }

https://play.golang.org/p/pmQpPC2q8k5

Rezultati:

1 (4+3.000000000000001i)

Shohim që e kemi fituar rezultatin përafërsisht të njëjtë, diferenca është 0.000000000000001 apo 10^-14, diferencë kjo që mund të jetë e papërfillshme në varësi prej natyrës së problemit që zgjidhet.

Pasaktësia buron nga fakti e komponentet e numrit kompleks janë float64 dhe domosdo do të ndodhin përafrime të vlerave sepse këtë e imponon vetë natyra e numrave të tipit float.

Bitwise operators

Bitwise AND operator

Kryhet operacioni AND ndaj vlerave binare të dy numrave bit për bit në pozita të njëjta. Rezultati i fituar është:

• 0 & 0 = 0
• 0 & 1 = 0
• 1 & 0 = 0
• 1 & 1 = 1

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x = 202
 9 	var y = 107
10 	fmt.Printf("%4v| %08b\n", x, x)
11 	fmt.Printf("%4v| %08b\n", y, y)
12 	fmt.Println("______________")
13 	fmt.Printf("%4v| %08b\n", x&y, x&y)
14 }

https://play.golang.org/p/fE6bLqAKff5

Rezultati:

1  202| 11001010
2  107| 01101011
3 ______________
4   74| 01001010

Bitwise OR operator

Kryhet operacioni OR ndaj vlerave binare të dy numrave bit për bit në pozita të njëjta. Rezultati i fituar është:

• 0 | 0 = 0
• 0 | 1 = 1
• 1 | 0 = 1
• 1 | 1 = 1

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x = 202
 9 	var y = 107
10 	fmt.Printf("%4v| %08b\n", x, x)
11 	fmt.Printf("%4v| %08b\n", y, y)
12 	fmt.Println("______________")
13 	fmt.Printf("%4v| %08b\n", x|y, x|y)
14 }

https://play.golang.org/p/zjE0213pbil

Rezultati:

1  202| 11001010
2  107| 01101011
3 ______________
4  235| 11101011

### Bitwise XOR operator

Kryhet operacioni XOR ndaj vlerave binare të dy numrave bit për bit në pozita të njëjta. Rezultati i fituar është:

• 0 | 0 = 0
• 0 | 1 = 1
• 1 | 0 = 1
• 1 | 1 = 0

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x = 202
 9 	var y = 107
10 	fmt.Printf("%4v| %08b\n", x, x)
11 	fmt.Printf("%4v| %08b\n", y, y)
12 	fmt.Println("______________")
13 	fmt.Printf("%4v| %08b\n", x^y, x^y)
14 }

https://play.golang.org/p/nmpYzMQdCWi

Rezultati:

1  202| 11001010
2  107| 01101011
3 ______________
4  161| 10100001

Bitwise NOT operator

Ky operator, zerot i kthen në njësha, njëshat në zero.

• ^0 = 1
• ^1 = 0

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x uint8 = 123
 9 	fmt.Printf("%4v| %08b\n", x, x)
10 	fmt.Println("______________")
11 	fmt.Printf("%4v| %08b\n", ^x, ^x)
12 }

https://play.golang.org/p/hie6IHjoRDu

Rezultati:

1  123| 01111011
2 ______________
3  132| 10000100

Bitwise AND NOT operator

Biti i numrit të parë kryen operacionin AND me NOT-in e numrit të dytë.

• 0 &^ 0 = 0
• 0 &^ 1 = 0
• 1 &^ 0 = 1
• 1 &^ 1 = 0

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x = 123
 9 	var y = 6
10 	fmt.Printf("%4v| %08b\n", x, x)
11 	fmt.Printf("%4v| %08b\n", y, y)
12 	fmt.Println("______________")
13 	fmt.Printf("%4v| %08b\n", x&^y, x&^y)
14 }

https://play.golang.org/p/c7UyUxnCKUz

Rezultati:

1  123| 01111011
2    6| 00000110
3 ______________
4  121| 01111001

Bitwise shift operators

Operatorët për zhvendosje të bitave (bitwise shift operators) bëjnë zhvendosjen e vlerës së një objekti binar. Operandi i majtë paraqet vlerën, ndërsa i djathti numrin e pozitave për zhvendosjen e bitave të vlerës.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	fmt.Printf("%3v << %v  | %3v (%08b)\n", 2, 5, 2<<5, 2<<5)
 9 	fmt.Printf("%3v >> %v  | %3v (%08b)\n", 64, 5, 64>>5, 64>>5)
10 }

https://play.golang.org/p/Rknmaievs2w

Rezultati:

1   2 << 5  |  64 (01000000)
2  64 >> 5  |   2 (00000010)

Në rreshtin 8 kryhet operacioni 2<< 5, që do të thotë që vlera e numrit 2 (që në formë binare është 00000010), të zhvendoset për 5 pozita majtas. Pra, njësi do të zhvendoset 5 herë majtas, me ç’rast formohet numri binar 01000000, e që është vlera 64.

Në rreshtin 9 kryhet veprim i kundërt: vlera e numrit 64 (01000000) do të zhvendoset djathtas, pra njëshi do të zhvendoset për pesë pozita më djathtas, me çka fitohet numri binar 00000010, që është numri 2.

Bitwise left shift operator

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x uint = 1
 9 	fmt.Printf("%v = %08b\n", x, x)
10 	fmt.Println("________________________")
11 	var i uint
12 	for i = 0; i < 8; i++ {
13 		r := x << i
14 		fmt.Printf("%v << %v  | %3v (%08b)\n", x, i, r, r)
15 	}
16 }

https://play.golang.org/p/yIC7d1CT5NF

Rezultati:

 1 1 = 00000001
 2 ________________________
 3 1 << 0  |   1 (00000001)
 4 1 << 1  |   2 (00000010)
 5 1 << 2  |   4 (00000100)
 6 1 << 3  |   8 (00001000)
 7 1 << 4  |  16 (00010000)
 8 1 << 5  |  32 (00100000)
 9 1 << 6  |  64 (01000000)
10 1 << 7  | 128 (10000000)

E vërejmë njëshin binar si zhvendoset nga një pozitë majtas, prej vlerës binare 00000001 deri në vlerën binare 10000000.

Bitwise right shift operator

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x uint = 128
 9 	fmt.Printf("%v = %08b\n", x, x)
10 	fmt.Println("________________________")
11 	var i uint
12 	for i = 0; i < 8; i++ {
13 		r := x >> i
14 		fmt.Printf("%v >> %v  | %3v (%08b)\n", x, i, r, r)
15 	}
16 }

https://play.golang.org/p/Yl3YULGqkdj

Rezultati:

 1 128 = 10000000
 2 ________________________
 3 128 >> 0  | 128 (10000000)
 4 128 >> 1  |  64 (01000000)
 5 128 >> 2  |  32 (00100000)
 6 128 >> 3  |  16 (00010000)
 7 128 >> 4  |   8 (00001000)
 8 128 >> 5  |   4 (00000100)
 9 128 >> 6  |   2 (00000010)
10 128 >> 7  |   1 (00000001)

Stringjet

Një string është sekuencë karakteresh e gjatësisë së caktuar që përdoret për ruajtjen e tekstit. Go ofron suport për karakteret Unicode, me çka mundësohet përdorimi i shkronjave të alfabeteve të ndryshme si dhe shenjave të shumta speciale.

Një string vendoset ndërmjet thonjëzave apo shenjave backtick (`):
“Hello, World”

`Hello,
World`

Nëse stringu vendoset brenda thonjëzave, stringu nuk mund të përmbajë rreshta të rinj (newlines) ndërsa special escape sequences janë të lejuara.

Shenja \n zëvendësohet me newline ndërsa \t me tabulator.

Nëse stringu vendoset brenda backticks, stringun mund ta ndajmë në disa rreshta.

Karaktereve individuale të stringut mund t’iu qasemi sikur të ishte varg, duke përdorur indeksin, për aq kohë sa karakteret i takojnë tabelës ASCII.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "Golang"
 9 	fmt.Println(a[0])
10 	fmt.Println(string(a[0]))
11 }

https://play.golang.org/p/W8Fbgr2NLKK

Rezultati:

1 71
2 G

Si rezultat i fmt.Println(a[0]) fitohet kodi i karakterit të parë (indeksi 0) e që është 71. Me anë të funksionit string() mund ta konvertojmë në karakter (G).

Nëse një karakter e vendosim brenda apostrofave, vlerë e variablit do të jetë kodi i atij karakteri. Nëse një karakter e vendosim brenda thonjëzave, atëherë vlerë do të jetë karakteri.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := 'A'
 9 	b := "B"
10 	fmt.Printf("%T %T \n", a, b)
11 	fmt.Printf("%v %v \n", a, b)
12 	fmt.Printf("%c %v", a, b)
13 }

https://play.golang.org/p/WL392-lPQ7w

Rezultati:

1 int32 string 
2 65 B 
3 A B

Pra, kur kemi deklaruar a := 'A', tipi i variablit a do të jetë int32, gjegjësisht rune, që do të jetë një numër, pra 65. Për ta printuar me fmt.Printf, përdoret formatimi “%c”, ose e konvertojmë variablin me funksionin string():

1 fmt.Printf("%v %v", string(a), b)

Mund t’iu qasemi edhe një sekuence të karakterëve duke e cekur numrin e karakterëve të dëshiruar.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "Golang"
 9 	fmt.Println(a[0:3])
10 }

https://play.golang.org/p/9I_gQlAwJw1

Rezultati:

1 Gol

Me a[0:3] kemi kërkuar 3 karakteret e njëpasnjëshëm duke filluar nga karakteri i parë [0], pastaj [1], pastaj [2], duke mos e përfshirë indeksin e fundit [3]. Në Go, kur ceket një diapazon i indekseve, nuk merret përfshihet indeksi i fundit, por përfshirja bëhet prej indeksit të cekur fillestar deri te ai i parafundit.

Vërejmë se në këtë rast fitojmë stringun “Gol” dhe jo kodet e karakterëve, pra nuk kemi nevojë të bëjmë konvertim eksplicit me funksionin string().

Karaktereve individualë mund t’iu qasemi edhe me strukturën for-range:

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "Golang"
 9 
10 	// Mënyra 1
11 	// i -> indeksi, a[i] -> kodi i karakterit, string(a[i]) -> karakteri
12 
13 	for i := range a {
14 		fmt.Println(i, a[i], string(a[i]))
15 	}
16 
17 	// Mënyra 2
18 	// i -> indeksi, c -> kodi i karakterit, string(c) -> karakteri
19 
20 	for i, c := range a {
21 		fmt.Println(i, c, string(c))
22 	}
23 }

https://play.golang.org/p/shIDT8i9w4W

Rezultati:

 1 0 71 G
 2 1 111 o
 3 2 108 l
 4 3 97 a
 5 4 110 n
 6 5 103 g
 7 0 71 G
 8 1 111 o
 9 2 108 l
10 3 97 a
11 4 110 n
12 5 103 g

Kur kemi të bëjmë me Unicod karaktere, ka dallim esencial ndërmjet përdorimit të strukturës for dhe asaj for-range për ekstaktimin e karaktereve. Struktura for e zbërthen stringun bajt për bajt, ndërsa struktura for-range do ta zbërthejë sipas Unicode karakterve.

Një Unicode karakter zë ndërmjet 1 dhe 4 bajtëve dhe përfshin pothuajse të gjitha alfabetet e botës. Karakteret nga tabela ASCII konsumojnë nga 1 bajt, kështu që për shembull për alfabetin e gjuhës angleze, si struktura for si ajo for-range do të japin rezultat të njëjtë. Mirëpo, në rastin e gjuhës kineze në shembullin vijues, 1 karakter zë 3 bajtë dhe struktura for është e papërshtatshme për t’u përdorur për një string në gjuhën kineze. Në shembullin e mëposhtëm, zbërthimi i stringut në gjuhën kineze bëhet njëherë me for, pastaj me for-range.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	text := "新年快乐"
 9 	
10 	// bajt per bajt
11 	for i := 0; i < len(text); i++ {
12 		fmt.Println(string(text[i]))
13 	}
14 	
15 	// shkronje per shkronje
16 	for _, v := range text {
17 		fmt.Println(string(v))
18 	}
19 }

https://play.golang.org/p/wRc_nHvLqKr

Rezultati:

 1 æ
 2 
 3 °
 4 å
 5 ¹
 6 ´
 7 å
 8 ¿
 9 «
10 ä
11 ¹
12 
13 新
14 年
15 快
16 乐

Po ashtu, funksioni len() për një string që përmban Unicode karaktere do të raportojë gjatësi të gabuar, sepse len() tregon numrin e bajtëve, jo numrin e karaktereve. Një karakter ruhet si rune, që është int32. Pra, kur flasim për rune, flasim për një hapësirë 32 bitëshe, respektivisht 4 bajtëshe, hapësire kjo e mjaftueshme për reprezentimin e të gjitha karaktereve të Unicode. Për ta llogaritur saktë numrin e karaktereve, do ta përdorim funksionin RuneCountInString() nga pakoja utf8.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"unicode/utf8"
 6 )
 7 
 8 func main() {
 9 	fmt.Println(len("新年快乐"))
10 	fmt.Println(utf8.RuneCountInString("新年快乐"))
11 }

https://play.golang.org/p/kJNEwwKKMHU

Rezultati:

1 12
2 4

Karakteristikë e stringjeve në Go është se janë immutable, gjegjësisht nuk mund t’iu ndryshohet përmbajtja, pra nuk mund ta ndryshojmë drejtpërsëdrejti ndonjë karakter apo sekuencë të karaktereve të stringut .

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "Golang"
 9 
10 	fmt.Println(string(a[4]))
11 	a[4] = "m"
12 }

https://play.golang.org/p/j1bLHKiHiQt

Rezultati:

1 ./prog.go:11:7: cannot assign to a[4]

Pra, kur kemi tentuar ta ndryshojmë karakterin e pestë (indeksi 4), lajmërohet gabimi cannot assign to a[4].

Bashkangjitja e stringjeve (string concationation) kryhet me operatorin +.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "Golang"
 9 	fmt.Println(a)
10 
11 	b := a + " programming"
12 	fmt.Println(b)
13 
14 	b += " book"
15 	fmt.Println(b)
16 }

https://play.golang.org/p/ZqRiAmTl7Mc

Rezultati:

1 Golang
2 Golang programming
3 Golang programming book

Në shembullin vijues është një program i thjeshtë i cili do ta shifruar një tekst duke e përdorur “Caesar cipher”, tek i cili bëhet zhvendosja e shkronjave për disa pozita ta zëmë djathtas kur shifrojmë, pastaj për po aq pozita majtas kur deshifrojmë.

Do ta përdorim kodin e karakterit që është numër i plotë për ta kryer operacionit të mbledhjes p.sh. me 3 (për zhvendosje 3 pozita djathtas), ndërsa gjatë dekodimit do ta kryejmë operacionin e zbritjes për zhvendosje majtas.

Programi është fare i thjeshtë dhe në këtë formë funksionin vetëm me ASCII karaktere.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	mesazhi := "ABCabcxyzXYZ"
 9 	fmt.Println("Origjinali: ", mesazhi)
10 	koduar := ""
11 
12 	for i := 0; i < len(mesazhi); i++ {
13 		koduar += string(mesazhi[i] + 3)
14 	}
15 	fmt.Println("Forma e koduar: ", koduar)
16 
17 	dekoduar := ""
18 	for i := 0; i < len(koduar); i++ {
19 		dekoduar += string(koduar[i] - 3)
20 	}
21 	fmt.Println("Dekoduar: ", dekoduar)
22 }

https://play.golang.org/p/tMwdc-NsN2R

Rezultati:

1 Origjinali:  ABCabcxyzXYZ
2 Forma e koduar:  DEFdef{|}[\]
3 Dekoduar:  ABCabcxyzXYZ

Funksionet

len()

Tregon numrin e karaktereve që i përmban një string.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "Golang"
 9 	fmt.Println(len(a))
10 }

https://play.golang.org/p/oUCmOQW7M5L

Rezultati:

1 6

string()

E konverton kodin e karakterit në karakter.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	a := "P"
 9 	fmt.Println(a[0])
10 	fmt.Println(string(a[0]))
11 }

https://play.golang.org/p/G-gGIV08wU1

Rezultati:

1 80
2 P

Degëzimi (if)

if else

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x, y := 6, 9
 7 	if x < y {
 8 		fmt.Println("x më i vogël se y")
 9 	} else if x > y {
10 		fmt.Println("x më i madh se y")
11 	} else {
12 		fmt.Println("x baraz me y")
13 	}
14 }

https://play.golang.org/p/yS-PKpRjRo1

Rezultati:

1 x më i vogël se y

Shembulli i mësipërm mund të rishkruhet kështu:

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	if x, y := 6, 9; x < y {
 7 		fmt.Println("x më i vogël se y")
 8 	} else if x > y {
 9 		fmt.Println("x më i madh se y")
10 	} else {
11 		fmt.Println("x baraz me y")
12 	}
13 }

https://play.golang.org/p/ehMSSCiex-l

Rezultati:

1 x më i vogël se y

Ndryshimi ndërmjet dy shembujve të fundit qëndron në faktin se në shembullin e dytë variablat x dhe y janë variabla lokale brenda skopit të strukturës if, pra nuk do të jenë të qasshme kur dilet nga kjo strukturë. Kështu, nëse e shtojmë në fund një rresht që i printon vlerat e x dhe y, do të shohim se lajmërohet gabimi ku thuhet se x dhe y nuk janë të definuar.

Kodi i modifikuar, që e përmban edhe rreshtin fmt.Println(x, y):

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	if x, y := 6, 9; x < y {
 7 		fmt.Println("x më i vogël se y")
 8 	} else if x > y {
 9 		fmt.Println("x më i madh se y")
10 	} else {
11 		fmt.Println("x baraz me y")
12 	}
13 
14 	fmt.Println(x, y)
15 }

https://play.golang.org/p/3xrivR6WJ0a

Rezultati:

1 undefined: x
2 undefined: y

Degëzimi (switch)

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x := 20000
 7 
 8 	switch x {
 9 	case 10000:
10 		fmt.Println("Prishtina")
11 	case 20000:
12 		fmt.Println("Prizreni")
13 	case 70000:
14 		fmt.Println("Ferizaji")
15 	default:
16 		fmt.Println("Kod postar i panjohur")
17 	}
18 }

https://play.golang.org/p/Je35FFMxj6_-

Rezultati:

1 Prizreni

Blloku i kodit pas default ekzekutohet nëse nuk është plotësuar asnjë prej kushteve me case. Urdhëri default nuk është i domosdoshëm nëse logjika e kodit nuk e kërkon. Urdhëro default mund të vendoset kudo brenda switch, nuk është e domosdoshme të jetë në fund.

Tipi i vlerës që evaluuar në switch dhe tipi i vlerës në case duhet të përputhen. Nëse nuk përputhen, do të lajmërohet gabim gjatë kompajlimit. Vlerat në case nëse janë numerike, lejohet që në switch ta kemi variablin të tipit qoftë float, qoftë int.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x := 100.00
 7 
 8 	switch x {
 9 	case 100.00:
10 		fmt.Println("Prishtina")
11 	case 20000:
12 		fmt.Println("Prizreni")
13 	case 70000:
14 		fmt.Println("Ferizaji")
15 	default:
16 		fmt.Println("Kod postar i panjohur")
17 	}
18 }

https://play.golang.org/p/lFEFtH7CsbQ

Rezultati:

1 Prishtina

Kjo “tolerancë” nga ana e Go ndodh për shkak se krahasimin e vlerës së x e bëjmë ndaj vlerave numerike të cilat konsiderohen konstanta. Nëse në vend të atyre numrave vendosim variabla me të deklaruara me tip, atëherë do të kemi problem sepse Go do të kërkojë që variabli x dhe variabli me të cilin krahasohet të jenë të tipit identik, përndryshe do të raportohet gabimi për mospërputhjen e tipeve.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x := 10000
 7 	var a int16 = 20000
 8 
 9 	switch x {
10 	case 10000:
11 		fmt.Println("Prishtina")
12 	case a:
13 		fmt.Println("Prizreni")
14 	case 70000:
15 		fmt.Println("Ferizaji")
16 	default:
17 		fmt.Println("Kod postar i panjohur")
18 	}
19 }

https://play.golang.org/p/NtmdE9uh652

Rezultati:

1 invalid case a in switch on x (mismatched types int16 and int)

Secili case është scope në vete, kështu që variablat e deklaruara dhe inicializuara brenda atij blloku, nuk do të jenë të qasshëm jashtë strukturës switch.

Scope i case nuk ndryshon edhe në rastet kur kemi fallthrough nga një case në case-in vijues.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x := 10000
 7 
 8 	switch x {
 9 	case 10000:
10 		fmt.Println("Prishtina")
11 		a := 500
12 		fallthrough
13 	case 20000:
14 		fmt.Println(a)
15 		fmt.Println("Prizreni")
16 	case 70000:
17 		fmt.Println("Ferizaji")
18 	default:
19 		fmt.Println("Kod postar i panjohur")
20 	}
21 }

https://play.golang.org/p/OgGBkdIS3rX

Rezultati:

1 undefined: a

Pra, secili case është scope në vete dhe variablat e definuara në një case, nuk janë të qasshëm në case tjetër edhe kur bëjmë fallthrough.

Nëse nuk ka fare shprehje pas switch, vlera që evaluohet është boolean, prandaj dhe në case duhet të kemi shprehje boolean, siç janë operatorët e krahasimit.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	i := 1
 7 	switch {
 8 	case i < 5:
 9 		fmt.Println("i me i vogel se 5")
10 	case i == 5:
11 		fmt.Println("i baras 5")
12 	default:
13 		fmt.Println("i me i madh 5")
14 	}
15 }

https://play.golang.org/p/rtdtszn6ZrR

Rezultati:

1 i me i vogel se 5

Nëse në më tepër se një case plotësohet kushti, ekzekutohet vetëm kodi pas case të parë.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	i := 1
 7 	switch {
 8 	case i < 5:
 9 		fmt.Println("i me i vogel se 5")
10 	case i < 7:
11 		fmt.Println("i me i vogel se 7")
12 	}
13 }

https://play.golang.org/p/jfczKTCcaSU

Rezultati:

1 i me i vogel se 5

Switch në Go nuk ka nevojë për break.
Nëse duhet që nga një case të kalohet te tjetri case pa e evaluuar kushtin, përdoret urdhëri fallthrough.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	x := 20000
 7 
 8 	switch x {
 9 	case 10000:
10 		fmt.Println("Prishtina")
11 	case 20000:
12 		fmt.Println("Prizreni")
13 		fallthrough
14 	case 70000:
15 		fmt.Println("Ferizaji")
16 	default:
17 		fmt.Println("Kod postar i panjohur")
18 	}
19 }

https://play.golang.org/p/elGAO1aAXjC

Rezultati:

1 Prizreni
2 Ferizaji

Kllapat e mëdha (curly braces) nuk janë të domosdoshëm për definimin e bllokut të kodit pas case.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	i := 1
 7 	switch {
 8 	case i < 5:
 9 		{
10 			fmt.Println("i me i vogel se 5")
11 		}
12 	case i == 5:
13 		{
14 			fmt.Println("i baras 5")
15 		}
16 	default:
17 		{
18 			fmt.Println("i me i madh 5")
19 		}
20 	}
21 
22 	// Njëjtë si
23 
24 	switch {
25 	case i < 5:
26 		fmt.Println("i me i vogel se 5")
27 	case i == 5:
28 		fmt.Println("i baras 5")
29 
30 	default:
31 		fmt.Println("i me i madh 5")
32 	}
33 }

https://play.golang.org/p/qj3X-PyUAME

Rezultati:

1 i me i vogel se 5
2 i me i vogel se 5

Shprehjet në case mund të jenë vlera apo shprehje.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	a := 2
 7 	i := 8
 8 
 9 	switch i {
10 	case 5:
11 		fmt.Println("i baras 5")
12 	case a + 6:
13 		fmt.Println("i baras 8")
14 	}
15 }

https://play.golang.org/p/Z147M9xT7Co

Rezultati:

1 i baras 8

Mund të përdorim çfarëdo numri të case.

Brenda case mund të vendosen disa shprehje të përputhjes, të ndarë me presje.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	a := 5
 7 
 8 	switch a {
 9 	case 5, 6, 7:
10 		fmt.Println("a baras me 5, 6 ose 7")
11 	case 8:
12 		fmt.Println("a baras me 8")
13 	}
14 }

https://play.golang.org/p/WW4022ZHACD

Rezultati:

1 a baras me 5, 6 ose 7

Switch initializer

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"time"
 6 )
 7 
 8 func main() {
 9 	switch m := time.Now(); {
10 	case m.Month() >= 12 || m.Month() < 3:
11 		fmt.Println("Dimër")
12 	case m.Month() >= 3 && m.Month() < 6:
13 		fmt.Println("Pranverë")
14 	case m.Month() >= 6 && m.Month() < 9:
15 		fmt.Println("Verë")
16 	case m.Month() >= 9 && m.Month() < 12:
17 		fmt.Println("Vjeshtë")
18 	default:
19 		fmt.Println("Nuk di cila stinë është")
20 	}
21 }

https://play.golang.org/p/ZvvHIkLzc6p

Rezultati:

1 Vjeshtë

Shembulli në vijim ka të bëjë me ditët e javës. Lexohet dita e javës nga sistemi nëpërmes pakos time dhe pastaj bëhet degëzimi në varësi prej vlerës së kthyer. Për vlerat ` time.Saturday dhe time.Sunday` do të raportohet “Fundjavë”, ndërsa për vlerat tjera do të raportohet “Ditë pune”.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 	"time"
 6 )
 7 
 8 func main() {
 9 	switch time.Now().Weekday() {
10 	case time.Saturday, time.Sunday:
11 		fmt.Println("Fundjavë")
12 	default:
13 		fmt.Println("Ditë pune")
14 	}
15 }

https://play.golang.org/p/U3Yu8KGbY6-

Rezultati:

1 Ditë pune

Switch mund të përdoret edhe për determinimin e tipeve të variablave, në rastet kur funksioni pranon si parametër një interfejs të zbrazët. Interfejsat e zbrazët përdoren për pranimin e vlerave tipeve të ndryshme. Pas pranimit të vlerës, analizojmë me switch v := i.(type) cilit tip konkret i përket variabli i bartur në funksion.

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6 	printo("Tung")
 7 	printo(67)
 8 	printo(true)
 9 }
10 
11 func printo(i interface{}) {
12 	switch v := i.(type) {
13 	case int:
14 		fmt.Printf("Tipi është integer për %v\n", v)
15 	case string:
16 		fmt.Printf("Tipi është string për %v\n", v)
17 	case bool:
18 		fmt.Printf("Tipi është bool për %v\n", v)
19 	default:
20 		fmt.Printf("Nuk di çfarë tipi është %v \n", v)
21 	}
22 }

https://play.golang.org/p/flsKeobzBA2

Rezultati:

1 Tipi është string për Tung
2 Tipi është integer për 67
3 Tipi është bool për true

Ciklet (for)

for

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	sum := 0
 9 	for i := 0; i < 100; i++ {
10 		sum += i
11 	}
12 	fmt.Println(sum)
13 }

https://play.golang.org/p/iWDx5k3TGZ8

break

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	i := 0
 9 	for {
10 		if i == 10 {
11 			break
12 		}
13 		fmt.Println("Vlera e i është:", i)
14 		i++
15 	}
16 	fmt.Println("Dalja nga cikli")
17 }

https://play.golang.org/p/hkZAYJ_rVtN

continue

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	for i := 1; i <= 5; i++ {
 9 		if i == 3 {
10 			continue
11 		}
12 		fmt.Println(i)
13 	}
14 }

https://play.golang.org/p/5yyYPx2XEYs

Tipet kompozite: Vargjet

Vargjet (arrays) dhe struktet (structs) janë tipe agregate, vlerat e tyre janë lista të vlerave të tjera në memorje.
Të gjitha elementet e një vargu janë të një tipi.

Vargjet

Vargu është një sekuencë e gjatësisë fikse të vlerave të tipit të caktuar. Për shkak të gjatësisë fikse, vargjet shumë rrallë përdoren drejtpërsëdrejti. Në vend të përdorimit direkt të vargjeve, në Go rekomandohet përdorimi i segmenteve (slices), të cilave mund t’u shtohen apo largohen elementet, sipas nevojës.

Anëtarëve individualë të vargut mund t’i qasemi duke përdorur indeksin, dhe indeksi i elementit të parë është zeroja. Numrin e elementeve të një vargu e lexojmë me funksionin len().

1 var a  = [5]int{7, 2, 3, 4, 9} // Vargu a me 5 numra të plotë
2 fmt.Println(a[0]) // Shtype anëtarin e parë të vargut a
3 fmt.Println(len(a)) // Trego sa anëtarë i ka vargu a 
4 fmt.Println(a[len(a)-1]) // Shtype anëtarin e fundit të vargut a

https://play.golang.org/p/r_en5mgRAHS

Me përdorimin e strukturës for mund t’iu qasemi në mënyrë sekuencionale indekseve dhe anëtarëve të një vargu.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var a = [5]int{7, 2, 3, 4, 9}
 9 
10 	// Shtypi indekset dhe vlerat e anëtarëve të vargut
11 	for i, v := range a {
12 		fmt.Printf("%d %d\n", i, v)
13 	}
14 
15 	// Shtypi vlerat e anëtarëve të vargut
16 	for _, v := range a {
17 		fmt.Printf("%d\n", v)
18 	}
19 }

https://play.golang.org/p/WQu60tVtTpq

Elementet e një vargu të ri kanë “zero vlerë” , që në rastin e numrave është zero, për stringjet - string i zbrazët (“”). Në shembullin vijues, anëtarit të tretë (me indeksin 2), nuk i është dhënë vlerë, prandaj x[2] ka vlerë 0.

 1 package main
 2 
 3 import (
 4 	"fmt"
 5 )
 6 
 7 func main() {
 8 	var x [3]int = [3]int{1, 2}
 9 	fmt.Println(x[2]) 
10 }