• Share Ideas, Start Something Good.

Installation of Go [Windows]

Variables & Operators in Golang

Array & Pointers in Golang

Structs in Golang

Slice and Functions in slice used in Golang

Ranges and Maps in Golang

Golang – For Loop use cases

GoLang– Break use cases

Golang – Switch use cases

Go – if-else use cases

Use cases of functions in Golang

Use cases of recursion in GoLang

Use case of Interface in GoLang

GoLang Map

GoLang– Break

GoLang String

Slice in Go Language

Structure in Golang

Introduction :

Variables in Go Language

Go Constants

Go output function

Go comments

Go Data Type

Go Conditions

Operators in Golang

Array In Golang

Slice in Go Language

Maps in Golang

Range and mapping in Golang

Loop in Go Language

Structure in Golang

Switch Statement in Golang

Function in Go Language

Recursion in Go Language

Interface in Go Lang

Goroutines in Go Language

Files and directories with examples

Files and directories with examples

  • date 10th September, 2022 |
  • by Prwatech |
  • 0 Comments

Working with Files and Directories

 

Working with files and directories is a fundamental aspect of software development and system administration. Files represent persistent data stored on storage devices, while directories (or folders) provide a way to organize and structure files hierarchically within a file system.

In software development, interacting with files and directories allows applications to read input data, write output data, store configurations, and manage resources such as logs and temporary files. Common operations include reading from and writing to files, creating, deleting, moving, and renaming files and directories, and querying file metadata such as size, permissions, and timestamps.

File system operations are essential in system administration for managing server configurations, deploying applications, performing backups, and monitoring system health. Administrators use tools and commands to navigate file systems, set permissions, manage file attributes, and troubleshoot disk space issues.

  • Create an empty file

    Plain text
    Copy to clipboard
    Open code in new window
    EnlighterJS 3 Syntax Highlighter
    package main
    import (
    "log"
    "os"
    )
    func main() {
    emptyFile, err := os.Create("empty.txt")
    if err != nil {
    log.Fatal(err)
    }
    log.Println(emptyFile)
    emptyFile.Close()
    }
    package main import ( "log" "os" ) func main() { emptyFile, err := os.Create("empty.txt") if err != nil { log.Fatal(err) } log.Println(emptyFile) emptyFile.Close() }
    package main 
import (
    "log"
    "os"
)
 
func main() {
    emptyFile, err := os.Create("empty.txt")
    if err != nil {
        log.Fatal(err)
    }
    log.Println(emptyFile)
    emptyFile.Close()
}

    Output :

    Plain text
    Copy to clipboard
    Open code in new window
    EnlighterJS 3 Syntax Highlighter
    PS C:\GO_Language\file> go run empty.go
    2022/08/20 15:45:16 &{0xc00007e780}
    PS C:\GO_Language\file> go run empty.go 2022/08/20 15:45:16 &{0xc00007e780}
    PS C:\GO_Language\file> go run empty.go
2022/08/20 15:45:16 &{0xc00007e780}

    • Create directory

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "log"
      "os"
      )
      func main() {
      _, err := os.Stat("text")
      if os.IsNotExist(err) {
      errDir := os.MkdirAll("text", 0755)
      if errDir != nil {
      log.Fatal(err)
      }
      }
      }
      package main import ( "log" "os" ) func main() { _, err := os.Stat("text") if os.IsNotExist(err) { errDir := os.MkdirAll("text", 0755) if errDir != nil { log.Fatal(err) } } }
      package main
