[go] Go 예제 및 관용구 [닫기]

Program / 글쓴이

언어를 배울 수있는 Go 코드가 많지 않으며, 저만 실험 해본 것도 아닙니다. 따라서 언어에 대해 흥미로운 것을 발견했다면 여기에 예제를 게시하십시오.

나는 또한 찾고있다

  • Go에서 일을하는 관용적 방법,
  • Go로 “포팅 된”C / C ++ 스타일
  • 구문에 대한 일반적인 함정,
  • 정말 흥미로운 거죠.

답변

진술 연기

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

답변

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>

답변

나는 ” i = 0; i < len; i++이 시대에 왜 우리가 말해야 하는가?” 라는 문구와 함께 for-loop에 대해 불평하는 두 사람을 보았다 .

동의하지 않습니다. 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를 많이 좋아하기 시작했습니다. 🙂

답변

가서 당신의 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"))
}

.Read ()에 대한 도움을 주신 Scott Wales에게 감사드립니다 .

이것은 두 개의 문자열과 두 개의 버퍼로 여전히 상당히 투박해 보이므로 Go 전문가가 조언이 있으면 알려주십시오.

답변

다음은 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 (!)

답변

병렬 할당으로 변수를 바꿀 수 있습니다.

x, y = y, x

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

간단하지만 효과적인.

답변

다음은 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

지금은 스위치 버전이 좀 더 깔끔해 보입니다.