Tidak banyak kode Go untuk dipelajari, dan saya yakin saya bukan satu-satunya yang bereksperimen dengannya. Jadi, jika Anda menemukan sesuatu yang menarik tentang bahasa tersebut, silakan kirim contohnya di sini.

Saya juga mencari

• cara idiomatis untuk melakukan sesuatu di Go,
• Gaya berpikir C / C ++ "diporting" ke Go,
• kesalahan umum tentang sintaksis,
• sesuatu yang menarik, sungguh.

Tunda pernyataan

Pernyataan "defer" memanggil fungsi yang eksekusinya ditangguhkan saat fungsi di sekitarnya kembali.

DeferStmt = Ekspresi "menunda".

Ekspresi tersebut harus berupa pemanggilan fungsi atau metode. Setiap kali pernyataan "defer" dijalankan, parameter ke pemanggilan fungsi dievaluasi dan disimpan lagi tetapi fungsi tersebut tidak dipanggil. Panggilan fungsi yang ditangguhkan dijalankan dalam urutan LIFO segera sebelum fungsi sekitarnya kembali, tetapi setelah nilai yang dikembalikan, jika ada, telah dievaluasi.

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);
}

Memperbarui:

defersekarang juga merupakan cara idiomatik untuk menangani panicdengan cara seperti pengecualian :

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)
}

File objek Go sebenarnya menyertakan header cleartext:

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>

Saya telah melihat beberapa orang mengeluh tentang loop-for, di sepanjang baris "mengapa kita harus mengatakan i = 0; i < len; i++di zaman sekarang ini?".

Saya tidak setuju, saya suka untuk konstruksi. Anda dapat menggunakan versi panjang jika Anda mau, tetapi idiomatis Go adalah

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

The for .. rangemembangun loop atas semua elemen dan persediaan dua nilai - indeks idan nilai v.

range juga berfungsi pada peta dan saluran.

Namun, jika Anda tidak suka fordalam bentuk apa pun, Anda dapat menentukan each, mapdll. Dalam beberapa baris:

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
}

cetakan

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

Saya mulai sangat menyukai Go :)

Pergi dan dapatkan reputasi stackoverflow Anda

Ini adalah terjemahan dari jawaban ini .

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"))
}

Terima kasih kepada Scott Wales atas bantuannya dengan .Read ().

Ini masih terlihat cukup kikuk, dengan dua string dan dua buffer, jadi jika ada pakar Go yang memiliki saran, beri tahu saya.

Inilah contoh bagus iota dari pos 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 (!)

Anda dapat menukar variabel dengan tugas paralel:

x, y = y, x

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

sederhana tetapi efektif.

Berikut ini adalah idiom dari Efektif Go halaman

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

Pernyataan switch menjadi true ketika tidak ada ekspresi yang diberikan. Jadi ini setara dengan

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

Saat ini, versi sakelar tampak sedikit lebih bersih bagi saya.

Jenis sakelar :

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");
}

Saat mengimpor paket, Anda dapat menentukan ulang namanya menjadi apa pun yang Anda inginkan:

package main

import f "fmt"

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

Parameter hasil bernama

Kembali atau hasil "parameter" dari fungsi Go dapat diberi nama dan digunakan sebagai variabel biasa, seperti parameter yang masuk. Ketika dinamai, mereka diinisialisasi ke nilai nol untuk tipenya saat fungsi dimulai; jika fungsi menjalankan pernyataan pengembalian tanpa argumen, nilai saat ini dari parameter hasil digunakan sebagai nilai yang dikembalikan.

Nama tidak wajib tetapi dapat membuat kode lebih pendek dan lebih jelas: ini adalah dokumentasi. Jika kita menamai hasil nextInt maka menjadi jelas mana yang dikembalikan int adalah yang mana.

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

Karena hasil yang diberi nama diinisialisasi dan dikaitkan dengan pengembalian tanpa hiasan, hasil tersebut dapat menyederhanakan dan juga memperjelas. Ini adalah versi io.ReadFull yang menggunakannya dengan baik:

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;
}

Dari jawaban James Antill :

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

Juga, potensi jebakan: perbedaan halus antara operator penerima dan pengirim:

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))
}

Saya suka Anda dapat mendefinisikan ulang tipe, termasuk primitif seperti int, sebanyak yang Anda suka dan melampirkan metode yang berbeda. Seperti mendefinisikan tipe 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))
}

Yang mencetak

Number:  5 five V

The RomanNumber()panggilan dasarnya gips, itu mengubah jenis int sebagai jenis yang lebih spesifik dari int. Dan Println()panggilan di String()belakang layar.

Mengembalikan saluran

Ini adalah idiom sejati yang cukup penting: bagaimana memasukkan data ke dalam saluran dan menutupnya setelahnya. Dengan ini Anda dapat membuat iterator sederhana (karena range akan menerima saluran) atau filter.

// 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;
}

Batas waktu untuk pembacaan saluran:

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

Dicuri dari Davies Liu .

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

Karena range secara otomatis memeriksa saluran tertutup, kita dapat mempersingkatnya menjadi ini:

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

Ada pengaturan sistem make yang dapat Anda gunakan di $ GOROOT / src

Siapkan makefile Anda dengan

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

Anda kemudian dapat menggunakan alat pengujian otomatis dengan menjalankan make test, atau menambahkan paket dan objek bersama dari cgo ke $ GOROOT Anda dengan make install.

Hal menarik lainnya di Go adalah itu godoc. Anda dapat menjalankannya sebagai server web di komputer Anda menggunakan

godoc -http=:8080

di mana 8080 adalah nomor port, dan seluruh situs web di golang.org kemudian tersedia di localhost:8080.

Ini adalah implementasi dari tumpukan. Ini mengilustrasikan menambahkan metode ke sebuah tipe.

Saya ingin membuat bagian tumpukannya menjadi irisan dan menggunakan properti irisan, tetapi meskipun saya membuatnya bekerja tanpa type, saya tidak dapat melihat sintaks untuk menentukan irisan dengan a 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()
}

Memanggil kode c dari go

Anda dapat mengakses tingkat perjalanan yang lebih rendah dengan menggunakan runtime c.

Fungsi C ada dalam bentuk

void package·function(...)

(perhatikan pemisah titik adalah karakter unicode) di mana argumen dapat berupa tipe dasar go, irisan, string, dll. Untuk mengembalikan panggilan nilai

FLUSH(&ret)

(Anda dapat mengembalikan lebih dari satu nilai)

Misalnya untuk membuat sebuah fungsi

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

di C yang Anda gunakan

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

Perhatikan bahwa Anda masih harus mendeklarasikan fungsi dalam file go, dan Anda harus menjaga memorinya sendiri. Saya tidak yakin apakah mungkin untuk memanggil pustaka eksternal menggunakan ini, mungkin lebih baik menggunakan cgo.

Lihat $ GOROOT / src / pkg / runtime untuk contoh yang digunakan dalam runtime.

Lihat juga jawaban ini untuk menghubungkan kode c ++ dengan go.

Berikut adalah contoh go menggunakan paket sqlite3.

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

Apakah Anda menonton pembicaraan ini ? Ini menunjukkan banyak hal keren yang dapat Anda lakukan (akhir pembicaraan)

Tumpukan berdasarkan jawaban lain, tetapi menggunakan penambahan irisan tidak memiliki batas ukuran.

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
}

Ada banyak program kecil di testdirektori utama. Contoh:

• peano.go mencetak faktorial.
• hilbert.go memiliki beberapa perkalian matriks.
• iota.go memiliki contoh hal iota yang aneh.