-- Go

Go ile Dosya İşlemleri #2

Go ile Dosya İşlemleri #2

İki bölümden oluşan Go ile Dosya İşlemleri serisinin son makalesidir. İlk makale için şuraya tıklayınız.

Tam olarak n byte’ı oku (Read Exactly n Bytes)

package main

import (
	"io"
	"log"
	"os"
)

func main() {

	/*
	   Tam olarak n byte'ı oku (Read Exactly n Bytes)
	*/

	// Okumak için dosyayı aç
	file, err := os.Open("demo.txt")
	if err != nil {
		log.Fatal(err)
	}

	byteSlice := make([]byte, 2)
	numBytesRead, err := io.ReadFull(file, byteSlice)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Number of bytes read: %d\n", numBytesRead)
	log.Printf("Data read: %s\n", byteSlice)
}

En az n byte oku (Read At Least n Bytes)

package main

import (
	"io"
	"log"
	"os"
)

func main() {

	/*
	   En az n byte oku (Read At Least n Bytes)
	*/

	// Okumak için dosyayı aç
	file, err := os.Open("demo.txt")
	if err != nil {
		log.Fatal(err)
	}

	byteSlice := make([]byte, 512)
	minBytes := 8
	// io.ReadAtLeast() okumak için en az minBytes bulamıyorsa hata döndürecektir.
	numBytesRead, err := io.ReadAtLeast(file, byteSlice, minBytes)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Number of bytes read: %d\n", numBytesRead)
	log.Printf("Data read: %s\n", byteSlice)
}

Dosyanın Tüm Byte’ları Oku (Read All Bytes of File)

package main

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

func main() {

	/*
	   Dosyanın Tüm Byte'ları Oku (Read All Bytes of File)
	*/

	// Okumak için dosya aç
	file, err := os.Open("demo.txt")
	if err != nil {
		log.Fatal(err)
	}

	// os.File.Read(), io.ReadFull(), ioutil.ReadAll() ve io.ReadAtLeast() da kullanılabilir
	data, err := ioutil.ReadAll(file)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Data as hex: %x\n", data)
	fmt.Printf("Data as string: &s\n", data)
	fmt.Printf("Number of bytes read:", len(data))
}

Dosyayı Hızlı Okuma (Quick Read Whole File to Memory)

package main

import (
	"io/ioutil"
	"log"
)

func main() {

	/*
	   Dosyayı Hızlı Okuma (Quick Read Whole File to Memory)
	*/

	// Dosyadan byte dilimine okuma yapma
	data, err := ioutil.ReadFile("demo.txt")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Data read: %s\n", data)
}

Use Buffered Reader

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

