🔄 Lesson 2.3: Type Conversion and Coercion

# Python: use int() and float()
age_str = "25"
price_str = "19.99"

age = int(age_str)         # 25 (integer)
price = float(price_str)   # 19.99 (float)

print(age + 5)     # 30
print(price * 2)   # 39.98

# What if the string isn't a valid number?
# bad = int("hello")  # ValueError: invalid literal
# bad = int("12.5")   # ValueError: can't convert float string to int
# Use float() first: int(float("12.5"))  → 12

// JavaScript: several options
let ageStr = "25";
let priceStr = "19.99";

// Number() — the cleanest option
let age = Number(ageStr);        // 25
let price = Number(priceStr);    // 19.99

// parseInt() and parseFloat() — more forgiving
let parsed1 = parseInt("42px");      // 42 (stops at non-digit)
let parsed2 = parseFloat("3.14abc"); // 3.14

// The + shortcut (unary plus)
let quick = +"25";  // 25

// What if the string isn't a valid number?
console.log(Number("hello"));   // NaN (Not a Number)
console.log(Number(""));        // 0 (empty string → 0!)
console.log(Number("  "));      // 0 (whitespace → 0!)

// C#: Parse() or Convert methods
string ageStr = "25";
string priceStr = "19.99";

int age = int.Parse(ageStr);          // 25
double price = double.Parse(priceStr); // 19.99

// Convert class (alternative)
int age2 = Convert.ToInt32(ageStr);    // 25
double price2 = Convert.ToDouble(priceStr); // 19.99

// What if the string isn't valid?
// int bad = int.Parse("hello");  // FormatException!

// TryParse — safe conversion (no crash)
if (int.TryParse("42", out int result))
{
    Console.WriteLine($"Parsed: {result}");  // Parsed: 42
}
else
{
    Console.WriteLine("Not a valid number");
}

# Python: use str()
age = 25
price = 19.99

age_str = str(age)       # "25"
price_str = str(price)   # "19.99"

# Useful for concatenation
print("Age: " + str(age))   # "Age: 25"

# But f-strings handle this automatically!
print(f"Age: {age}")         # "Age: 25" (easier!)

// JavaScript: several options
let age = 25;
let price = 19.99;

// String() function
let ageStr = String(age);        // "25"

// .toString() method
let priceStr = price.toString(); // "19.99"

// Concatenation trick (implicit coercion)
let quick = age + "";            // "25"
let quick2 = "" + price;         // "19.99"

// Template literals handle it automatically
console.log(`Age: ${age}`);      // "Age: 25"

// C#: .ToString() or Convert
int age = 25;
double price = 19.99;

string ageStr = age.ToString();       // "25"
string priceStr = price.ToString();   // "19.99"

// Convert class
string ageStr2 = Convert.ToString(age);  // "25"

// Formatting while converting
string formatted = price.ToString("F2");   // "19.99"
string currency = price.ToString("C");     // "$19.99"

// Interpolation handles it automatically
Console.WriteLine($"Age: {age}");  // "Age: 25"

# Python: use bool() to see the boolean value

# Falsy values (these all become False):
print(bool(0))        # False
print(bool(0.0))      # False
print(bool(""))       # False (empty string)
print(bool([]))       # False (empty list)
print(bool(None))     # False

# Truthy values (everything else is True):
print(bool(1))        # True
print(bool(-5))       # True (any non-zero number)
print(bool("hello"))  # True (any non-empty string)
print(bool(" "))      # True (space is not empty!)
print(bool([1,2]))    # True (non-empty list)

// JavaScript: use Boolean() to see the boolean value

// Falsy values (these all become false):
console.log(Boolean(0));          // false
console.log(Boolean(""));         // false (empty string)
console.log(Boolean(null));       // false
console.log(Boolean(undefined));  // false
console.log(Boolean(NaN));        // false

