Jednoduchá webová aplikace v Go

15.5.2018 02:19 | Přečteno: 2976× | Linux |

Nejprve několik slov o samotném jazyku.

Rychlý úvod do Go

Neinicializované proměnné mají nulové hodnoty. Čísla 0, boolean false, řetězce "", interface a referenční typy (slices, ukazatele, mapy, channels, funkce) nil.

Pokud je proměnná již deklarována, chová se krátká deklarace jako přiřazení.

Krátká deklarace musí deklarovat alespoň jednu novou proměnnou.

Krátká deklarace může být použita pouze uvnitř funkce.

Životnost globálních proměnných je po celou dobu běhu programu a jejich viditelnost je v rámci package. Lokální proměnné jsou alokovány buď ze zásobníku (stack), nebo dynamicky z heapu, pokud k nim vede ukazatel nebo jiný druh reference.

Viditelnost mimo balíček se řídí velikostí prvního písmena v názvu funkce, metody, proměnné nebo nového typu.

Pokud je stejné jméno definováno jak ve vnějším, tak ve vnitřním bloku, je vnitřní deklarace nalezena jako první.

Příklad níže má tři různé proměnné x, protože každá deklarace se nachází v jiném lexikálním bloku.

func main() {
    x := "hello!"
    for i := 0; i < len(x); i++ {
        x := x[i]
        if x != '!' {
            x := x + 'A' - 'a'
            fmt.Printf("%c", x)    // "HELLO" (one letter per iteration)
        }
    }	
}

V následující části programu má f platnost pouze v bloku if, takže není vidět v dalších příkazech, které následují.

if f, err := os.Open(fname); err != nil {    // compile error: unused: f
    return err
}
f.ReadByte()                                 // compile error: undefined f
f.Close()                                    // compile error: undefined f

Tudíž je občas nutné deklarovat proměnou před podmínkou:

f, err := os.Open(fname)
if err != nil {
    return err
}
f.ReadByte()
f.Close()

Slice je jednoduchá datová struktura, která umožňuje přístup k prvkům pole, kterému se říká underlying array. Slice má tři komponenty: ukazatel, délku a kapacitu. Protože slice obsahuje ukazatel, mohou funkce měnit prvky odkazovaného, spodního pole.

// reverse reverses a slice of ints in place.
func reverse(s []int) {
    for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}

Zde obracíme pole:

a := [...]int{0, 1, 2, 3, 4, 5}
reverse(a[:])
fmt.Println(a) // "[5 4 3 2 1 0]"

a zde slice:

s := []int{0, 1, 2, 3, 4, 5}
// Rotate s left by two positions.
reverse(s[:2])
reverse(s[2:])
reverse(s)
fmt.Println(s) // "[2 3 4 5 0 1]"

V případě, že chceme změnit u slice ukazatel, délku nebo kapacitu, musíme použít přiřazení, aby došlo k aktualizaci hodnot. Proto vestavěná funkce append má tento tvar:

runes = append(runes, r)

Zde je kontext:

var runes []rune
for _, r := range "Čau, Světe" {
    runes = append(runes, r)
}
fmt.Printf("%q\n", runes) // "['Č' 'a' 'u' ',' ' ' 'S' 'v' 'ě' 't' 'e']"

Tak to by bylo na úvod vše. Akorát bych poznamenal, že výše uvedené příklady jsou pouze útržky kódu a například bez importování příslušných balíčků ze standardní knihovny nebudou fungovat.

GOPATH

Abychom v Go mohli tvořit větší projekty, musíme nejprve nastavit environmentální proměnnou GOPATH. V Debianu 8 přidáme na konec souborů .bashrc a .profile řádek export GOPATH=/home/me/go. O tom, zda skutečně byla GOPATH nastavena, se můžeme přesvědčit v terminálu příkazem $ go env, který vypisuje seznam všech environmentálních proměnných. V tuto chvíli můžeme zkompilovat i program, který obsahuje vlastní balíčky, ale pouze pokud kompilaci provádíme z příkazové řádky. GUI aplikace, například Geany, GOPATH stále nevidí a kompilátor hledá balíčky jen v GOROOT, kde se nachází standardní knihovna. Musíme tedy vytvořit v domovském adresáři soubor .xsessionrc opět s řádkem export GOPATH=/home/me/go. Nyní už bychom měli mít možnost importovat vlastní balíčky i v GUI. Balíček (package) je v Go vlastně obdobou tříd či modulů v jiných jazycích.

