异常处理 #

try
    statements
catch e
    handle_error(e)
end

try
    x = 1 / 0
catch e
    println("Error: $e")
end

try
    parse(Int, "abc")
catch e
    if e isa ArgumentError
        println("Invalid argument")
    else
        rethrow()
    end
end

function divide(a, b)
    b == 0 && throw(DivideError())
    return a / b
end

divide(10, 0)

function validate_age(age)
    age < 0 && error("Age cannot be negative")
    age > 150 && error("Age seems unrealistic")
    return age
end

validate_age(-1)

throw(ArgumentError("Invalid argument"))
throw(DomainError(-1, "sqrt expects non-negative"))
throw(ErrorException("Something went wrong"))
throw(BoundsError([1, 2, 3], 5))
throw(DivideError())

Exception
├── ArgumentError
├── BoundsError
├── CompositeException
├── DivideError
├── DomainError
├── EOFError
├── ErrorException
├── InexactError
├── InitError
├── InterruptException
├── InvalidStateException
├── KeyError
├── LoadError
├── OutOfMemoryError
├── ReadOnlyMemoryError
├── RemoteException
├── MethodError
├── OverflowError
├── ParseError
├── StackOverflowError
├── SystemError
├── TypeError
├── UndefKeywordError
├── UndefRefError
├── UndefVarError
└── StringIndexError

ArgumentError("message")
DomainError(value, "message")
BoundsError(array, index)
KeyError(key)
MethodError(f, args)
TypeError(:func, :arg, expected, got)
UndefVarError(:variable)

file = nothing
try
    file = open("data.txt", "r")
    process(file)
catch e
    println("Error: $e")
finally
    file !== nothing && close(file)
end

function process_file(filename)
    file = open(filename, "r")
    try
        return read(file, String)
    finally
        close(file)
    end
end

struct MyError <: Exception
    message::String
    code::Int
end

Base.showerror(io::IO, e::MyError) = print(io, "MyError($(e.code)): $(e.message)")

function process(x)
    x < 0 && throw(MyError("Value cannot be negative", 1001))
    return sqrt(x)
end

try
    process(-1)
catch e
    if e isa MyError
        println("Code $(e.code): $(e.message)")
    else
        rethrow()
    end
end

function safe_parse(s, default=nothing)
    try
        parse(Int, s)
    catch
        default
    end
end

safe_parse("123", 0)
safe_parse("abc", 0)

function with_retry(f, max_attempts=3)
    for attempt in 1:max_attempts
        try
            return f()
        catch e
            attempt == max_attempts && rethrow()
            println("Attempt $attempt failed: $e")
            sleep(1)
        end
    end
end

function validate_all(validators)
    errors = String[]
    for (name, validator) in validators
        try
            validator()
        catch e
            push!(errors, "$name: $e")
        end
    end
    return errors
end

function safe_divide(a, b)
    try
        a / b
    catch e
        if e isa DivideError
            return Inf
        else
            rethrow()
        end
    end
end

safe_divide(10, 2)
safe_divide(10, 0)

function read_config(filename)
    try
        content = read(filename, String)
        return eval(Meta.parse(content))
    catch e
        if e isa SystemError
            println("File not found: $filename")
            return Dict{String, Any}()
        else
            println("Parse error: $e")
            rethrow()
        end
    end
end

struct ValidationError <: Exception
    field::Symbol
    message::String
end

function validate_user(data)
    isempty(get(data, :name, "")) && throw(ValidationError(:name, "Name is required"))
    age = get(data, :age, 0)
    age < 0 && throw(ValidationError(:age, "Age cannot be negative"))
    age > 150 && throw(ValidationError(:age, "Age seems unrealistic"))
    return true
end

try
    validate_user(Dict(:name => "", :age => 25))
catch e
    if e isa ValidationError
        println("Validation failed: $(e.field) - $(e.message)")
    end
end