// Truthy values (everything else is true):
console.log(Boolean(1));          // true
console.log(Boolean(-5));         // true
console.log(Boolean("hello"));    // true
console.log(Boolean(" "));        // true
console.log(Boolean("0"));        // true! ("0" is non-empty)
console.log(Boolean([]));         // true! (empty array is truthy!)

// C#: strict — no automatic truthy/falsy!

// C# does NOT let you use numbers or strings as booleans:
// if (1) {}        // ERROR: Cannot convert int to bool
// if ("hello") {}  // ERROR: Cannot convert string to bool

// You must use explicit boolean expressions:
int count = 5;
if (count > 0)  // explicit comparison — this is OK
{
    Console.WriteLine("Has items");
}

// Convert explicitly with Convert.ToBoolean
Console.WriteLine(Convert.ToBoolean(0));     // False
Console.WriteLine(Convert.ToBoolean(1));     // True
Console.WriteLine(Convert.ToBoolean("true")); // True
// Convert.ToBoolean("hello")  // FormatException!

# Python: refuses to mix types — CLEAR errors

# print("5" + 3)     # TypeError!
# print("5" - 3)     # TypeError!
# print("5" * 3)     # "555" — this one works! (string repetition)
# print("5" * "3")   # TypeError!

# Python's philosophy: if it's ambiguous, crash.
# This means bugs are found EARLY.

// JavaScript: wild implicit coercion

// The + operator: if EITHER side is a string, concatenate
console.log("5" + 3);      // "53" (number → string, then join)
console.log(5 + "3");      // "53"
console.log("5" + true);   // "5true"

// Other operators: convert strings TO numbers
console.log("5" - 3);      // 2  (string → number, then subtract)
console.log("5" * 3);      // 15 (string → number, then multiply)
console.log("5" / "2");    // 2.5

// The REALLY weird stuff:
console.log(true + true);      // 2
console.log(true + "1");       // "true1"
console.log([] + []);          // "" (empty string!)
console.log([] + {});          // "[object Object]"
console.log({} + []);          // 0 (or "[object Object]" — depends!)

// Why does + behave differently from - ?
// + is BOTH addition AND concatenation.
// - is ONLY subtraction, so JS converts to numbers.

// C#: allows SAFE implicit conversions only

// Small type → big type: OK (no data loss)
int small = 42;
double big = small;     // int → double (implicit, safe)
long bigger = small;    // int → long (implicit, safe)

// Big type → small type: REQUIRES explicit cast
double pi = 3.14;
// int truncated = pi;           // ERROR: cannot implicitly convert
int truncated = (int)pi;         // 3 — explicit cast required

// String + number: converts number to string (like JS)
Console.WriteLine("Score: " + 42);   // "Score: 42"

// But string - number: NOT allowed (unlike JS)
// Console.WriteLine("5" - 3);      // ERROR!

# Python: input() always returns a string
user_input = input("Enter your age: ")   # e.g., user types "25"
print(type(user_input))   # <class 'str'>

# Must convert before doing math!
age = int(user_input)
birth_year = 2026 - age
print(f"You were born around {birth_year}")

# Safe version with error handling
try:
    age = int(input("Enter your age: "))
    print(f"Next year you'll be {age + 1}")
except ValueError:
    print("That's not a valid number!")

// Browser: prompt() always returns a string (or null)
let userInput = prompt("Enter your age:");  // e.g., "25"
console.log(typeof userInput);  // "string"

// Must convert before doing math!
let age = Number(userInput);

// Check for invalid input
if (isNaN(age) || userInput === null) {
    console.log("That's not a valid number!");
} else {
    let birthYear = 2026 - age;
    console.log(`You were born around ${birthYear}`);
}

// Node.js uses readline (more complex — shown later)

// C#: Console.ReadLine() always returns a string
Console.Write("Enter your age: ");
string userInput = Console.ReadLine();  // e.g., "25"

// Safe conversion with TryParse
if (int.TryParse(userInput, out int age))
{
    int birthYear = 2026 - age;
    Console.WriteLine($"You were born around {birthYear}");
}
else
{
    Console.WriteLine("That's not a valid number!");
}