[GO] Go 스터디

Go 기본 구조

import "fmt"

func main() {
    fmt.Println("Hello world")
}

함수와 매개변수

import "fmt"

//① 매개변수 타입, 리턴 타입은 이름 뒤에 지정해줍니다
func add1(x int, y int) int { //매개변수의 타입은 뒤에, Return 타입도 뒤에!
    return x + y
}

//② 매개변수 x, y가 같은 타입일 때에는 타입을 한 번만 명시해 줄 수 있습니다.
func add2(x, y int) int { //동일한 타입의 매개변수 경우 한번에 명시 가능
    return x + y
}

func main() {
    fmt.Println("add1(x int, y int)의 결과: ", add1(42, 13))
    fmt.Println("add2(x, y int)의 결과: ", add2(42, 13))
}

함수가 여러 값을 Return 하는 방법

1. Return할 변수 선언 (var로 변수를 선언할 필요가 없다.)

//② return뒤에 리턴할 변수를 선언하는 방법. ①과는 달리 함수 내부에서 `quotient`를 `var`로 선언하지 않고 바로 씁니다.
func divide2(dividend, divisor int) (quotient, remainder int) {
    quotient = (int)(dividend/divisor)
    remainder = dividend%divisor
    return //return이라고만 적으면 미리 return값으로 정해 놓은 quotient와 remainder를 return합니다.
}

2. Return Type 명시

//① return 뒤에 리턴 타입을 적어주는 방법
func divide1(dividend, divisor int) (int, int) {
    var quotient = (int)(dividend/divisor)
    var remainder = dividend%divisor
    return quotient, remainder
}

변수 선언 방법

import "fmt"

//① 변수를 하나 선언
var num1 int //파이썬, C와 다르게 var라는 키워드로 변수를 선언하고, 변수 이름 그 뒤에 타입을 명시한다.

//② 같은 타입을 가지는 변수를 여러 개 선언
var num2, num3 int 

//③ 여러 변수에 한 번에 값을 초기화 : 선언과 동시에 값을 초기화하면 타입을 명시할 필요가 없습니다.
var num4, num5, str1 = 4, 5, "example" 

//④ 함수 밖에서는 :=를 쓸 수 없습니다.
errorvar := str1

//⑤ 다른 타입을 가지는 변수를 여러 개 선언
var (
    i int
    b bool
    s string
)

func main(){
    fmt.Println("①", num1)
    fmt.Println("②", num2, num3)
    fmt.Println("③", num4, num5, str1)
    
    //④ 함수 안에서는 :=를 쓰면 var과 타입을 지정하지 않고 변수를 선언과 동시에 초기화할 수 있습니다.
    num6 := 6 /////함수 안에 있다면 타입을 명시하지 않고 :=로 선언 가능
    fmt.Println("④", num6)
    
    fmt.Println("⑤", i, b, s)
}

기본 자료형(Type)

var (
    i int
    f float64 //64비트 float
    MaxInt uint64 = 1<<64 - 1
    z complex128 = cmplx.Sqrt(-5 + 12i)
)

Go는 묵시적 형변환이 불가능하다.

func main() {
    const format = "%T(%v)\n"
    fmt.Printf(format, MaxInt, MaxInt)
    fmt.Printf(format, z, z)
    
    // int에서 float64로 묵시적 타입 변환을 할 수 없습니다
    f = i //Error
    
    // 다른 타입을 저장하려면 변환할타입(변수) 와 같이, 형 변환을 해줘야 합니다.
    f = float64(i)
}

Zero Value: 선언만 하고 초기화만 할 경우 타입별 Zero Value로 초기화된다.

var (
    i int // zero value = 0
    f float64 // zero value = 0
    b bool // zero value = false
    s string // zero value = ""
)

상수선언

// 상수도 선언과 동시에 초기화하면 타입을 지정하지 않아도 됩니다.
const Pi1 float32 = 3.14
const Pi2 = 3.14

// 괄호로 묶으면 상수 키워드를 한 번만 명시합니다.
const (
    Big_const   = 1 << 100
    Small_const = Big_const >> 99 
)

// 오버플로우가 발생합니다.
var Big_var = 1 << 100 //error
const Big_var = 1 << 100 //var가 아닌 const로 선언할 경우, var로 표현할 수 없는 범윌르 저장하여 수를 정밀하게 표현

Small_const가 같은 경우에는, 선언시 타입을 명사하지 않았으므로 함수에 따라 다양한 타입이 될 수 있다.

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
    return x * 0.1
}

func main() {
    fmt.Println("needInt(Small_const):", needInt(Small_const)) 
		// Small_const 상수 선언시 타입을 지정하지 않았기 때문에 int형으로 자동으로 변환됩니다
    fmt.Println("needFloat(Small_const):", needFloat(Small_const)) 
		// Small_const 상수 선언시 타입을 지정하지 않았기 때문에 float64형으로 자동으로 변환됩니다
    fmt.Println("needFloat(Big_const):", needFloat(Big_const))
    
}

[실행 결과]
출력 〉
needInt(Small_const): 21
needFloat(Small_const): 0.2
needFloat(Big_const): 1.2676506002282295e+29