Claude's Profile

Blog

Go Tour-2

Go Tour-2

Go Tour

슬라이스

•

슬라이스는 배열의 값을 가르키며, []T 로 만들 수 있다.

import "fmt"

func main () {
    p := []int{1,2,3,4,5}
    fmt.Println(p)

    fmt.Println("p[0:3] == ", p[0:3])
    fmt.Println("p[:3] == ", p[:3])
    fmt.Println("p[2:] == ",p[2:])
}
Go
복사

•

make 함수로 슬라이스를 만들 수 있다.

•

len 는 슬라이스 길이, cap 는 슬라이스에 저장 가능한 최대 길이를 반환한다

import "fmt"

func main () {
    p := make([]int, 5) // len = 5, cap = 5
    fmt.Println("p == ", p)
    fmt.Println("len(p) == ", len(p))
    fmt.Println("cap(p) == ", cap(p))

    q := make([]int, 0, 5) // len = 0, cap = 5
    fmt.Println("q == ", q)
    fmt.Println("q[:cap(q)] == ", q[:cap(q)])
    fmt.Println("q[1:] == ", q[1:])

    var z []int // len = 0, cap = 0
    fmt.Println("z == ", z)
    fmt.Println("len(z) == ", len(z))
    fmt.Println("cap(z) == ", cap(z))
}
Go
복사

•

for 문에서 range 함수를 통해 슬라이스나 맵을 이터레이트 할 수 있다

import "fmt"

func main () {
    p := []int {2,4,6,8,10,12}
    for i, v := range p {
        fmt.Println("index == ", i)
        fmt.Println("value == ", value)
    }

    for i := range p {
        fmt.Println("index == ", i)
    }

    for _, v := range p {
        fmt.Println("value == ", v)
    }
}
Go
복사

맵(Map)

•

Map 은 키를 지정하여 키:벨류 형태로 저장할 수 있다

•

맵은 사용하기전에 반드시 make 를 명시해줘야한다.

type Vertax struct {
    Lat float64
    Lng float64
}

var m map[string]Vertax

func main () {
    m = make(map[string]Vertax)
    m["Seoul"] = Vertax {37.541, 126.986}
    fmt.Println("m == ", m)
    fmt.Println("m['Seoul'] == ", m["Seoul"])
}
Go
복사

•

만약 맵에 키가 존재하지 않을 경우, 타입에 맞는 zero value 가 된다

•

delete(map, key) 로 삭제할 수 있다

import "fmt"

type Vertax struct {
    Lat float64
    Lng float64
}

var m = map[string]Vertax {
    "Seoul": {
        37.541, 126.986,
    },
    "Busan": {
        35.06, 129.0203,
    },
}

func main () {
    fmt.Println(m)
    
    fmt.Println(m["Seoul"])
    m["Seoul"] = Vertax{37.33, 126.5815}
    fmt.Println(m["Seoul"])

    delete(m, "Seoul")
    fmt.Println(m)

    v, ok := m["Seoul"]
    fmt.Println(ok)
    fmt.Println(v)
}
Go
복사

함수

•

함수도 값이기 때문에 변수로 사용할 수 있다

import "fmt"

func main () {
    hap := func(x int, y int) int {
        return x + y
    }
    fmt.Println(hap(1,2))
}
Go
복사

•

클로저

import "fmt"

func adder () func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main () {
    a, b := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(
            a(i + 1),
            b(i * 2),
        )
    }
}
Go
복사

•

A Tour of Go 44

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
    i, j := 0, 1
    return func () int {
        sum := i
        i, j = j, i + j
        return sum
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}
Go
복사

스위치

•

다른 언어와 Switch 와 동일한 기능을 하지만, case문의 코드 실행이 끝나면 자동으로 break 하는게 다르다

•

스위치는 위에서부터 아래로 케이스를 찾는다

•

스위치에서 조건을 생략하면 switch true 와 동일한 수행을 한다

◦

if-then-else 가 길어질 경우, 이 방법을 사용하면 코드가 깔끔해질 수 있다

import (
    "fmt"
    "runtime"
)

func main () {
    switch os := runtime.GOOS; os {
        case "darwin":
            fmt.Println("Mac OS")
        case "linux":
            fmt.Println("linux")
        default:
            fmt.Println(os)
    }
}
Go
복사

메소드

•

고에는 클래스가 없지만, 메소드를 구조체에 붙혀서 사용할 수 있다

•

구조체 뿐만 아니라 어떠한 타입에도 메소드를 붙힐 수 있다

◦

다른 패키지에 있는 타입이나 기본 타입에는 붙힐 수 없다

import "fmt"

type Vertax struct {
    Lat, Lng float64
}

func (v *Vertax) toString() string {
    return fmt.Sprintf("%f / %f", v.Lat, v.Lng)
}

func main () {
    v := Vertax{23, 25}
    fmt.Println(v.toString())
}
Go
복사

인터페이스

import "fmt"

type MyInterface interface {
    Abs() float64
}

func main () {
    var a MyInterface
    v := Vertax{10, 15}

    a = v
    fmt.Println(a.Abs())

    a = MyFloat(5)
    fmt.Println(a.Abs())
}

type MyFloat float64
func (m MyFloat) Abs() float64 {
    if m < 0 {
        return float64(-m)
    }
    return float64(m)
}

type Vertax struct {
    X, Y float64
}
func (v Vertax) Abs() float64 {
    return v.X + v.Y
}
Go
복사

에러

import (
    "fmt"
    "time"
)

type CustomError struct {
    When time.Time
    What string
}

func (e *CustomError) Error() string {
    return fmt.Sprintf("at %v, %s", e.When, e.What)
}

func run() error {
    return &CustomError{time.Now(), "Custom Error Test"}
}

func main () {
    err := run()
    if (err != nil) {
        fmt.Println(err)
    }
}
Go
복사

고루틴과 채널

import "fmt"

func fibonacci (n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        y, x = x, x + y
    }
    close(c)
}

func main () {
    c := make (chan int, 15)
    go fibonacci(cap(c), c)
    for r := range c {
        fmt.Println(r)
    }
}
Go
복사

•

select 를 이용하면 다수의 채널로 부터 수신을 채널별로 다른 동작을 할 수 있다

import "fmt"

func fibonacci (c, q chan int) {
    x, y := 0, 1
    for {
        select {
            case c <- x:
                x, y = y, x + y
            case <- q:
                fmt.Println("quit")
                return
        }
    }
}

func main () {
    c := make(chan int, 10)
    q := make(chan int)

    go func() {
        for i := 0; i < cap(c); i++ {
            fmt.Println(<-c)
        }
        q <- 0
    }()
    fibonacci(c, q)
}
Go
복사

import (
    "time"
    "fmt"
)

func main () {
    tick := time.Tick(1000)
    boom := time.After(5000)
    for {
        select {
            case <- tick:
                fmt.Println("Tick!!")
            case <- boom:
                fmt.Println("Boom!!")
                return
            default:
                fmt.Println("...")
                time.Sleep(500)
        }
    }
}
Go
복사