Non c'è molto codice Go da cui imparare la lingua e sono sicuro di non essere l'unico a sperimentarlo. Quindi, se hai scoperto qualcosa di interessante sulla lingua, per favore pubblica un esempio qui.

Sto anche cercando

• modi idiomatici per fare le cose in Go,
• Stile di pensiero C / C ++ "portato" su Go,
• insidie ​​comuni sulla sintassi,
• qualcosa di interessante, davvero.

Rinviare dichiarazioni

Un'istruzione "defer" richiama una funzione la cui esecuzione è rimandata al momento in cui ritorna la funzione circostante.

DeferStmt = "defer" espressione.

L'espressione deve essere una chiamata di funzione o di metodo. Ogni volta che viene eseguita l'istruzione "defer", i parametri della chiamata di funzione vengono valutati e salvati di nuovo ma la funzione non viene richiamata. Le chiamate di funzione differite vengono eseguite in ordine LIFO immediatamente prima della restituzione della funzione circostante, ma dopo che i valori restituiti, se presenti, sono stati valutati.

lock(l);
defer unlock(l);  // unlocking happens before surrounding function returns

// prints 3 2 1 0 before surrounding function returns
for i := 0; i <= 3; i++ {
    defer fmt.Print(i);
}

Aggiornare:

deferè ora anche il modo idiomatico di gestire panicin modo eccezionale :

package main

import "fmt"

func main() {
    f()
    fmt.Println("Returned normally from f.")
}

func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
    fmt.Println("Calling g.")
    g(0)
    fmt.Println("Returned normally from g.")
}

func g(i int) {
    if i > 3 {
        fmt.Println("Panicking!")
        panic(fmt.Sprintf("%v", i))
    }
    defer fmt.Println("Defer in g", i)
    fmt.Println("Printing in g", i)
    g(i+1)
}

I file oggetto Go in realtà includono un'intestazione in chiaro:

jurily@jurily ~/workspace/go/euler31 $ 6g euler31.go
jurily@jurily ~/workspace/go/euler31 $ cat euler31.6
amd64
  exports automatically generated from
  euler31.go in package "main"
    import

$$  // exports
  package main
    var main.coin [9]int
    func main.howmany (amount int, max int) (? int)
    func main.main ()
    var main.initdone· uint8
    func main.init ()

$$  // local types
  type main.dsigddd_1·1 struct { ? int }

$$

!
<binary segment>

Ho visto un paio di persone lamentarsi del for-loop, sulla falsariga di "perché dovremmo dire i = 0; i < len; i++in questo giorno ed età?".

Non sono d'accordo, mi piace il costrutto for. Puoi usare la versione lunga se lo desideri, ma l'idiomatico Go lo è

var a = []int{1, 2, 3}
for i, v := range a {
    fmt.Println(i, v)
}

Il for .. rangecostrutto ripercorre tutti gli elementi e fornisce due valori: l'indice ie il valore v.

range funziona anche su mappe e canali.

Tuttavia, se non ti piace forin qualsiasi forma, puoi definire each, mapecc. In poche righe:

type IntArr []int

// 'each' takes a function argument.
// The function must accept two ints, the index and value,
// and will be called on each element in turn.
func (a IntArr) each(fn func(index, value int)) {
    for i, v := range a {
        fn(i, v)
    }
}

func main() {
    var a = IntArr([]int{2, 0, 0, 9}) // create int slice and cast to IntArr
    var fnPrint = func(i, v int) {
        fmt.Println(i, ":", v)
    } // create a function

    a.each(fnPrint) // call on each element
}

stampe

0 : 2
1 : 0
2 : 0
3 : 9

Sto iniziando a piacermi molto Go :)

Vai e ottieni la tua reputazione di stackoverflow

Questa è una traduzione di questa risposta .

package main

import (
    "json"
    "fmt"
    "http"
    "os"
    "strings"
)

func die(message string) {
    fmt.Printf("%s.\n", message);
    os.Exit(1);
}

