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
복사