Go 기초 문법 - 변수, 함수, if, for, 배열, 구조체, 인터페이스

fmt 출력이랑 간단한 변수선언은 초기세팅 때 해봤으니까 넘어가고, 다른 기초문법부터 정리하겠다. 변수 선언에서 추가로 기억할만한건 destructuring랑 스왑 정도다.

var d, e, f int = 40, 50, 60
g, h, i := 70, 80, 90
x, y := 1, 2
x, y = y, x // 이게 된다...

# 함수 func - 단일 값 반환, 다중 값 반환, 반환 변수명 명시

go의 함수를 보면서 재밌다고 느낀건 리턴값을 여러개 줄 수 있다는 것이다. 반환값에 이름을 붙여서 다루는 부분도 특이하다.

package main

import "fmt"

func add(x int, y int) int {
    return x + y
}

func plusMinus(x int, y int) (int, int) {
    return x + y, x - y
}

func namedPlusMinus(x int, y int) (p int, m int) {
    p = x + y // 함수 선언 때 명시해둔 변수를 갖고 와서 쓸 수 있다
    m = x - y
    return  // 명시적 반환값 없이 반환
}

func main() {
    result := add(1, 1)
    plus, minus := plusMinus(1, 1) 
    fmt.Println(result) // 2
    fmt.Println(plus) // 2
    fmt.Println(minus) // 0
}

# 조건문과 반복문 if, switch, for

golang에서 조건을 붙일 때는 괄호로 묶지 않는다. 괄호가 있으나 없으나 상관없어야될 것 같은데 괄호가 있으면 오류를 내뿜는다. vscode에서 go플러그인을 달았더니 알아서 괄호를 빼버리는 것도 볼 수 있다.

package main

import "fmt"

func main() {
    x := 10
    if (x > 5) {
        fmt.Println("x는 5보다 큽니다.")
    }
    if x > 5 { // 이게 맞음
        fmt.Println("x는 5보다 큽니다.")
    }
}

else if나 else도 동일하게 사용한다.

if문에서 변수선언도 가능한데, 여기서 선언한 변수는 if문 스코프 밖에서 사용할 수 없다.

if x := 10; x > 5 {
    fmt.Println("x는 5보다 큽니다.")
}
fmt.Println(x) // x에 접근할 수 없다.

간결함을 지향하는 언어답게 뭐가 많이 없다.

switch~case

x := 2
switch x {
case 1:
    fmt.Println("One")
case 2:
    fmt.Println("Two")
case 3:
    fmt.Println("Three")
default:
    fmt.Println("Other")
}

if~else if ~ else 랑 동일한 개념이다. 기존 switch case랑 다른 점이라면 break가 없어도 밑으로 쭉 내려가지 않는다. 조건을 넣어서 사용할 수도 있어서 코틀린의 when과 더 유사하다고 보면 될 것 같다.

age := 25
switch {
case age < 18:
    fmt.Println("Child")
case age >= 18 && age < 30:
    fmt.Println("Young Adult")
case age >= 30 && age < 60:
    fmt.Println("Adult")
default:
    fmt.Println("Senior")
}

쭉 타고 내려가게 하고 싶으면 fallthrough 키워드를 선언하면 된다.

x := 1
switch x {
case 1:
    fmt.Println("One")
    fallthrough
case 2:
    fmt.Println("Two")
default:
    fmt.Println("Other")
}

이 코드는 One, Two를 출력한다.

 

반복문에서도 while이 없고 for로 다양한 구문을 작성할 수  있다.

for i := 1; i <= 5; i++ {  // 초기값; 조건; 증감
    fmt.Println(i)  // 1부터 5까지 출력
}

이게 기본 for문이다. while처럼 사용하려면 조건만 있는 for를 쓰면 된다. 

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

무한루프를 원한다면??? 조건 마저없애고, break 조건을 넣어두면 된다.

