Kintamųjų ir konstantų supratimas programoje „Go“.

Kintamieji ir konstantos yra pagrindinės daugelio programavimo kalbų sąvokos. Jie yra duomenų saugojimo ir tvarkymo elementai. Šiame straipsnyje išnagrinėsime, kaip Go veikia kintamieji ir konstantos.

Kas yra kintamieji?

Kintamasis yra saugojimo vieta, identifikuojama pavadinimu (arba identifikatoriumi), kuriame yra reikšmė. Ši reikšmė gali keistis (arba kisti) programos vykdymo metu, taigi ir pavadinimas „kintamasis“.

Pavyzdžiui:

myName := "temitope"
fmt.Println(myName)

myName = "oyedele"
fmt.Println(myName)

Sukūrėme kintamąjį su identifikatoriumi myName kurioje yra eilutės reikšmė. Tada pakeitėme reikšmę į kitą eilutę, parodydami, kad kintamieji yra kintami.

Kintamieji leidžia saugoti įvairių tipų duomenis, pvz., sveikuosius skaičius, slankiojo kablelio skaičius, eilutes ar objektus.

Kaip sukurti kintamąjį

Yra du pagrindiniai būdai, kaip sukurti kintamąjį programoje Go: aiški deklaracija ir trumpoji deklaracija.

Aiški deklaracija

Tai yra tradicinis būdas sukurti kintamąjį programoje Go. Tai apima naudojimą var raktinį žodį ir deklaruoti kintamojo tipą, kad jūsų kodas būtų lengviau skaitomas ir aiškesnis.

package main

import "fmt"

func main() {
    var age int = 25
    var name string = "Temitope"
    var height float64 = 5.7

    fmt.Println(age, name, height)
}

Prieš priskirdami reikšmę kiekvienam kintamajam, deklaravome jo duomenų tipą.

Išvestis:

25 Temitope 5.7

The var raktinį žodį ir duomenų tipą taip pat galima naudoti nepriskiriant pradinės reikšmės:

package main

import "fmt"

func main() {
    var age int
    var name string
    var height float64

    age = 25
    name = "Temitope"
    height = 5.7

    fmt.Println(age, name, height)
}

Tokiu būdu kintamieji pirmiausia deklaruojami be pradinės reikšmės. Tada joms priskiriamos reikšmės vėliau kode su tokia pačia išvestimi kaip ir pirmame pavyzdyje.

Trumpoji kintamojo deklaracija

Sutrumpinta kintamojo deklaracijos sintaksė (:=) yra glaustesnis būdas deklaruoti kintamuosius. Šis metodas leidžia deklaruoti ir inicijuoti kintamąjį vienoje eilutėje, aiškiai nenurodant jo tipo, nes tipas yra numanomas iš priskirtos vertės.

package main

import "fmt"

func main() {
    age := 25
    name := "Temitope"
    height := 5.7

    fmt.Println(age, name, height)
}

Čia kiekvienas kintamasis buvo deklaruotas kartu su jo verte, o „Go“ nustatė duomenų tipą.

Išvestis:

25 Temitope 5.7

Vienas sutrumpinto kintamojo deklaracijos trūkumas yra tas, kad jį galima naudoti tik funkcijoje.

Kelios kintamųjų deklaracijos

Galite deklaruoti ir inicijuoti kelis kintamuosius toje pačioje eilutėje, atskirdami kiekvieną kintamąjį kableliu. Šis metodas yra paprastas ir nesudėtingas, dažniausiai naudojamas, kai kintamieji yra susiję arba kai norite juos inicijuoti kartu. Pavyzdžiui:

package main

import "fmt"

func main() {
    var age, height int = 25, 180
    var name, city string = "Temitope", "New York"

    fmt.Println(age, height)
    fmt.Println(name, city)
}

Išvestis:

25 180
Temitope New York

Taip pat bloke galite deklaruoti kelis kintamuosius:

package main

import "fmt"

func main() {
    var (
        age    int    = 25
        name   string = "Temitope"
        height int    = 180
        city   string = "New York"
    )

    fmt.Println(age, name, height, city)
}

Išvestis:

25 Temitope 180 New York

Nulinės vertės

Kai kintamieji deklaruojami jų inicijuojant, jiems pagal numatytuosius nustatymus priskiriamos nulinės reikšmės, atsižvelgiant į kintamojo tipą. Toliau pateikiamas pavyzdys, kaip galite deklaruoti numatytąsias reikšmes:

package main

import "fmt"

func main() {
    var intValue int
    var floatValue float64
    var boolValue bool
    var stringValue string
    var ptrValue *int
    var sliceValue ()int
    var mapValue map(string)int

    fmt.Println("Zero values:")
    fmt.Println("int:", intValue)
    fmt.Println("float64:", floatValue)
    fmt.Println("bool:", boolValue)
    fmt.Println("string:", stringValue)
    fmt.Println("pointer:", ptrValue)
    fmt.Println("slice:", sliceValue)
    fmt.Println("map:", mapValue)
}

Išvestis:

Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: ()
map: map()

Kas yra kintamoji apimtis?

Kintamojo apimtis nustato, kur jį galima pasiekti ir modifikuoti jūsų kode. Kintamieji gali būti deklaruojami globaliai arba lokaliai.

Pasauliniai kintamieji

Visuotiniai kintamieji deklaruojami už bet kurios funkcijos ribų, paprastai failo viršuje, ir juos gali pasiekti bet kuri to paties paketo funkcija. Pavyzdžiui:

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {
    globalCounter++
}

func main() {
    fmt.Println("Initial Counter:", globalCounter)
    incrementCounter()
    fmt.Println("After Increment:", globalCounter)
}

