Elysia Tools

Explore ferramentas, exemplos, explicações visuais e guias temáticos em um espaço claro.

Categorias populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegação

Go

Exemplos de Operações de Arquivo Web Go

Exemplos de operações de arquivo Web Go incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo

Exemplos

Entradas desta coleção

CódigogoSimples

Leitura/Escrita de Arquivo de Texto

Ler e escrever arquivos de texto com várias opções de codificação usando Go file I/O

Dificuldade

4/10

Tempo estimado

20 min

Etiquetas

go, web, file operations

Pré-requisitos

Basic Go, File I/O, os package

go
// Web Go Text File Read/Write Examples
// Using Go file I/O for file operations

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"unicode/utf8"
)

// 1. Reading Text Files

// ReadTextFile reads a text file and returns its content
func ReadTextFile(filePath string) (string, error) {
	content, err := ioutil.ReadFile(filePath)
	if err != nil {
		return "", fmt.Errorf("error reading file: %v", err)
	}
	return string(content), nil
}

// ReadTextFileWithEncoding reads a text file with specific encoding
func ReadTextFileWithEncoding(filePath string, encoding string) (string, error) {
	// Go primarily works with UTF-8, but we can read and validate
	content, err := ioutil.ReadFile(filePath)
	if err != nil {
		return "", fmt.Errorf("error reading file: %v", err)
	}

	// Validate UTF-8
	if !utf8.Valid(content) {
		return "", fmt.Errorf("file contains invalid UTF-8 sequences")
	}

	return string(content), nil
}

// ReadTextFileLineByLine reads a text file line by line
func ReadTextFileLineByLine(filePath string) ([]string, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, fmt.Errorf("error opening file: %v", err)
	}
	defer file.Close()

	var lines []string
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading file: %v", err)
	}

	return lines, nil
}

// ReadTextFileInChunks reads a text file in chunks
func ReadTextFileInChunks(filePath string, chunkSize int) ([]string, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, fmt.Errorf("error opening file: %v", err)
	}
	defer file.Close()

	var chunks []string
	buffer := make([]byte, chunkSize)

	for {
		n, err := file.Read(buffer)
		if err != nil && err != io.EOF {
			return nil, fmt.Errorf("error reading file: %v", err)
		}

		if n == 0 {
			break
		}

		chunks = append(chunks, string(buffer[:n]))
	}

	return chunks, nil
}

// ReadTextFileWithBuffer reads a text file using buffered I/O
func ReadTextFileWithBuffer(filePath string) (string, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return "", fmt.Errorf("error opening file: %v", err)
	}
	defer file.Close()

	var buffer bytes.Buffer
	_, err = io.Copy(&buffer, file)
	if err != nil {
		return "", fmt.Errorf("error reading file: %v", err)
	}

	return buffer.String(), nil
}

// 2. Writing Text Files

// WriteTextFile writes text content to a file
func WriteTextFile(filePath string, content string) error {
	err := ioutil.WriteFile(filePath, []byte(content), 0644)
	if err != nil {
		return fmt.Errorf("error writing file: %v", err)
	}
	return nil
}

// WriteTextLines writes a list of lines to a text file
func WriteTextLines(filePath string, lines []string) error {
	file, err := os.Create(filePath)
	if err != nil {
		return fmt.Errorf("error creating file: %v", err)
	}
	defer file.Close()

	writer := bufio.NewWriter(file)
	for _, line := range lines {
		_, err := writer.WriteString(line + "\n")
		if err != nil {
			return fmt.Errorf("error writing to file: %v", err)
		}
	}

	return writer.Flush()
}

// WriteTextFileWithPermissions writes text content with specific permissions
func WriteTextFileWithPermissions(filePath string, content string, perm os.FileMode) error {
	err := ioutil.WriteFile(filePath, []byte(content), perm)
	if err != nil {
		return fmt.Errorf("error writing file: %v", err)
	}
	return nil
}

// AppendToTextFile appends text content to an existing file
func AppendToTextFile(filePath string, content string) error {
	file, err := os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
	if err != nil {
		return fmt.Errorf("error opening file: %v", err)
	}
	defer file.Close()

	_, err = file.WriteString(content)
	if err != nil {
		return fmt.Errorf("error appending to file: %v", err)
	}

	return nil
}

// WriteTextFileAtomic writes content atomically (using temp file)
func WriteTextFileAtomic(filePath string, content string) error {
	// Write to temporary file
	tempPath := filePath + ".tmp"
	err := ioutil.WriteFile(tempPath, []byte(content), 0644)
	if err != nil {
		return fmt.Errorf("error writing temp file: %v", err)
	}

	// Rename atomically
	err = os.Rename(tempPath, filePath)
	if err != nil {
		os.Remove(tempPath) // Cleanup
		return fmt.Errorf("error renaming file: %v", err)
	}

	return nil
}

// 3. File Info Helper

// GetFileSize gets the size of a file in bytes
func GetFileSize(filePath string) (int64, error) {
	info, err := os.Stat(filePath)
	if err != nil {
		return 0, fmt.Errorf("error getting file info: %v", err)
	}
	return info.Size(), nil
}

// GetFileExtension gets the file extension
func GetFileExtension(filePath string) string {
	return filepath.Ext(filePath)
}

// GetFileNameWithoutExtension gets the file name without extension
func GetFileNameWithoutExtension(filePath string) string {
	return strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
}