Webová aplikace

V GOPATH vytvoříme tři složky, a to src, pkg a bin. Složka src obsahuje zdrojové kódy k našemu projektu. Do složky pkg se ukládají objektové soubory pro vlastní balíčky a ve složce bin vzniká spustitelný soubor.

A nyní již samotná aplikace.

go/src/projectx/filecsv/getlinescsv.go

package filecsv

import (
    "encoding/csv"
    "io/ioutil"    
    "strings"        
)

type Table [][]string 

func GetLines(file string) (Table, error) {
    
    bytes, err := ioutil.ReadFile(file)
    if err != nil {
        return nil, err
    }
    
    str := string(bytes)

    r := csv.NewReader(strings.NewReader(str))

    var t Table
    if t, err = r.ReadAll(); err != nil {    
        return nil, err
    }

    return t, nil    
}

func (t Table) AlterColor(n int, s1, s2 string) string {
    
    if n % 2 == 0 {  
        return s1
    }
    
    return s2    
}

Zde máme vlastní balíček filecsv, který obsahuje jednu funkci a jednu metodu. Funkce GetLines načítá ze souboru bajty, které jsou poté převedeny funkcí string na řetězec, a metoda ReadAll vrací slice sliců, který obsahuje csv data v podobě dvourozměrného pole.

Metodu AlterColor využijeme až v samotné HTML šabloně, při zobrazování tabulky, kdy nám bude střídat barvu řádků kvůli lepší čitelnosti.

go/src/projectx/main.go

package main

import (
    "fmt"
    "log"
    "net/http"    
    "projectx/filecsv"
    "time"
    tmp "html/template"    
)


type Page struct { 
    Rows filecsv.Table
}

const (
    tempLayout = "templates/layout.html"
    tempHello  = "templates/hello.html"
    tempFuncs  = "templates/funcs.html"
    tempStats  = "templates/stats.html"
    csvFuncs   = "csvdata/funcs"
    csvStats   = "csvdata/stats"
)

var Data Page


func main() {
        
    mux := http.NewServeMux()

    files := http.FileServer(http.Dir("public"))
    mux.Handle("/server/", http.StripPrefix("/server/", files))
    
    mux.HandleFunc("/", tutorial)
    mux.HandleFunc("/functions", functions)
    mux.HandleFunc("/popularity", popularity)    
    
    server := &http.Server{
        Addr:         "127.0.0.1:8080",
        Handler:      mux,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
    }

    server.ListenAndServe()    
}

func tutorial(w http.ResponseWriter, r *http.Request) {        
    
    Data.Rows = nil
    
    t := tmp.Must(tmp.ParseFiles(tempLayout, tempHello))
    t.ExecuteTemplate(w, "layout", Data)    
}

func functions(w http.ResponseWriter, r *http.Request) {    
     
    var err error
    Data.Rows, err = filecsv.GetLines(csvFuncs)    
    if err != nil {
        log.Fatal(err)
    }    
    
    t := tmp.Must(tmp.ParseFiles(tempLayout, tempFuncs))
    t.ExecuteTemplate(w, "layout", Data)    
}

func popularity(w http.ResponseWriter, r *http.Request) {                      
                          
    var err error
    Data.Rows, err = filecsv.GetLines(csvStats)    
    if err != nil {
        log.Fatal(err)
    }    
    
    t := tmp.Must(tmp.ParseFiles(tempLayout, tempStats))
    t.ExecuteTemplate(w, "layout", Data)    
}

func (p Page) Date() string {
    
    return fmt.Sprintf(time.Now().Format("02 Jan 2006 15:04"))
}

