23.1. 프로그램언어 고(Go)의 파일 읽기와 쓰기

by

프로그램언어 고(Go)의 텍스트 파일 읽기

고(Go) 프로그램 언어의 텍스트 파일 읽기에 대해 설명드리겠습니다.

고(Go)에서 텍스트 파일 읽기를 위해서는 os 패키지의 Open 함수를 이용하여 파일을 열고, bufio 패키지의 NewReader 함수로 파일을 읽을 수 있습니다. 

f, err := os.Open("data.txt")
if err != nil {
    return err
}
defer f.Close()

r := bufio.NewReader(f)
for {
    line, err := r.ReadString('\n') 
    if err == io.EOF {
        break
    } else if err != nil {
        return err
    }
    fmt.Println(line)
}

위 코드는 “data.txt” 파일을 열고, bufio의 Reader를 이용하여 한 라인씩 읽습니다.
ReadString 함수에서 ‘\n’ 문자를 만나면 한 라인의 읽기가 종료됩니다.

그리고 읽은 라인을 Println 함수를 이용하여 출력합니다.
만약 io.EOF 에러가 발생하면 파일의 끝에 도달했음을 의미하여 for문을 종료합니다.

이 외에도 Scanner 패키지를 이용할 수 있습니다.

f, err := os.Open("data.txt")
if err != nil {
    return err
}
defer f.Close()

scanner := bufio.NewScanner(f)
for scanner.Scan() {
    line := scanner.Text()
    fmt.Println(line) 
}

if err := scanner.Err(); err != nil {
    return err
}

Scanner를 이용할 경우 Scan 메서드를 호출하여 한 라인씩 읽고, Text 메서드로 읽은 문자열 내용을 얻을 수 있습니다.

이상으로 고(Go) 프로그램언어의 텍스트 파일 읽기에 대해 간략히 설명드렸습니다.
오류나 누락된 부분이 있다면 양해 부탁드립니다.

프로그램언어 고(Go)에서의 바이너리 파일 읽기

고(Go)언어에서 바이너리 파일을 읽는 방법은 주로 os 패키지와 io 패키지를 사용합니다.

바이너리 파일을 열 때에는 os.Open() 함수를 사용하여 파일을 엽니다. 그리고 io.ReadAll() 함수를 사용하여 파일의 내용을 바이트 슬라이스로 읽어옵니다. 마지막으로 파일을 닫기 위해 Close() 메서드를 호출합니다.

다음은 바이너리 파일 읽기의 간단한 예제 코드입니다.


package main

import (
    "fmt"
    "io"
    "os"
)

func main() {

    // 바이너리 파일 열기
    f, err := os.Open("./data.bin")
    if err != nil {
        panic(err)
    }
    defer f.Close()

    // 바이너리 파일 내용 읽기
    data, err := io.ReadAll(f)
    if err != nil {
        panic(err) 
    }

    fmt.Printf("type: %T, length: %d bytes\n", data, len(data))

}

이 코드는 ./data.bin 바이너리 파일을 열고 io.ReadAll 함수로 파일의 모든 내용을 바이트 슬라이스로 읽어 data 변수에 저장합니다.

그리고 나서 data 변수의 타입과 크기를 출력하여 바이너리 데이터가 제대로 읽혔는지 확인할 수 있습니다.

바이너리 데이터 처리를 위해 bytes 패키지나 encoding/binary 패키지 등을 추가로 사용할 수도 있습니다.

이렇게 고(Go) 언어의 표준 라이브러리를 사용하면 간편하게 바이너리 파일을 읽고 조작할 수 있습니다.

앞으로도 고(Go) 언어 사용에 많은 도움이 되었으면 좋겠습니다.

프로그램언어 고(Go)의 텍스트 파일 쓰기

Go언어에서 텍스트 파일 쓰기를 위해서는 os 패키지의 File 타입을 이용합니다. 


package main

import (
    "os"
)

func main() {

    // 파일을 쓰기 모드로 열기 
    file, err := os.Create("data.txt")
    if err != nil {
        return 
    }
    defer file.Close()

    // 파일에 문자열 쓰기
    _, err = file.WriteString("Hello World") 
    if err != nil {
        return
    }

    // 파일에 바이트 슬라이스 쓰기
    data := []byte{1, 2, 3}
    _, err = file.Write(data) 
    if err != nil {
        return
    }

}

위의 예제코드에서 os.Create() 함수를 사용하여 “data.txt”라는 파일을 쓰기 모드로 열 수 있습니다.
그리고 나서 file.WriteString()이나 file.Write() 함수를 이용하여 문자열이나 바이트 슬라이스를 파일에 쓸 수 있습니다.