// FormatFileSize formats file size in human-readable format
func FormatFileSize(bytes int64) string {
	const (
		KB = 1024
		MB = KB * 1024
		GB = MB * 1024
		TB = GB * 1024
	)

	switch {
	case bytes >= TB:
		return fmt.Sprintf("%.2f TB", float64(bytes)/float64(TB))
	case bytes >= GB:
		return fmt.Sprintf("%.2f GB", float64(bytes)/float64(GB))
	case bytes >= MB:
		return fmt.Sprintf("%.2f MB", float64(bytes)/float64(MB))
	case bytes >= KB:
		return fmt.Sprintf("%.2f KB", float64(bytes)/float64(KB))
	default:
		return fmt.Sprintf("%d B", bytes)
	}
}

// GetFileDetails gets detailed information about a file
func GetFileDetails(filePath string) (map[string]interface{}, error) {
	info, err := os.Stat(filePath)
	if err != nil {
		return nil, fmt.Errorf("error getting file info: %v", err)
	}

	absPath, err := filepath.Abs(filePath)
	if err != nil {
		return nil, fmt.Errorf("error getting absolute path: %v", err)
	}

	return map[string]interface{}{
		"name":            filepath.Base(filePath),
		"size":            info.Size(),
		"readable_size":   FormatFileSize(info.Size()),
		"extension":       GetFileExtension(filePath),
		"modified_time":   info.ModTime(),
		"is_file":         !info.IsDir(),
		"is_dir":          info.IsDir(),
		"absolute_path":   absPath,
		"mode":            info.Mode(),
	}, nil
}

// 4. File Validation

// FileExists checks if a file exists
func FileExists(filePath string) bool {
	_, err := os.Stat(filePath)
	return !os.IsNotExist(err)
}

// IsFile checks if path is a file
func IsFile(filePath string) bool {
	info, err := os.Stat(filePath)
	if err != nil {
		return false
	}
	return !info.IsDir()
}

// IsDirectory checks if path is a directory
func IsDirectory(dirPath string) bool {
	info, err := os.Stat(dirPath)
	if err != nil {
		return false
	}
	return info.IsDir()
}

// ValidateFile validates file properties
func ValidateFile(filePath string, maxSizeMB int64) (map[string]interface{}, error) {
	result := make(map[string]interface{})
	result["valid"] = true
	result["errors"] = []string{}

	if !FileExists(filePath) {
		result["valid"] = false
		result["errors"] = append(result["errors"].([]string), "File does not exist")
		return result, nil
	}

	if !IsFile(filePath) {
		result["valid"] = false
		result["errors"] = append(result["errors"].([]string), "Path is not a file")
		return result, nil
	}

	if maxSizeMB > 0 {
		size, err := GetFileSize(filePath)
		if err != nil {
			result["valid"] = false
			result["errors"] = append(result["errors"].([]string), fmt.Sprintf("Error getting file size: %v", err))
			return result, nil
		}

		sizeMB := size / (1024 * 1024)
		if sizeMB > maxSizeMB {
			result["valid"] = false
			result["errors"] = append(result["errors"].([]string), fmt.Sprintf("File size (%.2fMB) exceeds limit (%dMB)", float64(sizeMB), maxSizeMB))
		}
	}

	return result, nil
}

// 5. Batch File Operations

// ReadMultipleFiles reads multiple text files
func ReadMultipleFiles(filePaths []string) map[string]string {
	results := make(map[string]string)

	for _, filePath := range filePaths {
		content, err := ReadTextFile(filePath)
		if err == nil {
			results[filePath] = content
		}
	}

	return results
}

// BatchWriteFiles writes to multiple files
func BatchWriteFiles(fileDataMap map[string]string) ([]string, []string) {
	var successful []string
	var failed []string

	for filePath, content := range fileDataMap {
		err := WriteTextFile(filePath, content)
		if err == nil {
			successful = append(successful, filePath)
		} else {
			failed = append(failed, filePath)
		}
	}

	return successful, failed
}

// SearchInFiles searches for text in multiple files
func SearchInFiles(filePaths []string, searchText string, caseSensitive bool) map[string][]int {
	results := make(map[string][]int)

	if !caseSensitive {
		searchText = strings.ToLower(searchText)
	}

	for _, filePath := range filePaths {
		lines, err := ReadTextFileLineByLine(filePath)
		if err != nil {
			continue
		}

		var matchingLines []int
		for i, line := range lines {
			searchLine := line
			if !caseSensitive {
				searchLine = strings.ToLower(line)
			}

			if strings.Contains(searchLine, searchText) {
				matchingLines = append(matchingLines, i+1)
			}
		}

		if len(matchingLines) > 0 {
			results[filePath] = matchingLines
		}
	}

	return results
}

// 6. File Encoding Utilities

// DetectFileEncoding detects file encoding (simplified)
func DetectFileEncoding(filePath string) (string, error) {
	content, err := ioutil.ReadFile(filePath)
	if err != nil {
		return "", err
	}

	// Check for BOM
	if len(content) >= 3 && content[0] == 0xEF && content[1] == 0xBB && content[2] == 0xBF {
		return "UTF-8 with BOM", nil
	}

	// Validate UTF-8
	if utf8.Valid(content) {
		return "UTF-8", nil
	}

	// Default to ASCII/unknown
	return "ASCII/Unknown", nil
}