V balíčku main funkce tutorial, functions a popularity představují tři webové stránky.

Funkce FileServer a metoda Handle nastaví složku public tak, aby ji prohlížeč viděl po zadání adresy /server/. V naší aplikaci ji používáme k načtení css souboru.

<link rel="stylesheet" href="/server/css/project.css" />

Metoda HandleFunc po zadání adresy / zavolá příslušnou funkci, která odpoví na požadavek prohlížeče HTML šablonou. Na adresu / se dostaneme, když do prohlížeče zadáme localhost:8080.

Must je pomocná funkce, která zachytává chyby. Tato funkce pochází z balíčku template, ale my jsme tento název v importu zkrátili pouze na tmp.

Hlavička metody ExecuteTemplate ma tento tvar:

func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error

Poslední parameter je typu interface{}, což znamená, že mu můžeme předat jakýkoliv typ, např. řetězec, pole, strukturu, část podstruktury a jiný.

Metoda Date se pojí s typem Page a vrací řetezec s aktuálním datumem v uvedeném formátu. Kdybychom v HTML šabloně chtěli použít místo metody funkci, museli bychom šablony sestavit pomocí metody Funcs.

Zde více informací o timeoutech a nastavení serveru:

https://blog.cloudflare.com/the-complete-guide-to-golang-net-http-timeouts

https://medium.com/@nate510/don-t-use-go-s-default-http-client-4804cb19f779

Na sessions, cookies a práci s databází bych doporučil třeba Go Web Programming, autor má všechny kódy z knihy na gitu, mimochodem ve druhé kapitole (na gitu) najdete celý kód k jeho ukázkové aplikaci chitchat.

Kompilace

$ go build main.go

Vytvoří spustitelný soubor main.

$ go build

Vytvoří spustitelný soubor projectx.

$ go run main.go

Spustí dočasný spustitelný soubor.

$ go install

Vytvoří objektový soubor pro balíček filecsv ve složce pkg a spustitelný soubor ve složce bin.

$ go install projectx

to samé co $ go install.

go install projectx/filecsv

Vytvoří objektový soubor pro balíček filecsv ve složce pkg.

Ostatní soubory

Pro úplnost přikládám i ostatní soubory projektu.

go/src/projectx/csvdata/funcs

make,len,cap,new
append,copy,close,delete
complex,real,imag,panic
recover,,,

go/src/projectx/csvdata/stats

1st,2nd,3rd,4th,5th,6th,7th,8th,9th,10th
JavaScript,Python,Ruby,PHP,Java,C++,C,Objective-C,C#,Go
JavaScript,Python,Ruby,Java,PHP,C++,C,Go,C#,Shell
JavaScript,Python,Java,Ruby,PHP,C++,Go,C,C#,Shell
JavaScript,Python,Java,PHP,Ruby,Go,C++,C#,C,TypeScript
JavaScript,Python,Java,Go,Ruby,C++,PHP,TypeScript,C#,C

go/src/projectx/templates/layout.html

{{define "layout"}}

<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="/server/css/project.css" /> 
</head>
<body>

<div id="wrapper">
  <div id="header">
    <h1>The Go Programming Language</h1>  
  </div> 
  <div id="nav">
    <ul>      
      <li><a href="/">Tutorial</a></li>
      <li><a href="/functions">Functions</a></li>
      <li><a href="/popularity">Popularity</a></li>      
      <li>Item4</li>
      <li>Item5</li>
      <li>Item6</li>
    </ul>
  </div>
  <div id="outside_div">
    <div id="inside_div">   
      {{template "content" .}}
    </div>
  </div>
  <div id="footer">
    <p>{{.Date}}</p>
  </div>
</div>

</body>
</html>

{{end}}

go/src/projectx/templates/hello.html

{{define "content"}}

<h3>Hello, World</h3>

<pre>
package main

import "fmt"                     // fmt is a package

func main() {
    fmt.Println("Hello, World!")
}		
</pre>