defer 문을 사용하여 함수가 끝나기 전에 파일을 닫을 수 있습니다.

또한 매 쓰기 작업 이후에 에러처리를 해주는 것이 좋습니다. 파일 쓰기 중에 문제가 발생하면 err 변수에 에러내용이 반환되기 때문입니다.

텍스트 파일 쓰기에 있어 이상적인 방법이며, 이 예제를 참고하셔서 Go언어로 텍스트 파일 쓰기를 하시기 바랍니다. 많은 도움이 되었기를 바랍니다.

프로그램언어 고(Go)에서의 바이너리 파일 쓰기

프로그램언어 고(Go)에서 바이너리 파일을 쓰기 위해서는 os 패키지의 OpenFile 함수를 사용합니다. 이 함수를 통해 파일을 열고, 파일 디스크립터를 얻습니다.

그리고 열린 파일 디스크립터에 Write 함수를 사용하여 바이너리 데이터를 쓸 수 있습니다.

예를 들어 다음과 같이 할 수 있습니다.


package main

import (
    "os"
)

func main() {

    // 바이너리 데이터
    data := []byte{0x1, 0x2, 0x3} 

    // 파일을 쓰기 모드로 열기 
    f, _ := os.OpenFile("data.bin", os.O_WRONLY|os.O_CREATE, 0666)

    // 파일에 바이너리 데이터 쓰기
    f.Write(data)

    // 파일 닫기
    f.Close()
}

위 예제에서 os.OpenFile 함수를 사용하여 “data.bin”이라는 바이너리 파일을 쓰기 모드(os.O_WRONLY)로 열었습니다.

그리고 f.Write 함수를 사용하여 바이너리 데이터 슬라이스를 파일에 기록했습니다.

마지막으로 파일을 닫았습니다.

이와 같이 Go언어에서는 파일 디스크립터를 통해 바이너리 데이터를 직접 파일에 쓸 수 있습니다.

파일 쓰기에 관련된 함수 사용법이나 주의사항들은 아래 링크를 참고하시기 바랍니다.

https://golang.org/pkg/os/#File.Write

https://golang.org/pkg/os/#OpenFile

저는 Go언어의 바이너리 파일 쓰기에 대해 위와 같이 설명드렸습니다. 보다 자세한 사항이 필요하시다면 댓글을 남겨주세요.

프로그램언어 고(Go)에서의 파일 일괄 읽기 및 쓰기

Go언어에서 파일 일괄 읽기 및 쓰기를 하는 방법은 다음과 같습니다.


package main

import (
    "bufio"
    "fmt"
    "io"
    "io/ioutil"
    "os"
)

// 파일 읽기
func readFile(filePath string) {
    // 파일 열기
    file, err := os.Open(filePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 파일 전체 읽기
    data, err := ioutil.ReadAll(file)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(data))
    
    // 라인 단위로 읽기
    reader := bufio.NewReader(file) 
    for {
        line, err := reader.ReadString('\n')    
        if err == io.EOF {
            break 
        } else if err != nil {
            panic(err)
        }
        fmt.Println(line) 
    }
}

// 파일 쓰기
func writeFile(filePath string) {
    // 파일 열기 
    file, err := os.Create(filePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 파일에 문자열 쓰기
    text := "Hello World!\n" 
    _, err = file.WriteString(text)
    if err != nil {
        panic(err)
    }

    // 파일에 byte slice 쓰기
    data := []byte{1, 2, 3, 4, 5}
    _, err = file.Write(data)
    if err != nil {
       panic(err)
    }  
}

func main() {
    readFile("./data.txt")
    writeFile("./output.txt")  
}

파일 읽기 함수에서는 filePath로 전달받은 파일을 열고, 파일 전체 데이터나 라인 단위로 데이터를 읽어오는 코드입니다.

ioutil.ReadAll 함수를 사용하면 파일 전체 내용을 []byte 타입으로 한번에 읽어올 수 있습니다.

bufio.NewReader를 사용하면 행 단위로 읽기 쉽게 처리할 수 있습니다.

파일 쓰기 함수에서는 새 파일을 생성하고 문자열이나 바이트 슬라이스를 기록하는 WriteString, Write 메소드를 사용하였습니다.

이와 같이 Go언어의 파일 처리에서 파일 열기/닫기, 읽기/쓰기를 쉽게 처리할 수 있습니다.
주석과 예제 코드로 파일 일괄 읽기 및 쓰기에 대해 설명드렸습니다.
이해에 도움이 되셨기를 바랍니다.

Leave a Comment