Začínáme programovat v Go: 7. díl – funkce

V dneším díle tutoriálu se podíváme na funkce. Funkce je blok příkazů, které mají se mají provést po zavolání. Funkce se vytváří pomocí klíčového slova func. Už jsme se setkali s funkcí main, kterou musí mít program, pokud se má spustil a také s funkcí Println z balíčku fmt, která do konzole zobrazí předané hodnoty (argumenty). V této části tutoriálu se naučíme vytvářet si funkce vlastní.

func sayHello() {
	fmt.Println("Ahoj")
}

Tato funkce zobrazí do konzole text „Ahoj“.

func sayName(name string) {
	fmt.Println("Jmenuji se", name)
}

Tato funkce zobrazí text „Jmenuji se“ a zároveň text, který dostane jako argument. Dalo by se to zapsat též jako fmt.Println(„Jmenuji se “ + name)

func getBy() string {
	return "Měj se"
}

Tato funkce vrátí hodnotu (textový retězec). Pokud chceme, aby funkce něco vrátila, použijeme klíčové slovo return. Zde říkám vrať string „Měj se“. Zároveň musíme určit, jaký datový typ má funkce vracet. Typ návratové hodnoty se zadává za kulaté závorky (func getBy() string { … }).

A zde je celý kód.

package main

import (
	"fmt"
)

func main() {
	sayHello()
	sayName("John")
	fmt.Println(getBy())
}

func sayHello() {
	fmt.Println("Ahoj")
}

func sayName(name string) {
	fmt.Println("Jmenuji se", name)
}

func getBy() string {
	return "Měj se"
}

Ještě upozorním na příkaz fmt.Println(getBy()). Nejdříve se zavolá funkce getBy(), která vrátí string „Měj se“. Tento string se předá do funkce Println, která jej vytiskne. Je to totéž, jako bycho provedli toto:

var by string = getBy()
fmt.Println(by)

Úkol
Vytvořte program se čtyřmi funkcemi. Každá funkce bude mít dva parametry (dvě celá čísla) a bude vracet výsledek. Funkce budou pro sčítán, odčítání, násobení a dělení. Výsledky zobrazte pomocí funkce Println. Opět upozorňuji na to, že pokud počítáte s celými čísly, tak výsledek operace dělení, který vrací desetinné číslo, bude pouze celočíselná část (3 : 2 = 1,5 celočíselná část je 1, takže výsledek bude 1 a ne 1,5)

Možné řešení

package main

import (
	"fmt"
)

func main() {
	var x int = 6
	var y int = 2

	/* Hodnotu vrácenou funkcí můžeme uložit do proměnné a tu potom zobrazit */
	var addResult = add(x, y)
	fmt.Println(addResult)

	/* Nebo můžeme rovnou zobrazit hodnotu bez mezikroku s přiřazením proměnné. */
	fmt.Println(substract(x, y))
	fmt.Println(multiply(x, y))
	fmt.Println(divide(x, y))
}

func add(x int, y int) int {
	return x + y
}

func substract(x int, y int) int {
	return x - y
}

func multiply(x int, y int) int {
	return x * y
}

func divide(x int, y int) int {
	return x / y
}

Začínáme programovat v Go: 6. díl – základní datové typy

V tomto díle se seznámíme s některými základními datovými typy. Nebude se jednat o komplexní výčet. S dalšími se pak postupně seznámíme v dalších dílech tutoriálu.

boolean
Hodnota může být pravda (true), nebo nepravda (false)

string
Textový řetězec. S tímto datovým typem jsme se již setkali. Cokoliv uzavřené v dvojitých uvozovkách je považováno za textový retězec (string).

int
Celé číslo.

Nejlepší je ukázat si vše na příkladu.

package main

import "fmt"

func main() {
	var x int = 12
	var y int = 7
	var a string = "12"
	var b string = "7"
	var yes bool = true
	var no bool = false

	fmt.Println(x, y, x + y)
	fmt.Println(a, b, a + b)
	fmt.Println(yes, no)
}