// ConvertFileEncoding converts file from one encoding to another
func ConvertFileEncoding(inputPath, outputPath string, fromEncoding, toEncoding string) error {
	// Read input file
	content, err := ioutil.ReadFile(inputPath)
	if err != nil {
		return fmt.Errorf("error reading input file: %v", err)
	}

	// Write to output file
	err = ioutil.WriteFile(outputPath, content, 0644)
	if err != nil {
		return fmt.Errorf("error writing output file: %v", err)
	}

	return nil
}

// Usage Examples
func main() {
	fmt.Println("=== Web Go Text File Read/Write Examples ===\n")

	// 1. Read text file
	fmt.Println("--- 1. Read Text File ---")
	content, err := ReadTextFile("example.txt")
	if err == nil {
		fmt.Printf("Content length: %d characters\n", len(content))
	}

	// 2. Read line by line
	fmt.Println("\n--- 2. Read Line by Line ---")
	lines, err := ReadTextFileLineByLine("example.txt")
	if err == nil {
		fmt.Printf("Number of lines: %d\n", len(lines))
		fmt.Printf("First 3 lines: %v\n", lines[:min(3, len(lines))])
	}

	// 3. Write text file
	fmt.Println("\n--- 3. Write Text File ---")
	err = WriteTextFile("output.txt", "Hello, World!\nThis is a new file.")
	if err == nil {
		fmt.Println("File written successfully")
	}

	// 4. Write lines
	fmt.Println("\n--- 4. Write Lines ---")
	linesToWrite := []string{"Line 1", "Line 2", "Line 3"}
	err = WriteTextLines("lines.txt", linesToWrite)
	if err == nil {
		fmt.Println("Lines file written successfully")
	}

	// 5. Get file details
	fmt.Println("\n--- 5. File Details ---")
	details, err := GetFileDetails("example.txt")
	if err == nil {
		fmt.Printf("Name: %v\n", details["name"])
		fmt.Printf("Size: %v\n", details["readable_size"])
		fmt.Printf("Extension: %v\n", details["extension"])
	}

	// 6. File validation
	fmt.Println("\n--- 6. File Validation ---")
	validation, err := ValidateFile("example.txt", 1)
	if err == nil {
		fmt.Printf("Valid: %v\n", validation["valid"])
	}

	fmt.Println("\n=== All Text File Operations Completed ===")
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}
CódigogoIntermediário

Copiar/Mover Arquivos

Copiar e mover arquivos com rastreamento de progresso e tratamento de erros

Dificuldade

6/10

Tempo estimado

25 min

Etiquetas

go, web, file operations

Pré-requisitos

Intermediate Go, io package, filepath package

go
// Web Go File Copy/Move Examples
// File copy and move operations with progress tracking

package main

import (
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"time"
)

// 1. File Copy Operations

// CopyFile copies a file from source to destination
func CopyFile(sourcePath, destinationPath string) error {
	sourceFile, err := os.Open(sourcePath)
	if err != nil {
		return fmt.Errorf("error opening source file: %v", err)
	}
	defer sourceFile.Close()

	// Ensure destination directory exists
	destDir := filepath.Dir(destinationPath)
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return fmt.Errorf("error creating destination directory: %v", err)
	}

	destFile, err := os.Create(destinationPath)
	if err != nil {
		return fmt.Errorf("error creating destination file: %v", err)
	}
	defer destFile.Close()

	// Copy contents
	_, err = io.Copy(destFile, sourceFile)
	if err != nil {
		return fmt.Errorf("error copying file: %v", err)
	}

	// Copy file permissions
	sourceInfo, err := os.Stat(sourcePath)
	if err != nil {
		return fmt.Errorf("error getting source file info: %v", err)
	}

	err = os.Chmod(destinationPath, sourceInfo.Mode())
	if err != nil {
		return fmt.Errorf("error setting file permissions: %v", err)
	}

	return nil
}

// CopyFileWithBuffer copies a file using a buffer
func CopyFileWithBuffer(sourcePath, destinationPath string, bufferSize int) error {
	sourceFile, err := os.Open(sourcePath)
	if err != nil {
		return fmt.Errorf("error opening source file: %v", err)
	}
	defer sourceFile.Close()

	destDir := filepath.Dir(destinationPath)
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return fmt.Errorf("error creating destination directory: %v", err)
	}

	destFile, err := os.Create(destinationPath)
	if err != nil {
		return fmt.Errorf("error creating destination file: %v", err)
	}
	defer destFile.Close()

	buffer := make([]byte, bufferSize)
	_, err = io.CopyBuffer(destFile, sourceFile, buffer)
	if err != nil {
		return fmt.Errorf("error copying file: %v", err)
	}

	sourceInfo, err := os.Stat(sourcePath)
	if err != nil {
		return fmt.Errorf("error getting source file info: %v", err)
	}

	return os.Chmod(destinationPath, sourceInfo.Mode())
}

