📋 Syntax Cheat Sheet

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

# Ternary
result = "pass" if score >= 60 else "fail"

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else {
    grade = "C";
}

// Ternary
const result = score >= 60 ? "pass" : "fail";

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else {
    grade = "C";
}

// Ternary
string result = score >= 60 ? "pass" : "fail";

# For loop (range)
for i in range(5):         # 0, 1, 2, 3, 4
    print(i)

# For loop (over collection)
for item in items:
    print(item)

# For loop (with index)
for i, item in enumerate(items):
    print(f"{i}: {item}")

# While loop
while count < 10:
    count += 1

# Break and continue
for x in items:
    if x == "skip": continue
    if x == "stop": break

// For loop (classic)
for (let i = 0; i < 5; i++) {
    console.log(i);
}

// For...of (over collection)
for (const item of items) {
    console.log(item);
}

// forEach (with index)
items.forEach((item, i) => {
    console.log(`${i}: ${item}`);
});

// While loop
while (count < 10) {
    count++;
}

// Break and continue work the same

// For loop (classic)
for (int i = 0; i < 5; i++) {
    Console.WriteLine(i);
}

// Foreach (over collection)
foreach (var item in items) {
    Console.WriteLine(item);
}

// For loop with index
for (int i = 0; i < items.Count; i++) {
    Console.WriteLine($"{i}: {items[i]}");
}

// While loop
while (count < 10) {
    count++;
}

// Break and continue work the same

# Basic function
def greet(name):
    return f"Hello, {name}!"

# Default parameters
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

# Multiple return values
def divide(a, b):
    return a // b, a % b

quotient, remainder = divide(17, 5)

# Lambda
double = lambda x: x * 2

// Basic function
function greet(name) {
    return `Hello, ${name}!`;
}

// Default parameters
function greet(name, greeting = "Hello") {
    return `${greeting}, ${name}!`;
}

// Arrow function
const double = (x) => x * 2;

// Async function
async function fetchData(url) {
    const res = await fetch(url);
    return await res.json();
}

// Basic method
static string Greet(string name) {
    return $"Hello, {name}!";
}

// Default parameters
static string Greet(string name, string greeting = "Hello") {
    return $"{greeting}, {name}!";
}

// Expression body
static int Double(int x) => x * 2;

// Void (no return value)
static void PrintMessage(string msg) {
    Console.WriteLine(msg);
}

// Async method
static async Task<string> FetchData(string url) {
    return await client.GetStringAsync(url);
}

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name} says {self.sound}!"

    def __str__(self):
        return f"Animal({self.name})"

class Dog(Animal):              # Inheritance
    def __init__(self, name):
        super().__init__(name, "Woof")

    def speak(self):            # Override
        return f"{self.name} barks loudly!"

dog = Dog("Rex")
print(dog.speak())

class Animal {
    constructor(name, sound) {
        this.name = name;
        this.sound = sound;
    }

    speak() {
        return `${this.name} says ${this.sound}!`;
    }

    toString() {
        return `Animal(${this.name})`;
    }
}

class Dog extends Animal {       // Inheritance
    constructor(name) {
        super(name, "Woof");
    }

    speak() {                    // Override
        return `${this.name} barks loudly!`;
    }
}

const dog = new Dog("Rex");
console.log(dog.speak());

class Animal {
    public string Name { get; set; }
    public string Sound { get; set; }

    public Animal(string name, string sound) {
        Name = name; Sound = sound;
    }

    public virtual string Speak()    // virtual = overridable
        => $"{Name} says {Sound}!";

    public override string ToString()
        => $"Animal({Name})";
}

class Dog : Animal {                 // Inheritance
    public Dog(string name) : base(name, "Woof") { }

    public override string Speak()   // Override
        => $"{Name} barks loudly!";
}

var dog = new Dog("Rex");
Console.WriteLine(dog.Speak());

try:
    result = int(input("Number: "))
    print(10 / result)
except ValueError:
    print("Not a number!")
except ZeroDivisionError:
    print("Can't divide by zero!")
except Exception as e:
    print(f"Error: {e}")
finally:
    print("Always runs")

# Raise an exception
raise ValueError("Invalid input")

try {
    const num = parseInt(input);
    if (isNaN(num)) throw new Error("Not a number!");
    console.log(10 / num);
} catch (err) {
    console.log(`Error: ${err.message}`);
} finally {
    console.log("Always runs");
}

// Throw an error
throw new Error("Invalid input");

try {
    int num = int.Parse(Console.ReadLine()!);
    Console.WriteLine(10 / num);
}
catch (FormatException) {
    Console.WriteLine("Not a number!");
}
catch (DivideByZeroException) {
    Console.WriteLine("Can't divide by zero!");
}
catch (Exception ex) {
    Console.WriteLine($"Error: {ex.Message}");
}
finally {
    Console.WriteLine("Always runs");
}

// Throw an exception
throw new ArgumentException("Invalid input");