[[:oktatas:programozás:go|< Go]]

====== Go nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) 2025, Sallai András
  * Szerkesztve: 2025
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu

===== Bevezetés =====

A Go nyelv **Google** által támogatott nyelv, de a tulajdonosa **Robert Griesemer**. 2007-ben kezdték, az első nyilvános kiadás 2009-ben volt. Névütközés miatt Golang nyelvnek szokták nevezni.

A fejlesztés során az egyszerűség és a hatékonyság volt a cél. Szintaxisa a C nyelvhez
áll közel, a típusdeklaráció kivételével. De eltér az if és a ciklus utasítások szintaxisa is.

Webhely:
  * https://go.dev/
===== Helló Világ =====

Készítsünk egy hello.go nevű állományt, amelynek tartalma a következő:

<code go hello.go>
package main

import "fmt"

func main() {
    fmt.Println("Helló Világ")
}
</code>

Futtatás:
  go run hello.go


Fordítás és fordított alkalmazás futtatása:
  go build hello.go
  ./hello

A Go programokat egy .go kiterjesztésű fájlba írjuk. Futtatni a go run paranccsal tudjuk. Fordítás és futtatásra is lehetőség van.



===== Megjegyzés =====

<code go>
// egy soros

/* több
   soros
   megjegyzés
   */
</code>

===== Kivitel =====

<code go ki.go>
package main

func main() {
    println("Helló Világ!")
}

</code>


<code go ki.go>
package main

import "fmt"

func main() {
    fmt.Println("első")
    fmt.Println("második")
}
</code>


<code go ki.go>
package main

import "fmt"

func main() {
    fmt.Print("első")
    fmt.Println("második")
}
</code>


Kifejezések:

<code go ki.go>
fmt.Println(3 * 5)
</code>

Több paraméter:

<code go>
fmt.Println("egy", "kettő")
</code>

===== Escape szekvenciák =====

<code go escape.go>
package main

import "fmt"

func main() {
    fmt.Println("me\ntés")
}
</code>


<code go escape.go>
package main

import "fmt"

func main() {
    fmt.Println("men\tés")
}
</code>


| \a | Csengőhang |
| \b | Backspace |
| \\\\ | Backslash |
| \t | Vízszintes tabulátor |
| \n | Új sor |
| \f | Lapdobás |
| \r | Kocsi vissza |
| \v | Függőleges tabulátor |
| <nowiki>\'</nowiki> | Egyszeres idézőjel |
| <nowiki>\"</nowiki> | Kétszeres idézőjel |


| \x | pontosan két hexadecimális szám követi |
| \  | pontosan három hexadecimális szám követi |
| \u | pontosan négy hexadecimális szám követi|
| \U | pontosan nyolc hexadecimális szám követi |


===== Változók =====

<code go>
var a = 35
</code>

Egyszerűsített verzió:

<code go>
a := 35
</code>

<code go valtozo.go>
package main

import "fmt"

func main() {
    var a = 35
    fmt.Println(a)
}

</code>

==== Valós számok ====

<code go>
var num1 float32 = 3.14
var num2 float64 = 2.71828
</code>

===== Formázott kimenet =====

<code go forma.go>
package main

import "fmt"

func main() {
	var a = 35
	fmt.Printf("%d\n", a)
}

</code>

===== Matematikai könyvtárak =====

<code go matek.go>
package main

import (
    "fmt"
    "math"
)

func main() {
    var a = -9.0
    fmt.Println(math.Abs(a))
}
</code>

===== Véletlen szám =====

<code go rand.go>
package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())
    var a = rand.Intn(10-1) + 1
    fmt.Println(a)
}

</code>

===== Operátorok =====

<code go opera.go>
package main

func main() {
	var a = 30
	var b = 35
	var res1 = a + b
	var res2 = a - b
	var res3 = a * b
	var res4 = a / b

	println(res1, res2, res3, res4)
}

</code>

===== Konvertálás =====

Szöveg számmá:

<code go>
package main

import (
    "fmt"
    "reflect"
    "strconv"
)

func main() {
    var szoveg = "45"
    var szam, err = strconv.Atoi(szoveg)

    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(reflect.TypeOf(szam))
    }
}
</code>

===== Bekérés =====

<code go beker.go>
package main

import (
	"fmt"
)

func main() {
	var nev string
	fmt.Print("Add meg a neved: ")
	fmt.Scanln(&nev)
	fmt.Println("Helló ", nev)
}
</code>

  go run beker.go


Szám bekérése:

<code go beker.go>
package main

import (
	"fmt"
)

func main() {
	var num int
	fmt.Print("Add meg az életkorod: ")
	fmt.Scanln(&num)
	fmt.Println("Helló ", num, " éves")
}
</code>

===== Szelekció =====

