Không có nhiều mã cờ vây để học ngôn ngữ và tôi chắc chắn rằng mình không phải là người duy nhất thử nghiệm nó. Vì vậy, nếu bạn phát hiện ra điều gì đó thú vị về ngôn ngữ này, vui lòng đăng một ví dụ ở đây.

Tôi cũng đang tìm kiếm

• những cách thành ngữ để làm những việc trong cờ vây,
• Phong cách tư duy C / C ++ được "chuyển" sang Go,
• những cạm bẫy phổ biến về cú pháp,
• bất cứ điều gì thú vị, thực sự.

Trì hoãn tuyên bố

Câu lệnh "defer" gọi một hàm mà việc thực thi của nó bị hoãn lại thời điểm hàm xung quanh trả về.

Biểu thức DeferStmt = "defer".

Biểu thức phải là một hàm hoặc một lệnh gọi phương thức. Mỗi khi câu lệnh "defer" thực thi, các tham số của lệnh gọi hàm được đánh giá và lưu lại nhưng hàm không được gọi. Các lệnh gọi hàm hoãn lại được thực hiện theo thứ tự LIFO ngay trước khi hàm xung quanh trả về, nhưng sau khi các giá trị trả về, nếu có, đã được đánh giá.

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

Cập nhật:

deferbây giờ cũng cách thành ngữ để xử lý panictrong một ngoại lệ giống như cách:

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

Tệp đối tượng Go thực sự bao gồm tiêu đề văn bản rõ ràng:

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>

Tôi đã thấy một vài người phàn nàn về vòng lặp lặp lại, cùng với dòng "tại sao chúng ta phải nói i = 0; i < len; i++trong thời đại ngày nay?".

Tôi không đồng ý, tôi thích xây dựng. Bạn có thể sử dụng phiên bản dài nếu muốn, nhưng thành ngữ cờ vây là

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

Cấu for .. rangetrúc lặp lại trên tất cả các phần tử và cung cấp hai giá trị - chỉ số ivà giá trị v.

range cũng hoạt động trên bản đồ và kênh.

Tuy nhiên, nếu bạn không thích forở bất kỳ hình thức nào, bạn có thể xác định each, mapv.v. trong một vài dòng:

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
}

bản in

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

Tôi bắt đầu thích Đi rất nhiều :)

Đi và có được danh tiếng stackoverflow của bạn

Đây là bản dịch của câu trả lời này .

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

Cảm ơn Scott Wales đã giúp đỡ với .Read ().

Điều này trông vẫn khá rắc rối, với hai dây và hai bộ đệm, vì vậy nếu bất kỳ chuyên gia cờ vây nào có lời khuyên, hãy cho tôi biết.

Đây là một ví dụ hay về iota từ bài đăng của 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 (!)

Bạn có thể hoán đổi các biến bằng cách gán song song:

x, y = y, x

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

đơn giản mà hiệu quả.

Đây là một thành ngữ từ trang Cờ vây hiệu quả

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

Câu lệnh switch chuyển thành true khi không có biểu thức nào được đưa ra. Vì vậy, điều này tương đương với

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

Hiện tại, phiên bản chuyển đổi trông gọn gàng hơn một chút đối với tôi.

Loại công tắc :

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

Khi nhập các gói, bạn có thể xác định lại tên thành bất kỳ thứ gì bạn muốn:

package main

import f "fmt"

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

Các thông số kết quả được đặt tên

Các "tham số" trả về hoặc kết quả của một hàm Go có thể được đặt tên và được sử dụng như các biến thông thường, giống như các tham số đến. Khi được đặt tên, chúng được khởi tạo thành giá trị 0 cho kiểu của chúng khi hàm bắt đầu; nếu hàm thực thi một câu lệnh trả về không có đối số, các giá trị hiện tại của các tham số kết quả được sử dụng làm giá trị trả về.

Tên không bắt buộc nhưng chúng có thể làm cho mã ngắn hơn và rõ ràng hơn: chúng là tài liệu. Nếu chúng ta đặt tên cho các kết quả của nextInt thì rõ ràng int trả về là cái nào.

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

