Code Language Converter

CODE CONVERSION: Python -> JavaScript

    CONVERTED CODE:
    ----------------
    function calculateAverage(numbers) {
      // Python's sum([]) returns 0, but JS reduce() throws on empty arrays
      // without an initial value — so we handle the empty case explicitly.
      if (!numbers || numbers.length === 0) {
        return 0;
      }
      return numbers.reduce((sum, n) => sum + n, 0) / numbers.length;
    }

    function filterEven(numbers) {
      // Python list comprehension -> JS .filter() chain
      return numbers.filter((n) => n % 2 === 0);
    }
    ----------------

    IMPORTANT DIFFERENCES:
    • Empty array handling — Python's sum([]) returns 0; JS reduce() throws without an initial value. Converted code explicitly checks length.
    • Naming convention — Python uses snake_case (calculate_average); JavaScript uses camelCase (calculateAverage).
    • Null vs undefined — JS has both null and undefined; Python only has None. Added a "!numbers" check to handle either.
    • Strict equality — Used === not == to avoid JS type coercion bugs.
    • Division by zero — Python raises ZeroDivisionError; JS returns Infinity or NaN. Explicit length check prevents NaN.

    REQUIRED IMPORTS/PACKAGES:
    • None — uses only built-in JS array methods.

    NOTES:
    Python's list comprehensions are one of its most distinctive features. In JavaScript, the closest equivalents are .map(), .filter(), and .reduce() used together. If you're converting many list comprehensions, it's worth learning those patterns thoroughly — they're foundational to idiomatic JS.

CODE CONVERSION: JavaScript -> Python

    CONVERTED CODE:
    ----------------
    import asyncio
    import aiohttp

    async def fetch_users(ids):
        # Fetch multiple users concurrently and return only active ones.
        # Uses aiohttp for HTTP and asyncio.gather for concurrency.
        async with aiohttp.ClientSession() as session:
            tasks = [_fetch_user(session, user_id) for user_id in ids]
            users = await asyncio.gather(*tasks)

        # JS .filter() -> Python list comprehension with condition
        return [user for user in users if user.get("active")]

    async def _fetch_user(session, user_id):
        async with session.get(f"/api/users/{user_id}") as response:
            return await response.json()
    ----------------

    IMPORTANT DIFFERENCES:
    • Async model — Python's asyncio is more explicit than JavaScript's Promise model. You need an event loop running (asyncio.run()) and the "async with" context manager for resource cleanup.
    • HTTP library — Python has no built-in fetch(). aiohttp is the standard async HTTP library.
    • Concurrency primitive — JS Promise.all() maps to Python asyncio.gather(). Python requires unpacking the task list with *tasks.
    • Naming — camelCase (fetchUsers) becomes snake_case (fetch_users).
    • Truthiness — Python's list comprehension condition uses user.get("active") to return None instead of raising KeyError.
    • Return type — Python version returns a list; JS version returns a Promise that resolves to a list.

    REQUIRED IMPORTS/PACKAGES:
    • aiohttp — install with pip install aiohttp

    NOTES:
    JavaScript allows top-level await in modules; Python requires you to explicitly run an event loop. Wrap the top-level call in asyncio.run(...). Python's async ecosystem for HTTP is less mature than JS — httpx is a modern alternative to aiohttp with better sync/async symmetry.

CODE CONVERSION: Java -> TypeScript

    CONVERTED CODE:
    ----------------
    export class UserService {
      constructor(private readonly repo: UserRepository) {}

      findById(id: number | null): User | null {
        if (id === null || id === undefined || id < 0) {
          return null;
        }
        return this.repo.findById(id);
      }
    }

    export interface User {
      id: number;
      name: string;
      email: string;
    }

    export interface UserRepository {
      findById(id: number): User | null;
    }
    ----------------

    IMPORTANT DIFFERENCES:
    • Optional<T> — Java's Optional is a container type with .isPresent() and .map() methods. TypeScript uses union types (User | null) instead — no wrapper object.
    • Long vs number — Java's Long is a 64-bit integer. TypeScript's number is a 64-bit float, safe only up to 2^53. Use BigInt for larger IDs.
    • Constructor injection — TypeScript supports parameter properties, declaring the private readonly field directly in the constructor signature.
    • final keyword — Java's "final" field modifier maps to TypeScript's "readonly" modifier.
    • Null vs undefined — Java has only null; TypeScript has both. The converted code checks for either.
    • Visibility — Java defaults to package-private; TypeScript defaults to public. Every non-public member must be marked explicitly.

    REQUIRED IMPORTS/PACKAGES:
    • None — uses only built-in TypeScript types.

    NOTES:
    Java's Optional is used to force callers to handle the "no value" case explicitly. TypeScript's union types provide similar safety but differently: the compiler enforces a null check before use when strictNullChecks is enabled in tsconfig.json — highly recommended. For large migrations, look at ts-morph or similar tools for bulk conversion, but for individual classes hand-conversion with AI produces more idiomatic results.