{{end}}

go/src/projectx/templates/funcs.html

{{define "content"}}

<div id="table_stats">
<h3 class="table_space">Built-in Functions</h3>
<tt>
{{range .Rows}}
    {{range .}}
        {{.}}
    {{end}}
    <br />
{{end}}
</tt>
</div>

{{end}}

Tečka a samotný znak dolaru představují data, která byla předána šabloně. Tečka se však v range mění na prvky pole nebo struktury.


go/src/projectx/templates/stats.html

{{define "content"}}

<h3>GitHub Language Stats</h3>

<table>
<tr class="head"><td>Ranking</td><td>2014 Q1</td><td>2015 Q1</td>
<td>2016 Q1</td><td>2017 Q1</td><td>2018 Q1</td></tr>

{{$r := .Rows}}
{{range $i, $v := index .Rows 0}}
<tr class="{{$.Rows.AlterColor $i "even" "odd"}}"><td>{{index $r 0 $i}}</td>
<td>{{index $r 1 $i}}</td><td>{{index $r 2 $i}}</td><td>{{index $r 3 $i}}</td>
<td>{{index $r 4 $i}}</td><td>{{index $r 5 $i}}</td></tr>
{{end}}

</table>

<a class="table_link" href="https://madnight.github.io/githut/#/pull_requests/2018/1">github</a>

{{end}}

Dám sem i css, ale moc ho neumím, takže pro jistotu přikládám i obrázky, abyste viděli, jak by celá stránka měla vypadat.

go/src/projectx/public/css/project.css

a, body, br, div, h1, h3, li, link,
p, pre, table, td, tr, tt, ul {
    margin: 0;
    padding: 0;
    border: 0;
}


body {
    background: #fff;
    font: 100% sans-serif;    
}

#wrapper {
    max-width: 1000px;
    margin: 30px auto;    
    background: #fff;
}

#header {    
    background: #cce6ff;
    border-top: 1px solid black;
    border-bottom: 1px solid black;
    padding: 20px;
}

#nav {
    width: 25%;
    height: 600px;
    border-right: 1px solid black;
    float: left;    
}

#outside_div {
    width: 74%;    
    height: 600px;    
    float: right;    
}

#footer {
    border-top: 1px solid black;
    clear: both;
}

#header h1 {
    font-weight: 500;
}

#nav ul {
    margin: 40px 60px;
}

#nav li {
    margin: 5px;
}

#inside_div {
    margin: 40px 30px;
}

#inside_div h3 {
    font-weight: 500;
    margin-bottom: 20px;
}

table {
    font-size: .9em;    
    border-collapse: collapse;
    margin: 10px 0;
}

th, td {    
    padding: .5em .75em;
}

td {
    border: 1px solid black;
}

tr.head {    
    background: #cce6ff;
    color: #000;    
}


tr.even {
    background: #fff;
}

tr.odd {
    background: #ededed;
}

a.table_link  {    
    display: inline-block;
    margin-top: 10px;
}

pre {
    background: #ededed;
    padding: 20px;
    width: 500px;
}

Tak to byl takový pokus o velice jednoduchou aplikaci v Go, která může sloužit jako základ k většímu projektu. A až budu Go lépe umět, tak třeba napíši blog na nějaké pokročilejší téma.        

Obrázky

Komentáře

[Roman]

