没有很多 Go 代码可以用来学习这门语言，而且我确信我不是唯一一个尝试它的人。因此，如果您发现有关该语言的有趣内容，请在此处发布示例。
我也在寻找
- 在 Go 中做事的惯用方式，
- C/C++ 的思维方式“移植”到 Go，
- 关于语法的常见缺陷，
- 任何有趣的事情，真的。
问问题
26366 次
25 回答
35
延迟语句
“defer”语句调用一个函数，该函数的执行被推迟到周围函数返回的那一刻。
DeferStmt =“延迟”表达式。
表达式必须是函数或方法调用。每次执行“defer”语句时，函数调用的参数都会重新计算并保存，但不会调用函数。延迟函数调用在周围函数返回之前以 LIFO 顺序执行，但在返回值（如果有）已被评估之后。
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);
}
更新：
defer现在也是以类似异常的panic方式处理的惯用方式：
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)
}
于 2009-11-13T16:26:30.340 回答
25
Go 目标文件实际上包含一个明文标题：
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>
于 2009-11-13T00:03:36.163 回答
22
我见过一些人抱怨 for 循环，大意是“我们为什么要i = 0; i < len; i++在这个时代说出来？”。
我不同意，我喜欢 for 构造。如果你愿意，你可以使用长版本，但惯用的 Go 是
var a = []int{1, 2, 3}
for i, v := range a {
fmt.Println(i, v)
}
该for .. range构造循环遍历所有元素并提供两个值 - 索引i和值v。
range也适用于地图和频道。
尽管如此，如果您不喜欢for任何形式，您可以在几行中定义等each：map
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
}
印刷
0 : 2
1 : 0
2 : 0
3 : 9
我开始非常喜欢 Go :)
于 2009-11-16T22:47:45.817 回答
19
去获取你的 stackoverflow 声誉
这是这个答案的翻译。
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"))
}
这看起来仍然相当笨重，有两个字符串和两个缓冲区，所以如果任何 Go 专家有建议，请告诉我。
于 2009-11-12T12:21:12.680 回答
19
这是Kinopiko 帖子中 iota 的一个很好的例子：
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 (!)
于 2009-11-12T10:41:23.377 回答
18
这是来自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
当没有给出表达式时，switch 语句打开 true。所以这相当于
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
目前，switch 版本对我来说看起来更干净一些。
于 2009-11-12T15:18:50.343 回答
18
您可以通过并行赋值交换变量：
x, y = y, x
// or in an array
a[j], a[i] = a[i], a[j]
简单但有效。
于 2009-11-22T04:38:59.623 回答
17
类型开关：
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");
}
于 2009-12-16T02:05:35.723 回答
16
导入包时，您可以将名称重新定义为您想要的任何名称：
package main
import f "fmt"
func main() {
f.Printf("Hello World\n")
}
于 2009-11-13T04:32:09.413 回答
14
命名结果参数
Go 函数的返回或结果“参数”可以指定名称并用作常规变量，就像传入参数一样。当命名时，它们在函数开始时被初始化为它们的类型的零值；如果函数执行没有参数的 return 语句，则使用结果参数的当前值作为返回值。
这些名称不是强制性的，但它们可以使代码更短更清晰：它们是文档。如果我们命名 nextInt 的结果，很明显哪个返回的 int 是哪个。
func nextInt(b []byte, pos int) (value, nextPos int) {
因为命名结果被初始化并与一个简单的返回相关联，所以它们可以简化和澄清。这是一个很好地使用它们的 io.ReadFull 版本：
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;
}
于 2009-11-22T00:41:43.220 回答
13
我喜欢你可以重新定义类型，包括像 int 这样的原语，你喜欢多少次都可以，并附加不同的方法。就像定义 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))
}
哪个打印出来
Number: 5 five V
该RomanNumber()调用本质上是一个强制转换，它将 int 类型重新定义为更具体的 int 类型。并在幕后Println()打电话。String()
于 2009-11-16T07:31:17.207 回答
13
/*
* 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))
}
于 2009-11-12T06:00:47.293 回答
12
返回频道
这是一个非常重要的真正成语：如何将数据输入通道并在之后关闭它。有了这个，您可以制作简单的迭代器（因为 range 将接受一个通道）或过滤器。
// 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;
}
于 2009-11-22T16:29:09.390 回答
11
通道读取超时：
ticker := time.NewTicker(ns);
select {
case v := <- chan_target:
do_something_with_v;
case <- ticker.C:
handle_timeout;
}
盗自Davies Liu。
于 2009-11-23T21:36:17.723 回答
11
for {
v := <-ch
if closed(ch) {
break
}
fmt.Println(v)
}
由于 range 自动检查关闭的通道，我们可以缩短为：
for v := range ch {
fmt.Println(v)
}
于 2009-11-22T15:33:27.663 回答
9
您可以在 $GOROOT/src 中使用一个 make 系统设置
设置你的makefile
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
然后，您可以通过运行 make test 来使用自动化测试工具，或者使用 make install 将包和共享对象从 cgo 添加到您的 $GOROOT。
于 2009-11-12T09:55:55.103 回答
7
这是一个堆栈的实现。它说明了向类型添加方法。
我想将堆栈的一部分变成一个切片并使用切片的属性，但是尽管我可以在没有 . 的情况下使用它，但type我看不到使用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()
}
于 2009-11-12T07:57:39.647 回答
7
Go 中另一个有趣的事情是godoc. 您可以使用它在您的计算机上将其作为 Web 服务器运行
godoc -http=:8080
其中 8080 是端口号，然后可以在 golang.org 上访问整个网站localhost:8080。
于 2009-11-15T12:28:28.963 回答
4
从 go 调用 c 代码
使用 c 运行时可以访问较低级别的 go。
C 函数的形式为
void package·function(...)
（注意点分隔符是一个 unicode 字符）其中参数可能是基本的 go 类型、切片、字符串等。返回值调用
FLUSH(&ret)
（您可以返回多个值）
例如，创建一个函数
package foo
bar( a int32, b string )(c float32 ){
c = 1.3 + float32(a - int32(len(b))
}
在 C 中你使用
#include "runtime.h"
void foo·bar(int32 a, String b, float32 c){
c = 1.3 + a - b.len;
FLUSH(&c);
}
请注意，您仍然应该在 go 文件中声明该函数，并且您必须自己处理内存。我不确定是否可以使用它调用外部库，使用 cgo 可能会更好。
查看 $GOROOT/src/pkg/runtime 以获取运行时中使用的示例。
另请参阅此答案以将 c++ 代码与 go 链接。
于 2009-11-12T09:38:59.723 回答
4
这是一个使用 sqlite3 包的示例。
于 2010-07-05T09:09:42.660 回答
3
基于另一个答案的堆栈，但使用切片附加没有大小限制。
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()
}
于 2010-11-12T16:10:16.030 回答
3
你看过这个演讲吗？它展示了你可以做的很多很酷的事情（谈话结束）
于 2009-11-12T06:01:16.230 回答
3
const ever = true
for ever {
// infinite loop
}
于 2009-11-12T22:19:14.797 回答
2
test主目录中有很多小程序。例子：
peano.go打印阶乘。hilbert.go有一些矩阵乘法。iota.go有奇怪的iota事情的例子。
于 2009-11-12T06:13:01.577 回答