Go (más néven Golang) egy nyílt forráskódú, statikusan típusos programozási nyelv. Eredetileg a Google fejlesztette ki. A Go néhány figyelemre méltó jellemzője az egyszerűség, a nagy teljesítmény, az olvashatóság és a hatékonyság.
Mint minden más kiemelkedő programozási nyelv, a Go szabványos könyvtára is csomagok gazdag készletét kínálja. Azonban a funkciókat harmadik féltől származó csomagok beépítésével is bővíthetjük. Ez az útmutató bemutatja a csomagok importálását és a Go-projektekbe való beépítését.
Előfeltételek
Az útmutató követéséhez a következő összetevőkre lesz szüksége:
- Egy megfelelően konfigurált Ubuntu szerver. Tudjon meg többet a saját Ubuntu szerverének konfigurálásáról a CloudSigma-n.
- A Go programozási környezet. Használhatja ezt az útmutatót a Go telepítéséhez Ubuntu-ra.
- Egy modern szövegszerkesztő, például Vim, Sublime Text, Atom, Visual Studio Code, Brackets, stb. Ez az útmutató a Visual Studio Code-ot fogja használni .
Step 1 – A Go telepítése
Korábban már tárgyaltuk az alapvető Go programozási nyelv telepítését Ubuntu 20.04-re. Létezik azonban egy egyszerűbb alternatív módszer is: g (egy könnyűsúlyú Go verziókezelő).
Azért fogjuk a g eszközt használni, mert az Ubuntu csomagtárolóiból vagy a snap-ből elérhető Go verziók egyike sem tartalmazza a legújabb elérhető Go verziót (v1.18 ezen útmutató írásakor). Mindig ajánlott bármely programozási nyelv csomagjának legújabb elérhető verzióját használni.
A következő parancs futtatja a g telepítő szkriptet:
|
1 |
wget -qO- https://git.io/g-install | sh -s |
A változtatások életbe lépéséhez újra kell indítania a shell munkamenetet. Az újraindítás után ellenőrizze a telepítést:
|
1 |
go version |
|
1 |
which go |
A Go telepítése után ajánlott a gopls telepítése is. Ez a hivatalos Go nyelvű szerver. Kompatibilis számos szövegszerkesztővel, mint például a VS Code, Vim, Emacs, Sublime Text, Atom és még sok más. Futtassa a következő parancsot:
|
1 |
go install golang.org/x/tools/gopls@latest |
A Go programozási környezetünk most már készen áll.
Step 2 – Egy minta Go szkript létrehozása
Az ebben az útmutatóban bemutatott összes kód egyetlen Go szkriptben elfér. Hozzon létre egy minta Go szkriptet:
|
1 |
touch practice.go |
A szkript módosítása után a következő Go paranccsal futtathatjuk azt:
|
1 |
go run practice.go |
Itt a Go fordító értelmező módban fogja futtatni a kódot.
Step 3 – A szabványos könyvtári csomagok használata
A Go hatalmas gyűjteménnyel rendelkezik a szabványos könyvtárában. Számos csomagból áll, például:
- fmt: Formázott I/O-t valósít meg a C-hez hasonló függvényekkel ( printf és scanf ).
- http: Ez a csomag függvényeket biztosít webszolgáltatások létrehozásához, adatok küldéséhez és fogadásához a http protokollon keresztül, stb.
Bármely csomag beépítéséhez egy Go projektbe, azt az import utasítással kell megvalósítani. Az utasítást az import kulcsszóval és a csomagok nevével kell deklarálni. Például a math/rand importálásához az import utasítás így nézne ki:
|
1 |
import "math/rand" |
A következő kód különböző függvényeket valósít meg a math/rand csomagból:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "math/rand" func main() { for i := 0; i < 10; i++ { println(rand.Intn(25)) } } |
Ez a kód egy egyszerű for ciklust mutat be, amely 10 véletlenszerű egész számot (0-tól 24-ig) ír ki a képernyőre. Itt:
- rand.Int() : Ez a függvényhívás egy véletlenszerű egész számot ad vissza.
- rand.Intn() : Hasonlóan működik, mint a rand.Int() de elfogad egy paramétert, amely meghatározza a véletlenszerű egész számok tartományát (0-tól a megadott számig).
Ezután futtassa a kódot:
|
1 |
go run practice.go |
A kimenet így fog kinézni:
Vegye figyelembe, hogy a kimenet pontosan ugyanaz lesz, mivel a véletlenszám-generátor magértéke alapértelmezés szerint egy rögzített érték. Ez a tulajdonsága egy pszeudovéletlenszám-generátornak. További információkat tudhat meg a véletlenszerű magról itt.
4. lépés – Több csomag importálása
A nagyobb és összetettebb projekteknek több csomagot is be kell építeniük. Hogyan importálhatja őket a Go kódjába? Az egyik érvényes lehetőség az, hogy minden egyes importált csomaghoz külön import utasításokat használ. Ez a megközelítés azonban nem hatékony a következő importálási struktúrához képest:
|
1 2 3 4 5 6 7 8 9 |
import ( "<package_1>" "<package_2>" "<package_3>" ) |
Itt egyetlen import utasítás egyszerre több csomagot is magában foglal. Ez csökkenti a megírandó kód mennyiségét, miközben javítja az olvashatóságot.
A következő kód működés közben mutatja be ezt a funkciót:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Futtassa a kódot:
|
1 |
go run practice.go |
A kimenet valahogy így fog kinézni:
5. lépés – További Go könyvtárak telepítése
A Go szabványos könyvtára számos hasznos csomagot tartalmaz. Ezek tervezésüknél fogva általános célúak. Lehetővé teszi a fejlesztők számára, hogy saját csomagokat hozzanak létre a szabványos könyvtárra építve, hogy megfeleljenek a specifikus igényeiknek. Tekintse meg a hivatalos Go csomagadatbázist.
Mi van, ha egy harmadik féltől származó Go csomagot kell implementálnia? A Go tartalmazza a go install parancsot (a go get elavult). Ez bármilyen harmadik féltől származó Go csomagot le tud tölteni az internetről.
A bemutatóhoz telepíteni fogjuk a cobra-cli csomagot. A következő Go parancs letölti és telepíti a szükséges fájlokat, és integrálja a csomagot a Go könyvtárrendszerbe:
|
1 |
go install github.com/spf13/cobra-cli@latest |
A cobra-cli binárisának a következő helyen kell lennie:
|
1 |
ls -l $GOPATH/bin |
A többi csomagfájlnak a következő helyen kell lennie:
|
1 |
ls -l $GOPATH/pkg/mod/github.com/spf13 |
A Go v1.11 verziótól kezdve a Go modulok határozzák meg az importálni kívánt csomag verzióját. Ezt itt részletesen elmagyarázzák: Go Modules GitHub.
6. lépés – Csomagálnevek
Különböző helyzetekben ütköző csomagneveket találhat a helyi és az importált csomagok között. Itt az álnévadás (aliasing) megoldhatja az ütközést. Az álnév-struktúra valahogy így néz ki:
|
1 |
import <alias> "import_package_name" |
Módosítsuk az egyszerű Go programunkat, hogy beépítsük a fmt_alias álnevet a fmt :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( fmt_alias "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt_alias.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Vegye figyelembe, hogy a fmt.Printf() helyett a fmt_alias.Printf() .
A Go azonban nem annyira befogadó az álnevekkel szemben. Ha álneveket használ az importálási névütközések elkerülése érdekében, javasolt a leginkább helyi vagy projekt-specifikus importáláshoz álnevet rendelni. Például, ha egy helyi strings csomagot és egy strings rendszercsomagot is szeretne, akkor a helyi csomagnak kell álnevet adnia, nem a rendszercsomagnak.
A legjobb gyakorlat az, hogy eleve elkerüljük a névütközéseket.
7. lépés – Importálások formázása
Megtanultuk az összes importálást egyetlen import utasítással deklarálni. Mi van, ha több importálása van? Például:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import ( "fmt" "os" "github.com/example/foo" "github.com/example/bar" "math/rand" "github.com/abc/pqr/xyz" ) |
Az importok formázása meghatározott sorrendbe rendezi a csomagokat, javítva a kód konzisztenciáját. Mivel csak az importok sorrendjét rendezi, megelőzi a felesleges commitokat is. Emellett megakadályozza a szükségtelen kódmódosításokat és a zavaró kód-felülvizsgálatokat.
A legtöbb modern szerkesztő automatikusan formázza az importokat. Alternatív megoldásként támogatják a goimports eszközt. Az iparágban bevett gyakorlat a goimports használata az importok manuális rendezése helyett. Emellett a goimports a kód stílusbeli változásait is tükrözi.
Így nézhet ki az import blokk, miután alkalmaztuk a goimports :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import ( fmt_alias "fmt" "math/rand" "os" "github.com/example/foo" "github.com/example/bar" "github.com/abc/pqr/xyz" ) |
Észrevesz valamilyen mintát?
- Az összes szabványos könyvtár az első csoportba van rendezve.
- A csoportokat üres sorok választják el, ami javítja a kód olvashatóságát.
Záró gondolatok
Az importálás a Go-ban egy erőteljes funkció, amely lehetővé teszi a Go-ba be nem épített függvények meghívását. Bár a szabványos könyvtár számos általános célú csomagot kínál, a Go támogatja a külső csomagokat is. Ez az útmutató bemutatja a beépített és a külső Go csomagok importálását.
Ebben az útmutatóban az értelmező segítségével futtattuk a Go programjainkat. Azonban a jobb teljesítmény érdekében a kódokat önálló binárisokká is fordíthatja. További információkat itt talál a Go programok fordításáról. Ha szeretné megtudni, hogyan kell Go webalkalmazást telepíteni Nginx-szel, tekintse meg ezt az útmutatót. Emellett megtekintheti az alábbi útmutatónkat is, amely bemutatja, hogyan írhat saját Go csomagokat.
Ön Go fejlesztő? A CloudSigma Go API-támogatást kínál a projektjeivel való zökkenőmentes integráció érdekében.
Kellemes kódolást!
Hozzászólások
Még nincsenek hozzászólások. Legyen Ön az első.