1
2
3
4
5
6
7

enum MyError: Error { case failed(String) }

func load(_ path: String) throws -> String {
    throw MyError.failed("missing: \(path)")
}

let r: Result<String, Error> = Result { try load("a.txt") }

1
2
3
4
5
6
7

func load(path string) (string, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return "", fmt.Errorf("load %s: %w", path, err)
    }
    return string(data), nil
}

1
2
3
4
5
6
7
8
9

class ConfigError(Exception):
    def __init__(self, key: str):
        super().__init__(f"missing key: {key}")
        self.key = key

def load(cfg: dict) -> str:
    if "path" not in cfg:
        raise ConfigError("path")
    return cfg["path"]

1
2
3
4
5
6

fun load(path: String): Result<String> = runCatching {
    require(path.isNotEmpty()) { "empty path" }
    File(path).readText()
}

val text = load("a.txt").getOrElse { "default" }

1
2
3
4

public String load(Path p) throws IOException {   // checked：必须声明
    if (!Files.exists(p)) throw new IllegalArgumentException("missing");  // unchecked
    return Files.readString(p);
}

1
2
3
4
5
6
7
8

#include <expected>

std::expected<int, std::string> parse(std::string_view s) {
    if (s.empty()) return std::unexpected("empty");
    return 42;
}

if (auto v = parse("42")) { /* 用 *v */ }

1
2
3
4
5
6
7
8

#include <errno.h>
#include <stdio.h>

FILE *f = fopen("a.txt", "r");
if (!f) {
    fprintf(stderr, "open failed: %s\n", strerror(errno));
    return -1;
}

1
2
3
4
5

function parse_port(s::AbstractString)
    v = tryparse(Int, s)
    v === nothing && throw(ArgumentError("bad port: $s"))
    return v
end

1
2
3
4
5
6