func main() {
    kinopiko_flair := "https://stackoverflow.com/users/flair/181548.json"
    response, _, err := http.Get(kinopiko_flair)
    if err != nil {
        die(fmt.Sprintf("Error getting %s", kinopiko_flair))
    }

    var nr int
    const buf_size = 0x1000
    buf := make([]byte, buf_size)

    nr, err = response.Body.Read(buf)
    if err != nil && error != os.EOF {
        die(fmt.Sprintf("Error reading response: %s", err.String()))
    }
    if nr >= buf_size { die ("Buffer overrun") }
    response.Body.Close()

    json_text := strings.Split(string(buf), "\000", 2)
    parsed, ok, errtok := json.StringToJson(json_text[0])
    if ! ok {
        die(fmt.Sprintf("Error parsing JSON %s at %s", json_text, errtok))
    }

    fmt.Printf("Your stackoverflow.com reputation is %s\n", parsed.Get ("reputation"))
}

Grazie a Scott Wales per l'aiuto con .Read ().

Questo sembra ancora abbastanza goffo, con le due corde e due buffer, quindi se qualche esperto di Go ha un consiglio, fammelo sapere.

Ecco un bell'esempio di iota dal post di Kinopiko :

type ByteSize float64
const (
    _ = iota;   // ignore first value by assigning to blank identifier
    KB ByteSize = 1<<(10*iota)
    MB
    GB
    TB
    PB
    YB
)

// This implicitly repeats to fill in all the values (!)

È possibile scambiare variabili mediante assegnazione parallela:

x, y = y, x

// or in an array
a[j], a[i] = a[i], a[j]

semplice ma efficace.

Ecco un idioma dalla pagina Effective Go

switch {
case '0' <= c && c <= '9':
    return c - '0'
case 'a' <= c && c <= 'f':
    return c - 'a' + 10
case 'A' <= c && c <= 'F':
    return c - 'A' + 10
}
return 0

L'istruzione switch diventa true quando non viene fornita alcuna espressione. Quindi questo è equivalente a

if '0' <= c && c <= '9' {
    return c - '0'
} else if 'a' <= c && c <= 'f' {
    return c - 'a' + 10
} else if 'A' <= c && c <= 'F' {
    return c - 'A' + 10
}
return 0

Al momento, la versione con interruttore mi sembra un po 'più pulita.

Tipo interruttori :

switch i := x.(type) {
case nil:
    printString("x is nil");
case int:
    printInt(i);  // i is an int
case float:
    printFloat(i);  // i is a float
case func(int) float:
    printFunction(i);  // i is a function
case bool, string:
    printString("type is bool or string");  // i is an interface{}
default:
    printString("don't know the type");
}

Quando importi i pacchetti, puoi ridefinire il nome in qualsiasi cosa tu voglia:

package main

import f "fmt"

func main() {
    f.Printf("Hello World\n")
}

Parametri dei risultati denominati

È possibile assegnare nomi ai "parametri" di ritorno o di risultato di una funzione Go e utilizzarli come variabili regolari, proprio come i parametri in entrata. Quando vengono nominati, vengono inizializzati ai valori zero per i loro tipi quando inizia la funzione; se la funzione esegue un'istruzione return senza argomenti, i valori correnti dei parametri del risultato vengono utilizzati come valori restituiti.

I nomi non sono obbligatori ma possono rendere il codice più breve e più chiaro: sono documentazione. Se nominiamo i risultati di nextInt diventa ovvio quale int restituito è quale.

