Dili öğrenmek için çok fazla Go kodu yok ve eminim onu ​​deneyen tek kişi ben değilim. Bu yüzden, dil hakkında ilginç bir şey bulursanız, lütfen buraya bir örnek gönderin.

Ben de arıyorum

• Go'da bir şeyler yapmanın deyimsel yolları,
• Go için "taşınan" C / C ++ tarzı düşünme,
• sözdizimi ile ilgili yaygın tuzaklar,
• gerçekten ilginç bir şey.

İfadeleri ertele

Bir "erteleme" ifadesi, yürütülmesi çevreleyen işlevin döndüğü ana kadar ertelenen bir işlevi çağırır.

DeferStmt = "erteleme" İfadesi.

İfade bir işlev veya yöntem çağrısı olmalıdır. "Erteleme" ifadesi her yürütüldüğünde, işlev çağrısının parametreleri değerlendirilir ve yeniden kaydedilir, ancak işlev çağrılmaz. Ertelenen işlev çağrıları, çevreleyen işlev dönmeden hemen önce, ancak varsa, dönüş değerleri değerlendirildikten sonra LIFO sırasına göre yürütülür.

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

Güncelleme:

deferşimdi aynı zamanda istisnaipanic bir şekilde başa çıkmanın deyimsel yoludur :

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

Go nesne dosyaları aslında bir açık metin başlığı içerir:

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>

"Bugün i = 0; i < len; i++ve bu çağda neden bunu söylemek zorundayız ?"

Katılmıyorum, inşa etmeyi seviyorum. İsterseniz uzun sürümü kullanabilirsiniz, ancak deyimsel Go şudur:

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

for .. rangeEndeksi - yapı tüm elemanları ve malzemeleri iki değeri döngüler ive değer v.

range ayrıca haritalar ve kanallar üzerinde de çalışır.

Yine de, forherhangi bir biçimde beğenmezseniz each, mapbirkaç satırda tanımlayabilirsiniz :

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
}

baskılar

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

Go'yu çok sevmeye başladım :)

Git ve stackoverflow itibarınızı kazanın

Bu, bu cevabın tercümesidir .

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

.Read () ile ilgili yardım için Scott Wales'e teşekkürler .

Bu, iki dizeli ve iki tamponla hala oldukça hantal görünüyor, bu nedenle herhangi bir Go uzmanının tavsiyesi varsa, bana bildirin.

İşte Kinopiko'nun gönderisinden güzel bir iota örneği :

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 (!)

Değişkenleri paralel atama ile takas edebilirsiniz:

x, y = y, x

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

basit ama etkili.

İşte Effective Go sayfasından bir deyim

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

Switch ifadesi, herhangi bir ifade verilmediğinde true olarak açılır. Yani bu eşdeğerdir

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

Şu anda, anahtar versiyonu bana biraz daha temiz görünüyor.

Tip anahtarları :

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

Paketleri içe aktarırken, adı istediğiniz herhangi bir şeye yeniden tanımlayabilirsiniz:

package main

import f "fmt"

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

Adlandırılmış sonuç parametreleri

Bir Go işlevinin dönüş veya sonuç "parametrelerine" adlar verilebilir ve gelen parametreler gibi normal değişkenler olarak kullanılabilir. Adlandırıldıklarında, işlev başladığında türleri için sıfır değerleriyle başlatılırlar; işlev bağımsız değişken içermeyen bir dönüş ifadesi çalıştırırsa, sonuç parametrelerinin geçerli değerleri döndürülen değerler olarak kullanılır.

İsimler zorunlu değildir, ancak kodu daha kısa ve daha net hale getirebilirler: belgelerdir. NextInt'in sonuçlarını adlandırırsak, döndürülen int'in hangisi olduğu açık hale gelir.

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