// CopyFileWithProgress copies a file with progress tracking
func CopyFileWithProgress(sourcePath, destinationPath string, progressCallback func(written, total int64)) error {
	sourceFile, err := os.Open(sourcePath)
	if err != nil {
		return fmt.Errorf("error opening source file: %v", err)
	}
	defer sourceFile.Close()

	sourceInfo, err := sourceFile.Stat()
	if err != nil {
		return fmt.Errorf("error getting source file info: %v", err)
	}

	destDir := filepath.Dir(destinationPath)
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return fmt.Errorf("error creating destination directory: %v", err)
	}

	destFile, err := os.Create(destinationPath)
	if err != nil {
		return fmt.Errorf("error creating destination file: %v", err)
	}
	defer destFile.Close()

	// Copy with progress
	buffer := make([]byte, 32*1024) // 32KB buffer
	var written int64

	for {
		n, err := sourceFile.Read(buffer)
		if n > 0 {
			w, writeErr := destFile.Write(buffer[:n])
			if writeErr != nil {
				return fmt.Errorf("error writing to destination: %v", writeErr)
			}
			written += int64(w)

			if progressCallback != nil {
				progressCallback(written, sourceInfo.Size())
			}
		}

		if err != nil {
			if err == io.EOF {
				break
			}
			return fmt.Errorf("error reading source: %v", err)
		}
	}

	// Copy permissions
	return os.Chmod(destinationPath, sourceInfo.Mode())
}

// 2. File Move Operations

// MoveFile moves a file from source to destination
func MoveFile(sourcePath, destinationPath string) error {
	// Try rename first (fastest if on same filesystem)
	err := os.Rename(sourcePath, destinationPath)
	if err == nil {
		return nil
	}

	// If rename fails, copy and delete
	if err := CopyFile(sourcePath, destinationPath); err != nil {
		return fmt.Errorf("error copying file: %v", err)
	}

	// Remove source file
	return os.Remove(sourcePath)
}

// MoveFileAtomic moves a file atomically
func MoveFileAtomic(sourcePath, destinationPath string) error {
	// Ensure destination directory exists
	destDir := filepath.Dir(destinationPath)
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return fmt.Errorf("error creating destination directory: %v", err)
	}

	// Atomic rename
	return os.Rename(sourcePath, destinationPath)
}

// 3. Directory Operations

// CopyDirectory copies entire directory recursively
func CopyDirectory(sourceDir, destinationDir string) error {
	sourceInfo, err := os.Stat(sourceDir)
	if err != nil {
		return fmt.Errorf("error getting source directory info: %v", err)
	}

	// Create destination directory
	if err := os.MkdirAll(destinationDir, sourceInfo.Mode()); err != nil {
		return fmt.Errorf("error creating destination directory: %v", err)
	}

	// Read source directory
	entries, err := os.ReadDir(sourceDir)
	if err != nil {
		return fmt.Errorf("error reading source directory: %v", err)
	}

	// Copy each entry
	for _, entry := range entries {
		sourcePath := filepath.Join(sourceDir, entry.Name())
		destPath := filepath.Join(destinationDir, entry.Name())

		if entry.IsDir() {
			// Recursively copy subdirectory
			if err := CopyDirectory(sourcePath, destPath); err != nil {
				return err
			}
		} else {
			// Copy file
			if err := CopyFile(sourcePath, destPath); err != nil {
				return err
			}
		}
	}

	return nil
}

// CopyDirectoryWithProgress copies directory with progress tracking
func CopyDirectoryWithProgress(sourceDir, destinationDir string, progressCallback func(current, total int, filename string)) error {
	// Count total files first
	totalFiles := 0
	filepath.Walk(sourceDir, func(path string, info os.FileInfo, err error) error {
		if !info.IsDir() {
			totalFiles++
		}
		return nil
	})

	copiedFiles := 0

	// Copy files
	return filepath.Walk(sourceDir, func(sourcePath string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		// Calculate destination path
		relPath, err := filepath.Rel(sourceDir, sourcePath)
		if err != nil {
			return err
		}
		destPath := filepath.Join(destinationDir, relPath)

		// Ensure destination directory exists
		destDir := filepath.Dir(destPath)
		if err := os.MkdirAll(destDir, 0755); err != nil {
			return err
		}

		// Copy file
		if err := CopyFile(sourcePath, destPath); err != nil {
			return err
		}

		copiedFiles++
		if progressCallback != nil {
			progressCallback(copiedFiles, totalFiles, filepath.Base(sourcePath))
		}

		return nil
	})
}

// MoveDirectory moves directory from source to destination
func MoveDirectory(sourceDir, destinationDir string) error {
	// Try atomic rename first
	err := os.Rename(sourceDir, destinationDir)
	if err == nil {
		return nil
	}

	// If rename fails, copy and delete
	if err := CopyDirectory(sourceDir, destinationDir); err != nil {
		return fmt.Errorf("error copying directory: %v", err)
	}

	return os.RemoveAll(sourceDir)
}

// 4. Batch Operations

// BatchRenameFiles renames files in a directory using a pattern
func BatchRenameFiles(directory string, renameFunc func(string) string) ([]string, []string) {
	var renamed []string
	var failed []string

	entries, err := os.ReadDir(directory)
	if err != nil {
		failed = append(failed, directory)
		return renamed, failed
	}

	for _, entry := range entries {
		if entry.IsDir() {
			continue
		}

		oldPath := filepath.Join(directory, entry.Name())
		newName := renameFunc(entry.Name())
		newPath := filepath.Join(directory, newName)

		if err := os.Rename(oldPath, newPath); err != nil {
			failed = append(failed, oldPath)
		} else {
			renamed = append(renamed, oldPath+" -> "+newPath)
		}
	}

	return renamed, failed
}

// 5. Safe File Operations