func main() {

	/*
	   Use Buffered Reader
	*/

	// Dosyayı aç ve onun üzerinden "buffered reader" oluştur
	file, err := os.Open("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	bufferedReader := bufio.NewReader(file)

	byteSlice := make([]byte, 5)
	byteSlice, err = bufferedReader.Peek(5)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Peeked at 5 bytes: %s\n", byteSlice)

	numBytesRead, err := bufferedReader.Read(byteSlice)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Read %d bytes: %s\n", numBytesRead, byteSlice)

	// Bir byte döner. Eğer okunacak byte yoksa hata döner.
	myByte, err := bufferedReader.ReadByte()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Read 1 byte: %c\n", myByte)

	// Byte slice döner
	dataBytes, err := bufferedReader.ReadBytes('\n')
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Read bytes: %s\n", dataBytes)

	// String döner
	dataString, err := bufferedReader.ReadString('\n')
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Read string: %s\n", dataString)
}

Read with a Scanner

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

func main() {

	/*
	   Read with a Scanner
	*/

	file, err := os.Open("test.txt")
	if err != nil {
		log.Fatal(err)
	}
	scanner := bufio.NewScanner(file)

	// Varsayılan scanner bufio.ScanLines'dır. Biz ScanWords'ı kullanalım.
	// SplitFunc türünde özel bir fonksiyon da kullanılabilir.
	scanner.Split(bufio.ScanWords)

	// Sonraki token'ı tara.
	success := scanner.Scan()
	if success == false {
		err = scanner.Err()
		if err == nil {
			log.Println("Scan completed and reached EOF")
		} else {
			log.Fatal(err)
		}
	}

	// Bytes() ya da Text() ile scan'dan veri elde edilebilir.
	fmt.Println("First word found:", scanner.Text())

	// Bir sonraki token'ı bulmak için scanner.Scan()'ı tekrar çağırın.
}

Archive Files

// Bu örnekte standart library kullanarak zip işlemlerini inceleyeceğiz.
// Aynı zamanda tar dosyalarını da desteklemektedir.
package main

import (
	"archive/zip"
	"log"
	"os"
)

func main() {

	/*
	   Archive Files
	*/

	outFile, err := os.Create("test.zip")
	if err != nil {
		log.Fatal(err)
	}
	defer outFile.Close()

	zipWriter := zip.NewWriter(outFile)

	var filesToArchive = []struct {
		Name, Body string
	}{
		{"test.txt", "String contents of file"},
		{"test2.txt", "\x61\x62\x63\n"},
	}

	for _, file := range filesToArchive {
		fileWriter, err := zipWriter.Create(file.Name)
		if err != nil {
			log.Fatal(err)
		}
		_, err = fileWriter.Write([]byte(file.Body))
		if err != nil {
			log.Fatal(err)
		}
	}

	err = zipWriter.Close()
	if err != nil {
		log.Fatal(err)
	}
}

Extract Archived Files

package main

import (
	"archive/zip"
	"io"
	"log"
	"os"
	"path/filepath"
)

func main() {

	/*
	   Extract Archived Files
	*/
	zipReader, err := zip.OpenReader("test.zip")
	if err != nil {
		log.Fatal(err)
	}
	defer zipReader.Close()

	for _, file := range zipReader.Reader.File {
		// Open the file inside the zip archive
		// like a normal file
		zippedFile, err := file.Open()
		if err != nil {
			log.Fatal(err)
		}
		defer zippedFile.Close()

		targetDir := "./"
		extractedFilePath := filepath.Join(
			targetDir,
			file.Name,
		)

		if file.FileInfo().IsDir() {
			log.Println("Creating directory:", extractedFilePath)
			os.MkdirAll(extractedFilePath, file.Mode())
		} else {
			log.Println("Extracting file:", file.Name)

			outputFile, err := os.OpenFile(
				extractedFilePath,
				os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
				file.Mode(),
			)
			if err != nil {
				log.Fatal(err)
			}
			defer outputFile.Close()

			_, err = io.Copy(outputFile, zippedFile)
			if err != nil {
				log.Fatal(err)
			}
		}
	}
}

Compress a File

package main

import (
	"compress/gzip"
	"log"
	"os"
)

func main() {

	/*
	   Compress a File
	*/

	outputFile, err := os.Create("test.txt.gz")
	if err != nil {
		log.Fatal(err)
	}

	gzipWriter := gzip.NewWriter(outputFile)
	defer gzipWriter.Close()

	_, err = gzipWriter.Write([]byte("Gophers rule!\n"))
	if err != nil {
		log.Fatal(err)
	}

	log.Println("Compressed data written to file.")
}

Uncompress a File

package main

import (
	"compress/gzip"
	"io"
	"log"
	"os"
)

func main() {

	/*
	   Uncompress a File
	*/

	gzipFile, err := os.Open("test.txt.gz")
	if err != nil {
		log.Fatal(err)
	}

	gzipReader, err := gzip.NewReader(gzipFile)
	if err != nil {
		log.Fatal(err)
	}
	defer gzipReader.Close()

	outfileWriter, err := os.Create("unzipped.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer outfileWriter.Close()

	_, err = io.Copy(outfileWriter, gzipReader)
	if err != nil {
		log.Fatal(err)
	}
}

Temporary Files and Directories

package main

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

func main() {

	/*
	   Temporary Files and Directories
	*/

	tempDirPath, err := ioutil.TempDir("", "myTempDir")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Temp dir created:", tempDirPath)

	tempFile, err := ioutil.TempFile(tempDirPath, "myTempFile.txt")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Temp file created:", tempFile.Name())
	// Dosyayı kapat
	err = tempFile.Close()
	if err != nil {
		log.Fatal(err)
	}
	err = os.Remove(tempFile.Name())
	if err != nil {
		log.Fatal(err)
	}
	err = os.Remove(tempDirPath)
	if err != nil {
		log.Fatal(err)
	}
}

Downloading a File Over HTTP

package main

import (
	"io"
	"log"
	"net/http"
	"os"
)

func main() {

	/*
	   Downloading a File Over HTTP
	*/

	newFile, err := os.Create("courses.html")
	if err != nil {
		log.Fatal(err)
	}
	defer newFile.Close()

	// HTTP GET request dijibil.com
	url := "http://www.dijibil.com/courses"
	response, err := http.Get(url)
	defer response.Body.Close()

	numBytesWritten, err := io.Copy(newFile, response.Body)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("Downloaded %d byte file.\n", numBytesWritten)
}

Github: https://github.com/cihanozhan/golang-file-samples

İyi çalışmalar.
Cihan Özhan

Yorumla

Yorum