Výsledek

12 7 19
12 7 127
true false

Při vytváření (deklaraci) proměnných se nejdříve uvede klíčové slovo var (jako variable), následně pak název proměnné a nakonec její datový typ. Rovnítkem se proměnné přiřadí hodnota.

Vytváříme dvě proměnné typu celé číslo (x, y), dvě proměnné typu textový řetězec (a, b) a dvě proměnné typu pravda nepravda (yes, no). Všimněte si, že pokud použime operátor pro sčítání (+) na čísla, provede se matematická operace sčítání (12 + 7 = 19) a pokud stejný operátor použijeme na textové řetězce, dojde k jejich spojení („12“ + „7“ = „127“). Funkce Println zobrazí všechny argumenty (hodnoty), které dostane.

Úkol
Vytvořte program, ve kterém budete mít několik proměnných typu int (celé číslo) a proveďte s nimi operace sčítání (+), odčítání (-), násobení (*) a dělení (/). Pozor na to, že int je celé číslo. Pokud budete dělit dvě celá čísla např. 7 děleno 3, tak výsledek bude 2 (a ne 2,3333333).

Možné řešení

package main

import "fmt"

func main() {
	var x int = 16
	var y int = 8

	fmt.Println(x + y)
	fmt.Println(x - y)
	fmt.Println(x * y)
	fmt.Println(x / y)
}

Začínáme programovat v Go: 5. díl – spojování řetězců

V tomto díle si ukážeme, jak spojovat textové řetězce dohromady. Textové řetězce můžeme spojovat pomocí operátoru + (plus).

var name string = "John"
var surname string = "Smith"