// SafeCopy copies file with safety checks
func SafeCopy(sourcePath, destinationPath string) error {
	// Validate source
	if _, err := os.Stat(sourcePath); err != nil {
		return fmt.Errorf("source file error: %v", err)
	}

	// Check if destination exists
	if _, err := os.Stat(destinationPath); err == nil {
		return fmt.Errorf("destination file already exists")
	}

	return CopyFile(sourcePath, destinationPath)
}

// SafeMove moves file with safety checks
func SafeMove(sourcePath, destinationPath string) error {
	// Validate source
	if _, err := os.Stat(sourcePath); err != nil {
		return fmt.Errorf("source file error: %v", err)
	}

	// Check if destination exists
	if _, err := os.Stat(destinationPath); err == nil {
		return fmt.Errorf("destination file already exists")
	}

	// Ensure destination directory exists
	destDir := filepath.Dir(destinationPath)
	if err := os.MkdirAll(destDir, 0755); err != nil {
		return fmt.Errorf("error creating destination directory: %v", err)
	}

	return MoveFile(sourcePath, destinationPath)
}

// 6. Backup and Restore

// CreateBackup creates backup of files/directories
func CreateBackup(sourcePaths []string, backupDir string, useTimestamp bool) (string, error) {
	var backupPath string

	if useTimestamp {
		timestamp := time.Now().Format("20060102_150405")
		backupPath = filepath.Join(backupDir, "backup_"+timestamp)
	} else {
		backupPath = filepath.Join(backupDir, "backup")
	}

	if err := os.MkdirAll(backupPath, 0755); err != nil {
		return "", fmt.Errorf("error creating backup directory: %v", err)
	}

	for _, source := range sourcePaths {
		dest := filepath.Join(backupPath, filepath.Base(source))

		info, err := os.Stat(source)
		if err != nil {
			continue
		}

		if info.IsDir() {
			if err := CopyDirectory(source, dest); err != nil {
				return "", err
			}
		} else {
			if err := CopyFile(source, dest); err != nil {
				return "", err
			}
		}
	}

	return backupPath, nil
}

// RestoreFromBackup restores files from backup directory
func RestoreFromBackup(backupDir, targetDir string) error {
	return CopyDirectory(backupDir, targetDir)
}

// Usage Examples
func main() {
	fmt.Println("=== Web Go File Copy/Move Examples ===\n")

	// 1. Copy file
	fmt.Println("--- 1. Copy File ---")
	err := CopyFile("source.txt", "copy.txt")
	if err == nil {
		fmt.Println("File copied successfully")
	} else {
		fmt.Printf("Error: %v\n", err)
	}

	// 2. Copy with progress
	fmt.Println("\n--- 2. Copy with Progress ---")
	err = CopyFileWithProgress("source.txt", "copy2.txt", func(written, total int64) {
		fmt.Printf("Progress: %d/%d bytes (%.1f%%)\n", written, total, float64(written)/float64(total)*100)
	})
	if err == nil {
		fmt.Println("File copied with progress successfully")
	}

	// 3. Move file
	fmt.Println("\n--- 3. Move File ---")
	err = MoveFile("old_name.txt", "new_name.txt")
	if err == nil {
		fmt.Println("File moved successfully")
	}

	// 4. Batch rename
	fmt.Println("\n--- 4. Batch Rename ---")
	renamed, failed := BatchRenameFiles(".", func(name string) string {
		return strings.Replace(name, ".txt", ".bak", 1)
	})
	fmt.Printf("Renamed %d files\n", len(renamed))
	fmt.Printf("Failed %d files\n", len(failed))

	// 5. Backup
	fmt.Println("\n--- 5. Backup ---")
	backupPath, err := CreateBackup([]string{"important_file.txt", "important_dir"}, "backups", true)
	if err == nil {
		fmt.Printf("Backup created at: %s\n", backupPath)
	}

	fmt.Println("\n=== All File Copy/Move Examples Completed ===")
}
CódigogoComplexo

Travessia de Diretório

Percorrer diretórios usando filepath.Walk, glob patterns e exploração de arquivos

Dificuldade

7/10

Tempo estimado

30 min

Etiquetas

go, web, file operations, directory

Pré-requisitos

Advanced Go, filepath package, ioutil package

go
// Web Go Directory Traversal Examples
// Using filepath.Walk and glob patterns for directory operations

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"sort"
	"strings"
)

// 1. Directory Listing

// DirectoryContents represents contents of a directory
type DirectoryContents struct {
	Directory   string
	Files       []string
	Directories []string
}

// ListDirectoryContents lists contents of a directory
func ListDirectoryContents(directory string, recursive bool) (*DirectoryContents, error) {
	result := &DirectoryContents{
		Directory:   directory,
		Files:       []string{},
		Directories: []string{},
	}

	if recursive {
		err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}

			if info.IsDir() && path != directory {
				result.Directories = append(result.Directories, path)
			} else if !info.IsDir() {
				result.Files = append(result.Files, path)
			}

			return nil
		})

		if err != nil {
			return nil, fmt.Errorf("error walking directory: %v", err)
		}
	} else {
		entries, err := ioutil.ReadDir(directory)
		if err != nil {
			return nil, fmt.Errorf("error reading directory: %v", err)
		}

		for _, entry := range entries {
			fullPath := filepath.Join(directory, entry.Name())

			if entry.IsDir() {
				result.Directories = append(result.Directories, fullPath)
			} else {
				result.Files = append(result.Files, fullPath)
			}
		}
	}

	return result, nil
}

// TreeNode represents a node in the directory tree
type TreeNode struct {
	Name     string
	Path     string
	IsDir    bool
	Children []*TreeNode
}

