A Golang, amelyet Go programozási nyelvnek is neveznek, egy nyílt forráskódú programozási nyelv, amelyet a Google tervezett 2007-ben. Ennek a nyelvnek az 1.0-s verzióját 2012-ben adták ki. Ez egy strukturált programozási nyelv, mint a C, és különböző típusú alkalmazások, például hálózati szolgáltatások, felhő alkalmazások, webalkalmazások stb. fejleszthetők Golang nyelven. Sokféle csomagot tartalmaz, mint például a Python. Nagyon könnyen megtanulható, ezért ez a nyelv népszerű az új programozók körében. Ebben az oktatóanyagban 30 Golang programozási példát magyaráztunk el, hogy megtanulják a Golang nyelvet az alapoktól.
Előfeltételek:
A Golangot különböző típusú operációs rendszerek támogatják. A Golang Ubuntu rendszerre történő telepítésének módját az oktatóanyag ezen részében mutattuk be. Futtassa a következő parancsokat a rendszer frissítéséhez és a Golang telepítéséhez, mielőtt az oktatóanyagban szereplő példákat gyakorolná.
$ sudo találó frissítés
$ sudo alkalmas telepítés nőnek
Futtassa a következő parancsot a Golang telepített verziójának ellenőrzéséhez.
$ go verzió
- Hello hello világ
- Golang karakterlánc változók
- Golang int a húrba
- Golang karakterlánc befelé t
- Golang karakterlánc összefűzése
- Golang többsoros karakterlánc
- Golang hasított karakterlánc
- Golang sprintf
- Golang enum
- Golang struktúra
- Golán tömb
- Golang készletek
- Golang for loop
- Golang a tartományért
- Golang while ciklus
- Golang folytatja
- Golang kapcsolótok
- Golang véletlen szám
- Golang alvás
- aranykor
- Golang uuid
- Golang olvassa el a fájlt
- Golang soronként olvassa el a fájlt
- Golang írás a fájlba
- Golang ellenőrizze, hogy létezik-e fájl
- Golán csv
- Golang yaml
- Golang http kérés
- Golang parancssori argumentumok
- Golang hibakezelés
Hello hello világ
A fő- A Golang csomag tartalmazza az összes szükséges csomagot a Golang programozáshoz, és ez szükséges a Golang szkript végrehajtásának elindításához. A fmt csomagot kell importálni a formázott karakterlánc terminálban történő kinyomtatásához. Hozzon létre egy Golang fájlt a következő szkripttel. A 'Hello World.' karakterlánc értéke a szkript végrehajtása után kerül kinyomtatásra a terminálba.
//Importálja az fmt csomagot a kimenet kinyomtatásához
import 'fmt'
//Határozza meg a main() függvényt a végrehajtás elindításához
func fő- () {
//Egy egyszerű üzenet nyomtatása az új sorral
fmt . Println ( 'Helló Világ.' )
}
Futtassa a következő parancsot a szkript végrehajtásához. Itt a szkript el lett mentve az example1, go fájlba.
$ futtasd az example1.go-tFuttassa a következő parancsot a Golang fájl bináris fájljának létrehozásához.
$ go build example1.go
Futtassa a következő parancsot a végrehajtható fájl futtatásához.
$ . / példa1A fenti parancsok végrehajtása után a következő kimenet jelenik meg,
Golang karakterlánc változók
A karakterlánc-változók az adattípus meghatározása nélkül és az adattípussal együtt használhatók Golangban. Hozzon létre egy Golang-fájlt a következő szkripttel, amely egyszerű karakterlánc-adatokat és a karakterlánc-adatokat a karakterlánc-változókkal nyomtatja ki. A felhasználási területek Printf() és Println() függvények jelennek meg a szkriptben.
csomag fő-//Importálja az fmt csomagot a kimenet kinyomtatásához
import 'fmt'
//A main() függvény meghatározása
func fő- () {
//Nyomtassa ki a karakterlánc értékét egy új sorral
fmt . Printf ( Tanulja meg a Golangot a LinuxHint.com webhelyről. \n ' )
//Az első karakterlánc-változó meghatározása
volt str1 = 'Golang programozás.'
//A változó kinyomtatása újsor nélkül
fmt . Printf ( 'Tanul' , str1 )
//A második karakterlánc-változó meghatározása
volt str2 = 'könnyű megtanulni.'
//Nyomtassa ki a változót újsorral
fmt . Println ( 'Ez' , str2 )
}
A fenti szkript végrehajtása után a következő kimenet jelenik meg. Ide kerül kinyomtatásra a két összefűzött karakterlánc kimenete.
Golang int a húrba
A strconv.Choke() és strconv.FormatInt() függvények segítségével az egész számot karakterlánc értékké alakíthatjuk Golangban. A strconv.Choke() az egész érték számsorrá alakítására szolgál. A strconv.FormatInt() függvény a decimális alapú egész értékek karakterláncsá alakítására szolgál. Hozzon létre egy Golang-fájlt a következő szkripttel, amely bemutatja az egész szám karakterláncsá alakításának módját Golangban a fent említett funkciók segítségével. A rendszer egy számot vesz a felhasználótól, és a szám megfelelő karakterlánc-értéke kerül kinyomtatásra kimenetként.
//A fő csomag hozzáadásacsomag fő-
//Importálja az fmt és strconv csomagokat
import (
'fmt'
'strconv'
)
//A fő függvény meghatározása
func fő- () {
//Egész változó deklarálása
volt n int
//Üzenet nyomtatása
fmt . Printf ( 'Írjon be egy számot:' )
//Bemenet vétele a felhasználótól
fmt . Letapogatás ( & n )
//Egész szám átalakítása stringgé az Itoa() függvény segítségével
konvertálni1 := strconv . megfulladt ( n )
fmt . Printf ( 'Egész szám átalakítása stringgé az Itoa(): %s használatával \n ' , konvertálni1 )
//Egész szám átalakítása stringgé a FormatInt() függvény segítségével
megtérít2 := strconv . FormatInt ( int64 ( n ), 10 )
fmt . Printf ( 'Egész szám átalakítása stringgé a FormatInt(): %s használatával \n ' , megtérít2 )
}
A következő kimenet jelenik meg a szkript végrehajtása után. A szám. A 45 karakterláncra lett konvertálva. „45”.
Golang karakterlánc int
A strconv.Atoi() függvény a karakterlánc egész számmá alakítására szolgál Golang nyelven. Egy karakterlánc értéket vesz fel, amelyet egész számmá alakít, és kétféle értéket ad vissza. Az egyik érték az egész szám, ha a beszélgetés sikeres, egy másik érték a hiba, ha a beszélgetés egyébként sikertelen nulla értéket adják vissza. Hozzon létre egy Golang-fájlt a következő szkripttel, amely számos karakterlánc-értéket egész számmá konvertál a használatával strconv.Atoi() funkció. A „342” karakterlánc értéke 342-es számmá alakul, és a végrehajtás után kinyomtatásra kerül.
//A fő csomag hozzáadásacsomag fő-
//Importálja az fmt és strconv csomagokat
import (
'fmt'
'strconv'
)
//A fő függvény meghatározása
func fő- () {
//String változó deklarálása
str := '342'
//A karakterláncot egész számmá alakítja az Atoi() függvény segítségével
ár , téved := strconv . filmelőzetes ( str )
//hibakeresés
ha téved == nulla {
//Nyomtassa ki a konvertált értéket
fmt . Printf ( 'A könyv ára %d \n ' , ár )
} más {
//Nyomtassa ki a hibaüzenetet
fmt . Println ( téved )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után. A „342” karakterlánc értéke itt 342-re lett konvertálva.
Golang karakterlánc összefűzése
Hozzon létre egy Golang fájlt a következő szkripttel, amely összefűzi a karakterláncokat a „+” operátorral a Printf() függvény segítségével. A Println() függvényt itt használták az összefűzött karakterlánc értékének kinyomtatására a „+” operátor használatával, a Printf() függvényt pedig az összefűzött karakterlánc értékének kinyomtatására a „%s” megadóval. Két karakterlánc-változót deklaráltak a szkriptben, amelyeket később összefűzünk.
//A fő csomag hozzáadásacsomag fő-
//Importálja az fmt csomagot a kimenet kinyomtatásához
import 'fmt'
//A fő függvény meghatározása
func fő- () {
//Két karakterlánc-változó deklarálása
volt str1 , str2 húr
//String értékek hozzárendelése
str1 = 'Golán'
str2 = 'programozás'
//Karakterlánc összefűzése '+' operátor használatával
fmt . Println ( 'Összefűzött karakterlánc-érték + operátor használatával:' , str1 + str2 )
//Karakterlánc összefűzése a '%s' specifikátor használatával
fmt . Printf ( 'Összefűzött karakterlánc-érték formátum-specifikátor használatával: %s%s \n ' , str1 , str2 )
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang többsoros karakterlánc
A következő példában három különböző módot mutatunk be a többsoros szöveg kinyomtatására a Golang szkript használatával. A „\n” karaktert használták az első karakterlánc-változóban a többsoros szöveg létrehozásához. A második karakterláncban a backtick-eket (`) használták a többsoros szöveg nyomtatására. A specifikációkkal ellátott backtick-eket (`) a harmadik karakterláncban használták többsoros szöveg nyomtatására.
csomag fő-//Importálja az fmt csomagot
import 'fmt'
//A fő függvény meghatározása
func fő- () {
//Többsoros karakterlánc-érték deklarálása '\n' karakterrel
str1 := 'A Golang programozása nagyon egyszerű \n tanulni. \n \n '
fmt . Printf ( str1 )
//Többsoros karakterlánc-érték deklarálása backtick-ekkel (`)
str2 := `Tanulj
Golang
tól től
LinuxHint
Blog.`
fmt . Printf ( '%s \n \n ' , str2 )
//Két karakterlánc-érték deklarálása
nyelv := 'golan'
fejlesztő := 'Google'
//String érték deklarálása változókkal és backtickekkel
str3 := `%s
van
fejlett
által
%s.`
fmt . Printf ( str3 , nyelv , fejlesztő )
//Új sor hozzáadása
fmt . Println ()
}
A következő kimenet jelenik meg a szkript végrehajtása után. A három, többsoros karakterlánc-értékeket tartalmazó karakterlánc-változó kimenete ide került kinyomtatásra.
Golang hasított karakterlánc
A strings.Split() függvényt használták a karakterlánc adatok felosztására az elválasztó alapján. A következő szkript egy karakterlánc-értéket vesz a felhasználótól, és a karakterlánc értékét a kettőspont (:) alapján osztja fel. A felosztási értékek teljes száma és az első két felosztási érték a végrehajtás után kerül kinyomtatásra.
csomag fő-//Importálja az fmt és a strings csomagokat
import (
'fmt'
'húrok'
)
//A fő függvény meghatározása
func fő- () {
//String változó deklarálása
volt str húr
//Üzenet nyomtatása
fmt . Printf ( 'Írjon be egy karakterláncot kettősponttal(:)-' )
//Bemenet vétele a felhasználótól
fmt . Letapogatás ( & str )
//Határozza meg az elválasztót
szétválasztó := ':'
//Vasd fel a karakterlánc értékét
split_value := húrok . Hasított ( str , szétválasztó )
//Számolja meg a felosztott értékek számát
hossz := csak ( split_value )
//Nyomtassa ki a felosztott értékek számát
fmt . Printf ( 'Az osztott értékek teljes száma %d \n ' , hossz )
//Nyomtassa ki a felosztott értékeket
fmt . Println ( 'Az első osztott érték' , split_value [ 0 ])
fmt . Println ( 'A második felosztási érték' , split_value [ 1 ])
}
A következő kimenet jelenik meg a szkript végrehajtása után. A „golang:google” bemeneti értéket a kettőspont (:) alapján két részre osztották.
Golang sprintf
A Sprintf() függvény a Golang nyelvben a formázott karakterlánc-értékek változóba való tárolására szolgál, mint más szabványos programozási nyelveknél. A következő szkriptben egy karakterláncot és egy egész változót deklaráltunk. Ezeknek a változóknak az értékeit a Sprintf() függvény segítségével formáztuk és egy változóban tároltuk.
csomag fő-//Importálja az fmt csomagot
import 'fmt'
//A fő függvény meghatározása
func fő- () {
//Két változó deklarálása
volt str húr
volt az egyiken int
//String érték hozzárendelése
str = 'golan'
//Számérték hozzárendelése
az egyiken = 2012
//A kombinált karakterlánc értékének tárolása egy változóban
kombinált_str := fmt . Sprintf ( 'A %s első verziója %d múlva jelenik meg.' , str , az egyiken )
//Nyomtassa ki a változót
fmt . Printf ( 'A Sprintf() kimenete: \n %s \n ' , kombinált_str )
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang enum
Az enum vagy enumerator a Golang nyelvben a kapcsolódó állandó értékek egy csoportjának adattípusának deklarálására szolgál. Az enum típus deklarációja a Golang nyelvben eltér a többi programozási nyelvtől. Egy 12 értékből álló enum típust deklaráltak, és az adott enum érték numerikus értékét később nyomtattuk ki.
csomag fő-//Importálja az fmt csomagot
import 'fmt'
//Deklarálja a típust a hónap értékének számban tárolásához (1-12)
típus Hónap int
//Konstansok deklarálása minden hónap értékéhez 1-től kezdve
const (
Jan hónap = iota + 1
Február
márc
Április
Lehet
Június
Július
Augusztus
szept
Október
November
December
)
//Főfüggvény deklarálása
func fő- () {
//Változó deklarálása havi értékkel
volt M_num = Lehet
//Nyomtassa ki a hónap megfelelő számértékét
fmt . Println ( 'A hónap értéke számban' , M_num )
}
A következő kimenet jelenik meg a szkript végrehajtása után. A május megfelelő számértéke 5.
Golang struktúra
A struktúra vagy struktúra a Golang nyelvben olyan típus deklarálására szolgál, amely különböző típusú változókat tartalmaz. Hasznos táblázatos adatok vagy több rekord tárolására. A következő szkriptben egy négy elemből álló szerkezeti változót deklaráltak. Ezután két rekordot adtunk hozzá a definiált struct változó használatával. A struktúra értékeinek különböző módon történő kinyomtatásának módját a script utolsó részében mutattuk be.
csomag fő-//Fmt csomag importálása
import 'fmt'
//Négy elemből álló szerkezet meghatározása
típus Termék struct {
id húr
név húr
méret húr
ár int
}
func fő- () {
//Az első szerkezeti változó deklarálása
termék1 := Termék { 'p-1209' , 'HDD' , '5 TB' , 80 }
//A második szerkezeti változó deklarálása
termék2 := Termék { 'p-7342' , 'Egér' , '' , tizenöt }
//Nyomtassa ki a szerkezeti változókat
fmt . Println ( 'Első termék:' , termék1 )
fmt . Println ( 'Második termék:' , termék2 )
//Az első szerkezeti változó négy értékének kinyomtatása külön
fmt . Println ( 'Első termékadatok:' )
fmt . Println ( 'azonosító:' , termék1 . id )
fmt . Println ( 'Név:' , termék1 . név )
fmt . Println ( 'Méret:' , termék1 . méret )
fmt . Println ( 'Ár: ' , termék1 . ár )
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golán tömb
A tömbváltozót a Golang nyelvben az adott adattípus több értékének tárolására használják, más szabványos programozási nyelvekhez hasonlóan. A karakterlánc-értékek tömbjének és a numerikus értékek tömbjének deklarálásának és elérésének módja a szkriptben látható.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
//Karakterláncértékek tömbjének deklarálása
str_arr := [ 4 ] húr { 'Google com' , 'ask.com' , 'bing.com' , 'you.com' }
//A karakterlánc tömbjének kinyomtatása
fmt . Println ( 'A string tömb értékei a következők: , str_arr )
//Nyomtassa ki a tömb 3. elemét
fmt . Println ( 'A tömb 3. értéke' , str_arr [ 2 ])
//Numerikus értékek tömbjének deklarálása
int_arr := [ 6 ] int { 65 , 3. 4 , 12 , 81 , 52 , 70 }
//Az egész számok tömbjének kinyomtatása
fmt . Println ( 'Az egész szám tömb értékei: ' , int_arr )
//Nyomtassa ki a tömb 4. elemét
fmt . Println ( 'A tömb 4. értéke' , int_arr [ 3 ])
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang készletek
A készlet a Golang másik adatstruktúrája, amely különböző értékek gyűjteményét tárolja. Egyedi értékek tárolására szolgál egy objektumban. A Golangnak nincs beépített adatszerkezete, mint a többi programozási nyelvnek. De ez a funkció megvalósítható üres struct{} és map használatával. A következő szkriptben a karakterláncok egy halmazváltozóját deklaráltuk egy üres struktúrával rendelkező leképezés használatával. Ezután három értéket adtunk hozzá, egy értéket töröltünk, és egy értéket ismét hozzáadtunk a készlethez. A készlet értékei egyben és külön is ki vannak nyomtatva.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
//A karakterláncok készletének meghatározása
éppen := térkép [ húr ] struct {}{}
//Három elem beszúrása a halmazba üres struktúra használatával
éppen [ 'Megy' ] = struct {}{}
éppen [ 'Bash' ] = struct {}{}
éppen [ 'Piton' ] = struct {}{}
//A halmaz aktuálisan meglévő elemeinek kinyomtatása
fmt . Println ( éppen )
//Egy elem eltávolítása a halmazból
töröl ( éppen , 'Piton' )
//Új elem hozzáadása a halmazhoz
éppen [ 'Jáva' ] = struct {}{}
//A beállított értékek kinyomtatása egy elem eltávolítása és hozzáadása után
fmt . Println ( éppen )
fmt . Printf ( ' \n A beállított értékek a következők: \n ' )
//A készlet minden elemét külön nyomtatja ki
számára l := hatótávolság éppen {
fmt . Println ( l )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang for loop
A for ciklus többféleképpen és különböző célokra használható Golangban. A ciklus három kifejezésének használatát mutatja be a következő szkript. A ciklus 5-ször ismétlődik, hogy 5 bemeneti értéket kapjon, és ezeknek a bemeneti értékeknek az összegét később nyomtatja ki.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
//Egész változó deklarálása
volt szám int
//Változó deklarálása az összeg értékének tárolására
volt összeg = 0
//A for ciklus meghatározása
számára n := 1 ; n < = 5 ; n ++ {
//Üzenet nyomtatása
fmt . Printf ( 'Írjon be egy számot:' )
//Bemenet vétele a felhasználótól
fmt . Letapogatás ( & szám )
//Adja hozzá a bemeneti számot az összeg változóval
összeg = összeg + szám
}
//Nyomtassa ki az összegzés eredményét
fmt . Printf ( 'Öt bemeneti érték összege %d \n ' , összeg )
}
A következő kimenet jelenik meg a szkript végrehajtása után. 6, 3, 4, 7 és 9 összege 29.
Golang a tartományért
A tartomány a for ciklussal együtt használatos a Golangban a karakterlánc, tömb és leképezés eléréséhez. A karakterláncok tömbjének elérési módját egy for ciklus tartomány használatával a következő szkript mutatja be. Az első for ciklus csak a tömbértékeket írja ki, a második for ciklus pedig a tömb indexeit és értékeit.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
//Deklarál egy karakterlánc tömböt
virágok := [ 4 ] húr { 'Rózsa' , 'Liliom' , 'Dalia' , 'Napvirág' }
fmt . Println ( 'A tömb értékei:' )
//Nyomtassa ki a tömbértékeket
számára _ , val := hatótávolság virágok {
fmt . Println ( val )
}
fmt . Println ( 'A tömb indexei és értékei a következők: )
//A tömb értékeinek kinyomtatása index alapján
számára ban ben , val := hatótávolság virágok {
fmt . Printf ( '%d := %s \n ' , ban ben + 1 , val )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang while ciklus
A Golangnak nincs while ciklusa, mint a többi programozási nyelvnek. A while ciklus funkciója azonban megvalósítható Golangban a for ciklus használatával. A while ciklus for ciklussal való megvalósításának módja a következő szkriptben látható. A for ciklus 4-szer ismétlődik, és négy számot vesz fel. Ezeknek a számoknak az összege a tört értékkel később kerül kinyomtatásra.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
számláló := 1
összeg := 0 . 0
volt szám úszó64
számára számláló < = 4 {
//Üzenet nyomtatása
fmt . Printf ( 'Írjon be egy számot:' )
//Bemenet vétele a felhasználótól
fmt . Letapogatás ( & szám )
//Adja hozzá a bemeneti számot az összeg változóval
összeg = összeg + szám
//Növelje a számlálót 1-gyel
számláló ++
}
//Nyomtassa ki az összegzés eredményét
fmt . Printf ( 'Négy bemeneti érték összege %0.2f \n ' , összeg )
}
A következő kimenet jelenik meg a szkript végrehajtása után. A 6,8, 3,2, 8,5 és 4,9 összege 23,40.
Golang folytatja
A folytatódó utasítás bármely ciklusban használatos az adott utasítások feltétel alapján történő elhagyására. A következő szkriptben a for ciklust használták annak a ciklusnak az iterálására, amely kihagyja a tömb 2. és negyedik értékének értékét a turpināt utasítással.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
számláló := 1
összeg := 0 . 0
volt szám úszó64
számára számláló < = 4 {
//Üzenet nyomtatása
fmt . Printf ( 'Írjon be egy számot:' )
//Bemenet vétele a felhasználótól
fmt . Letapogatás ( & szám )
//Adja hozzá a bemeneti számot az összeg változóval
összeg = összeg + szám
//Növelje a számlálót 1-gyel
számláló ++
}
//Nyomtassa ki az összegzés eredményét
fmt . Printf ( 'Négy bemeneti érték összege %0.2f \n ' , összeg )
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang kapcsolótok
A Golang nyelvben a kis- és nagybetűk váltása hasonló a többi programozási nyelvhez, de nincs szükség a break utasításra a Golang nyelvben. A kapcsolóblokkon belüli több esetérték meghatározásának módját a következő példa mutatja be.
csomag fő-//Fmt csomag importálása
import 'fmt'
func fő- () {
volt n int
//Üzenet nyomtatása
fmt . Printf ( 'Írja be a hónap értékét számban: ' )
//Bemenet vétele a felhasználótól
fmt . Letapogatás ( & n )
//Üzenet nyomtatása a megfelelő kis- és nagybetűérték alapján
kapcsoló n {
ügy 1 , 2 , 3 , 4 :
fmt . Println ( – Téli szemeszter. )
ügy 5 , 6 , 7 , 8 :
fmt . Println ( – Nyári félév. )
ügy 9 , 10 , tizenegy , 12 :
fmt . Println ( 'Őszi szemeszter.' )
alapértelmezett :
fmt . Println ( 'A hónap értéke kívül esik a tartományon.' )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang véletlen szám
A math/rand csomagot a Golangban véletlen számok generálására használták. A négyféle véletlenszám generálásának módját a következő szkript mutatja be. A rand.Int() függvény egy hosszú egész véletlenszám generálására szolgál. A rand.Intn(n) függvény az adott tartomány véletlenszerű egész számának generálására szolgál, és a legmagasabb érték kerül átadásra a függvény argumentumértékeként. A 999 van beállítva argumentumként a szkriptben. A rand.Float32() függvény egy rövid tört véletlenszám, a rand.Float64() függvény pedig egy hosszú tört véletlenszám generálására szolgál.
//Fő csomag hozzáadásacsomag fő-
//Importálja a szükséges modulokat
import (
'fmt'
'idő'
'matematika/rand'
)
func fő- () {
//Seed beállítása véletlen szám generálására
rand . Mag ( idő . Most () . UnixNano ())
//Generált véletlen egész szám nyomtatása
fmt . Println ( 'Véletlenszerű egész érték: ' , rand . Int ())
//Nyomtassa ki a véletlenszerű egész számot 999-en belül
fmt . Println ( 'Véletlenszerű egész szám tartománnyal: ' , rand . Intn ( 999 ))
//Véletlenszerű 32 bites float nyomtatása
fmt . Println ( 'Véletlenszerű 32 bites lebegő érték: ' , rand . Úszó32 ())
//Véletlenszerű 64 bites float nyomtatása
fmt . Println ( 'Véletlenszerű 64 bites lebegő érték: ' , rand . Úszó64 ())
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang alvás
A time.Sleep() függvény a Golangban a szkript végrehajtásának szüneteltetésére szolgál egy bizonyos ideig. A következő szkript kiszámolja három szám átlagát, és vár 3 másodpercet, mielőtt leállítja a szkriptet.
//Fő csomag hozzáadásacsomag fő-
//Importálja a szükséges csomagokat
import (
'fmt'
'idő'
)
func fő- () {
fmt . Println ( 'Indítsa el a script futtatását...' )
//Három változó meghatározása
a := 40
b := 30
c := 29
//Nyomtassa ki a változókat
fmt . Printf ( 'A három szám a következő: %d, %d, %d \n ' , a , b , c )
fmt . Println ( 'Három szám átlagának kiszámítása...' )
átl := ( a + b + c ) / 3
//3 másodperc késleltetés
idő . Alvás ( 3 * idő . Második )
//Nyomtassa ki az eredményeket
fmt . Printf ( 'Az átlagos érték %d \n ' , átl )
fmt . Println ( 'A program megszakadt.' )
}
A következő kimenet jelenik meg a szkript végrehajtása után.
aranykor
Az időcsomag Golangban az aktuális dátum és idő leolvasására szolgál. Ez a csomag számos módszerrel és tulajdonsággal rendelkezik a dátum és az idő különböző módon történő olvasásához. A dátum és idő, „Mon Jan 2 15:04:05 -0700 MST 2006” referenciaértékként szolgál a Golangban a dátum és idő eléréséhez. Az időcsomag felhasználási módjait a következő példa mutatja be.
csomag fő-//Importálja a szükséges csomagokat
import (
'fmt'
'idő'
)
func fő- () {
//Olvassa be az aktuális dátumot és időt
Ma := idő . Most ()
//Az aktuális dátum kinyomtatása
fmt . Printf ( 'Ma %s. \n ' , Ma . Formátum ( '2006. január 02.' ))
//Az aktuális dátum és idő nyomtatása
fmt . Printf ( 'A jelenlegi dátum és idő %s \n ' , Ma . Formátum ( idő . RFC1123 ))
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang uuid
Az UUID vagy univerzálisan egyedi azonosító a Golang szkripttel generálható. Ez egy 128 bites egyedi érték a számítógépes rendszer azonosítására. Le kell töltenie az uuid-t a github.com/google/uuid mielőtt végrehajtaná a következő szkriptet.
Lépjen a kezdőkönyvtárba, és futtassa a következő parancsokat a szükséges csomag letöltéséhez az uuid by Golang szkript létrehozásához.
$ go mod init uuid$ keresd meg a github.com-ot / Google / uuid
A következő szkriptben az első uuid az uuid.New() függvény használatával jön létre, amely egyedi azonosítót ad vissza. A második uuid-t az uuid.NewUUID() függvény hozza létre, amely két értéket ad vissza. Az érték tartalmazza az egyedi azonosítót, a második érték pedig a hibaüzenetet, ha létezik.
csomag fő-//Importálja a szükséges csomagokat
import (
'fmt'
'github.com/google/uuid'
)
func fő- () {
//Egyedi azonosító létrehozása a New() függvény segítségével
newID := uuid . Új ()
fmt . Printf ( 'Az első generált UUID %s. \n ' , newID )
//Egyedi azonosító létrehozása a NewUUID() függvény segítségével
newID , téved := uuid . ÚjUUID ()
//Hiba ellenőrzése
ha téved == nulla {
fmt . Printf ( 'A generált második UUID %s. \n ' , newID )
} más {
fmt . Println ( téved )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang olvassa el a fájlt
A io/ioutil A Golang csomag egy fájl tartalmának olvasására szolgál. A csomag ReadFile() függvénye beolvassa a fájl teljes tartalmát. Ez a függvény a fájl teljes tartalmát egy változóba adja vissza, ha a fájl létezik, különben hibaüzenet jelenik meg. Egy létező szövegfájl teljes tartalmának beolvasásának módját a következő szkript mutatja be.
//Fő csomag hozzáadásacsomag fő-
//Importálja a szükséges csomagokat
import (
'io/ioutil'
'fmt'
'napló'
)
func fő- () {
//Szövegfájl olvasása
szöveg , téved := ioutil . Fájl olvasása ( 'Languages.txt' )
//Hiba ellenőrzése
ha téved == nulla {
fmt . Printf ( 'A fájl tartalma: \n \n ' )
fmt . Println ( húr ( szöveg ))
} más {
log . Fatalf ( 'Fájlolvasási hiba: %v' , téved )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang soronként olvassa el a fájlt
A Golang „bufio” csomagja egy fájl tartalmának soronkénti olvasására szolgál. A következő szkriptben a bufio.NewScanner() egy objektumot hozott létre a fájl olvasásához. Ezután a Scan() függvényt használták a hurokkal a fájl minden sorának beolvasására és kinyomtatására.
//Fő csomag hozzáadásacsomag fő-
//Importálja a szükséges csomagokat
import (
'fmt'
'te'
'bufio'
)
func fő- () {
//Szöveges fájl megnyitása olvasásra
fh , téved := te . Nyisd ki ( 'Languages.txt' )
//Hiba ellenőrzése
ha téved == nulla {
//A fájl tartalmának beolvasása
olvas := bufio . NewScanner ( fh )
//Olvasd el soronként a fájlt
számára olvas . Letapogatás () {
fmt . Println ( olvas . Szöveg ())
}
} más {
fmt . Println ( téved )
}
//Zárja be a fájlt
elhalasztja fh . Bezárás ()
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang írás a fájlba
A te A Golang csomag egy fájl megnyitására szolgál íráshoz és a WriteString() A funkció a tartalom fájlba írására szolgál. A háromsoros szövegfájl létrehozásának és írásának módja a te csomag.
csomag fő-//Importálja a szükséges csomagokat
import (
'fmt'
'te'
)
func fő- () {
//Fájl megnyitása íráshoz
fh , hiba1 := te . Teremt ( 'elemek.txt' )
//Fájllétrehozási hiba ellenőrzése
ha hiba1 == nulla {
//Írja be a fájlba
_ , hiba2 := fh . WriteString ( 'Toll \n Ceruza \n Vonalzó \n ' )
//Fájlírási hiba ellenőrzése
ha hiba2 != nulla {
fmt . Println ( 'Fájlírási hiba történt. \n ' )
}
} más {
fmt . Println ( 'Fájl létrehozási hiba történt. \n ' )
}
//Zárja be a fájlt
elhalasztja fh . Bezárás ()
}
A következő kimenet jelenik meg a szkript végrehajtása után. A kimenet azt mutatja, hogy az items.txt fájl sikeresen létrejött.
Golang ellenőrzi, hogy létezik-e fájl
A te A Golang csomag segítségével ellenőrizheti a fájl létezését. A következő szkriptben a fájl elérési útja a szkriptből lesz átvéve. Ha az elérési út nem létezik, akkor az os.State() függvény egy an os.ErrNotExist hiba.
csomag fő-//Importálja a szükséges modult
import (
'hibák'
'fmt'
'te'
)
func fő- () {
volt fájl elérési út húr
fmt . Printf ( 'Írjon be egy meglévő fájlnevet: ' )
//Vegye el a fájl elérési útját a felhasználótól
fmt . Letapogatás ( & fájl elérési út )
//Ellenőrizze a fájl elérési útját
_ , hiba := te . statisztika ( fájl elérési út )
//Ellenőrizze az os.Stat kimenetét
ha ! hibákat . Is ( hiba , te . ErrNotExist ) {
fmt . Println ( 'A fájl található.' )
} más {
fmt . Println ( 'A fájl nem található.' )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golán csv
A „kódolás/csv” csomagot a Golangban használják a CSV-fájl tartalmának olvasására. A csv.NewReader() függvény a CSV-fájl olvasására szolgál. A példa szkriptjének végrehajtása előtt hozzon létre egy CSV-fájlt. Itt, a ügyfelek.csv fájlt használták a CSV-fájl olvasási módjának bemutatására.
csomag fő-//Importálja a szükséges csomagokat
import (
'kódolás/csv'
'fmt'
'te'
)
func fő- () {
//CSV-fájl megnyitása olvasásra
fh , téved := te . Nyisd ki ( 'customers.csv' )
//Ellenőrizze a hibát
ha téved != nulla {
fmt . Println ( téved )
} más {
//Objektum létrehozása a CSV-fájl olvasásához
scanner := csv . NewReader ( fh )
//Olvassa el a CSV-fájl összes rekordját
rekordokat , _ := scanner . Mindent olvas ()
//Sorról sorra olvassa el a CSV-fájlt
számára _ , r := hatótávolság rekordokat {
számára _ , c := hatótávolság r {
fmt . Printf ( '%s' , c )
}
fmt . Println ()
}
}
//Zárja be a fájlt
elhalasztja fh . Bezárás ()
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang yaml
A yaml.Marshal() függvény a Golangban a yaml adatok tartalmának olvasására szolgál. Le kell töltened a yaml csomagot használni a yaml.Marshal() . Lépjen a kezdőkönyvtárba, és futtassa a következő parancsot a letöltéshez yaml csomag.
$ szerezz < a href = 'http://gopkg.in/yaml.v2' > gopkg.in / yaml.v2 a >A következő szkriptben egy négy elemből álló szerkezeti változót deklaráltak, amelyet később egy yaml objektum adatokkal történő meghatározására használtak. Ezután a yaml.Marshal() függvényt használták a yaml adatok eléréséhez.
csomag fő-//Importálja a szükséges csomagokat
import (
'fmt'
'gopkg.in/yaml.v2'
)
//Négy elemből álló szerkezet deklarálása
típus Könyv struct {
Cím húr
Szerző húr
Kiadvány húr
Ár húr
}
func fő- () {
//A szerkezet objektumának létrehozása
könyv1 := Könyv {
Cím : 'Learning Go' ,
Szerző : 'John Bodner' ,
Kiadvány : 'O'Relly' ,
Ár : '39 dollár' ,
}
//A yaml adatok beolvasása a struct alapján
y_data , téved := yaml . Marshall ( &book1 )
//Ellenőrizze a hibát
ha téved == nulla {
//Nyomtassa ki a yaml adatokat
fmt . Println ( húr ( y_data ))
} más {
fmt . Printf ( 'Hiba az elrendezés során. %v' , téved )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang http kérés
A net/http A Golang csomag a http kérések elküldésére szolgál egy webhelynek. A http.Get() függvény a kérés elküldésére szolgál. Visszaadja a webhely válaszát vagy a hibaüzenetet. A http kérés webhelyre küldésének módja, https://example.com a következő szkriptben látható.
csomag fő-//Importálja a szükséges csomagokat
import (
'fmt'
'net/http'
)
func fő- () {
//GET kérés küldése egy webhelynek
res , téved := http . Kap ( 'https://example.com' )
//Hiba ellenőrzése
ha téved == nulla {
//Nyomtassa ki a webhely által küldött választ
fmt . Println ( res )
} más {
//Nyomtassa ki a hibaüzenetet
fmt . Println ( téved )
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang parancssori argumentumok
A szkript végrehajtása során átadott értékeket parancssori argumentumértékeknek nevezzük. Az os csomag a Golang parancssori argumentumértékeinek beolvasására szolgál. Az argumentumok értékeit az Args[] tömb tárolja. A tartományt tartalmazó for ciklust használták a szkriptben az argumentumértékek kinyomtatására a szkript neve nélkül minden sorba.
csomag fő-//Importálja a szükséges csomagokat
import (
'fmt'
'te'
)
func fő- () {
fmt . Println ( 'Minden argumentumérték:' )
//Minden argumentumérték nyomtatása a szkript nevével
fmt . Println ( te . Args )
fmt . Println ( 'Argumentum értékek:' )
//Minden argumentumérték nyomtatása szkriptnév nélkül
számára ban ben , _ := hatótávolság te . Args {
ha ban ben == 0 {
folytatni
}
fmt . Println ( te . Args [ ban ben ])
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Golang hibakezelés
A Golangnak nincs try-catch blokkja, mint a többi programozási nyelvnek. Azonban a hibákat csomag használható a Golangban a szkript hibáinak kezelésére. A következő szkriptben egy egész számot veszünk a felhasználótól. Ha a felhasználó negatív számot vesz fel, akkor hibaüzenet jelenik meg. A hibák.Új() funkciót használták itt a hibaüzenet generálására.
csomag fő-//Importálja a szükséges csomagokat
import (
'hibák'
'fmt'
)
func fő- () {
volt n int
fmt . Printf ( 'Írjon be egy számot:' )
fmt . Letapogatás ( & n )
//Ellenőrizze a bemeneti értéket
eredmény , téved := Pozitív ( n )
//Hiba ellenőrzése
ha téved != nulla {
fmt . Println ( téved )
} más {
fmt . Printf ( '%d %s \n ' , n , eredmény )
}
}
///Funkció meghatározása a pozitív szám ellenőrzéséhez
func Pozitív ( az egyiken int ) ( húr , hiba ) {
ha szám < 0 {
Visszatérés '' , hibákat . Új ( 'Írjon be egy pozitív számot.' )
} más {
Visszatérés 'a szám pozitív.' , nulla
}
}
A következő kimenet jelenik meg a szkript végrehajtása után.
Következtetés:
A Golang egy népszerű programozási nyelv, amely számos hasznos csomagot tartalmaz, például a Python programozási nyelvet. Bármely kezdő felhasználó megtanulhatja a Golangot első programozási nyelvként, mert nagyon könnyű megtanulni. Ebben az oktatóanyagban az alapvető 30 golang-példát magyaráztuk el, hogy a kezdetektől megtanulják a golangot, és a tanulók programokat írhassanak golang nyelven. Ennek a nyelvnek az egyik fő korlátja, hogy nem tartalmazza az objektum-orientált programozás jellemzőit, de alkalmas a strukturált programozás tanulására.