fmt.Println(name + " " + surname")

Tato část kódu by na obrazovku vytiskla John Smith. Došlo by ke spojení tří textových řetězců a to „John“, “ “ a „Smith“ a zobrazení výsledného spojeného řetězce na konzoli. Mezera je textový retězec o délce (počtu znaků) jedna.

Zde je jiný příklad. Jen připomínám, že hodnota ve dvojitých uvozovkách je textový řetězec, i když obsahuje číslice.

package main

import "fmt"

func main() {
	var a string = "111"
	var b string = "222"
	var c string = a

	var whole string = a + b + c

	fmt.Println(whole)
}

Výsledek

111222111

Jak jste si mohli všimnout, můžeme vytvářet proměnné i tak, že jim přiřadíme jako hodnotu jinou proměnnou (v našem případě proměnná c má stejnou hodnotu jako a). V příkladu byla vytvořena proměnná whole, která obsahovala hodnotu spojení tří textových řetězců a to 111 222 a 111.

Úkol
Vytvořte program, který bude mít alespoň tři textové proměnné a ty spojte do jedné věty.

Možné řešení

package main

import "fmt"

func main() {
	var first string = "Toto"
	var second string = "je"
	var third string = "možné"
	var fourth string = "řešení"
	var fifth string = "úkolu"
	var space string = " "

	fmt.Println(first + space + second + space + third + space + fourth + space + fifth)
}

Začínáme programovat v Go: 4. díl – proměnné

V tomto díle tutoriálu se podíváme na proměnné. Proměnná je vlastně pojmenování hodnoty. Následně pak pracujeme s tímto pojmenováním (proměnnou). Proměnná se vytváří (deklaruje) pomocí klíčového slova var. Jelikož Go je typový jazyk, proměnné jsou určitého typu. Doposud, aniž jsme si to uvědomovali, jsme používali datový typ string, což je textový řetězec. Cokoliv uzavřené mezi dvě dvojité uvozovky je řetězec. V předchozích dílech jsme volali metodu Println z balíčku fmt a předávali jí string (textový řetězec).

Zde je ukázka, jak se proměnné typu string vytváří.

var jmeno string = "John"
var prijmeni string = "Smith"

Vytváříme dvě proměnné. První je proměnná jmeno, obsahující textový řetězec (je typu string) s hodnotou John. Druhá proměnná je prijmeni, je také datového typu string a obsahuje hodnotu Smith.

fmt.Println(jmeno)
fmt.Println(primeni)

Zobrazíme hodnoty obou proměnných. Použijeme-li proměnnou, použije se její hodnota. Jak jsme uvedli výše, proměnná je pojmenovaná hodnota.

Zde je celý program

package main

import "fmt"

func main() {
	var name string = "John"
	var surname string = "Smith"
	
	fmt.Println(name)
	fmt.Println(surname)
}

Výsledek

John
Smith

Úkol
Zkuste si vytvořit vlastní program, který bude mít několik textových proměnných a ty vypíše do konzole.

Možné řešení

package main

import "fmt"

func main() {
	var w = "white"
	var b = "blue"
	var r = "red"
	
	fmt.Println(w)
	fmt.Println(b)
	fmt.Println(r)
}

Začínáme programovat v Go: 3 díl, další program

V tomto díle tutoriálu si vytvoříme další jednoduchý prográmek a znovu si jej popíšeme. Náš program bude vypisovat informace a bude se jmenovat info.go. V naší pracovní ploše (workspace) si vytvoříme adresář programs (do něj nyní budeme dávat naše krátké prográmky) a v něm soubor info.go (název mého workspace je vitfo.cz).

go
└───src
    └───vitfo.cz
        └───programs
                info.go

Obsah souboru info.go

package main

import "fmt"

/* Prints info */
func main() {
	fmt.Println("name: Jonh")
	fmt.Println("surname: Smith")
	fmt.Println("year of birth: 1999")
}

Popis
Každý go program se skládá z balíčků. Program (běh programu) začíná v balíčku main a v jeho hlavní metodě, která se také jmenuje main.
Pokud program potřebuje něco, co už je někde vytvořeno, importuje si balíček, ve kterém se daná funkcionalita nachází, pomocí klíčového slova import.
Z balíčků, které importujeme, můžeme používate pouze jména (funkce, proměnné), které začínají velkým písmenem. Pokud jsou v importovaném balíčku funkce a proměnné začínající na malé písmeno, nelze je použít (jsou používané jen v daném balíčku a nejsou přístupné zvenku). V našem případě to znamená, že balíček fmt obsahuje funkci s velkým počátečním písmenem Println.
Příkazy v některých programovacích jazycích se musí ukončovat speciálním znakem (velmi často je to středník). V go stačí konec rádky.
Komentáře se vkládají mezi /* */. Komentáře nemají vliv na program a jeho funkčnost, ale dělají program čitelnější. Komentáře jsou informace pro nás nebo jiného programátora.

Výsledek
Program spustíme go run info.go

C:\Users\vitfo\go\src\vitfo.cz\programs>go run info.go
name: Jonh
surname: Smith
year of birth: 1999

Úkol
Rozšiřte aktuální prográmek tak, aby vypisoval ještě další informace (oblíbenou barvu, místo narození, …)

Možné řešení:

package main

import "fmt"

/* Prints info */
func main() {
	fmt.Println("name: Jonh")
	fmt.Println("surname: Smith")
	fmt.Println("year of birth: 1999")
	fmt.Println("place of birth: Czech Republic")
	fmt.Println("favourite color: blue")
}

Začínáme programovat v Go: 2. díl – popis programu

V úvodním příspěvku o programování v jazyce Go jsme si ve složce go\src vytvořili pracovní složku (workspace) s názvem workspace. Doporučovaný způsob je, vytvořit si workspace a adresářovou strukturu, která bude jedinečná. Ideálním způsobem je za název workpace použít doménové jméno (pokud takové vlastníte). Pokud ne, stačí unikátní název. V %USERPROFILE%\go (na Windows v C:\Users\YourName\go) si vytvoříme složku src (tu už máme) a v ní adresářovou strukturu např. vitfo.cz\hello (ze začátku vám bude stačit i původní název workspace).

V minulém příspěvku jsme instalaci Go otestovali vytvořením souboru hello.go a jeho spuštěním. Nyní si kód tohoto souboru vysvětlíme.

package main

import "fmt"

func main() {
	fmt.Printf("Hello world")
}

package

package main

První řádek v programu určuje balíček (package), ve kterém se program nachází. Tento příkaz je povinný. Program (běh programu) začíná v balíčku main. Pokud má být program spustitelný, je třeba, aby měl alespoň jeden soubor s package main. Program hello má jediný soubor, a protože ho chceme spouštět, obsahuje řádek package main.

import

import "fmt"

Řádka s import říká, že se má načíst (importovat) balíček s názvem fmt (fmt je zkratka pro format). Tento balíček obsahuje funkce a pokud je chceme použít, musíme balíček nejdříve naimportovat. Jinak řečeno, pokud program potřebuje něco, co už je někde vytvořeno, importuje si balíček, ve kterém se daná funkcionalita nachází, pomocí klíčového slova import.

funkce main

func main() {
	...
}

Řádek s func main() vytváří funkci s názvem main, což je vstupní bod programu (vstupním bodem programu je soubor s package main, který obsahuje funkci main, která je to první, co se z programu zavolá). Klíčové slovo func se používá pro definování funkce.

importované fukce

fmt.Printf("Hello world")

Příkaz fmt.Prinln() znamená, že z importovaného balíčku fmt se volá funkce Println(). Funkce Println má jeden parametr. Hodnota, která se funkci předá (argument), se vytiskne. Všimněte si velkého písmene v názvu funkce. To znamená, že tato funkce je přístupná (dá se použít) i jinde, než v souboru, kde byla vytvořena. Pokud by v balíčku fmt byla funkce println() nemohli bychom ji použít.

Go a proměnná GOPATH

Proměnná GOPATH určuje místo, kde se hledá go kód. We Windows je to typicky v C:\Users\uživatelské_jméno\go.

Příkaz go env GOPATH vytiskne do konzole hodnotu proměnné GOPATH.

c:\>go env GOPATH
C:\Users\vitfo\go

Číst dál

Začínáme programovat v Go: 1 díl – instalace a první program

Go je programovací jazyk vytvořený společností Google. Jako jeho autoři jsou uváděni Robert Griesemer, Rob Pike a Ken Thompson a jako datum vzniku rok 2009. Jedná se kompilovaný a typovaný (používá datové typy) jazyk.

Instalace (pro Windows)
Stránka pro stažení zde. Kliknout na instalátor pro Microsoft Windows (koncovka .msi). Spustit stažený soubor.

Ověření instalace
Vytvořte si adresář go\src\hello (mkdir go\src\hello) v C:\Users\vaše_uživatelké_jméno. V adresári hello si vytvořte soubor hello.go. Do něj napište následující text.

package main

import "fmt"

func main() {
	fmt.Printf("Hello world")
}

Soubor uložte a v příkazovém řádku spusťte příkaz go build (v C:\Users\vaše_uživatelké_jméno\go\workspace\src\hello).
Pokud si nyní vypíšete obsah složky hello, zjistíte, že zde přibyl soubor hello.exe. Jedná se o spustitelný soubor, který byl vytvořen přízem build. Tento soubor spusťe. V příkazovém řádku to znamená, že napíšete jeho jméno (ať již bez přípony .exe nebo s ní – fungují oba způsoby).

c:\Go\workspace\src\hello>hello.exe
Hello world
c:\Go\workspace\src\hello>hello
Hello world

Pokud se vám zobrazil text „Hello world“, go instalace je funkční. Příkaz go clean smaže spustitelný soubor z adresáře. Kód si můžete vyzkoušel i bez buildu. Stačí zadat go run nazev_programu.