func nextInt(b []byte, pos int) (value, nextPos int) {

Poiché i risultati con nome sono inizializzati e legati a un ritorno disadorno, possono semplificare e chiarire. Ecco una versione di io.ReadFull che li utilizza bene:

func ReadFull(r Reader, buf []byte) (n int, err os.Error) {
    for len(buf) > 0 && err == nil {
        var nr int;
        nr, err = r.Read(buf);
        n += nr;
        buf = buf[nr:len(buf)];
    }
    return;
}

Dalla risposta di James Antill :

foo := <-ch     // This blocks.
foo, ok := <-ch // This returns immediately.

Inoltre, una potenziale trappola: la sottile differenza tra gli operatori di ricezione e invio:

a <- ch // sends ch to channel a
<-ch    // reads from channel ch

/* 
 * How many different ways can £2 be made using any number of coins?
 * Now with 100% less semicolons!
 */

package main
import "fmt"


/* This line took me over 10 minutes to figure out.
 *  "[...]" means "figure out the size yourself"
 * If you only specify "[]", it will try to create a slice, which is a reference to an existing array.
 * Also, ":=" doesn't work here.
 */
var coin = [...]int{0, 1, 2, 5, 10, 20, 50, 100, 200}

func howmany(amount int, max int) int {
    if amount == 0 { return 1 }
    if amount < 0 { return 0 }
    if max <= 0 && amount >= 1 { return 0 }

    // recursion works as expected
    return howmany(amount, max-1) + howmany(amount-coin[max], max)
}


func main() {
    fmt.Println(howmany(200, len(coin)-1))
}

Mi piace che tu possa ridefinire i tipi, comprese le primitive come int, tutte le volte che vuoi e collegare metodi diversi. Come definire un tipo RomanNumeral:

package main

import (
    "fmt"
    "strings"
)

var numText = "zero one two three four five six seven eight nine ten"
var numRoman = "- I II III IV V VI VII IX X"
var aText = strings.Split(numText, " ")
var aRoman = strings.Split(numRoman, " ")

type TextNumber int
type RomanNumber int

func (n TextNumber) String() string {
    return aText[n]
}

func (n RomanNumber) String() string {
    return aRoman[n]
}

func main() {
    var i = 5
    fmt.Println("Number: ", i, TextNumber(i), RomanNumber(i))
}

Che stampa

Number:  5 five V

La RomanNumber()chiamata è essenzialmente un cast, ridefinisce il tipo int come un tipo più specifico di int. E Println()chiama String()dietro le quinte.

Restituzione di un canale

Questo è un vero idioma abbastanza importante: come inserire dati in un canale e chiuderlo in seguito. Con questo puoi creare semplici iteratori (dato che range accetterà un canale) o filtri.

// return a channel that doubles the values in the input channel
func DoublingIterator(input chan int) chan int {
    outch := make(chan int);
    // start a goroutine to feed the channel (asynchronously)
    go func() {
        for x := range input {
            outch <- 2*x;    
        }
        // close the channel we created and control
        close(outch);
    }();
    return outch;
}

Timeout per le letture dei canali:

ticker := time.NewTicker(ns);
select {
    case v := <- chan_target:
        do_something_with_v;
    case <- ticker.C:
        handle_timeout;
}

Rubato a Davies Liu .

for {
    v := <-ch
    if closed(ch) {
        break
    }
    fmt.Println(v)
}

Poiché l'intervallo verifica automaticamente la presenza di un canale chiuso, possiamo accorciarlo a questo:

for v := range ch {
    fmt.Println(v)
}

C'è un sistema di creazione che puoi usare in $ GOROOT / src

Imposta il tuo makefile con

TARG=foobar           # Name of package to compile
GOFILES=foo.go bar.go # Go sources
CGOFILES=bang.cgo     # Sources to run cgo on
OFILES=a_c_file.$O    # Sources compiled with $Oc
                      # $O is the arch number (6 for x86_64)

include $(GOROOT)/src/Make.$(GOARCH)
include $(GOROOT)/src/Make.pkg

È quindi possibile utilizzare gli strumenti di test automatizzati eseguendo make test o aggiungere il pacchetto e gli oggetti condivisi da cgo a $ GOROOT con make install.

Un'altra cosa interessante in Go è quella godoc. Puoi eseguirlo come server web sul tuo computer usando

godoc -http=:8080

dove 8080 è il numero di porta e l'intero sito Web su golang.org è quindi disponibile all'indirizzo localhost:8080.

Questa è un'implementazione di uno stack. Illustra l'aggiunta di metodi a un tipo.

Volevo trasformarne la parte dello stack in una sezione e utilizzare le proprietà della sezione, ma sebbene typeriuscissi a farlo funzionare senza , non riuscivo a vedere la sintassi per definire una sezione con un file type.

package main

import "fmt"
import "os"

const stack_max = 100

type Stack2 struct {
    stack [stack_max]string
    size  int
}

func (s *Stack2) push(pushed_string string) {
    n := s.size
    if n >= stack_max-1 {
        fmt.Print("Oh noes\n")
        os.Exit(1)
    }
    s.size++
    s.stack[n] = pushed_string
}

func (s *Stack2) pop() string {
    n := s.size
    if n == 0 {
        fmt.Print("Underflow\n")
        os.Exit(1)
    }
    top := s.stack[n-1]
    s.size--
    return top
}

func (s *Stack2) print_all() {
    n := s.size
    fmt.Printf("Stack size is %d\n", n)
    for i := 0; i < n; i++ {
        fmt.Printf("%d:\t%s\n", i, s.stack[i])
    }
}

func main() {
    stack := new(Stack2)
    stack.print_all()
    stack.push("boo")
    stack.print_all()
    popped := stack.pop()
    fmt.Printf("Stack top is %s\n", popped)
    stack.print_all()
    stack.push("moo")
    stack.push("zoo")
    stack.print_all()
    popped2 := stack.pop()
    fmt.Printf("Stack top is %s\n", popped2)
    stack.print_all()
}

Chiamare il codice c da go

È possibile accedere al livello inferiore di go utilizzando il runtime c.

Le funzioni C sono nella forma

void package·function(...)

(nota che il separatore di punti è un carattere unicode) dove gli argomenti possono essere tipi di go di base, sezioni, stringhe ecc. Per restituire una chiamata a valore

FLUSH(&ret)

(puoi restituire più di un valore)

Ad esempio, per creare una funzione

package foo
bar( a int32, b string )(c float32 ){
    c = 1.3 + float32(a - int32(len(b))
}

in C usi

#include "runtime.h"
void foo·bar(int32 a, String b, float32 c){
    c = 1.3 + a - b.len;
    FLUSH(&c);
}

Nota che dovresti comunque dichiarare la funzione in un file go e che dovrai prenderti cura della memoria da solo. Non sono sicuro che sia possibile chiamare librerie esterne usando questo, potrebbe essere meglio usare cgo.

Guarda $ GOROOT / src / pkg / runtime per esempi usati nel runtime.

Vedi anche questa risposta per collegare il codice c ++ con go.

Ecco un esempio di go utilizzando il pacchetto sqlite3.

http://github.com/bikal/gosqlite-example

Hai guardato questo discorso ? Mostra molte cose interessanti che puoi fare (fine del discorso)

Uno stack basato sull'altra risposta, ma utilizzando l'aggiunta di slice per non avere limiti di dimensione.

package main

import "fmt"
import "os"

type Stack2 struct {
        // initial storage space for the stack
        stack [10]string
        cur   []string
}

func (s *Stack2) push(pushed_string string) {
        s.cur = append(s.cur, pushed_string)
}

func (s *Stack2) pop() (popped string) {
        if len(s.cur) == 0 {
                fmt.Print("Underflow\n")
                os.Exit(1)
        }
        popped = s.cur[len(s.cur)-1]
        s.cur = s.cur[0 : len(s.cur)-1]
        return
}

func (s *Stack2) print_all() {
        fmt.Printf("Stack size is %d\n", len(s.cur))
        for i, s := range s.cur {
                fmt.Printf("%d:\t%s\n", i, s)
        }
}

func NewStack() (stack *Stack2) {
        stack = new(Stack2)
        // init the slice to an empty slice of the underlying storage
        stack.cur = stack.stack[0:0]
        return
}

func main() {
        stack := NewStack()
        stack.print_all()
        stack.push("boo")
        stack.print_all()
        popped := stack.pop()
        fmt.Printf("Stack top is %s\n", popped)
        stack.print_all()
        stack.push("moo")
        stack.push("zoo")
        stack.print_all()
        popped2 := stack.pop()
        fmt.Printf("Stack top is %s\n", popped2)
        stack.print_all()
}

const ever = true

for ever {
    // infinite loop
}

Ci sono molti piccoli programmi nella testdirectory principale. Esempi:

• peano.go stampa fattoriali.
• hilbert.go ha qualche moltiplicazione di matrici.
• iota.go ha esempi della cosa strana iota.