Python 프로그래머를 위한 TypeScript에 대한 간단한 소개

# Python: You hope this works
def process_user(user):
    return user.name.upper()

// TypeScript: You know this works
function processUser(user: User): string {
    return user.name.toUpperCase();
}

# Python
name = "Alice"
age = 30
is_active = True
scores = [95, 87, 92]
user = {"name": "Bob", "age": 25}

// TypeScript
const name = "Alice";          // string (inferred)
const age = 30;                // number (inferred)
const isActive = true;         // boolean (inferred)
const scores = [95, 87, 92];   // number[] (inferred)
const user = { name: "Bob", age: 25 }; // object (inferred)

// Or be explicit
const name: string = "Alice";
const scores: number[] = [95, 87, 92];

# Python
def greet(name: str, excited: bool = False) -> str:
    suffix = "!" if excited else "."
    return f"Hello, {name}{suffix}"

// TypeScript
function greet(name: string, excited = false): string {
    const suffix = excited ? "!" : ".";
    return `Hello, ${name}${suffix}`;
}

// Or arrow function (Python lambda equivalent)
const greet = (name: string, excited = false): string => 
    `Hello, ${name}${excited ? "!" : "."}`;

# Python
class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email
    
    def greet(self) -> str:
        return f"Hi, I'm {self.name}"

// TypeScript
class User {
    constructor(public name: string, public email: string) {}
    
    greet(): string {
        return `Hi, I'm ${this.name}`;
    }
}

# Python
from typing import Union
def process_id(user_id: Union[str, int]) -> str:
    return str(user_id)

// TypeScript
function processId(userId: string | number): string {
    return userId.toString();
}

# Python
from typing import Literal
Status = Literal["pending", "approved", "rejected"]

def update_status(status: Status) -> None:
    print(f"Status: {status}")

// TypeScript
type Status = "pending" | "approved" | "rejected";

function updateStatus(status: Status): void {
    console.log(`Status: ${status}`);
}

# Python
from dataclasses import dataclass

@dataclass
class User:
    name: str
    email: str
    age: int

// TypeScript
interface User {
    name: string;
    email: string;
    age: number;
}

// Use it anywhere
const user: User = { name: "Alice", email: "[email protected]", age: 30 };

# Python
from typing import TypeVar, List
T = TypeVar('T')

def first(items: List[T]) -> T:
    return items[0]

// TypeScript
function first(items: T[]): T {
    return items[0];
}

// Works with anything
const firstNumber = first([1, 2, 3]);      // number
const firstString = first(["a", "b", "c"]);  // string

function isString(value: unknown): value is string {
    return typeof value === "string";
}

function processValue(value: string | number) {
    if (isString(value)) {
        return value.toUpperCase();
    }
    return value.toFixed(2);
}

type User = {
    name: string;
    email: string;
    age: number;
};

// Make all properties optional
type PartialUser = Partial;

// Make all properties readonly
type ReadonlyUser = Readonly;

// Pick specific properties
type UserContact = Pick;

// Result type pattern (inspired by Rust)
type Result = { success: true; data: T } | { success: false; error: E };

// Make this file a module
export {};

// Assuming you have a User type and parseUser function
interface User {
    name: string;
    // ... other properties
}

function parseUser(data: unknown): User {
    // Your parsing logic here
    // This should throw an error if parsing fails
    if (!data || typeof data !== 'object') {
        throw new Error('Invalid user data');
    }
    
    const user = data as any;
    if (!user.name || typeof user.name !== 'string') {
        throw new Error('User name is required and must be a string');
    }
    
    return { name: user.name };
}

async function safeParseUser(data: unknown): Promise> {
    try {
        const user = parseUser(data);
        return { success: true, data: user };
    } catch (error) {
        // Fix: Handle the case where error might not have a message property
        const errorMessage = error instanceof Error ? error.message : String(error);
        return { success: false, error: errorMessage };
    }
}

// Usage (wrapped in an async function or use at top level in a module)
async function example() {
    const rawData = { name: "John Doe" }; // Example data
    const result = await safeParseUser(rawData);

    if (result.success) {
        console.log(result.data.name); // TypeScript knows this is User
    } else {
        console.error(result.error);   // TypeScript knows this is string
    }
}

// Call the example function
example();