A if utasítás használható szelekcióra. A if kulcsszó után zárójelek nélkül leírjuk a feltételt. 
A blokkot a kapcsos zárójelek "{}" határozzák meg.

<code go szel.go>
package main

import (
	"fmt"
)

func main() {
	var num int
	fmt.Print("Írj be egy számot: ")
	fmt.Scanln(&num)

	if num > 0 {
		fmt.Println("A szám pozitív.")
	} else if num < 0 {
		fmt.Println("A szám negatív.")
	} else {
		fmt.Println("A szám nulla.")
	}
}

</code>


A switch:

<code go szel.go>
package main

import (
	"fmt"
)

func main() {
	var num int
	fmt.Print("Írj be egy számot: ")
	fmt.Scanln(&num)

	switch num {
	case 0:
		fmt.Println("Nulla")
	case 1:
		fmt.Println("Egy")
	case 2:
		fmt.Println("Kettő")
	default:
		fmt.Println("Imseretlen")
	}
}
</code>

===== Iteráció =====

A Go nyelvben egyetlen ciklus utasítás van, de az használható több módon is.

Számláló típusú ciklus:

<code go ite.go>
package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}
</code>

A for csak feltétellel, azaz amíg típusú ciklus:

<code go ite.go>
package main

import (
	"fmt"
)

func main() {
	i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}
}
</code>

Végtelen ciklus megszakítva:

<code go cik.go>
func main() {
	i := 0
	for {
		if i > 5 {
			break
		}
		fmt.Println(i)
		i++
	}
}

</code>


A range ciklus:

<code go cik.go>
package main

import (
	"fmt"
)

func main() {
	nums := []int{1, 2, 3, 4, 5}

	for index, value := range nums {
		fmt.Println(index, value)
	}
}

</code>

===== Függvények =====

A függvényeket a **func** kulcsszóval vezetjük be. Sorrendjük mindegy.
Ha visszatérési értéket is megadunk a **return** utasítást kell használnunk.

<code go fug.go>
package main

import (
	"fmt"
)

func main() {
	about()
}

func about() {
	fmt.Println("Para Irén")
	fmt.Println("Szeged")
}

</code>


<code go fugpa.go>
package main

import (
	"fmt"
)

func main() {
	calcDouble(10)
}

func calcDouble(num int) {
	fmt.Println(num * 2)
}

</code>

Visszaadott érték:

<code go vissza.go>
package main

import (
	"fmt"
)

func main() {
	var sum = calcSum(1, 2)

	fmt.Println(sum)
}

func calcSum(num1 int, num2 int) int {
	return num1 + num2
}
</code>

===== Karakterláncok =====

<code go kar.go>
package main

import (
	"fmt"
)

func main() {
	var szoveg string = `
		Aranyszabály
		köztudott
		`
	fmt.Println(szoveg)
}
</code>

==== Hossz ====

Hány bájt hosszú:

<code go>
word := "árvíztűrő"
fmt.Println(len(word))
</code>

Karakterek száma:

<code go karakterek.go>
package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	word := "árvíztűrő"
	fmt.Println(utf8.RuneCountInString(word))
}
</code>

===== Tömbök =====

<code go tomb.go>
package main

import (
	"fmt"
)

func main() {
	var numbers [4]int
	numbers[0] = 35
	numbers[1] = 45
	numbers[2] = 55
	numbers[3] = 65
	fmt.Println(numbers[0])
}
</code>

Tömb kezdőértékkel:
<code go tomb2.go>
package main

import (
	"fmt"
)

func main() {
	numbers := [4]int{35, 45, 55, 65}
	fmt.Println(numbers[0])
}

</code>

==== Valós számok ====


<code go>
numbers := [4]float32{3.7, 3.5, 3.4, 3.6}
fmt.Println(numbers)
</code>


==== Méret ====

<code go>
numbers := [4]int{35, 45, 55, 65}
fmt.Println(len(numbers))
</code>


==== Fájlkezelés ====

<code go hozzafuzes.go>
package main

import (
	"fmt"
	"os"
)

func main() {
	fp, err := os.OpenFile("beker.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer fp.Close()
	fmt.Fprintln(fp, "alma")
}
</code>

A **defer** utasítás hatására a bezárás csak akkor hajtódik végre, ha függvény végrehajtása
a végére ért.


Beolvasás:

<code go beolvas.go>
package main

import (
	"fmt"
	"os"
)

func main() {
	data, err := os.ReadFile("beker.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(string(data))
}

</code>

==== Beolvasás soronkénti bejárással ====

<code go beolvasbejar.go>
package main

import (
	"fmt"
	"os"
	"bufio"
)

func main() {
	file, err := os.Open("beker.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		fmt.Println(err)
	}
}

</code>