i := 0
for {
    fmt.Println(i)
    i++
    if i >= 5 {
        break
    }
}

# 배열

var arr [3]int  // 정수형 배열 선언, 길이 3
// arr := [3]int{1, 2, 3} // 선언과 동시에 초기화 해야되니까 {} 이걸로 묶어서 해준다
// arr := [...]int{1, 2, 3} // 배열길이계산을 컴파일러에게 넘기는 방법도 가능하다
arr[0] = 1
arr[1] = 2
arr[2] = 3

fmt.Println(arr)  // [1 2 3] 출력

배열 부터는 혼선이 생기기 시작했다. 자바의 경우 int[] arr 이런 식으로 쓰고, c면 int arr[] 이렇게 썼기 때문이다. 다행히 선언만 다르고 나머지는 비슷해서 적응되고 있다.

for문과 배열을 이용해 순회도는것도 가능한데 range를 사용한다.

for index, value := range arr {
    fmt.Printf("index: %d, value: %d\n", index, value)
}

# 구조체

이 부분은 자바로 class 만들다 와서 그런지 그나마 쉽게 이해했다.

type Node struct {
    v 	int
    w   int
}

p := Node{v: 1, w: 30}

선언하는 게 좀 다르긴한데 보고 이해 못할 정도는 아니다. 근데 golang은 기본적으로 call by value이기 때문에, 자바처럼 원본에 참조가 필요하다면 구조체 포인터...를 써야된다.

p := &Node{v: 3, w: 25}

그냥 구조체 포인터도 new로 생성할 수 있다.

p2 := new(Node) // 값이 비어있는 구조체 포인터
p2.v = 7
p2.w = 77

구조체 포인터를 사용할 때는 일반 포인터 값을 사용할 때 처럼 *를 안붙여도 된다.

func (p *Node) zero() { // 반환타입 없다
    p.v = 0
}

*로 파라미터를 받으면 포인터를 참조하고 있는 거라서 이 함수의 실행은 함수 스코프 바깥에 영향을 미친다. 그냥 함수랑 조금 다른데, Node 구조체에 대한 함수를 정의하고 있다.

# 인터페이스

인터페이스는 구조체와 거의 유사하게 생겼다.

type Describer interface {
    Describe() string
}

type Person struct {
    Name string
    Age  int
}

interface라고 지정해서 사용한다. 위 코드 상으로는 Describe 함수를 구현해야되는 Describer 인터페이스다.

// Person 구조체가 Describer 인터페이스를 구현
func (p Person) Describe() string {
    return fmt.Sprintf("Name: %s, Age: %d", p.Name, p.Age)
}

func main() {
    var d Describer
    p := Person{Name: "Alice", Age: 30}
    d = p
    fmt.Println(d.Describe())  // "Name: Alice, Age: 30"
}

Person 구조체가 Describe 인터페이스를 구현했기 때문에 d = p로 할당할 수 있다.

다중 상속과 같은 개념도 가능하다.

type Describer interface {
    Describe() string
}

type Worker interface {
    Work()
}

type Person struct {
    Name string
    Age  int
}

func (p Person) Describe() string {
    return fmt.Sprintf("Name: %s, Age: %d", p.Name, p.Age)
}

func (p Person) Work() {
    fmt.Printf("%s is working.\n", p.Name)
}

func main() {
    var d Describer
    var w Worker
    p := Person{Name: "Alice", Age: 30}
    d = p
    w = p
    fmt.Println(d.Describe())  // "Name: Alice, Age: 30"
    w.Work()                   // "Alice is working."
}

 

빈 인터페이스를 매개변수 타입으로 선언해서 제네릭처럼 쓸 수도 있다.

func foo(i interface{}) {
    fmt.Printf("Type: %T, Value: %v\n", i, i)
}

 

 

 

 

도움이 됐다면 댓글이나 공감 버튼 한 번씩 누르고 가주세요!