import (
    "log"
    "os"
) 	
func main() {
    _, err := os.Stat("text")
    if os.IsNotExist(err) {
        errDir := os.MkdirAll("text", 0755)
        if errDir != nil {
            log.Fatal(err)
        }
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run create.go
      PS C:\GO_Language\file> go run create.go
      PS C:\GO_Language\file> go run create.go

       

    • Rename a file

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "log"
      "os"
      )
      func main() {
      oldName := "test.txt"
      newName := "testing.txt"
      err := os.Rename(oldName, newName)
      if err != nil {
      log.Fatal(err)
      }
      }
      package main import ( "log" "os" ) func main() { oldName := "test.txt" newName := "testing.txt" err := os.Rename(oldName, newName) if err != nil { log.Fatal(err) } }
      package main
import (
    "log"
    "os"
)	
 
func main() {
    oldName := "test.txt"
    newName := "testing.txt"
    err := os.Rename(oldName, newName)
    if err != nil {
        log.Fatal(err)
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run rename.go
      PS C:\GO_Language\file> go run rename.go
      PS C:\GO_Language\file> go run rename.go

       

    • Copy file at the specified location

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "io"
      "log"
      "os"
      )
      func main() {
      sourceFile, err := os.Open("C:/GO_Language/file/test.txt")
      if err != nil {
      log.Fatal(err)
      }
      defer sourceFile.Close()
      // Create new file
      newFile, err := os.Create("C:/GO_Language/test.txt ")
      if err != nil {
      log.Fatal(err)
      }
      defer newFile.Close()
      bytesCopied, err := io.Copy(newFile, sourceFile)
      if err != nil {
      log.Fatal(err)
      }
      log.Printf("Copied %d bytes.", bytesCopied)
      }
      package main import ( "io" "log" "os" ) func main() { sourceFile, err := os.Open("C:/GO_Language/file/test.txt") if err != nil { log.Fatal(err) } defer sourceFile.Close() // Create new file newFile, err := os.Create("C:/GO_Language/test.txt ") if err != nil { log.Fatal(err) } defer newFile.Close() bytesCopied, err := io.Copy(newFile, sourceFile) if err != nil { log.Fatal(err) } log.Printf("Copied %d bytes.", bytesCopied) }
      package main

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

func main() {

    sourceFile, err := os.Open("C:/GO_Language/file/test.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer sourceFile.Close()

    // Create new file
    newFile, err := os.Create("C:/GO_Language/test.txt ")
    if err != nil {
        log.Fatal(err)
    }
    defer newFile.Close()

    bytesCopied, err := io.Copy(newFile, sourceFile)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Copied %d bytes.", bytesCopied)
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run f1.go
      2022/08/20 15:39:48 Copied 59 bytes.
      PS C:\GO_Language\file> go run f1.go 2022/08/20 15:39:48 Copied 59 bytes.
      PS C:\GO_Language\file> go run f1.go
2022/08/20 15:39:48 Copied 59 bytes.

       

    • Move a File

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "log"
      "os"
      )
      func main() {
      oldLocation := "C:/GO_Language/test.txt"
      newLocation := "C:/GO_Language/file/test.txt"
      err := os.Rename(oldLocation, newLocation)
      if err != nil {
      log.Fatal(err)
      }
      }
      package main import ( "log" "os" ) func main() { oldLocation := "C:/GO_Language/test.txt" newLocation := "C:/GO_Language/file/test.txt" err := os.Rename(oldLocation, newLocation) if err != nil { log.Fatal(err) } }
      package main

import (
    "log"
    "os"
)

func main() {
    oldLocation := "C:/GO_Language/test.txt"
    newLocation := "C:/GO_Language/file/test.txt"
    err := os.Rename(oldLocation, newLocation)
    if err != nil {
        log.Fatal(err)
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run move.go
      PS C:\GO_Language\file> go run move.go
      PS C:\GO_Language\file> go run move.go

       

    • Getting Metadata of a file

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "fmt"
      "log"
      "os"
      )
      func main() {
      fileStat, err := os.Stat("test.txt")
      if err != nil {
      log.Fatal(err)
      }
      fmt.Println("File Name:", fileStat.Name())
      fmt.Println("Size:", fileStat.Size())
      fmt.Println("Permissions:", fileStat.Mode())
      fmt.Println("Last Modified:", fileStat.ModTime())
      fmt.Println("Is Directory: ", fileStat.IsDir())
      }
      package main import ( "fmt" "log" "os" ) func main() { fileStat, err := os.Stat("test.txt") if err != nil { log.Fatal(err) } fmt.Println("File Name:", fileStat.Name()) fmt.Println("Size:", fileStat.Size()) fmt.Println("Permissions:", fileStat.Mode()) fmt.Println("Last Modified:", fileStat.ModTime()) fmt.Println("Is Directory: ", fileStat.IsDir()) }
      package main
import (
    "fmt"
    "log"
    "os"
)
 
func main() {
    fileStat, err := os.Stat("test.txt")
 
    if err != nil {
        log.Fatal(err)
    }
 
    fmt.Println("File Name:", fileStat.Name())        
    fmt.Println("Size:", fileStat.Size())             
    fmt.Println("Permissions:", fileStat.Mode())      
    fmt.Println("Last Modified:", fileStat.ModTime()) 
    fmt.Println("Is Directory: ", fileStat.IsDir())   
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run matadata.go
      File Name: test.txt
      Size: 59
      Permissions: -rw-rw-rw-
      Last Modified: 2022-08-20 15:39:48.8907731 +0530 IST
      Is Directory: false
      PS C:\GO_Language\file> go run matadata.go File Name: test.txt Size: 59 Permissions: -rw-rw-rw- Last Modified: 2022-08-20 15:39:48.8907731 +0530 IST Is Directory: false
      PS C:\GO_Language\file>  go run matadata.go
File Name: test.txt
Size: 59
Permissions: -rw-rw-rw-
Last Modified: 2022-08-20 15:39:48.8907731 +0530 IST
Is Directory:  false

       

    • Deleting a specific file

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "log"
      "os"
      )
      func main() {
      err := os.Remove("C:/GO_Language/test.txt ")
      if err != nil {
      log.Fatal(err)
      }
      }
      package main import ( "log" "os" ) func main() { err := os.Remove("C:/GO_Language/test.txt ") if err != nil { log.Fatal(err) } }
      package main
import (
    "log"
    "os"
)
 
func main() {
    err := os.Remove("C:/GO_Language/test.txt ")
    if err != nil {
        log.Fatal(err)
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run delete.go
      PS C:\GO_Language\file> go run delete.go
      PS C:\GO_Language\file>  go run delete.go

       

    • Read a text file character by character

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "bufio"
      "fmt"
      "io/ioutil"
      "os"
      "strings"
      )
      func main() {
      filename := "test.txt"
      filebuffer, err := ioutil.ReadFile(filename)
      if err != nil {
      fmt.Println(err)
      os.Exit(1)
      }
      inputdata := string(filebuffer)
      data := bufio.NewScanner(strings.NewReader(inputdata))
      data.Split(bufio.ScanRunes)
      for data.Scan() {
      fmt.Print(data.Text())
      }
      }
      package main import ( "bufio" "fmt" "io/ioutil" "os" "strings" ) func main() { filename := "test.txt" filebuffer, err := ioutil.ReadFile(filename) if err != nil { fmt.Println(err) os.Exit(1) } inputdata := string(filebuffer) data := bufio.NewScanner(strings.NewReader(inputdata)) data.Split(bufio.ScanRunes) for data.Scan() { fmt.Print(data.Text()) } }
      package main
import (
    "bufio"
    "fmt"
    "io/ioutil"
    "os"
    "strings"
)
 
func main() {
    filename := "test.txt"
 
    filebuffer, err := ioutil.ReadFile(filename)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    inputdata := string(filebuffer)
    data := bufio.NewScanner(strings.NewReader(inputdata))
    data.Split(bufio.ScanRunes)
 
    for data.Scan() {
        fmt.Print(data.Text())
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run readchar.go
      Sandeep
      Ramesh
      Shankar
      Mohan
      dhanaji
      Rajya
      Sohel
      PS C:\GO_Language\file> go run readchar.go Sandeep Ramesh Shankar Mohan dhanaji Rajya Sohel
      PS C:\GO_Language\file>  go run readchar.go
Sandeep 
Ramesh
Shankar 
Mohan
dhanaji
Rajya
Sohel

       

    • Truncate File Content

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "log"
      "os"
      )
      func main() {
      err := os.Truncate("test.txt", 100)
      if err != nil {
      log.Fatal(err)
      }
      }
      package main import ( "log" "os" ) func main() { err := os.Truncate("test.txt", 100) if err != nil { log.Fatal(err) } }
      package main
import (
    "log"
    "os"
)
 
func main() {
    err := os.Truncate("test.txt", 100)
 
    if err != nil {
        log.Fatal(err)
    }
}
      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run truncate.go
      PS C:\GO_Language\file> go run truncate.go
      PS C:\GO_Language\file>  go run truncate.go

       

    • Append Content in a Text File

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "fmt"
      "os"
      )
      func main() {
      msg := "Add this content at end"
      fname := "test.txt"
      f, err := os.OpenFile(fname, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
      if err != nil {
      fmt.Println(err)
      os.Exit(-1)
      }
      defer f.Close()
      fmt.Fprintf(f, "%s\n", msg)
      }
      package main import ( "fmt" "os" ) func main() { msg := "Add this content at end" fname := "test.txt" f, err := os.OpenFile(fname, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660) if err != nil { fmt.Println(err) os.Exit(-1) } defer f.Close() fmt.Fprintf(f, "%s\n", msg) }
      package main
 
import (
    "fmt"
    "os"
)
 
func main() {
    msg := "Add this content at end"
    fname := "test.txt"
 
    f, err := os.OpenFile(fname, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0660)
 
    if err != nil {
        fmt.Println(err)
        os.Exit(-1)
    }
    defer f.Close()
 
    fmt.Fprintf(f, "%s\n", msg)
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run append.go
      PS C:\GO_Language\file> go run append.go
      PS C:\GO_Language\file> go run append.go

       

    • Change file permission, ownership, and timestamps

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "log"
      "os"
      "time"
      )
      func main() {
      _, err := os.Stat("test.txt")
      if err != nil {
      if os.IsNotExist(err) {
      log.Fatal("File does not exist.")
      }
      }
      log.Println("File exist.")
      // Change permissions Linux.
      err = os.Chmod("test.txt", 0777)
      if err != nil {
      log.Println(err)
      }
      // Change file ownership.
      err = os.Chown("test.txt", os.Getuid(), os.Getgid())
      if err != nil {
      log.Println(err)
      }
      // Change file timestamps.
      addOneDayFromNow := time.Now().Add(24 * time.Hour)
      lastAccessTime := addOneDayFromNow
      lastModifyTime := addOneDayFromNow
      err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
      if err != nil {
      log.Println(err)
      }
      }
      package main import ( "log" "os" "time" ) func main() { _, err := os.Stat("test.txt") if err != nil { if os.IsNotExist(err) { log.Fatal("File does not exist.") } } log.Println("File exist.") // Change permissions Linux. err = os.Chmod("test.txt", 0777) if err != nil { log.Println(err) } // Change file ownership. err = os.Chown("test.txt", os.Getuid(), os.Getgid()) if err != nil { log.Println(err) } // Change file timestamps. addOneDayFromNow := time.Now().Add(24 * time.Hour) lastAccessTime := addOneDayFromNow lastModifyTime := addOneDayFromNow err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime) if err != nil { log.Println(err) } }
      package main
import (
"log"
"os"
"time"
)

func main() {
_, err := os.Stat("test.txt")
if err != nil {
if os.IsNotExist(err) {
log.Fatal("File does not exist.")
}
}
log.Println("File exist.")

// Change permissions Linux.
err = os.Chmod("test.txt", 0777)
if err != nil {
log.Println(err)
}

// Change file ownership.
err = os.Chown("test.txt", os.Getuid(), os.Getgid())
if err != nil {
log.Println(err)
}

// Change file timestamps.
addOneDayFromNow := time.Now().Add(24 * time.Hour)
lastAccessTime := addOneDayFromNow
lastModifyTime := addOneDayFromNow
err = os.Chtimes("test.txt", lastAccessTime, lastModifyTime)
if err != nil {
log.Println(err)
}
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run change.go
      2022/08/20 16:55:42 File exist.
      2022/08/20 16:55:42 chown test.txt: not supported by windows
      PS C:\GO_Language\file> go run change.go 2022/08/20 16:55:42 File exist. 2022/08/20 16:55:42 chown test.txt: not supported by windows
      PS C:\GO_Language\file> go run change.go
2022/08/20 16:55:42 File exist.
2022/08/20 16:55:42 chown test.txt: not supported by windows

       

    • Compress a list of files into a ZIP file

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "archive/zip"
      "fmt"
      "io"
      "log"
      "os"
      )
      func appendFiles(fname string, zipw *zip.Writer) error {
      file, err := os.Open(fname)
      if err != nil {
      return fmt.Errorf("Failed to open %s: %s", fname, err)
      }
      defer file.Close()
      wr, err := zipw.Create(fname)
      if err != nil {
      msg := "Failed to create entry for %s in zip file: %s"
      return fmt.Errorf(msg, fname, err)
      }
      if _, err := io.Copy(wr, file); err != nil {
      return fmt.Errorf("Failed to write %s to zip: %s", fname, err)
      }
      return nil
      }
      func main() {
      flags := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
      file, err := os.OpenFile("test.zip", flags, 0644)
      if err != nil {
      log.Fatalf("Failed to open zip for writing: %s", err)
      }
      defer file.Close()
      var files = []string{"test1.txt", "test2.txt", "test3.txt"}
      zipw := zip.NewWriter(file)
      defer zipw.Close()
      for _, filename := range files {
      if err := appendFiles(filename, zipw); err != nil {
      log.Fatalf("Failed to add file %s to zip: %s", fname, err)
      }
      }
      }
      package main import ( "archive/zip" "fmt" "io" "log" "os" ) func appendFiles(fname string, zipw *zip.Writer) error { file, err := os.Open(fname) if err != nil { return fmt.Errorf("Failed to open %s: %s", fname, err) } defer file.Close() wr, err := zipw.Create(fname) if err != nil { msg := "Failed to create entry for %s in zip file: %s" return fmt.Errorf(msg, fname, err) } if _, err := io.Copy(wr, file); err != nil { return fmt.Errorf("Failed to write %s to zip: %s", fname, err) } return nil } func main() { flags := os.O_WRONLY | os.O_CREATE | os.O_TRUNC file, err := os.OpenFile("test.zip", flags, 0644) if err != nil { log.Fatalf("Failed to open zip for writing: %s", err) } defer file.Close() var files = []string{"test1.txt", "test2.txt", "test3.txt"} zipw := zip.NewWriter(file) defer zipw.Close() for _, filename := range files { if err := appendFiles(filename, zipw); err != nil { log.Fatalf("Failed to add file %s to zip: %s", fname, err) } } }
      package main
import (
    "archive/zip"
    "fmt"
    "io"
    "log"
    "os"
)
 
func appendFiles(fname string, zipw *zip.Writer) error {
    file, err := os.Open(fname)
    if err != nil {
        return fmt.Errorf("Failed to open %s: %s", fname, err)
    }
    defer file.Close()
 
    wr, err := zipw.Create(fname)
    if err != nil {
        msg := "Failed to create entry for %s in zip file: %s"
        return fmt.Errorf(msg, fname, err)
    }
 
    if _, err := io.Copy(wr, file); err != nil {
        return fmt.Errorf("Failed to write %s to zip: %s", fname, err)
    }
 
    return nil
}
 
func main() {
    flags := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
    file, err := os.OpenFile("test.zip", flags, 0644)
    if err != nil {
        log.Fatalf("Failed to open zip for writing: %s", err)
    }
    defer file.Close()
 
    var files = []string{"test1.txt", "test2.txt", "test3.txt"}
 
    zipw := zip.NewWriter(file)
    defer zipw.Close()
 
    for _, filename := range files {
        if err := appendFiles(filename, zipw); err != nil {
            log.Fatalf("Failed to add file %s to zip: %s", fname, err)
        }
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run compress.go
      PS C:\GO_Language\file> go run compress.go
      PS C:\GO_Language\file> go run compress.go

       

    • Extract or Unzip

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      package main
      import (
      "archive/zip"
      "io"
      "log"
      "os"
      "path/filepath"
      )
      func main() {
      zipReader, _ := zip.OpenReader("test.zip")
      for _, file := range zipReader.Reader.File {
      zippedFile, err := file.Open()
      if err != nil {
      log.Fatal(err)
      }
      defer zippedFile.Close()
      tDir := "./"
      extractedFilePath := filepath.Join(
      tDir,
      file.Name,
      )
      if file.FileInfo().IsDir() {
      log.Println("Directory Created:", extractedFilePath)
      os.MkdirAll(extractedFilePath, file.Mode())
      } else {
      log.Println("File extracted:", file.Name)
      opFile, err := os.OpenFile(
      extractedFilePath,
      os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
      file.Mode(),
      )
      if err != nil {
      log.Fatal(err)
      }
      defer opFile.Close()
      _, err = io.Copy(opFile, zippedFile)
      if err != nil {
      log.Fatal(err)
      }
      }
      }
      }
      package main import ( "archive/zip" "io" "log" "os" "path/filepath" ) func main() { zipReader, _ := zip.OpenReader("test.zip") for _, file := range zipReader.Reader.File { zippedFile, err := file.Open() if err != nil { log.Fatal(err) } defer zippedFile.Close() tDir := "./" extractedFilePath := filepath.Join( tDir, file.Name, ) if file.FileInfo().IsDir() { log.Println("Directory Created:", extractedFilePath) os.MkdirAll(extractedFilePath, file.Mode()) } else { log.Println("File extracted:", file.Name) opFile, err := os.OpenFile( extractedFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode(), ) if err != nil { log.Fatal(err) } defer opFile.Close() _, err = io.Copy(opFile, zippedFile) if err != nil { log.Fatal(err) } } } }
      package main
import (
    "archive/zip"
    "io"
    "log"
    "os"
    "path/filepath"
)
 
func main() {
    zipReader, _ := zip.OpenReader("test.zip")
    for _, file := range zipReader.Reader.File {
 
        zippedFile, err := file.Open()
        if err != nil {
            log.Fatal(err)
        }
        defer zippedFile.Close()
 
        tDir := "./"
        extractedFilePath := filepath.Join(
            tDir,
            file.Name,
        )
 
        if file.FileInfo().IsDir() {
            log.Println("Directory Created:", extractedFilePath)
            os.MkdirAll(extractedFilePath, file.Mode())
        } else {
            log.Println("File extracted:", file.Name)
 
            opFile, err := os.OpenFile(
                extractedFilePath,
                os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
                file.Mode(),
            )
            if err != nil {
                log.Fatal(err)
            }
            defer opFile.Close()
 
            _, err = io.Copy(opFile, zippedFile)
            if err != nil {
                log.Fatal(err)
            }
        }
    }
}

      Output :

      Plain text
      Copy to clipboard
      Open code in new window
      EnlighterJS 3 Syntax Highlighter
      PS C:\GO_Language\file> go run extract.go
      2022/08/20 17:11:43 File extracted: test1.txt
      2022/08/20 17:11:43 File extracted: test2.txt
      2022/08/20 17:11:43 File extracted: test3.txt
      PS C:\GO_Language\file> go run extract.go 2022/08/20 17:11:43 File extracted: test1.txt 2022/08/20 17:11:43 File extracted: test2.txt 2022/08/20 17:11:43 File extracted: test3.txt
      PS C:\GO_Language\file> go run extract.go 
2022/08/20 17:11:43 File extracted: test1.txt
2022/08/20 17:11:43 File extracted: test2.txt
2022/08/20 17:11:43 File extracted: test3.txt

       

0
0
[ssba-buttons]
Generic selectors
Exact matches only
Search in title
Search in content
Post Type Selectors
Filter by Categories
Amazon Athena
Amazon DynamoDB
Amazon EC2
Amazon ElastiCache
Amazon EMR
Amazon RDS
Amazon Redshift
Amazon Route 53
Amazon Simple Queue Service (SQS)
Amazon Simple Storage Service (S3)
Amazon Virtual Private Cloud (VPC)
Apache Spark
Apache Spark CASSANDRA
Apache Spark INTRODUCTION
Apache Spark KAFKA
Apache Spark RDD
Apache Spark SCALA
Apache Spark SQL
AWS
AWS Elastic Load Balancing
AWS Identity and Access Management (IAM)
AWS Introduction
AWS Lambda
AZURE
Azure Architectural Components
Azure Compute Services - 2
Azure Compute Services Part - 1
Azure networking services
Azure Serverless Technologies
Azure Storage Services
BIGQUERY
Cassandra
Cassandra Modules
Cloud fundamental concepts - 2
Cloud Fundamental Concepts -1
CLOUD SQL
CLOUD STORAGE
Data Science
Data Science Modules
DATAFLOW
DATAPROC
Elasticsearch 
Elasticsearch Modules
Getting Started with Cloud
GitHub
GitHub Modules
GitLab
GitLab Modules
Golang
Golang Modules
Google Cloud Platform
Hadoop
Hadoop Admin
Hadoop Admin Modules
HBase
HDFS
HIVE
IAM
INSTANCE
Interview Questions
Interview Questions
KUBERNETES
Linux
LINUX ARCHITECTURE
LINUX COMMANDS
LINUX FILE SYSTEM
LINUX INTRODUCTION
Machine Learning
MACHINE LEARNING MODULES
MapReduce
Module 1
Module 2
Module 3
Module 4
MySQL 
MYSQL BASIC COMMANDS
MySQL DATA TYPES
MySQL INTRODUCTION
NETWORKING
Pig
Power BI
PUBSUB
Python
PYTHON DATA TYPES
PYTHON DATA VISUALIZATION
PYTHON EXCEPTION HANDLING
PYTHON FILE HANDLING
PYTHON FUNCTIONS
PYTHON INTRODUCTION
PYTHON NumPy
PYTHON OOPS
PYTHON PANDAS
PYTHON VARIABLES
R Programming
R Programming
Scala 
Scala Modules
Software Installation
Software Installation Modules
Sqoop
Statistics
Statistics Modules
Tableau 
Tableau Calculations
Tableau Charts
Tableau Filters
Tableau Formatting
Tableau Groups
Tableau Introduction
Tableau Parameters
Tableau Sets
Troubleshooting
Troubleshooting Modules
YARN

Recent Blogs


Take a Big Step in Your Career

    Quick Support

    image image