// ListDirectoryTree lists directory as a tree structure
func ListDirectoryTree(directory string, maxDepth int) (*TreeNode, error) {
	return buildTree(directory, 0, maxDepth)
}

func buildTree(path string, depth, maxDepth int) (*TreeNode, error) {
	if maxDepth >= 0 && depth > maxDepth {
		return &TreeNode{
			Name:     filepath.Base(path),
			Children: []*TreeNode{},
		}, nil
	}

	info, err := os.Stat(path)
	if err != nil {
		return nil, err
	}

	node := &TreeNode{
		Name:  filepath.Base(path),
		Path:  path,
		IsDir: info.IsDir(),
	}

	if info.IsDir() {
		entries, err := ioutil.ReadDir(path)
		if err != nil {
			return node, nil
		}

		// Sort entries
		sort.Slice(entries, func(i, j int) bool {
			return entries[i].Name() < entries[j].Name()
		})

		for _, entry := range entries {
			childPath := filepath.Join(path, entry.Name())
			child, err := buildTree(childPath, depth+1, maxDepth)
			if err != nil {
				continue
			}
			node.Children = append(node.Children, child)
		}
	}

	return node, nil
}

// PrintDirectoryTree prints directory tree structure
func PrintDirectoryTree(tree *TreeNode, indent int) {
	prefix := strings.Repeat("  ", indent)
	icon := "📁"
	if !tree.IsDir {
		icon = "📄"
	}
	fmt.Printf("%s%s %s\n", prefix, icon, tree.Name)

	for _, child := range tree.Children {
		PrintDirectoryTree(child, indent+1)
	}
}

// 2. File Pattern Matching

// FindFilesByPattern finds files matching a pattern
func FindFilesByPattern(directory, pattern string) ([]string, error) {
	var matches []string

	err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return nil
		}

		if info.IsDir() {
			return nil
		}

		matched, err := filepath.Match(pattern, filepath.Base(path))
		if err != nil {
			return nil
		}

		if matched {
			matches = append(matches, path)
		}

		return nil
	})

	if err != nil {
		return nil, err
	}

	return matches, nil
}

// FindFilesByExtension finds files with specific extension
func FindFilesByExtension(directory, extension string) ([]string, error) {
	if !strings.HasPrefix(extension, ".") {
		extension = "." + extension
	}
	return FindFilesByPattern(directory, "*"+extension)
}

// FindFilesByName finds files by name pattern
func FindFilesByName(directory, namePattern string) ([]string, error) {
	return FindFilesByPattern(directory, namePattern)
}

// 3. Directory Statistics

// DirectoryStats represents statistics about a directory
type DirectoryStats struct {
	TotalFiles       int64
	TotalDirectories int64
	TotalSize        int64
	ExtensionCounts  map[string]int
	LargestFiles     []FileEntry
}

// FileEntry represents a file entry with size
type FileEntry struct {
	Path string
	Size int64
}

// GetDirectoryStatistics gets statistics about a directory
func GetDirectoryStatistics(directory string) (*DirectoryStats, error) {
	stats := &DirectoryStats{
		ExtensionCounts: make(map[string]int),
		LargestFiles:    []FileEntry{},
	}

	err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			if path != directory {
				stats.TotalDirectories++
			}
			return nil
		}

		stats.TotalFiles++
		stats.TotalSize += info.Size()

		// Track extensions
		ext := strings.ToLower(filepath.Ext(path))
		stats.ExtensionCounts[ext]++

		// Track largest files
		stats.LargestFiles = append(stats.LargestFiles, FileEntry{
			Path: path,
			Size: info.Size(),
		})

		return nil
	})

	if err != nil {
		return nil, err
	}

	// Sort largest files
	sort.Slice(stats.LargestFiles, func(i, j int) bool {
		return stats.LargestFiles[i].Size > stats.LargestFiles[j].Size
	})

	// Keep top 10
	if len(stats.LargestFiles) > 10 {
		stats.LargestFiles = stats.LargestFiles[:10]
	}

	return stats, nil
}

// 4. File Search in Directory

// SearchInDirectory searches for text in files within a directory
func SearchInDirectory(directory, searchText, filePattern string) (map[string][]int, error) {
	results := make(map[string][]int)

	matches, err := FindFilesByPattern(directory, filePattern)
	if err != nil {
		return nil, err
	}

	for _, filePath := range matches {
		matchingLines, err := searchInFile(filePath, searchText)
		if err != nil {
			continue
		}

		if len(matchingLines) > 0 {
			results[filePath] = matchingLines
		}
	}

	return results, nil
}

func searchInFile(filePath, searchText string) ([]int, error) {
	content, err := ioutil.ReadFile(filePath)
	if err != nil {
		return nil, err
	}

	lines := strings.Split(string(content), "\n")
	var matchingLines []int

	for i, line := range lines {
		if strings.Contains(line, searchText) {
			matchingLines = append(matchingLines, i+1)
		}
	}

	return matchingLines, nil
}

// 5. Directory Comparison

// DirectoryComparison represents comparison results
type DirectoryComparison struct {
	OnlyInDir1 []string
	OnlyInDir2 []string
	Different  []string
	Same       []string
}

