Go ir viena no modernajām programmēšanas valodām, kas daudzās aptaujās gūst panākumus, jo izstrādātāji izvēlējās valodu. Go ir viegli lietojama un saprotama sintakse, vienlaikus nodrošinot augstākā līmeņa veiktspēju.
Varat izmantot Go, lai izveidotu dažādas lietojumprogrammas, sākot no tīmekļa lietotnēm un beidzot ar komandrindas programmām, mākoņpakalpojumiem un tīklu izveidi. Go trešo pušu pakotņu ekosistēma atbalsta daudzus citus lietošanas gadījumus.
Go piedāvā lielāko daļu funkciju, ko jūs varētu sagaidīt mūsdienu valodā: vispārīgie līdzekļi, vienlaicīgums, veida secinājumi, atkritumu savākšana un daudzas citas.
Darba sākšana ar Go
Go var palaist lielākajā daļā operētājsistēmu. Doties uz instalāciju lapa un lejupielādējiet savai operētājsistēmai vēlamo Go versiju.
Kad esat lejupielādējis un instalējis Go, varat sāciet rakstīt un palaist Go kodu failos ar a .iet faila paplašinājums.
Jūs atradīsiet, ka Go ir lielākā daļa funkciju un daudzas citas programmēšanas valodas funkcijas. Ja jums ir iepriekšēja programmēšanas pieredze, jums vajadzētu atrast vienkāršāku informāciju.
Mainīgie programmā Go
Go ir diezgan izteiksmīgs fundamentālā līmenī. Ir divi veidi, kā Go var deklarēt mainīgos. Jūs varat izmantot var atslēgvārds, lai deklarētu dažādu datu tipu mainīgos. Pēc identifikatora norādīšanas jums būs jāiestata mainīgā datu tips.
var a virkne
var b starpt
var c jebkura
var vecums virkne = "piecus gadus vecs"
var vecums = 5// ekvivalents var age int = 5
fmt. Println (vecums)
Tu vari izmantot jebkura kā datu tipu, ja neesat pārliecināts par mainīgā datu tipu.
Varat arī deklarēt konstantes ar konst atslēgvārdu līdzīgi mainīgo deklarēšanai.
konst vecums = "pieci gadi"
Konstantes pēc to deklarēšanas nav iespējams modificēt.
Go nodrošina alternatīvu veidu, kā deklarēt mainīgos funkcijās. Ņemiet vērā kolu lietošanu pirms vienādības zīmes:
funcgalvenais() {
vecums := "pieci gadi" // ekvivalents var age = "pieci gadi"
}Nosacījumi pakalpojumā Go
Programmā Go ir arī nosacījumi lēmumu pieņemšanai programmās. Jūs varat izmantot ja un cits paziņojumus savā kodā, lai apstrādātu lēmumus.
Šeit ir piemērs ja apgalvojums, kas salīdzina divus veselus skaitļus vienlīdzībai:
var a starpt = 12
ja a == 12 {
fmt. Println("a ir divpadsmit")
}
Jūs varat izmantot tikai cits paziņojumi pēc an norādīšanas ja paziņojums, un jums ir jānorāda cits bloks pēc slēgšanas ja bloķēt:
var a starpt = 12
ja a == 12 {
fmt. Println("a ir divpadsmit")
} cits {
fmt. Println ("a nav vienāds ar divpadsmit")
}
The cits bloks darbojas tikai tad, kad ja apgalvojums tiek novērtēts kā nepatiess. Go nesniedz citus, ja paziņojumus, taču varat tos izmantot slēdzis izteikumi sarežģītiem nosacījuma paziņojumiem.
Šeit ir a anatomija slēdzis paziņojums Go.
vecums := 7
slēdzis vecums {
lietu1:
fmt. Println ("viens")
lietu2:
fmt. Println("divi")
lietu3:
fmt. Println("trīs")
noklusējuma:
fmt. Println("nulle")
}
Varat izveidot pārslēgšanas paziņojumus, izmantojot slēdzis atslēgvārdu, pēc kura varat norādīt dažādus gadījumus ar lietu atslēgvārds. Varat apstrādāt noklusējuma reģistru, izmantojot a noklusējuma atslēgvārds.
Loops in Go
Go nodrošina for-ciklus atkārtotiem uzdevumiem, un atšķirībā no vairuma valodu programmā Go nav cilpas kamēr vai do-while.
Varat izmantot populāro C stila for-loop vai diapazons for-loop, ko atbalsta noteiktas datu struktūras.
Tālāk ir sniegts piemērs C stila cilpas izmantošanai programmā Go:
funcprinteris() {
priekš es := 0; es <= 3; i++ {
fmt. Println (i)
}
}
Varat izmantot Go iebūvēto diapazonu for-loop saliktām datu struktūrām, piemēram, šķēlumiem, kartēm un masīviem. The diapazons funkcija atgriež indeksu un indeksa elementu, šķērsojot datu struktūru.
priekš indekss, vērtība := diapazons dataStructure {
}Masīvi programmā Go
Masīvi ir viens no saliktajiem datu veidiem programmā Go. Go masīvi ir līdzīgi C stila masīviem, un tiem ir noteikts garums deklarācijā un instancē.
Lūk, kā jūs varat deklarēt masīvus programmā Go:
var arr [5]virkne
arr := [7]starpt{0, 1, 2, 3, 4, 5, 6}
Varat izmantot indeksēšanu, lai piekļūtu, piešķirtu un atjauninātu elementus masīva pozīcijā:
arr[3] = "trīs"
Iepriekš minētais kods atjaunina vai ievieto virkni kā ceturto ierakstu arr masīva mainīgais.
Šķēles programmā Go
Go nodrošina šķēles kā alternatīvu masīviem nenoteikta garuma datu apstrādei. Šķēles ir līdzīgas masīviem, izņemot to, ka varat mainīt šķēlumu garumu.
Jums būs jāizmanto iebūvētais veidot funkcija, lai izveidotu šķēli. Nododiet sadaļas datu tipu un sākotnējo garumu make funkcijai.
šķēle := veidot([]virkne, 9)
šķēle[2] = "divi"
Varat izmantot pievienošanas funkciju, lai ievietotu elementus šķēlēs. Pēc noklusējuma pievienot funkcija ievieto elementus šķēles beigās.
šķēle = pievienot(šķēle, "desmit")
Darbs ar pievienošanas darbībām šķēlēs var būt dārgs, jo Go izveido jaunu masīvu katrai pievienošanas darbībai.
Kartes pakalpojumā Go
Kartes ir Go iebūvētais asociatīvais (atslēgas vērtību pāra) datu tips. Jūs varat izmantot veidot funkciju, lai izveidotu karti vai vienkāršu deklarāciju, kurā jums būs jāveido karte.
kartes := veidot(karte[virkne]starpt) // izmantojot make funkciju
kartes := karte[virkne]starpt{"viens": 1, "divi": 2, "trīs": 3} // kartes deklarēšana un ģenerēšana
Varat piekļūt vērtībām kartē, norādot taustiņus. Varat arī ievietot vērtības kartē, norādot atslēgu un vērtību pāri.
kartes ["viens"] = 1// ievietošana kartē
viens := kartes["viens"] // piekļūstot elementam no kartes
Jūs varat izmantot dzēst funkcija, lai no kartēm noņemtu atslēgu un vērtību pārus. The dzēst funkcija saņem kartes identifikatoru un tā pāra atslēgu, kuru vēlaties noņemt:
dzēst(kartes, "viens")
Funkcijas programmā Go
Funkcijas ir rīks koda atkārtotai izmantošanai Go. Varat deklarēt funkcijas, izmantojot func atslēgvārds, kam seko funkcijas identifikators:
funcgalvenais() {
}
Funkcijas var pieņemt argumentus un atgriezt vērtības. Jums būs jānorāda argumenta veids līdzās argumentu identifikatoram.
funcpievienot(x virkne, g starpt)starpt {
atgriezties x + y
}
Jūs norādīsiet atgriešanas veidu pirms funkcijas koda bloka un atgriezīsiet norādītā tipa vērtību funkcijām, kas atgriež vērtības.
Struktūras lietotnē Go
Iet nav objektorientēta valoda pēc dizaina, bet varat ieviest objektorientētas funkcijas programmā Go izmantojot struktūras.
Struktūras ir lietotāja definēti veidi citu datu tipu grupēšanai vienā entītijā. Go struktūrās var būt jebkura Go atbalstītā veida vērtības, un funkcijas var ieviest struktūras.
Lūk, kā jūs varat deklarēt struktūru Go:
veids Spēle struktūra {
Vārds virkne
gads starpt
PlayTime pludiņš64
Spēlētāji jebkuri
valstis karte[virkne]virkne
}
The Spēle struct ir lauki ar kartes, virknes, vesela skaitļa un peldošā punkta veidiem. Varat izveidot struktūras ar noklusējuma vērtībām vai piešķirt tām vērtības.
var mko spēle // noklusējuma vērtības instantiācija
// instantimentēšana ar vērtībām
mko := spēle{
Nosaukums: "Vērtība",
Gads: 1231,
Spēlēšanas laiks: 1345412,
Spēlētāji: [2]virkne{"9", "sīkumi"},
dati: karte[virkne]starpt{"viens": 1, "divi": 2, "trīs": 2},
}
Funkcijas var ieviest un piekļūt struktūru veidiem. Pirms funkcijas identifikatora jums būs jānorāda struct parametrs.
func(g spēle)FindGame(vārds virkne) {
a := g. gads // piekļūstot struct laukiem
var b = g. valstis // piekļūstot struct laukiem
}
Kad funkcijai nododat struktūru, funkcijai ir piekļuve struktūras laukiem, un funkcija kļūst par struktūras metodi.
Go ir daudz lietošanas gadījumu
Jūs esat apguvis Go programmēšanas valodas pamatus un sintaksi, lai sāktu rakstīt Go programmas.
Ir daudz lauku un lietojumprogrammu, kur varat izmantot Go. Go tiek plaši izmantota kā servera puses valoda, un jūs vienmēr varat izpētīt arī tīmekļa lietojumprogrammu izveidi.
