포트폴리오
← 모든 글

Go 언어 기초 문법 (1) - 변수, 상수, 함수

1. Go 언어의 특징

Go(Golang)는 Google에서 개발한 정적 타입(Statically Typed) 기반의 컴파일 언어이다.

Java, C#과 마찬가지로 컴파일 과정에서 타입 검사를 수행하지만, Go는 컴파일 결과로 실행 파일을 직접 생성할 수 있다는 특징이 있다.

주요 특징

  • 컴파일 언어: 소스 코드를 컴파일하여 실행 파일 생성
  • 정적 타입 언어: 컴파일 시점에 변수와 함수의 타입 검사
  • 타입 추론 지원: 타입을 명시하지 않아도 초기 값을 통해 자동으로 타입 결정
  • 간결한 문법: 불필요한 문법을 줄여 코드의 가독성 향상
  • 다중 반환값 지원: 함수에서 여러 개의 값을 반환 가능
참고: Go에서 변수 타입을 항상 명시해야 하는 것은 아니다. 타입을 생략하더라도 초기값을 통해 타입을 추론할 수 있다. 단, 타입을 추론할 수 없는 선언이나 타입에 맞지 않는 값의 대입은 컴파일 오류가 발생한다.

2. 변수와 상수 (Variable & Constant)

Go에서는 var 키워드를 사용하여 변수를 선언하고, const 키워드를 사용하여 상수를 선언한다.

2.1 변수 (Variable)

변수는 선언 이후 값을 변경할 수 있는 저장 공간이다.

기본 문법

var 변수명 타입 = 값

예제

package main

import "fmt"

func main() {
    var name string = "mocha"

    fmt.Println(name) // mocha

    name = "lee"

    fmt.Println(name) // lee
}

var 키워드를 통해 string 타입의 변수를 선언했으며, 이후 다른 문자열을 대입할 수 있다.

단, 한 번 결정된 변수의 타입은 변경할 수 없다.

var name string = "mocha"

name = 100 // 컴파일 오류 발생

2.2 타입 추론 (Type Inference)

Go에서는 초기값이 존재한다면 변수 타입을 생략할 수 있다.

var name = "mocha"
var age = 30
var isActive = true

컴파일러가 초기값을 기준으로 타입을 결정한다.

  • name: string
  • age: int
  • isActive: bool

※ 하지만 되도록 타입을 꼭 입력한다!

2.3 짧은 변수 선언 (Short Variable Declaration)

Go에서는 := 연산자를 사용하여 변수 선언과 초기값 할당을 동시에 처리할 수 있다.설정된 값에 따른 타입이 결정된다.

func main() {
    name := "mocha"
    age := 30

    fmt.Println(name, age)
}

특징

  • var 키워드 및 타입 선언 생략
  • 초기 값을 기준으로 타입 자동 추론
  • 함수 내부에서만 사용 가능
  • 선언 시 초기 값 필수

주의 사항

// 함수 외부에서는 사용 불가
name := "mocha" // 컴파일 오류

func main() {
    name := "mocha" // 정상
}

패키지 수준에서는 var 또는 const를 사용해야 한다.

또한 같은 스코프에서 :=를 사용할 때는 왼쪽 변수 중 최소 하나가 새로 선언되는 변수여야 한다.

2.4 상수 (Constant)

상수는 선언 이후 값을 변경할 수 없는 값이다.

const 키워드를 사용하여 선언한다.

const name string = "mocha"

타입을 생략하여 선언하는 것도 가능하다.

const name = "mocha"
const maxCount = 100

예제

package main

import "fmt"

func main() {
    const name string = "mocha"

    fmt.Println(name)

    // name = "lee" // 컴파일 오류 발생
}

상수에는 컴파일 시점에 결정 가능한 상수 표현식만 사용할 수 있다.

2.5 변수와 상수 비교


3. 함수 (Function)

Go에서는 func 키워드를 사용하여 함수를 정의한다.

함수 선언 시 매개변수의 타입을 지정하며, 반환값이 존재하는 경우 반환 타입도 지정한다.

3.1 기본 함수 선언

기본 문법

func 함수명(매개변수명 타입) 반환타입 {
    // 실행 코드
    return 반환값
}

예제

package main

import "fmt"

func multiply(a int, b int) int {
    return a * b
}

func main() {
    result := multiply(3, 5)

    fmt.Println(result) // 15
}

multiply() 함수는 두 개의 정수를 전달받아 곱셈 결과를 반환한다.

매개변수의 타입이 동일하다면 다음과 같이 간략하게 작성할 수 있다.

