Не так много кода Go, чтобы выучить язык, и я уверен, что я не единственный, кто экспериментирует с ним. Итак, если вы узнали что-то интересное о языке, отправьте здесь пример.
Я также ищу
Операторы отсрочки
Оператор "отложить" вызывает функцию, выполнение которой отложено до момента возвращения окружающей функции.
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);
}
Update:
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)
}
Объектные файлы Go на самом деле включают заголовок с открытым текстом:
[email protected] ~/workspace/go/euler31 $ 6g euler31.go
[email protected] ~/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>
Я видел пару людей, которые жаловались на цикл for, по i = 0; я < len; i++ "почему мы должны говорить i = 0; я < len; i++ в i = 0; я < len; i++ дни и в этом возрасте?".
Я не согласен, мне нравится для конструкции. Вы можете использовать длинную версию, если хотите, но идиоматический 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 очень много :)
Вот хороший пример iota из Kinopiko post:
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 (!)
Это перевод этого ответа.
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().
Это выглядит довольно неуклюже, с двумя строками и двумя буферами, поэтому, если у кого-либо из экспертов Go есть советы, дайте мне знать.
Здесь идиома со страницы 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
На данный момент версия переключателя выглядит немного чище для меня.
Вы можете менять переменные по параллельному назначению:
x, y = y, x
// or in an array
a[j], a[i] = a[i], a[j]
простой, но эффективный.
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");
}
При импорте пакетов вы можете переопределить имя на что угодно:
package main
import f "fmt"
func main() {
f.Printf("Hello World\n")
}
foo := <-ch // This blocks.
foo, ok := <-ch // This returns immediately.
Кроме того, потенциальная ловушка: тонкая разница между операторами приема и отправки:
a <- ch // sends ch to channel a
<-ch // reads from channel ch
Именованные параметры результата
Возврат или результат "параметров" Функция Go может иметь имена и используются как обычные переменные, так же как и входящие параметры. Когда он называется, они инициализируются нулем значения для их типов, когда функция начинается; если функция выполняет оператор возврата без аргументы, текущие значения параметры результата используются как возвращаемые значения.
Имена не являются обязательными, но они может сделать код короче и понятнее: это документация. Если мы назовем результаты 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;
}
/*
* 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))
}
Мне нравится, что вы можете переопределять типы, включая примитивы типа 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() за кулисами.
Это истинная идиома, которая очень важна: как подавать данные в канал и закрывать его потом. С этим вы можете создавать простые итераторы (поскольку диапазон принимает канал) или фильтры.
// 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;
}
for {
v := <-ch
if closed(ch) {
break
}
fmt.Println(v)
}
Поскольку диапазон автоматически проверяет наличие закрытого канала, мы можем сократить это:
for v := range ch {
fmt.Println(v)
}
Таймаут для чтения канала:
ticker := time.NewTicker(ns);
select {
case v := <- chan_target:
do_something_with_v;
case <- ticker.C:
handle_timeout;
}
Украден из Дэвис Лю.
Имеется система make, которую вы можете использовать в $GOROOT/src
Настройте свой файл с помощью
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-тест или добавьте пакет и общие объекты из cgo в ваш $GOROOT с make install.
Это реализация стека. Это иллюстрирует добавление методов к типу.
Я хотел превратить часть стека в срез и использовать свойства среза, но, хотя я получил это для работы без 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()
}
Еще одна интересная вещь в Go - это godoc. Вы можете запустить его как веб-сервер на своем компьютере, используя
godoc -http=:8080
где 8080 - номер порта, а весь сайт на golang.org доступен в localhost:8080.
Вызов кода c из go
Возможно получить доступ к более низкому уровню go, используя c runtime.
C функции имеют вид
void package·function(...)
(обратите внимание, что разделитель точек является символом юникода), где аргументы могут быть основными типами 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 для примеров, используемых во время выполнения.
См. также этот ответ для связывания кода С++ с go.
Вот пример с использованием пакета sqlite3.
Вы смотрели этот разговор? Это показывает много классных вещей, которые вы можете сделать (конец разговора)
const ever = true
for ever {
// infinite loop
}
Стек, основанный на другом ответе, но использующий срез, добавляющий без ограничения размера.
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()
}
В главном каталоге есть много небольших программ в test. Примеры:
peano.go печатает факториалы.hilbert.go имеет некоторое матричное умножение.iota.go есть примеры странной вещи iota.