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.

package main

import (
    "fmt"
)

func main() {
    var x int
    fmt.Println(x)
}

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

Rezultati:

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:

var x int
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.

package main

import (
    "fmt"
)

func main() {
    var x int = 5
    var y int8 = 9

    fmt.Println(x + y)
}

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

Rezultati:

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 int8int, ashtu që të dy numrat t’i përkasin tipit të njëjtë. Kjo bëhet me funksionin int().

package main

import (
    "fmt"
)

func main() {
    var x int = 5
    var y int8 = 9

    fmt.Println(x + int(y))
}

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

Rezultati:

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:

package main

import (
    "fmt"
)

func main() {
    x := 5
    y := 9

    fmt.Println(x + int(y))
}

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

Rezultati:

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.

package main

import (
    "fmt"
)

func main() {
    x := 2147483647
    fmt.Printf("%T", x)
}

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

Rezultati:

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.

package main

import "fmt"

func main() {
    x := 5
    x = 9

    fmt.Println(x)
}

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

Rezultati:

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

package main

import "fmt"

func main() {
    var x, y int
    x, y = 1, 3

    var a, b, c = 5.0, 8.5, 3.8
    // Njëjtë sikur
    // var a, b, c float32 = 5.0, 8.5, 3.8

    fmt.Println("x=", x, "y=", y, "a=", a, "b=", b, "c=", c)
}

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

Rezultati

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.

package main

import "fmt"

func main() {
    var (
        a = 5
        b = 3.2
        c = 8
    )
    fmt.Println("a=", a, "b=", b, "c=", c)
}

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

Rezultati:

a= 5 b= 3.2 c= 8

Rideklarimi i variablave

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

package main

import "fmt"

func main() {
    x := 5
    x := 9
    fmt.Println(x)
}

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.

package main

import "fmt"

func main() {
    var x int = 5
    var x int = 9
    fmt.Println(x)
}

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

Gjatë kompajlimit, lajmërohet gabimi:

./prog.go:7:6: x redeclared in this block
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().

package main

import "fmt"

var x int = 5

func main() {
    var x int = 9
    fmt.Println(x)
}

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

Rezultati:

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.

package main

import "fmt"

var x int = 5

func main() {
    fmt.Println(x)
}

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

Rezultati:

5

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

package main

import "fmt"

var x int = 1

func main() {
    fmt.Println(x)
    var x int = 2
    {
        var x int = 3
        fmt.Println(x)
    }
    fmt.Println(x)
}

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

Rezultati:

1
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.

package main

import "fmt"

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

    fmt.Println(x)
}

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

Rezultati:

./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.

package main

import "fmt"

func main() {
    for i := 1; i < 3; i++ {
        fmt.Println(i)
    }

    fmt.Println(i)
}

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

Rezultati:

./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.

package main

import "fmt"

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

    fmt.Println(i)
}

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

Rezultati:

1
2
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.

package main

import "fmt"

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

    fmt.Println(i)
}

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

Rezultati:

1
2
3

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

package main

import (
    "fmt"
)

func main() {
    for i := 1; i <= 5; i++ {
        x := 5
        y := x + i
        fmt.Println(y)
    }
}

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

Rezultati:

6
7
8
9
10

Konvencionet mbi emërtimin e variablave

Konvertimet ndërmjet tipeve

All Rights Reserved Theme by 404 THEME.