Go 기초: 정수, 부동 소수점, 불리언 및 문자열 데이터 유형 탐색

현대적이고 정적 타입이며 컴파일되는 프로그래밍 언어인 Go는 모든 애플리케이션의 기반을 형성하는 강력한 내장 데이터 유형 세트를 제공합니다. 이러한 기본 유형을 이해하는 것은 효율적이고 명시적이며 오류 없는 Go 프로그램을 작성하는 데 매우 중요합니다. 이 문서는 Go의 주요 기본 데이터 유형인 정수, 부동 소수점 숫자, 불리언 및 문자열을 자세히 살펴보고 설명적인 코드 예제를 통해 해당 특성 및 실제 적용을 설명합니다.

Go의 정수: 짝수 숫자

Go의 정수는 0을 포함하여 양수와 음수 모두를 나타내는 전체 숫자를 나타냅니다. Go는 비트 크기와 부호 여부에 따라 다양한 정수 유형을 제공합니다. 이 명시적인 타이핑은 메모리 효율성을 촉진하고 예상치 못한 오버플로 문제를 방지하는 데 도움이 됩니다.

부호 있는 정수: 이 유형은 양수 및 음수 값을 모두 나타낼 수 있습니다.

• int8: -128 ~ 127
• int16: -32768 ~ 32767
• int32 (또는 유니코드 코드 포인트를 나타낼 때 rune): -2,147,483,648 ~ 2,147,483,647
• int64: -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807
• int: 플랫폼 독립적이며 일반적으로 32 또는 64비트이며, 기본 시스템의 워드 크기와 일치합니다. 대부분의 시나리오에서 성능과 범위 간의 최상의 균형을 제공하므로 일반적인 정수 산술 연산에 가장 일반적으로 사용되는 정수 유형입니다.

부호 없는 정수: 이 유형은 음수가 아닌 값(0 및 양수)만 나타낼 수 있습니다. 숫자가 음수가 되지 않을 것임을 알 때 유용하며, 양수 값에 대해 전체 비트 범위를 활용할 수 있습니다.

• uint8 (또는 byte): 0 ~ 255
• uint16: 0 ~ 65535
• uint32: 0 ~ 4,294,967,295
• uint64: 0 ~ 18,446,744,073,709,551,615
• uint: 플랫폼 독립적이며 일반적으로 32 또는 64비트입니다.

유형 추론 및 제로 값: 명시적으로 유형을 지정하지 않고 정수 변수를 선언하면 Go의 유형 추론은 숫자 리터럴에 대해 int로 기본 설정됩니다. 모든 정수 유형의 제로 값은 0입니다.

package main

import "fmt"

func main() {
    // 명시적으로 유형이 지정된 정수
    var age int = 30
    var smallNum int8 = 100
    var bigCounter uint64 = 1_000_000_000_000 // 가독성을 위한 밑줄

    // 유형 추론
    temperature := -5
    distance := 10_000

    // 값 및 유형 인쇄
    fmt.Printf("Age: %d (Type: %T)\n", age, age)
    fmt.Printf("Small Number: %d (Type: %T)\n", smallNum, smallNum)
    fmt.Printf("Big Counter: %d (Type: %T)\n", bigCounter, bigCounter)
    fmt.Printf("Temperature: %d (Type: %T)\n", temperature, temperature)
    fmt.Printf("Distance: %d (Type: %T)\n", distance, distance)

    // 정수 오버플로 (설명용, 캐스트하지 않으면 컴파일 오류/패닉 발생)
    // var maxInt8 int8 = 127
    // maxInt8 = maxInt8 + 1 // 컴파일 오류 발생: 상수 128은 int8 오버플로
    // 처리 방법:
    var i8 int8 = 127
	i8++ // 2의 보수 표현으로 인해 -128로 올바르게 오버플로됩니다.
	fmt.Printf("int8 overflow: %d\n", i8)
}

정수에 대한 주요 요점: 메모리를 절약하기 위해 예상 값 범위를 수용할 수 있는 가장 작은 정수 유형을 선택하되, 특정 범위나 메모리 제약 조건에 따르지 않는 한 일반적인 용도에는 int를 기본값으로 사용하십시오. 산술 연산을 수행할 때 잠재적인 오버플로 문제를 염두에 두십시오.

부동 소수점 숫자: Go의 소수점

부동 소수점 숫자 또는 "플로트"는 분수 부분을 가진 숫자를 나타내는 데 사용됩니다. Go는 정밀도가 다른 두 가지 부동 소수점 유형을 제공합니다.