func multiply(a, b int) int {
    return a * b
}

3.2 반환값이 없는 함수

반환값이 존재하지 않는 함수는 반환 타입을 생략한다.

package main

import "fmt"

func sayHello(name string) {
    fmt.Println("Hello", name)
}

func main() {
    sayHello("mocha")
}

실행 결과

Hello mocha
참고: Java와 C#에서는 반환값이 없는 함수에 void를 사용하지만, Go에는 void 타입을 명시하지 않는다. 반환 타입 자체를 생략한다.

4. 다중 반환값 (Multiple Return Values)

Go 함수는 하나의 값뿐만 아니라 여러 개의 값을 반환할 수 있다.

반환 타입은 괄호 () 안에 쉼표로 구분하여 작성한다.

4.1 여러 개의 값 반환

package main

import (
    "fmt"
    "strings"
)

func lenAndUpper(name string) (int, string) {
    return len(name), strings.ToUpper(name)
}

func main() {
    totalLength, upperName := lenAndUpper("mocha")

    fmt.Println(totalLength, upperName)
}

실행 결과

5 MOCHA

함수는 다음 두 가지 값을 반환한다.

  1. len(name): 문자열의 길이를 바이트 단위로 반환
  2. strings.ToUpper(name): 문자열을 대문자로 변환

참고로 len()은 UTF-8 문자열의 문자 개수가 아닌 바이트 수를 반환하므로, 한글 등 멀티바이트 문자를 다룰 때는 주의해야 한다.

4.2 반환값 무시하기 (_)

Go에서는 반환받은 값이 필요하지 않은 경우 _(Blank Identifier)를 사용하여 해당 값을 무시할 수 있다.

func main() {
    totalLength, _ := lenAndUpper("mocha")

    fmt.Println(totalLength)
}

실행 결과

5

반대로 두 번째 반환값만 필요한 경우에도 사용할 수 있다.

func main() {
    _, upperName := lenAndUpper("mocha")

    fmt.Println(upperName)
}

실행 결과

MOCHA

주의사항

Go에서는 선언한 지역 변수를 사용하지 않으면 컴파일 오류가 발생한다.

totalLength, upperName := lenAndUpper("mocha")

fmt.Println(totalLength)
// upperName이 사용되지 않아 컴파일 오류 발생

이러한 경우 _를 사용하면 불필요한 변수를 생성하지 않고 반환값을 무시할 수 있다.


5. 가변 인자 함수 (Variadic Function)

Go에서는 함수에 전달할 인자의 개수가 정해져 있지 않은 경우 ... 문법을 사용한다.

이를 가변 인자 함수(Variadic Function) 라고 한다.

5.1 가변 인자 선언

package main

import "fmt"

func repeatMe(words ...string) {
    fmt.Println(words)
}

func main() {
    repeatMe("a", "b", "c", "d", "e")
}

실행 결과

[a b c d e]

words ...string은 여러 개의 문자열 인자를 전달받는다는 의미이다.

함수 내부에서는 전달된 인자를 []string 슬라이스로 처리한다.

5.2 가변 인자 순회

range를 사용하면 전달된 인자들을 순회할 수 있다.

func repeatMe(words ...string) {
    for index, word := range words {
        fmt.Println(index, word)
    }
}

실행 결과

0 a
1 b
2 c
3 d
4 e

5.3 슬라이스를 가변 인자로 전달하기

슬라이스에 저장된 값을 가변 인자 함수에 전달할 때는 ...을 사용한다.

func main() {
    words := []string{"a", "b", "c"}

    repeatMe(words...)
}

주의사항

  • 가변 인자는 함수의 마지막 매개변수에만 선언할 수 있다.
  • 하나의 함수에서 가변 인자 매개변수는 하나만 사용할 수 있다.
  • 인자를 하나도 전달하지 않아도 정상 호출된다.

6. 핵심 내용 정리

마무리

이번 학습에서는 Go 언어의 기본적인 변수, 상수, 함수 선언 방법을 살펴보았다.

Go는 정적 타입 언어이지만 타입 추론을 지원하므로 간결하게 코드를 작성할 수 있다.

특히 다른 언어와 비교했을 때 다음 세 가지 문법이 특징적이다.

  • :=를 활용한 간단한 변수 선언
  • 함수의 다중 반환값 지원
  • ...을 활용한 가변 인자 처리

Go를 처음 학습한다면 해당 문법들을 이해하고 익숙해지는 것이 중요하다.

Tags: Go Golang Go 기초 변수와 상수 Go Function Backend Programming