Šiame pavyzdyje globalCounter yra pasaulinis kintamasis, pasiekiamas tiek incrementCounter funkcija ir main funkcija. Vertė globalCounter išlieka per funkcijų skambučius.

Vietiniai kintamieji

Kita vertus, vietiniai kintamieji yra deklaruojami funkcijoje arba bloke ir yra pasiekiami tik toje konkrečioje funkcijoje ar bloke. Jie sukuriami, kai funkcija arba blokas yra vykdomas, ir sunaikinami, kai tik jis yra baigtas. Pavyzdžiui:

package main

import "fmt"

func incrementCounter() {
    localCounter := 0
    localCounter++
    fmt.Println("Local Counter:", localCounter)
}

func main() {
    incrementCounter()
    incrementCounter()
}

Šiame pavyzdyje localCounter yra vietinis kintamasis viduje incrementCounter funkcija. Kiekvieną kartą incrementCounter vadinamas nauju localCounter sukuriamas, inicijuojamas iki 0 ir padidinamas. Vertė localCounter tarp funkcijų iškvietimų neišlieka.

Vardų suteikimo konvencijos Go

Tinkamas kintamųjų įvardijimas yra labai svarbus norint parašyti švarų, skaitomą ir prižiūrimą kodą. „Go“ turi konkrečius kintamųjų įvardijimo susitarimus ir taisykles:

• Naudokite aprašomuosius pavadinimus: pasirinkite pavadinimus, kurie aiškiai apibūdina kintamojo tikslą ar turinį, pvz age, totalPricearba userName.
• Naudokite „CamelCase“ kelių žodžių pavadinimams: „Go“ kintamųjų pavadinimams, kuriuos sudaro keli žodžiai, įprasta naudoti „camelCase“. Pirmasis žodis rašomas mažosiomis raidėmis, o kiekvieno paskesnio žodžio pirmoji raidė rašoma didžiąja.
• Venkite naudoti apatinius brūkšnius: laikykitės CamelCase, kad atitiktumėte Go idiomatinį stilių, venkite pabraukimų, kad atskirtumėte žodžius kintamųjų pavadinimuose.
• Trumpalaikiams kintamiesiems naudokite trumpus pavadinimus: trumpalaikiams kintamiesiems, pvz., kilpų skaitikliams ar indeksams, priimtina naudoti trumpus pavadinimus, pvz. i, jarba k.

Kas yra „Go“ konstantos?

Konstantos yra nekintamos vertės, apibrėžtos kompiliavimo metu, kurių negalima keisti programos vykdymo metu. Jie naudingi nustatant vertes, kurios žinomos iš anksto ir išliks tokios pat.

Pavyzdžiui, jei kuriate internetinę parduotuvę, kurioje standartinis pristatymo mokestis visada yra 10 USD, galite jį deklaruoti kaip pastovų. Tai leidžia jį naudoti visoje programoje, kai reikia taikyti siuntimo mokesčius. Jei siuntimo įkainiai pasikeičia, vertę reikia atnaujinti tik vienoje vietoje.

Kaip deklaruoti konstantas Go

Galite deklaruoti konstantas naudodami const raktinis žodis, po kurio nurodomas pavadinimas, tipas (nebūtina, jei reikšmė reiškia tipą) ir konstantos reikšmė. Štai pavyzdys:

package main

import "fmt"

func main() {
    const pi float64 = 3.14159
    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)
    fmt.Println("Greeting:", greeting)
}

Jei bandysite pakeisti konstantą po to, kai ji buvo paskelbta, gausite kompiliavimo laiko klaidą.

„Go“ konstantų tipai

Konstantos gali būti suskirstytos į įvestas arba neįvestas. Abi skirtos tam pačiam tikslui – teikti fiksuotas, nekintamas reikšmes visoje programoje, tačiau skiriasi tuo, kaip „Go“ tvarko jų tipus ir kiek lankstūs jie naudojami.

Neįrašytos konstantos

Neįrašytoms konstantoms tipas nepriskiriamas, nebent jos naudojamos kontekste, kuriam reikalingas tipas. „Go“ nustato tipą toje vietoje, kur naudojama konstanta, todėl netipuotos konstantos tampa lankstesnės

nes juos galima naudoti įvairiuose kontekstuose nereikalaujant tipo konvertavimo.

package main

import "fmt"

const gravity = 9.81

func main() {
    var height int = 10
    var acceleration float64 = gravity * float64(height)

    fmt.Println("Acceleration:", acceleration)
}

Čia gravity yra neįvesta konstanta, leidžianti Go nustatyti jos tipą pagal jos naudojimą. Kada gravity naudojamas skaičiuojant su a float64Go automatiškai jį traktuoja kaip a float64.

Įvestos konstantos

Įvestos konstantos turi aiškiai deklaruotą tipą, tai reiškia, kad jas galima naudoti tik kontekstuose, kurie atitinka tą tipą, arba gali būti konvertuojami į suderinamą tipą. Tipinės konstantos yra griežtesnės, todėl vertė visada bus traktuojama kaip konkretus tipas, kuriuo ji buvo deklaruota.

package main

import "fmt"

const speedOfLight int = 299792458

func main() {
    var distance int = speedOfLight * 2
    fmt.Println("Distance:", distance)
}

Čia speedOfLight yra tipinė konstanta su tipu int. Jis gali būti naudojamas tik operacijose su kitais int vertės arba aiškiai konvertuoti į kitą tipą.

Tai Wrapas

Šiame straipsnyje mes ištyrėme, kas yra kintamieji ir konstantos ir kaip juos deklaruoti Go. Kintamieji ir konstantos yra labai svarbūs programavimo įrankiai, leidžiantys kūrėjams efektyviai valdyti ir manipuliuoti duomenimis. Suprasdami, kaip juos naudoti, galite žymiai pagerinti kodo kokybę.