Diky za clanek. Go pouzivam vic jak rok i v produkcnim backendu a mam ho moc rad. Jeste se hodi zminit, ze balicek se inicializuje pote, co ho nejaka cast aplikace importuje. To sice zni logicky, ale zacatecnikovi muze prijit divne, proc se nevola init() v nejakem balicku definovanem v podadresari kde ma "package main" :) toho se vyuziva treba i u globalnich registraci (napr mysql driver), tam pak staci slepy import "_ github.com/blah/mysql" a balicek implementujici sql interface se tim inicializuje a zaregistruje do aktualni app. GOPATH a dodrzovani adresarove struktury GOPATH/src/gitrepo.com/pkgname[/.../pkgname] je take velmi dulezite. Zadne relativni importy. Jo a skvely je i golint, gometalinter a gofmt. O tom by se dalo taky povidat. :) Hlavne osetrujte error returny a posilejte je vys (do volajiciho), idealne s poznamkou kde se to pokazilo (e.g. "error parsing config: %v", puvodniErr), je dobre mit i ty vlastni objekty implementujici Error interface, ale ja si na to bohuzel zatim moc nezvyk a vracim jen novy error generaci fmt.Errorf). Ale hlavne at vznika kvalitni kod, ktery kdyz neco selze, tak clovek vi co. A vypis do logu by mel byt spis az v "package main", baliky by mely jen vracet ty errors. Me oblibene IDE je vscode, i kdyz LiteIDE bylo taky fajn. Diky pomocnym nastrojum co go ma, je ale integrace do dalsich IDEs snazsi.

[Roman]

Hodne pomaha ucit se z cizich kodu a gobyexample.com. Skoro na vse uz nekdo napsal Go knihovnu. Pri vyberu cizi knihovny je vhone sledovat pocet hvezdicek v Github repo, datum posledniho commitu (zda je projekt aktivni) a pocet neuzavrenych issues (zda je bezproblemova). Pokud nevim, jestli vubec nejaka knihovna existuje, pouzivam jednoduchy Google search typu: imagemagick golang site:github.com (pripadne pak jeste bez site omezeni), sledovat pod jakou licenci balik je, zda je pro nas vhodny. Lidi napsali kolikrat vskutku famozni knihovny. Pak je tu golang.cz a v minulosti byla nejaka konference v Brne.

[sad]

Díky za tipy. Mě Go dost baví, asi proto, že vychází z céčka, ale mám obavy, zda budu schopen napsat web třeba velikosti abíčka, takže se chci pro jistotu naučit ještě Django. Což se může hodit i v případě, kdy záleží více na termínu dokončení projektu než na rychlosti aplikace.

[kralyk z abclinuxu]

Co mi na Go přijde dobré:

• gorutiny
• Na poměry managed jazyků má lehkotonážní runtime

Co se mi nelíbí:

• Nepodporuje verzování dependencí (wtf)
• Absence constness / immutability
• Implicitní implementace interfaces

[Roman]

Verzovani zavislosi se resi nastrojem "dep". Da se pouzit semver. Puvodne slo jen 'locknout' zavislosti do vendor podadresare. Kazdopadne v obou pripadech jde docilit reproducible builds a to je nejdulezitejsi.

Absence constness je feature. Clovek se s tim nemusi stvat a implicitne se ocekava, ze vse co sis nevyrobil sam mas povazovat za const, dokud nejsi explicitne vyzvan k opaku v dokumentaci.

Njn, interfaces. Tam slo o zjednoduseni prekladace. Ve vetsine pripadu no big deal, interface je proste pouze abstraktni a proste jen rika, co ma implementovany typ umet, staci. Oproti tomu C++xx je hrozne prekombinovany a slozity jazyk, v jednoduchosti je krasa.

Za pozitiva jeste stoji zminit uzitecne standardni baliky a nuceni vyvojaru k dokumentaci a system godoc, snaha psat prehlednejsi kod bez balastu (napr. nedovoli importovat balicek, co se nepouziva).

Ale samozrejme je treba na dany ukol volit ten nejlepsi nastroj (jazyk). U backendu mi prijde Go jako perfect fit.

[kralyk z abclinuxu]

Absence constness je feature.

Ne, není.

Oproti tomu C++xx je hrozne prekombinovany a slozity jazyk, v jednoduchosti je krasa.

Ne, že bych nesouhlasil, s tím C++ je to pravda, nicméně tímhle mají lidi okolo Go tendenci zdůvodňovat úplně cokoli...

Ale samozrejme je treba na dany ukol volit ten nejlepsi nastroj (jazyk). U backendu mi prijde Go jako perfect fit.

Jo, to celkem souhlasim, minimálně na běžné věci...