• float32: 32비트 부동 소수점 숫자이며, 약 6-7자리 소수점 정밀도를 제공합니다.
• float64: 64비트 부동 소수점 숫자이며, 약 15-17자리 소수점 정밀도를 제공합니다. 더 높은 정밀도로 인해 대부분의 계산에서 기본 유형이며 일반적으로 선호됩니다.

유형 추론 및 제로 값: 정수와 유사하게 Go는 명시적 유형 선언 없이 부동 소수점 리터럴에 대해 float64를 추론합니다. float32 및 float64의 제로 값은 모두 0.0입니다.

package main

import "fmt"

func main() {
    // 명시적으로 유형이 지정된 플로트
    var pi float32 = 3.14159265
    var gravity float64 = 9.80665

    // 유형 추론
    price := 99.99
    ratio := .5 // 유효한 플로트 리터럴

    fmt.Printf("Pi: %f (Type: %T)\n", pi, pi)
    fmt.Printf("Gravity: %f (Type: %T)\n", gravity, gravity)
    fmt.Printf("Price: %f (Type: %T)\n", price, price)
    fmt.Printf("Ratio: %f (Type: %T)\n", ratio, ratio)

    // 정밀도 시연
    var f32 float32 = 0.1 + 0.2
    var f64 float64 = 0.1 + 0.2
    fmt.Printf("0.1 + 0.2 (float32): %.20f\n", f32) // 정밀도 손실 관찰
    fmt.Printf("0.1 + 0.2 (float64): %.20f\n", f64) // 더 정확하지만 여전히 정확하지는 않음

    // 플로트 비교: 정밀도로 인해 직접 비교는 종종 문제가 됩니다.
    if f32 == 0.3 {
        fmt.Println("float32: 0.1 + 0.2는 0.3과 같습니다 (사실이 아닐 수 있습니다!)")
    } else {
        fmt.Println("float32: 0.1 + 0.2는 정확히 0.3과 같지 않습니다")
    }

    // 플로트 비교를 권장하는 방법: 두 숫자 간의 차이가 작은 엡실론 값보다 작은지 확인
    epsilon := 0.0000001
    if f64 - 0.3 < epsilon && 0.3 - f64 < epsilon { // 또는 math.Abs(f64 - 0.3) < epsilon
        fmt.Println("float64: 0.1 + 0.2는 약 0.3과 같습니다")
    }
}

플로트에 대한 주요 요점: 일반적인 부동 소수점 산술 연산의 경우 float64는 더 높은 정밀도로 인해 거의 항상 더 나은 선택입니다. 부동 소수점 숫자와의 직접적인 등가 비교(==)는 피하고 대신 두 숫자 간의 절대값이 작은 엡실론 값보다 작다는 것을 확인하십시오. 정확한 정밀도가 가장 중요한 재무 계산의 경우 센트/페니를 나타내기 위해 정수 유형을 사용하거나 전용 임의 정밀도 십진수 라이브러리를 사용하는 것을 고려하십시오.

불리언: Go의 논리 게이트

Go의 불리언은 true 또는 false의 진리 값을 나타냅니다. if 문, for 루프 및 논리 연산과 같은 제어 흐름 메커니즘에 필수적입니다.

• bool: Go의 유일한 불리언 유형입니다.

제로 값: bool의 제로 값은 false입니다.

package main

import "fmt"

func main() {
    // 불리언 변수 선언
    var isGoFun bool = true
    isLearning := false // 유형 추론

    fmt.Printf("Is Go fun? %t (Type: %T)\n", isGoFun, isGoFun)
    fmt.Printf("Am I learning? %t (Type: %T)\n", isLearning, isLearning)

    // 조건문에서 불리언 사용
    if isGoFun {
        fmt.Println("Keep coding!")
    } else {
        fmt.Println("Maybe try another language?")
    }

    // 논리 연산자
    hasPermission := true
    isAdmin := true
    isGuest := false

    if hasPermission && isAdmin { // 논리 AND
        fmt.Println("Access granted: Admin user.")
    }

    if isGuest || !isAdmin { // 논리 OR, 논리 NOT
        fmt.Println("Guest or non-admin access.")
    }

    // 제로 값
    var defaultBool bool
    fmt.Printf("Default boolean value: %t\n", defaultBool) // 출력: Default boolean value: false
}

Bool에 대한 주요 요점: Bool은 간단합니다. Go 프로그램 내에서 의사 결정 및 흐름 제어에 필수적입니다.

문자열: Go의 문자 시퀀스

Go의 문자열은 바이트의 불변 시퀀스입니다. 중요한 것은 Go 문자열은 기본적으로 UTF-8로 인코딩된다는 것입니다. 이는 단일 유니코드 문자가 여러 바이트를 차지할 수 있으므로 Go는 국제화된 텍스트 처리에 탁월합니다.