// CompareDirectories compares two directories and finds differences
func CompareDirectories(dir1, dir2 string) (*DirectoryComparison, error) {
	result := &DirectoryComparison{
		OnlyInDir1: []string{},
		OnlyInDir2: []string{},
		Different:  []string{},
		Same:       []string{},
	}

	files1 := make(map[string]int64)
	files2 := make(map[string]int64)

	// Walk dir1
	err := filepath.Walk(dir1, func(path string, info os.FileInfo, err error) error {
		if err != nil || info.IsDir() {
			return nil
		}

		relPath, err := filepath.Rel(dir1, path)
		if err != nil {
			return nil
		}

		files1[relPath] = info.Size()
		return nil
	})

	if err != nil {
		return nil, err
	}

	// Walk dir2
	err = filepath.Walk(dir2, func(path string, info os.FileInfo, err error) error {
		if err != nil || info.IsDir() {
			return nil
		}

		relPath, err := filepath.Rel(dir2, path)
		if err != nil {
			return nil
		}

		files2[relPath] = info.Size()
		return nil
	})

	if err != nil {
		return nil, err
	}

	// Find files only in dir1
	for path := range files1 {
		if _, exists := files2[path]; !exists {
			result.OnlyInDir1 = append(result.OnlyInDir1, path)
		}
	}

	// Find files only in dir2
	for path := range files2 {
		if _, exists := files1[path]; !exists {
			result.OnlyInDir2 = append(result.OnlyInDir2, path)
		}
	}

	// Compare common files
	for path := range files1 {
		if size2, exists := files2[path]; exists {
			if files1[path] == size2 {
				result.Same = append(result.Same, path)
			} else {
				result.Different = append(result.Different, path)
			}
		}
	}

	return result, nil
}

// 6. Directory Cleanup

// CleanupDirectory cleans up directory by removing files matching patterns
func CleanupDirectory(directory string, dryRun bool, patterns []string) ([]string, []string) {
	var deleted []string
	var failed []string

	if patterns == nil {
		patterns = []string{"*.tmp", "*.log", "*.bak", "*~"}
	}

	entries, err := ioutil.ReadDir(directory)
	if err != nil {
		failed = append(failed, directory)
		return deleted, failed
	}

	for _, entry := range entries {
		if entry.IsDir() {
			continue
		}

		fileName := entry.Name()
		fullPath := filepath.Join(directory, fileName)

		// Check if matches any pattern
		matches := false
		for _, pattern := range patterns {
			matched, _ := filepath.Match(pattern, fileName)
			if matched {
				matches = true
				break
			}
		}

		if matches {
			if dryRun {
				fmt.Printf("Would delete: %s\n", fullPath)
				deleted = append(deleted, fullPath)
			} else {
				if err := os.Remove(fullPath); err != nil {
					failed = append(failed, fullPath)
				} else {
					deleted = append(deleted, fullPath)
				}
			}
		}
	}

	return deleted, failed
}

// RemoveEmptyDirectories removes empty directories
func RemoveEmptyDirectories(directory string, recursive bool) int {
	removedCount := 0

	if recursive {
		// Process subdirectories first (bottom-up)
		filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
			if err != nil || !info.IsDir() || path == directory {
				return nil
			}

			if isEmptyDir(path) {
				if err := os.Remove(path); err == nil {
					removedCount++
					fmt.Printf("Removed empty directory: %s\n", path)
				}
			}

			return nil
		})
	}

	// Remove the root directory if it's empty
	if isEmptyDir(directory) {
		if err := os.Remove(directory); err == nil {
			removedCount++
			fmt.Printf("Removed empty directory: %s\n", directory)
		}
	}

	return removedCount
}

func isEmptyDir(dir string) bool {
	entries, err := ioutil.ReadDir(dir)
	if err != nil {
		return false
	}
	return len(entries) == 0
}

// Usage Examples
func main() {
	fmt.Println("=== Web Go Directory Traversal Examples ===\n")

	// 1. List directory contents
	fmt.Println("--- 1. List Directory Contents ---")
	contents, err := ListDirectoryContents(".", false)
	if err == nil {
		fmt.Printf("Files: %d\n", len(contents.Files))
		fmt.Printf("Directories: %d\n", len(contents.Directories))
	}

	// 2. Directory tree
	fmt.Println("\n--- 2. Directory Tree ---")
	tree, err := ListDirectoryTree(".", 2)
	if err == nil {
		PrintDirectoryTree(tree, 0)
	}

	// 3. Find files by pattern
	fmt.Println("\n--- 3. Find Files by Pattern ---")
	txtFiles, err := FindFilesByExtension(".", "txt")
	if err == nil {
		fmt.Printf("Text files: %d\n", len(txtFiles))
	}

	// 4. Directory statistics
	fmt.Println("\n--- 4. Directory Statistics ---")
	stats, err := GetDirectoryStatistics(".")
	if err == nil {
		fmt.Printf("Total files: %d\n", stats.TotalFiles)
		fmt.Printf("Total size: %s\n", FormatFileSize(stats.TotalSize))
		fmt.Printf("Extensions: %v\n", stats.ExtensionCounts)
	}

	// 5. Search in directory
	fmt.Println("\n--- 5. Search in Directory ---")
	searchResults, err := SearchInDirectory(".", "TODO", "*.txt")
	if err == nil {
		fmt.Printf("Files containing 'TODO': %d\n", len(searchResults))
	}

	// 6. Compare directories
	fmt.Println("\n--- 6. Compare Directories ---")
	comparison, err := CompareDirectories("dir1", "dir2")
	if err == nil {
		fmt.Printf("Only in dir1: %d\n", len(comparison.OnlyInDir1))
		fmt.Printf("Only in dir2: %d\n", len(comparison.OnlyInDir2))
		fmt.Printf("Different: %d\n", len(comparison.Different))
	}

	// 7. Cleanup
	fmt.Println("\n--- 7. Cleanup ---")
	deleted, _ := CleanupDirectory(".", true, []string{"*.tmp"})
	fmt.Printf("Would delete %d files\n", len(deleted))

	fmt.Println("\n=== All Directory Traversal Examples Completed ===")
}