public bool TryLoad(string path, out string content) {
    content = "";
    if (!File.Exists(path)) return false;   // Try 模式：失败不抛异常
    content = File.ReadAllText(path);
    return true;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

int parsePort(String s) {
  final v = int.tryParse(s);
  if (v == null) throw FormatException('bad port: $s');
  return v;
}

void main() {
  try {
    print(parsePort('x'));
  } on FormatException catch (e) {
    print('caught: $e');
  } finally {
    print('done');
  }
}

1
2
3
4
5
6
7

safe_log <- function(x) {
  if (x <= 0) stop("x must be positive", call. = FALSE)
  log(x)
}

r <- tryCatch(safe_log(-1), error = function(e) NA_real_)
print(r)   # NA

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

const ParseError = error{ Empty, TooLong };

fn parsePort(s: []const u8) ParseError!u16 {
    if (s.len == 0) return error.Empty;
    if (s.len > 5) return error.TooLong;
    return 8080;
}

pub fn main() void {
    const port = parsePort("") catch 8080;   // 失败就给默认值
    _ = port;
}

1
2
3
4
5
6
7
8

local function parse_port(s)
  local n = tonumber(s)
  if not n then error("bad port: " .. tostring(s)) end
  return n
end

local ok, err = pcall(parse_port, "x")
if not ok then print("caught: " .. tostring(err)) end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

function parsePort(s: string): number {
  const n = Number(s);
  if (!Number.isInteger(n)) throw new Error(`bad port: ${s}`);
  return n;
}

try {
  parsePort("x");
} catch (e: unknown) {
  if (e instanceof Error) console.error(e.message);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

async function load(path) {
  if (!path) throw new Error("empty path");
  return await fs.readFile(path, "utf8");
}

try {
  await load("");
} catch (e) {
  console.error(e instanceof Error ? e.message : e);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

function load(string $path): string {
    if (!is_file($path)) {
        throw new RuntimeException("missing: $path");
    }
    return file_get_contents($path);
}

try {
    echo load("a.txt");
} catch (RuntimeException $e) {
    error_log($e->getMessage());
} finally {
    echo "done\n";
}

1
2
3
4
5
6
7
8
9

def load(path)
  raise ArgumentError, "empty path" if path.to_s.empty?
  File.read(path)
rescue Errno::ENOENT => e
  warn "missing: #{e.message}"
  nil
ensure
  puts "done"
end

1
2
3
4
5
6
7
8

enum LoadError: Error { case missing(String) }

func load(_ path: String) throws -> String {
    if path.isEmpty { throw LoadError.missing(path) }
    return try String(contentsOfFile: path)      // try 继续传播
}

let text = try? load("")        // 失败变 nil

1
2
3
4
5
6
7

func load(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("load %s: %w", path, err)   // 包装并保留原因
    }
    return data, nil
}

1
2
3
4
5

def load(path: str) -> str:
    try:
        return open(path).read()
    except OSError as e:
        raise RuntimeError(f"cannot load {path}") from e   # 保留原因

1
2
3
4
5
6

fun load(path: String): String {
    require(path.isNotEmpty()) { "empty path" }   // 抛 IllegalArgumentException
    return File(path).readText()                   // kotlin.io 会抛异常
}

fun loadSafe(path: String): Result<String> = runCatching { load(path) }

1
2
3
4
5
6
7

public String load(Path p) throws IOException {   // checked：显式声明
    if (Files.notExists(p)) throw new NoSuchFileException(p.toString());
    return Files.readString(p);
}

// 想把 checked 变 unchecked（跨层简化）：
throw new UncheckedIOException(e);

1
2
3
4
5
6
7
8

struct LoadError : std::runtime_error {
    using std::runtime_error::runtime_error;
};

std::string load(const std::string& path) {
    if (path.empty()) throw LoadError("empty path");
    return read_file(path);     // 内部异常自动向外展开
}

1
2
3
4
5
6
7

int load(const char *path, char **out) {
    FILE *f = fopen(path, "r");
    if (!f) return -1;                 /* 上层继续检查 -1 */
    /* ... */
    fclose(f);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

function load(path::AbstractString)
    isfile(path) || throw(ArgumentError("missing: $path"))
    read(path, String)
end

try
    load("a.txt")
catch err
    @warn "load failed" exception = (err, catch_backtrace())
    rethrow()        # 记录之后继续向上抛
end

1
2
3
4
5
6
7
8
9

public string Load(string path) {
    if (!File.Exists(path)) throw new FileNotFoundException(path);
    return File.ReadAllText(path);
}

try { Load("a.txt"); }
catch (IOException e) when (e is not FileNotFoundException) {
    throw;                 // 保留原始堆栈
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Future<String> load(String path) async {
  if (path.isEmpty) throw ArgumentError('empty path');
  return await File(path).readAsString();   // 异常进入 Future
}

try {
  await load('');
} catch (e) {
  rethrow;        // 保留原始堆栈重新抛出
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

load_cfg <- function(path) {
  if (!file.exists(path)) {
    cond <- structure(
      class = c("configError", "error", "condition"),
      list(message = paste("missing:", path), call = NULL)
    )
    stop(cond)
  }
  readRDS(path)
}

1
2
3
4
5
6
7
8

const LoadError = error{ Missing, Empty };

fn load(path: []const u8) (LoadError || std.fs.File.OpenError)![]u8 {
    if (path.len == 0) return error.Empty;
    const f = try std.fs.cwd().openFile(path, .{});   // try 继续传播
    defer f.close();
    return try f.readToEndAlloc(std.heap.page_allocator, 1 << 20);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

local function load(path)
  local f, err = io.open(path, "r")
  if not f then return nil, err end        -- 惯例：返回 nil + 错误
  local data = f:read("a")
  f:close()
  return data
end

local ok, err = pcall(function() error("boom") end)
if not ok then print("caught:", err) end

1
2
3
4
5
6
7

async function load(path: string): Promise<string> {
  if (!path) throw new Error("empty path");
  return await fs.readFile(path, "utf8");
}

// 传播 = 调用方 await 时被抛出
await load("");

1
2
3
4
5
6

async function load(path) {
  if (!path) throw new Error("empty path");
  return await fs.readFile(path, "utf8");
}

load("").catch((e) => console.error("async:", e.message));   // Promise 传播

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

function load(string $path): string {
    if (!is_file($path)) {
        throw new RuntimeException("missing: $path");
    }
    return file_get_contents($path);
}

set_exception_handler(function (Throwable $e): void {
    error_log("uncaught: " . $e->getMessage());
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def load(path)
  raise ArgumentError, "empty path" if path.to_s.empty?
  File.read(path)
rescue ArgumentError
  raise                    # 重新抛出当前异常
end

begin
  load("")
rescue => e
  puts "#{e.class}: #{e.message}"
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

do {
    let text = try load("a.txt")
    print(text)
} catch LoadError.missing(let p) {
    print("missing: \(p)")
} catch {
    print("other: \(error)")
} 

defer { print("cleanup") }      // 退出作用域时执行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

data, err := os.ReadFile("a.txt")
if err != nil {
    if errors.Is(err, os.ErrNotExist) {          // 判断具体原因
        log.Println("missing")
    }
    var pathErr *os.PathError
    if errors.As(err, &pathErr) {                 // 取回具体错误类型
        log.Println("path:", pathErr.Path)
    }
    return
}

1
2
3
4
5

defer func() {
    if r := recover(); r != nil {                 // 兜住 panic
        log.Println("recovered:", r)
    }
}()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

try:
    text = open("a.txt").read()
except FileNotFoundError as e:
    print("missing:", e.filename)
except (OSError, ValueError) as e:      # 多类型捕获
    print("failed:", e)
else:
    print("ok, length:", len(text))      # 没有异常时执行
finally:
    print("done")                         # 一定执行

1
2
3
4
5

try:
    async with asyncio.TaskGroup() as tg:   # 异常组（3.11+）
        tg.create_task(work())
except* ValueError as eg:                    # 只接住组里的 ValueError
    print(eg.exceptions)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

val text = try {
    File("a.txt").readText()
} catch (e: java.io.FileNotFoundException) {
    "default"
} finally {
    println("done")
}

val len = runCatching { File("a.txt").readText() }
    .map { it.length }
    .getOrElse { 0 }

1
2
3
4
5
6
7
8
9

try (var in = Files.newInputStream(Path.of("a.txt"))) {   // 自动关闭
    in.readAllBytes();
} catch (FileNotFoundException | NoSuchFileException e) {  // multi-catch
    log.warn("missing", e);
} catch (IOException e) {
    throw new UncheckedIOException(e);
} finally {
    log.info("done");
}

1
2
3
4
5
6
7
8
9

try {
    auto text = load("a.txt");
} catch (const LoadError& e) {       // 按 const 引用捕获
    std::cerr << e.what() << '\n';
} catch (const std::exception& e) {
    std::cerr << "std: " << e.what() << '\n';
} catch (...) {                       // 兜底（不要吞掉后继续假装没事）
    std::cerr << "unknown\n";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int rc = 0;
FILE *f = fopen("a.txt", "r");
if (!f) { rc = -1; goto cleanup; }

char *buf = malloc(1024);
if (!buf) { rc = -2; goto cleanup; }

/* ... 使用 buf ... */

cleanup:
    free(buf);            /* free(NULL) 合法，所以可以无条件调用 */
    if (f) fclose(f);
    return rc;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

try
    v = parse(Int, "x")
catch err
    if err isa ArgumentError
        @warn "bad input" exception = err
    else
        rethrow()
    end
else
    @info "ok" value = v          # 没有异常时执行（1.8+）
finally
    @info "done"
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

try {
    var text = File.ReadAllText("a.txt");
}
catch (IOException e) when (e is FileNotFoundException) {
    Console.Error.WriteLine($"missing: {e.Message}");
}
catch (Exception e) {
    throw;                       // 保留堆栈
}
finally {
    Console.WriteLine("done");
}

1

using var stream = File.OpenRead("a.txt");   // 作用域结束自动 Dispose

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

try {
  final text = await load('a.txt');
} on FormatException catch (e, st) {     // 类型 + 对象 + 堆栈
  print('bad: ${e.message}');
  print(st);
} catch (e) {
  rethrow;                                // 保留原始堆栈
} finally {
  print('done');
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

res <- tryCatch(
  {
    readRDS("model.rds")
  },
  configError = function(e) { message("config problem"); NULL },
  error = function(e) { message("other: ", conditionMessage(e)); NULL },
  finally = message("done")
)

withCallingHandlers(
  log(-1),
  warning = function(w) message("warning: ", conditionMessage(w))
)

1
2
3
4
5
6
7
8
9

const value = parsePort("x") catch 8080;            // 默认值
const v2 = parsePort("x") catch |err| switch (err) { // 按错误分类
    error.Empty => 1,
    error.TooLong => 2,
};
const v3 = parsePort("x") catch |err| {
    std.log.err("failed: {}", .{err});
    return err;                                       // 记录后继续传播
};

1
2
3
4
5
6
7
8

local ok, err = pcall(load, "a.txt")
if not ok then
  print("caught:", err)
end

local ok2, err2 = xpcall(load, function(e)
  return debug.traceback(e, 2)     -- 附加堆栈
end, "a.txt")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

try {
  const text = await load("a.txt");
} catch (e: unknown) {
  if (e instanceof Error) console.error(e.message);        // 收窄
  else console.error("unknown error", e);
} finally {
  console.log("done");
}

const r = await load("a.txt").then(
  (v) => ({ ok: true, v }) as const,
  (e) => ({ ok: false, e }) as const,                       // 把失败当值
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

try {
  const text = await load("a.txt");
} catch (e) {
  console.error(e instanceof Error ? e.message : e);
} finally {
  console.log("done");
}

const results = await Promise.allSettled([load("a"), load("b")]);
for (const r of results) {
  if (r.status === "rejected") console.error(r.reason);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

try {
    $text = load("a.txt");
} catch (RuntimeException | Error $e) {      // 多 catch（含引擎 Error）
    error_log($e->getMessage());
} finally {
    echo "done\n";
}

set_error_handler(function (int $no, string $msg, string $file, int $line): bool {
    throw new ErrorException($msg, 0, $no, $file, $line);   // warning → 异常
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

begin
  text = load("a.txt")
rescue Errno::ENOENT => e
  warn "missing: #{e.message}"
  text = nil
rescue StandardError => e
  warn "other: #{e.class}"
else
  puts "ok"
ensure
  puts "done"            # 相当于 finally，一定执行
end

1
2
3
4
5

def load(path)
  File.read(path)
rescue Errno::ENOENT
  nil                    # 方法级 rescue（不用 begin/end）
end

1
2
3
4

struct AppError: Error, LocalizedError {
    let path: String
    var errorDescription: String? { "missing: \(path)" }
}

1
2
3
4
5

type ConfigError struct{ Key string }
func (e *ConfigError) Error() string { return "missing key: " + e.Key }

var ErrNotFound = errors.New("not found")            // 哨兵错误
err := errors.Join(ErrNotFound, io.ErrUnexpectedEOF)  // 合并错误（1.20+）

1
2
3
4
5

class AppError(Exception):
    def __init__(self, path: str, cause: Exception | None = None):
        super().__init__(f"load failed: {path}")
        self.path = path
        if cause: self.__cause__ = cause

1
2

with open("a.txt") as f:      # 上下文管理器：退出时自动关闭
    data = f.read()

1
2
3
4
5

class ConfigException(val key: String) : Exception("missing key: $key")

File("a.txt").bufferedReader().use { reader ->   // use：自动 close
    println(reader.readText())
}

1
2
3
4
5
6
7

class ConfigException extends RuntimeException {
    private final String key;
    ConfigException(String key) { super("missing key: " + key); this.key = key; }
    public String key() { return key; }
}

throw new ConfigException("path");                 // unchecked：不用声明

1
2
3
4
5
6
7
8

class ConfigError : public std::runtime_error {
public:
    explicit ConfigError(const std::string& key)
        : std::runtime_error("missing key: " + key), key_(key) {}
    const std::string& key() const { return key_; }
private:
    std::string key_;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

typedef enum { OK = 0, ERR_NOT_FOUND, ERR_IO, ERR_NOMEM } err_t;

static const char *err_str(err_t e) {
    switch (e) {
        case OK: return "ok";
        case ERR_NOT_FOUND: return "not found";
        case ERR_IO: return "io";
        case ERR_NOMEM: return "out of memory";
    }
    return "unknown";
}

1
2
3
4
5
6

struct ConfigError <: Exception
    key::String
end
Base.showerror(io::IO, e::ConfigError) = print(io, "missing key: ", e.key)

throw(ConfigError("path"))

1
2
3
4
5

public sealed class ConfigException : Exception {
    public string Key { get; }
    public ConfigException(string key, Exception? inner = null)
        : base($"missing key: {key}", inner) => Key = key;
}

1
2
3
4
5
6

class ConfigException implements Exception {
  final String key;
  ConfigException(this.key);
  @override
  String toString() => 'ConfigException: missing key $key';
}

1
2
3
4
5
6
7

new_config_error <- function(key) {
  structure(
    class = c("configError", "error", "condition"),
    list(message = paste("missing key:", key), call = NULL, key = key)
  )
}
stop(new_config_error("path"))

1
2
3
4
5
6
7

const ConfigError = error{ MissingKey, Empty };

fn load(path: []const u8) ConfigError!void {
    errdefer std.log.err("load failed: {s}", .{path});   // 只在错误路径执行
    if (path.len == 0) return error.Empty;
    return error.MissingKey;
}

1
2
3
4
5
6
7
8

local ConfigError = {}
ConfigError.__index = ConfigError

function ConfigError.new(key)
  return setmetatable({ message = "missing key: " .. key, key = key }, ConfigError)
end

error(ConfigError.new("path"))     -- 抛一个表

1
2
3
4
5
6

class ConfigError extends Error {
  constructor(public readonly key: string, options?: ErrorOptions) {
    super(`missing key: ${key}`, options);   // ES2022 的 cause
    this.name = "ConfigError";
  }
}

1
2
3
4
5
6
7
8
9

class ConfigError extends Error {
  constructor(key, options) {
    super(`missing key: ${key}`, options);
    this.name = "ConfigError";
    this.key = key;
  }
}

throw new ConfigError("path", { cause: new Error("io") });

1
2
3
4
5

class ConfigException extends RuntimeException {
    public function __construct(public readonly string $key, ?Throwable $previous = null) {
        parent::__construct("missing key: $key", 0, $previous);   // previous = cause
    }
}

1
2
3
4
5
6
7
8
9