• string: Go의 유일한 문자열 유형입니다.

제로 값: string의 제로 값은 빈 문자열 ""입니다.

package main

import "fmt"
import "strings" // 문자열 조작을 위한 패키지
import "unicode/utf8" // UTF-8 특정 작업을 위한 패키지

func main() {
    // 문자열 리터럴
    var greeting string = "Hello, Go!"
    message := "Go is awesome."

    // 여러 줄 원시 문자열 리터럴 (백틱 `): 줄바꿈 및 서식을 유지하고 이스케이프 시퀀스를 처리하지 않음
    poem := `This is a
    multi-line
    string literal.
    Newlines and tabs are preserved.`

    fmt.Printf("Greeting: %s (Type: %T)\n", greeting, greeting)
    fmt.Printf("Message: %s (Type: %T)\n", message, message)
    fmt.Printf("Poem:\n%s\n", poem)

    // 문자열 연결
    fullName := "John" + " " + "Doe"
    fmt.Println("Full Name:", fullName)

    // 문자열 길이 (문자/룬이 아닌 바이트 수)
    goLang := "Go语言" // Go语言은 6바이트로 구성됩니다 (Go: 2바이트, 语言: 2룬 * 3바이트/룬 = 6바이트)
    fmt.Printf("'%s'의 길이 (바이트): %d\n", goLang, len(goLang)) // 8바이트

    // UTF-8 문자열에서 룬 (문자) 수 계산
    fmt.Printf("'%s'의 룬 수: %d\n", goLang, utf8.RuneCountInString(goLang)) // 4룬 (G, o, 语, 言)

    // 개별 바이트 액세스 (문자가 아님)
    // fmt.Println(goLang[0]) // 바이트 값 71로 ASCII 'G'를 인쇄합니다.
    // fmt.Println(goLang[2]) // '语'의 첫 번째 바이트를 바이트 값 232 (다중 바이트 시퀀스의 시작)으로 인쇄합니다.

    // 문자열 반복 (룬 가져오기)
    fmt.Println("룬별 반복:")
    for i, r := range goLang {
        fmt.Printf("Index: %d, Rune: %c, Unicode: %U\n", i, r, r)
    }

    // 문자열 비교
    str1 := "apple"
    str2 := "Apple"
    str3 := "apple"

    fmt.Println("str1 == str2:", str1 == str2) // false (대소문자 구분)
    fmt.Println("str1 == str3:", str1 == str3) // true

    // 'strings' 패키지의 문자열 조작
    fmt.Println("'Go' 포함 여부:", strings.Contains(message, "Go"))     // true
    fmt.Println("'Go'로 시작 여부:", strings.HasPrefix(message, "Go")) // true
    fmt.Println("'awesome'를 'amazing'으로 바꾸기:", strings.Replace(message, "awesome", "amazing", 1)) // Go is amazing.

    // 제로 값
    var emptyString string
    fmt.Printf("Default string value: '%s'\n", emptyString) // 출력: Default string value: ''
    fmt.Printf("기본 문자열이 비어 있습니까? %t\n", len(emptyString) == 0) // true
}

문자열에 대한 주요 요점: Go는 내부적으로 문자열을 바이트 시퀀스, 특히 UTF-8로 인코딩 된 바이트로 취급합니다. 바이트 길이는 len()을 사용하고 문자 수는 utf8.RuneCountInString()을 사용합니다. 문자를 처리하기 위해 문자열을 반복할 때 올바르게 UTF-8 룬을 디코딩하는 for...range 루프를 사용하십시오. strings 및 unicode/utf8 패키지는 문자열 조작 및 문자 처리를 위한 풍부한 기능을 제공합니다. 문자열은 불변이며, 문자열을 수정하는 것처럼 보이는 모든 작업은 실제로 새 문자열을 생성합니다.

결론

Go의 기본 데이터 유형인 정수, 부동 소수점 숫자, 불리언 및 문자열을 이해하는 것은 언어를 마스터하는 데 기본이 됩니다. Go의 명시적 유형 시스템은 강력한 유형 추론과 결합하여 개발자가 강력하고 효율적인 코드를 작성하도록 돕습니다. 각 변수에 적합한 유형을 선택하고, 정수 오버플로 및 부동 소수점 정밀도와 같은 문제를 염두에 두고, Go의 내장 UTF-8 문자열 지원을 활용함으로써 안정적이고 성능이 뛰어난 애플리케이션을 구축할 수 있습니다. 이러한 기본 요소는 더 복잡한 데이터 구조 및 알고리즘을 위한 구성 요소 역할을 하며 고급 Go 프로그래밍을 위한 길을 열어줍니다.