Bởi vì các kết quả được đặt tên được khởi tạo và gắn liền với một kết quả trả về không được trang trí, chúng có thể đơn giản hóa cũng như làm rõ. Đây là một phiên bản của io.ReadFull sử dụng tốt chúng:

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

Từ câu trả lời của James Antill :

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

Ngoài ra, một cạm bẫy tiềm ẩn: sự khác biệt nhỏ giữa các toán tử nhận và gửi:

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

Tôi thích rằng bạn có thể xác định lại các kiểu, bao gồm các kiểu nguyên thủy như int, bao nhiêu lần tùy thích và đính kèm các phương thức khác nhau. Giống như xác định kiểu 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))
}

Cái nào in ra

Number:  5 five V

Các RomanNumber() gọi về cơ bản là một kiểu ép kiểu, nó định nghĩa lại kiểu int là một kiểu int cụ thể hơn. Và Println()các cuộc gọi String()ở hậu trường.

Trả lại một kênh

Đây là một thành ngữ thực sự khá quan trọng: làm thế nào để cung cấp dữ liệu vào một kênh và đóng nó sau đó. Với điều này, bạn có thể tạo các trình vòng lặp đơn giản (vì phạm vi sẽ chấp nhận một kênh) hoặc các bộ lọc.

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

Thời gian chờ cho các lần đọc kênh:

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

Bị đánh cắp từ Davies Liu .

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

Vì phạm vi tự động kiểm tra kênh đã đóng, chúng tôi có thể rút ngắn thành:

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

Có một hệ thống make được thiết lập mà bạn có thể sử dụng trong $ GOROOT / src

Thiết lập trang điểm của bạn với

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

Sau đó, bạn có thể sử dụng các công cụ kiểm tra tự động bằng cách chạy thử nghiệm thực hiện hoặc thêm gói và các đối tượng được chia sẻ từ cgo vào $ GOROOT của bạn với thực hiện cài đặt.

Một điều thú vị khác trong cờ vây là godoc . Bạn có thể chạy nó như một máy chủ web trên máy tính của mình bằng

godoc -http=:8080

trong đó 8080 là số cổng và toàn bộ trang web tại golang.org sau đó có sẵn tại localhost:8080.

Đây là một triển khai của một ngăn xếp. Nó minh họa việc thêm các phương thức vào một kiểu.

Tôi muốn làm cho phần ngăn xếp của nó thành một lát cắt và sử dụng các thuộc tính của lát cắt đó, nhưng mặc dù tôi đã làm việc đó mà không có dấu type, tôi không thể thấy cú pháp để xác định một lát cắt bằng 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()
}

Đang gọi mã c từ đi

Có thể truy cập mức thấp hơn của go bằng cách sử dụng c runtime.

Hàm C có dạng

void package·function(...)

(lưu ý dấu chấm phân cách là một ký tự unicode) trong đó các đối số có thể là các kiểu đi cơ bản, các lát cắt, chuỗi, v.v. Để trả về một lệnh gọi giá trị

FLUSH(&ret)

(bạn có thể trả về nhiều giá trị)

Ví dụ, để tạo một hàm

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

trong C bạn sử dụng

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

Lưu ý rằng bạn vẫn nên khai báo hàm trong tệp go và bạn sẽ phải tự quản lý bộ nhớ. Tôi không chắc liệu có thể gọi các thư viện bên ngoài bằng cách sử dụng này hay không, có thể tốt hơn nếu sử dụng cgo.

Nhìn vào $ GOROOT / src / pkg / runtime để biết các ví dụ được sử dụng trong runtime.

Xem thêm câu trả lời này để liên kết mã c ++ với go.

Đây là một ví dụ sử dụng gói sqlite3.

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

Bạn đã xem buổi nói chuyện này ? Nó cho thấy rất nhiều điều thú vị bạn có thể làm (kết thúc bài nói)

Một ngăn xếp dựa trên câu trả lời khác, nhưng sử dụng phần nối tiếp để không có giới hạn kích thước.

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
}

Có rất nhiều chương trình nhỏ trong testthư mục chính. Ví dụ:

• peano.go in giai thừa.
• hilbert.go có một số phép nhân ma trận.
• iota.go có các ví dụ về điều kỳ lạ iota.