From 3015cfb4367ffe7e06df5232cb4aa5924194715d Mon Sep 17 00:00:00 2001 From: Leonardy Kristianto Date: Wed, 28 Oct 2015 02:14:13 +0800 Subject: Rename go.html.markdown to go-hu.html.markdown --- hu-hu/go.html.markdown | 337 ------------------------------------------------- 1 file changed, 337 deletions(-) delete mode 100644 hu-hu/go.html.markdown (limited to 'hu-hu/go.html.markdown') diff --git a/hu-hu/go.html.markdown b/hu-hu/go.html.markdown deleted file mode 100644 index 638c9489..00000000 --- a/hu-hu/go.html.markdown +++ /dev/null @@ -1,337 +0,0 @@ ---- -language: Go -lang: hu-hu -filename: learngo-hu.go -contributors: - - ["Sonia Keys", "https://github.com/soniakeys"] -translators: - - ["Szabó Krisztián", "https://github.com/thenonameguy/"] - - ["Árpád Goretity", "https://github.com/H2CO3"] ---- - -A Go programozási nyelv az életszerű feladatok könnyebb elvégzése miatt született. -A mai legújabb programozási trendeket elkerülve, -praktikus megoldást nyújt a valós, üzleti problémákra. - -C-szerű szintaktikával és statikus típuskezeléssel rendelkezik. -A fordító szempillantás alatt végez és egy gyorsan futó,statikus futtatható állományt hoz létre. -A nyelv könnyen érthető, folyamatok közötti csatornákon áthaladó üzenetekkel kommunikáló konkurens programozást tesz lehetővé, így könnyen ki lehet használni -a mai számítógépek több magos processzorait, ez nagy rendszerek építéséhez ideális. - -A Go alap könyvtára mindenre területre kiterjed, ennek köszönhetően a nyelvnek egyre növekvő tábora van. - -```go -// Egy soros komment -/* Több - soros komment */ - -// Minden forrás fájl egy csomag-definícióval kezdődik, ez hasonlít a Python -// csomagkezelésére -// A main egy különleges csomagnév, ennek a fordítása futtatható állományt hoz -// létre egy könyvtár helyett. -package main - -// Az import rész meghatározza melyik csomagokat kívánjuk használni ebben a -// forrásfájlban -import ( - "fmt" // A Go alap könyvtárának része - "net/http" // Beépített webszerver! - "strconv" // Stringek átalakítására szolgáló csomag -) - -// Függvénydeklarálás, a main nevű függvény a program kezdőpontja. -func main() { - // Println kiírja a beadott paramétereket a standard kimenetre. - // Ha más csomagot függvényeit akarjuk használni, akkor azt jelezni kell a - // csomag nevével - fmt.Println("Hello world!") - - // Meghívunk egy másik függvényt ebből a csomagból - beyondHello() -} - -// A függvények paraméterei zárójelek között vannak. -// Ha nincsenek paraméterek, akkor is kötelező a zárójel-pár. -func beyondHello() { - var x int // Változó deklaráció, használat előtt muszáj ezt megtenni. - x = 3 // Változó értékadás - // "Rövid" deklaráció is létezik, ez az érték alapján deklarálja, - // definiálja és értéket is ad a változónak - y := 4 - sum, prod := learnMultiple(x, y) // a függvényeknek több - // visszatérési értéke is lehet - fmt.Println("sum:", sum, "prod:", prod) // egyszerű kiíratás - learnTypes() -} - -// A funkcióknak elnevezett visszatérési értékük is lehet -func learnMultiple(x, y int) (sum, prod int) { - return x + y, x * y // visszatérünk két értékkel - /* - sum = x + y - prod = x * y - return - Ez ugyanezzel az eredménnyel járt volna, mint a fenti sor. - Üres return esetén, az elnevezett visszatérési változók - aktuális értékeikkel térnek vissza. */ -} - -// Beépített típusok -func learnTypes() { - // Rövid deklarálás az esetek többségében elég lesz a változókhoz - s := "Tanulj Go-t!" // string típus - - s2 := `A "nyers" stringekben lehetnek - újsorok is!` // de ettől még ez is ugyanolyan string mint az s, nincs külön - // típusa - - // nem ASCII karakterek. Minden Go forrás UTF-8 és a stringek is azok. - g := 'Σ' // rúna(rune) típus, megegyezik az uint32-vel, egy UTF-8 karaktert - // tárol - - f := 3.14195 // float64, az IEEE-754 szabványnak megfelelő 64-bites - // lebegőpontos szám - c := 3 + 4i // complex128, belsőleg két float64-gyel tárolva - - // Var szintaxis változótípus-definiálással - var u uint = 7 // unsigned, az implementáció dönti el mekkora, akárcsak az - // int-nél - var pi float32 = 22. / 7 - - // Rövid deklarásnál átalakítás is lehetséges - n := byte('\n') // byte típus, ami megegyezik az uint8-al - - // A tömböknek fordítás-időben fixált méretük van - var a4 [4]int // egy tömb 4 int-tel, mind 0-ra inicializálva - a3 := [...]int{3, 1, 5} // egy tömb 3 int-tel, láthatóan inicalizálva egyedi - // értékekre - - // A "szeleteknek" (slices) dinamikus a méretük. A szeleteknek és a tömböknek is - // megvannak az előnyeik de a szeleteket sokkal gyakrabban használjuk. - s3 := []int{4, 5, 9} // vesd össze a3-mal, nincsenek pontok. - s4 := make([]int, 4) // allokál 4 int-et, mind 0-ra inicializálva - var d2 [][]float64 // ez csak deklaráció, semmi sincs még allokálva - bs := []byte("a slice") // típus konverzió szintaxisa - - p, q := learnMemory() // deklarál két mutatót (p,q), két int-re - fmt.Println(*p, *q) // * követi a mutatót. Ez a sor kiírja a két int értékét. - - // A map a dinamikusan növelhető asszociatív tömb része a nyelvnek, hasonlít - // a hash és dictionary típusokra más nyelvekben. - m := map[string]int{"three": 3, "four": 4} - m["one"] = 1 - - // A felhasználatlan változók fordítás-idejű hibát okoznak a Go-ban. - // Az aláhúzással "használod" a változókat, de eldobod az értéküket. - _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs - // Kiíratás is természetesen használatnak minősül - fmt.Println(s, c, a4, s3, d2, m) - - learnFlowControl() -} - -// A Go nyelvben szemétgyűjtés (garbage collection) működik. Megtalálhatók benne -// mutatók, de nincs pointeraritmetika. Ez azt jelenti, hogy üres (null) mutatóval még -// mindig hibázhatsz, de hozzáadni/műveleteket végezni már nem lehet. -func learnMemory() (p, q *int) { - // Elnevezett visszatérési változóknak int-re mutató a típusa - p = new(int) // a beépített "new" funkció, egy típusnak elegendő memóriát - // allokál, és visszaad rá egy mutatót. - // Az allokált int nullázva van, p többé nem üres mutató. - s := make([]int, 20) // allokáljunk 20 int változót egy memóriaterületen. - s[3] = 7 // adjunk értéket az egyiknek - r := -2 // hozzánk létre egy lokális változót - return &s[3], &r // A & megadja a memóriacímét a változónak -} - -func expensiveComputation() int { - return 1e6 -} - -func learnFlowControl() { - // Az elágazásoknak kötelező a kapcsos zárójel, a zárójel nem szükséges. - if true { - fmt.Println("megmondtam") - } - // A kód formátumát a nyelvvel járó "go" parancssori program "go fmt" - // parancsa szabványosítja - if false { - // így lehet - } else { - // if/else-t csinálni - } - // Használjunk switchet a hosszabb elágazások alkalmazása helyett. - x := 1 - switch x { - case 0: - case 1: - // Az "esetek" nem "esnek át", tehát - case 2: - // ez nem fog lefutni, nincs szükség break-ekre. - } - // A for ciklus sem használ zárójeleket - for x := 0; x < 3; x++ { - fmt.Println("iteráció", x) - } - // itt az x == 1. - - // A for az egyetlen ciklus fajta a Go-ban, de több formája van. - for { // végtelen ciklus - break // csak vicceltem - continue // soha nem fut le - } - - //Akárcsak a for-nál, az if-nél is lehet rövid deklarálással egy lokális változót létrehozni, - //ami a blokk összes if/else szerkezetén keresztül érvényes marad. - if y := expensiveComputation(); y > x { - x = y - } - // Függvényeket használhatjuk closure-ként is. - xBig := func() bool { - return x > 100 // a switch felett deklarált x-et használjuk itt - } - fmt.Println("xBig:", xBig()) // igaz (utoljára 1e6 lett az értéke az x-nek) - x /= 1e5 // így most már x == 10 - fmt.Println("xBig:", xBig()) // 10 pedig kisebb mint 100, tehát hamis - - // Ha nagyon-nagyon szükséges, akkor használhatjuk a jó öreg goto-t. - goto love -love: - - learnInterfaces() // Itt kezdődnek az érdekes dolgok! -} - -// Definiáljuk a Stringert egy olyan interfésznek, amelynek egy metódusa van, a -// String, ami visszatér egy stringgel. -type Stringer interface { - String() string -} - -// Definiáljuk a pair-t egy olyan struktúrának amelynek két int változója van, -// x és y. -type pair struct { - x, y int -} - -// Definiáljunk egy metódust a pair struktúrának, ezzel teljesítve a Stringer interfészt. -func (p pair) String() string { // p lesz a "fogadó" (receiver) - // Sprintf az fmt csomag egy publikus függvénye, műkődése megegyezik a C-s - // megfelelőjével. A pontokkal érjük el a mindenkori p struktúra elemeit - return fmt.Sprintf("(%d, %d)", p.x, p.y) -} - -func learnInterfaces() { - // A kapcsos zárójellel jelezzük, hogy egyből inicializálni - // szeretnénk a struktúra változóit a sorrendnek megfelelően. - p := pair{3, 4} - fmt.Println(p.String()) // meghívjuk a p String metódusát. - var i Stringer // deklaráljuk i-t Stringer típusú interfésznek - i = p // lehetséges, mert a pair struktúra eleget tesz a - // Stringer interfésznek - // Meghívjuk i String metódusát, az eredmény ugyanaz, mint az előbb. - fmt.Println(i.String()) - - // Az fmt csomag függvényei automatikusan meghívják a String függvényt - // hogy megtudják egy objektum szöveges reprezentációját. - fmt.Println(p) // ugyan az az eredmény mint az előbb, a Println meghívja - // a String metódust. - fmt.Println(i) // dettó - - learnErrorHandling() -} - -func learnErrorHandling() { - // ", ok" szokásos megoldás arra, hogy jól működött-e a függvény. - m := map[int]string{3: "three", 4: "four"} - if x, ok := m[1]; !ok { // ok hamis lesz, mert az 1 nincs benne a map-ban. - fmt.Println("nincs meg") - } else { - fmt.Print(x) // x lenne az érték, ha benne lenne a map-ban. - } - // A hiba érték többet is elmond a függvény kimeneteléről, mint hogy minden - // "ok" volt-e - if _, err := strconv.Atoi("non-int"); err != nil { // _ eldobja az értéket, - // úgy se lesz jó jelen - // esetben - // kiírja, hogy "strconv.ParseInt: parsing "non-int": invalid syntax" - fmt.Println(err) - } - // Az interfészekre még visszatérünk, addig is jöjjön a konkurens programozás! - learnConcurrency() -} - -// c egy csatorna, egy konkurens-biztos kommunikációs objektum. -func inc(i int, c chan int) { - c <- i + 1 // <- a "küldés" operátor, ha a bal oldalán csatorna van, így - // i+1-et küld be a csatornába -} - -// Az inc-et fogjuk arra használni, hogy konkurensen megnöveljünk számokat -func learnConcurrency() { - // Ugyanaz a make függvény, amivel korábban szeleteket hoztunk létre. - // A make allokál map-eket, szeleteket és csatornákat. - c := make(chan int) - // Indítsunk három konkurens goroutine-t. A számok konkurensen lesznek - // megnövelve, ha a számítógép képes rá és jól be van állítva, akkor pedig - // paralellizálva/egymás mellett. Mind a 3 ugyanabba a csatornába küldi az - // eredményeket. - go inc(0, c) // A go utasítás indít el goroutine-okat. - go inc(10, c) - go inc(-805, c) - // Beolvassuk 3x a csatornából az eredményeket és kiírjuk őket a kimenetre. - // Nem lehet tudni milyen sorrendben fognak érkezni az eredmények! - fmt.Println(<-c, <-c, <-c) // hogyha a jobb oldalon csatorna van, akkor a - // "<-" a beolvasó/kapó operátor - - cs := make(chan string) // még egy csatorna, ez stringekkel kommunikál - cc := make(chan chan string) // egy csatorna csatornával - go func() { c <- 84 }() // indítsunk egy új goroutine-t, csak azért - // hogy küldjünk egy számot - go func() { cs <- "wordy" }() // ugyanez, csak a cs csatornába stringet - // küldünk - // A select olyan mint a switch, csak feltételek helyett csatorna műveletek - // vannak. Véletlenszerűen kiválasztja az első olyan esetet, ahol létrejöhet - // kommunikáció. - select { - case i := <-c: // a megkapott értéket el lehet tárolni egy változóban - fmt.Println("ez egy", i) - case <-cs: // vagy el lehet dobni az értékét - fmt.Println("ez egy string volt") - case <-cc: // üres csatorna, soha nem fog rajta semmi se érkezni - fmt.Println("sose futok le :'( ") - } - // Ezen a ponton vagy c vagy a cs goroutine-ja lefutott. - // Amelyik hamarabb végzett, annak a megfelelő case-e lefutott, a másik - // blokkolva vár. - - learnWebProgramming() // a Go képes rá. Te is képes akarsz rá lenni. -} - -// Egy függvény a http csomagból elindít egy webszervert. -func learnWebProgramming() { - // A ListenAndServe első paramétre egy TCP port, amin kiszolgálunk majd. - // Második paramétere egy interfész, pontosabban a http.Handler interfész. - err := http.ListenAndServe(":8080", pair{}) - fmt.Println(err) // nem felejtjük el kiírni az esetleges hibákat! -} - -// Csináljunk a pair-ból egy http.Handler-t úgy, hogy implementáljuk az -// egyetlen metódusát, a ServeHTTP-t. -func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { - // Minden kapcsolatra elküldjük ezt a http.ResponseWriter-rel - w.Write([]byte("Megtanultad a Go-t Y perc alatt!")) -} -``` - -## További olvasmányok - -Minden Go-val kapcsolatos megtaláható a [hivatalos Go weboldalon](http://golang.org/). -Ott követhetsz egy tutorialt, játszhatsz a nyelvvel az interneten, és sok érdekességet olvashatsz. - -A nyelv specifikációját kifejezetten érdemes olvasni, viszonylag rövid és sokat tanul belőle az ember. - -Ha pedig jobban bele akarod vetni magad a Go-ba, akkor a legjobb praktikákat kilesheted a standard könyvtárból. -TIPP: a dokumentációban kattints egy függvény nevére és rögtön megmutatja a hozzá tartozó kódot! - -Ha pedig a nyelvnek egy bizonyos részéről szeretnél hasonló leírást találni, akkor a -[gobyexample.com](https://gobyexample.com/)-on megtalálod, amit keresel. -- cgit v1.2.3