How to validate command line input

Introduction

In the world of Golang command-line interface (CLI) development, input validation is crucial for creating robust and secure applications. This tutorial explores comprehensive strategies for validating and processing command-line inputs, helping developers build more reliable and user-friendly Golang CLI tools.

Skills Graph

CLI Input Basics

Understanding Command-Line Arguments

Command-line input is a fundamental way for users to interact with command-line interface (CLI) applications. In Golang, command-line arguments are passed to the program when it is executed and can be accessed through the os.Args slice.

Basic Argument Retrieval

Here's a simple example of how to access command-line arguments:

package main

import (
    "fmt"
    "os"
)

func main() {
    // os.Args[0] is the program name itself
    // os.Args[1:] contains the actual arguments
    args := os.Args[1:]
    
    fmt.Println("Number of arguments:", len(args))
    
    for i, arg := range args {
        fmt.Printf("Argument %d: %s\n", i, arg)
    }
}

Argument Types and Parsing

Command-line arguments are typically passed as strings. For different types of inputs, you'll need to parse them:

Common Argument Patterns

Using the flag Package

Golang's standard library provides a more robust way to handle command-line arguments:

package main

import (
    "flag"
    "fmt"
)

func main() {
    // Define flags
    name := flag.String("name", "Guest", "Your name")
    age := flag.Int("age", 0, "Your age")
    
    // Parse the flags
    flag.Parse()
    
    fmt.Printf("Name: %s, Age: %d\n", *name, *age)
}

Best Practices

1. Always validate and sanitize input
2. Provide clear usage instructions
3. Handle potential parsing errors
4. Use meaningful flag names

Error Handling Considerations

When working with CLI inputs, always anticipate and handle potential errors:

package main

import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Usage: program <number>")
        os.Exit(1)
    }
    
    num, err := strconv.Atoi(os.Args[1])
    if err != nil {
        fmt.Println("Invalid input. Please provide a number.")
        os.Exit(1)
    }
    
    fmt.Println("Parsed number:", num)
}

Tip: When developing CLI applications on LabEx, always test your input validation thoroughly to ensure robust and user-friendly interfaces.

Validation Strategies

Input Validation Overview

Input validation is crucial for ensuring the reliability and security of command-line applications. Proper validation helps prevent unexpected behavior and potential security vulnerabilities.

Validation Approaches

Basic Validation Techniques

Type Validation

package main

import (
    "fmt"
    "strconv"
)

func validateInteger(input string) (int, error) {
    num, err := strconv.Atoi(input)
    if err != nil {
        return 0, fmt.Errorf("invalid integer input: %v", err)
    }
    return num, nil
}

func main() {
    input := "123"
    value, err := validateInteger(input)
    if err != nil {
        fmt.Println("Validation failed:", err)
        return
    }
    fmt.Println("Valid integer:", value)
}

Range Validation

func validateAge(age int) error {
    if age < 0 || age > 120 {
        return fmt.Errorf("age must be between 0 and 120")
    }
    return nil
}

Advanced Validation Strategies

Regular Expression Validation

package main

import (
    "fmt"
    "regexp"
)

func validateEmail(email string) bool {
    pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
    match, _ := regexp.MatchString(pattern, email)
    return match
}

func main() {
    emails := []string{
        "[email protected]",
        "invalid-email",
    }

    for _, email := range emails {
        if validateEmail(email) {
            fmt.Printf("%s is a valid email\n", email)
        } else {
            fmt.Printf("%s is an invalid email\n", email)
        }
    }
}

Validation Strategy Comparison

Complex Validation Example

package main

import (
    "fmt"
    "strings"
)

type UserInput struct {
    Username string
    Password string
}

func (u UserInput) Validate() error {
    // Username validation
    if len(u.Username) < 3 || len(u.Username) > 20 {
        return fmt.Errorf("username must be between 3 and 20 characters")
    }

    // Password complexity validation
    if len(u.Password) < 8 {
        return fmt.Errorf("password must be at least 8 characters long")
    }

    if !strings.ContainsAny(u.Password, "!@#$%^&*()") {
        return fmt.Errorf("password must contain at least one special character")
    }

    return nil
}

func main() {
    input := UserInput{
        Username: "johndoe",
        Password: "secure!Pass123",
    }

    if err := input.Validate(); err != nil {
        fmt.Println("Validation error:", err)
        return
    }

    fmt.Println("Input is valid")
}

Best Practices

1. Always validate inputs before processing
2. Use multiple validation layers
3. Provide clear error messages
4. Handle edge cases

Tip: When developing on LabEx, implement comprehensive validation to ensure robust CLI applications.

Error Handling

Error Handling Fundamentals

Error handling is a critical aspect of robust CLI application development in Golang. Proper error management ensures graceful application behavior and provides meaningful feedback to users.

Error Handling Workflow

Basic Error Handling Patterns

Simple Error Checking

package main

import (
    "fmt"
    "os"
    "strconv"
)

func parseArgument(arg string) (int, error) {
    value, err := strconv.Atoi(arg)
    if err != nil {
        return 0, fmt.Errorf("invalid input: %s", arg)
    }
    return value, nil
}

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Usage: program <number>")
        os.Exit(1)
    }

    number, err := parseArgument(os.Args[1])
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(1)
    }

    fmt.Println("Parsed number:", number)
}

Advanced Error Handling Techniques

Custom Error Types

package main

import (
    "fmt"
    "errors"
)

type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("%s: %s", e.Field, e.Message)
}

func validateInput(input string) error {
    if len(input) < 3 {
        return &ValidationError{
            Field:   "Input",
            Message: "must be at least 3 characters long",
        }
    }
    return nil
}

func main() {
    err := validateInput("hi")
    if err != nil {
        var validationErr *ValidationError
        if errors.As(err, &validationErr) {
            fmt.Println("Validation Error:", validationErr)
        }
    }
}

Error Handling Strategies

Error Wrapping and Context

package main

import (
    "fmt"
    "errors"
)

func performOperation() error {
    err := innerFunction()
    if err != nil {
        return fmt.Errorf("operation failed: %w", err)
    }
    return nil
}

func innerFunction() error {
    return errors.New("specific error occurred")
}

func main() {
    err := performOperation()
    if err != nil {
        fmt.Println("Error:", err)
    }
}

Logging Errors

package main

import (
    "log"
    "os"
)

func main() {
    // Configure error logging
    errorLog := log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)

    // Example error logging
    err := someFunction()
    if err != nil {
        errorLog.Printf("Operation failed: %v", err)
        os.Exit(1)
    }
}

func someFunction() error {
    // Simulated error
    return fmt.Errorf("something went wrong")
}

Best Practices

1. Always handle errors explicitly
2. Provide clear and informative error messages
3. Use custom error types when appropriate
4. Log errors for debugging
5. Handle errors at the right level of abstraction

Tip: When developing on LabEx, implement comprehensive error handling to create resilient CLI applications.

Summary

Mastering command-line input validation in Golang requires a systematic approach to parsing, checking, and handling user inputs. By implementing robust validation techniques, error handling mechanisms, and thoughtful input processing strategies, developers can create more resilient and user-friendly command-line applications that gracefully manage unexpected or invalid inputs.