// FormatFileSize formats file size in human-readable format
func FormatFileSize(bytes int64) string {
	const (
		KB = 1024
		MB = KB * 1024
		GB = MB * 1024
	)

	switch {
	case bytes >= GB:
		return fmt.Sprintf("%.2f GB", float64(bytes)/float64(GB))
	case bytes >= MB:
		return fmt.Sprintf("%.2f MB", float64(bytes)/float64(MB))
	case bytes >= KB:
		return fmt.Sprintf("%.2f KB", float64(bytes)/float64(KB))
	default:
		return fmt.Sprintf("%d B", bytes)
	}
}

Ferramentas

Ferramentas frequentemente usadas com este exemplo

Relacionado

Coleções de exemplos relacionadas

Relacionado

Temas relacionados

Tema

Ajuste de codificação de imagens para peso, carregamento e entrega

Ajuste a profundidade de bits, a paleta e a transparência do PNG, escolha o carregamento JPEG progressivo ou baseline, configure os modos de qualidade do WebP e comprima o TIFF de arquivo até cada imagem caber no destino.

Tema

Validação de campos de email, telefone e código postal

Verifique a sintaxe de emails, telefones e códigos postais com contexto de país ou região para valores individuais e lotes, mantendo separado o resultado de formato, a entregabilidade, o alcance do telefone e a existência do endereço.

Tema

Tornar compatíveis arquivos antigos de voz e áudio

Identifique conflitos de codec, contêiner, amostragem, profundidade de bits e canais e escolha uma conversão verificável para o destino.

Tema

Verificação de Assinatura Destacada e Integridade de Arquivos

Gere ou reproduza o hash de um arquivo conhecido, compare-o com um checksum publicado e verifique uma assinatura Ed25519 destacada usando uma chave pública confiável por confirmação independente.

Início
Ferramentas3212
Exemplos593
Visualizações471
Visualizadores de arquivos103
Temas239
Etiquetas333
Imagens, áudio e vídeo657

Ferramentas de processamento, conversão e otimização de imagens, áudio e vídeo

Matemática, datas e finanças647

Calculadoras, ferramentas numéricas, lógica de datas, estatística e finanças

Design e cor298

Ferramentas de cor, layout, gráficos, estilo visual e apoio ao design

Texto e escrita209

Ferramentas de escrita, limpeza, formatação, extração e análise de texto

Desenvolvimento e Web193

Utilitários para desenvolvedores, rede, depuração web e automação

Conversão e codificação175

Ferramentas de conversão de formatos, arquivos, unidades, arquivos compactados e codificação

Lançamento de quiz de captação e transferência de contatos
Textos memoriais: revisão familiar e entrega para impressão
Hábitos privados: backup, restauração e revisão para partilha
De artigo a rascunhos de X e LinkedIn: revisão factual e entrega
Revisão de aula Markdown interativa e entrega offline

© 2026 Elysia Tools. Todos os direitos reservados.

DocumentaçãoPreçosSobreTermos de serviçoPolítica de privacidadeCookiesContato

Media

Conversor de MOV para MP4

Converte arquivos de vídeo MOV para formato MP4

Media

Conversor de MP4 para MOV

Converte arquivos de vídeo MP4 para formato MOV

Media

Remux inteligente

Reempacota contêineres com stream copy.

Media

Conversor de Video em Lote

Converta múltiplos arquivos de video entre diferentes formatos como MP4, WebM, MKV, AVI, MOV com configurações de qualidade e processamento em lote

Media

Vídeo para GIF Otimizado

Converte vídeos em formato GIF otimizado com configurações avançadas de compressão

Media

Cortador de Vídeo

Cortar e aparar clipes de vídeo com precisão, suportando múltiplos formatos e configurações de qualidade

Media

Espelhar Video Horizontalmente

Espelha o video da esquerda para direita mantendo o contêiner original e audio quando possivel

Media

Extrator de Streams de Video

Verifica streams antes e extrai audio, video sem audio ou ambos sem transcodificacao

Python

Exemplos de Operações de Arquivo Web Python

Exemplos de operações de arquivo Web Python incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo

Rust

Exemplos de Operações de Arquivo Web Rust

Exemplos de operações de arquivo Web Rust incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo

TypeScript

Exemplos de Operações de Arquivo Web TypeScript

Exemplos de operações de arquivo Web TypeScript incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo

Java

Exemplos de Operações de Arquivo Android Java

Exemplos de operações de arquivo Android Java incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo

Kotlin

Exemplos de Operações de Arquivo Android Kotlin

Exemplos de operações de arquivo Android Kotlin incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo

Objective-C

Exemplos de Operações de Arquivo macOS Objective-C

Exemplos de operações de arquivo macOS Objective-C incluindo leitura/escrita de arquivo de texto, copiar/mover, travessia de diretório e validação de arquivo