error-handling-patterns

預期結果:

Here is a pattern for robust file handling with proper error hierarchy:

**Python Example:**
```python
class FileReadError(ApplicationError):
"""Raised when file read operations fail."""
pass

class ParseError(ApplicationError):
"""Raised when JSON parsing fails."""
pass

def read_json_file(path: str) -> dict:
try:
with open(path, 'r') as f:
content = f.read()
return json.loads(content)
except FileNotFoundError as e:
raise FileReadError(f"File not found: {path}", details={"path": path}) from e
except json.JSONDecodeError as e:
raise ParseError(f"Invalid JSON in file: {path}", details={"path": path, "error": str(e)}) from e
```

**Key practices:**
- Use specific exception types for different error scenarios
- Include contextual information in exceptions
- Chain exceptions to preserve original stack trace
- Use context managers for automatic resource cleanup

預期結果:

For parallel service calls, consider these strategies:

**Option 1: Aggregate Errors**
Collect all errors and report them together rather than failing on the first error.

```typescript
async function fetchUserData(userId: string): Promise<UserData> {
const errors: Error[] = [];
let user: User | null = null;
let orders: Order[] = [];

try { user = await userService.getUser(userId); }
catch (e) { errors.push(e); }

try { orders = await orderService.getOrders(userId); }
catch (e) { errors.push(e); }

if (errors.length > 0) {
throw new AggregateError(errors, `${errors.length} operations failed`);
}

return { user, orders };
}
```

**Option 2: Result Types**
Use explicit success/failure types for each operation.

```typescript
async function fetchUserData(userId: string): Promise<Result<UserData>> {
const [userResult, ordersResult] = await Promise.all([
safePromise(userService.getUser(userId)),
safePromise(orderService.getOrders(userId))
]);

if (!userResult.ok) return Err(userResult.error);
if (!ordersResult.ok) return Err(ordersResult.error);

return Ok({ user: userResult.value, orders: ordersResult.value });
}
```

預期結果:

Here are the most dangerous anti-patterns and their fixes:

**Anti-Pattern 1: Empty Catch Blocks**
```python
try:
do_something()
except:
pass # Silent failure - bugs hide forever
```
**Fix:** Always log or re-raise exceptions.

**Anti-Pattern 2: Catching Too Broadly**
```python
try:
do_something()
except Exception:
# Hides bugs including typos and logic errors
pass
```
**Fix:** Catch specific exception types only.

**Anti-Pattern 3: Swallowing After Logging**
```python
try:
do_something()
except Exception as e:
logger.error(e)
# Error logged but not handled - caller doesn't know it failed
```
**Fix:** Re-raise or return error result.

**Anti-Pattern 4: Overly Generic Errors**
```python
raise Exception("Error occurred") # No context, no code, useless for debugging
```
**Fix:** Include what happened, what was being processed, and error codes.