Adlandırılmış sonuçlar başlatıldığından ve süslenmemiş bir dönüşe bağlandığından, basitleştirmenin yanı sıra açıklığa kavuşturabilirler. İşte onları iyi kullanan bir io.ReadFull sürümü:

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

Gönderen James Antill cevabı :

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

Ayrıca, potansiyel bir tuzak: alma ve gönderme operatörleri arasındaki ince fark :

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

İnt gibi ilkelleri içeren türleri istediğiniz kadar yeniden tanımlayabilmenizi ve farklı yöntemler ekleyebilmenizi seviyorum. RomanNumeral türünü tanımlamak gibi:

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

Hangi çıktı

Number:  5 five V

RomanNumber()Çağrı o int daha spesifik bir türü olarak int türünü yeniden tanımlayan, esasen bir atıldı. Ve perde arkasını Println()çağırır String().

Bir kanalı iade etmek

Bu oldukça önemli olan gerçek bir deyimdir: bir kanala veri nasıl beslenir ve daha sonra nasıl kapatılır. Bununla basit yineleyiciler (çünkü aralık bir kanalı kabul edeceğinden) veya filtreler yapabilirsiniz.

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

Kanal okumaları için zaman aşımı:

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

Davies Liu'dan çalındı .

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

Aralık otomatik olarak kapalı bir kanalı kontrol ettiğinden, buna kısaltabiliriz:

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

$ GOROOT / src'de kullanabileceğiniz bir make sistemi kurulumu var

Makefile'ınızı şu şekilde ayarlayın:

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

Daha sonra otomatik test araçlarını make test çalıştırarak kullanabilir veya make install ile paketi ve paylaşılan nesneleri cgo'dan $ GOROOT'unuza ekleyebilirsiniz.

Go'daki bir başka ilginç şey de bu godoc. Bunu kullanarak bilgisayarınızda bir web sunucusu olarak çalıştırabilirsiniz.

godoc -http=:8080

8080 bağlantı noktası numarasıdır ve golang.org'daki web sitesinin tamamı daha sonra adresinde mevcuttur localhost:8080.

Bu, bir yığının uygulamasıdır. Bir türe yöntem eklemeyi gösterir.

Yığın parçasını bir dilim haline getirmek ve dilimin özelliklerini kullanmak istedim, ancak bunu kullanmadan çalışsam da type, bir dilimi a ile tanımlamak için sözdizimini göremedim 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()
}

Hareket halindeyken c kodunu çağırma

Daha düşük go düzeyine c çalışma zamanını kullanarak erişmek mümkündür.

C fonksiyonları formdadır

void package·function(...)

(nokta ayırıcının bir unicode karakter olduğuna dikkat edin) burada argümanlar temel go türleri, dilimler, dizeler vb. olabilir. Bir değer çağrısı döndürmek için

FLUSH(&ret)

(birden fazla değer döndürebilirsiniz)

Örneğin, bir işlev oluşturmak için

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

C'de kullanırsın

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

İşlevi yine de bir go dosyasında bildirmeniz gerektiğini ve hafızayı kendiniz halletmeniz gerektiğini unutmayın. Bunu kullanarak harici kitaplıkları çağırmanın mümkün olup olmadığından emin değilim, cgo kullanmak daha iyi olabilir.

Çalışma zamanında kullanılan örnekler için $ GOROOT / src / pkg / runtime'a bakın.

Ayrıca c ++ kodunu go ile bağlamak için bu yanıta bakın .

İşte sqlite3 paketini kullanan bir go örneği.

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

Bu konuşmayı izledin mi? Yapabileceğin birçok harika şeyi gösteriyor (konuşmanın sonu)

Diğer yanıta dayalı, ancak boyut sınırı olmaması için dilim eklemeyi kullanan bir yığın.

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
}

testAna dizinde çok sayıda küçük program var . Örnekler:

• peano.go factorials yazdırır.
• hilbert.go bazı matris çarpımına sahiptir.
• iota.go tuhaf iota şeylerinin örnekleri var.