🧠 Lesson 3.3: Logical Operators and Truthiness

# Python uses English words: and, or, not
age = 25
has_id = True

# AND — both must be true
if age >= 18 and has_id:
    print("Entry allowed")

# OR — at least one must be true
is_student = False
is_senior = True
if is_student or is_senior:
    print("Discount available!")

# NOT — flips the value
is_banned = False
if not is_banned:
    print("Welcome!")

// JavaScript uses symbols: &&, ||, !
let age = 25;
let hasId = true;

// AND — both must be true
if (age >= 18 && hasId) {
    console.log("Entry allowed");
}

// OR — at least one must be true
let isStudent = false;
let isSenior = true;
if (isStudent || isSenior) {
    console.log("Discount available!");
}

// NOT — flips the value
let isBanned = false;
if (!isBanned) {
    console.log("Welcome!");
}

// C# uses the same symbols as JavaScript: &&, ||, !
int age = 25;
bool hasId = true;

// AND — both must be true
if (age >= 18 && hasId)
{
    Console.WriteLine("Entry allowed");
}

// OR — at least one must be true
bool isStudent = false;
bool isSenior = true;
if (isStudent || isSenior)
{
    Console.WriteLine("Discount available!");
}

// NOT — flips the value
bool isBanned = false;
if (!isBanned)
{
    Console.WriteLine("Welcome!");
}

# Can this person rent a car?
age = 22
has_license = True
has_insurance = True

can_rent = age >= 21 and has_license and has_insurance
print(f"Can rent: {can_rent}")  # True

# Is this a weekend or holiday?
day = "Saturday"
is_holiday = False

day_off = day in ("Saturday", "Sunday") or is_holiday
print(f"Day off: {day_off}")  # True

# Is this a valid password?
password = "Secret123"

is_valid = (
    len(password) >= 8
    and any(c.isupper() for c in password)
    and any(c.isdigit() for c in password)
)
print(f"Valid password: {is_valid}")  # True

// Can this person rent a car?
let age = 22;
let hasLicense = true;
let hasInsurance = true;

let canRent = age >= 21 && hasLicense && hasInsurance;
console.log(`Can rent: ${canRent}`);  // true

// Is this a weekend or holiday?
let day = "Saturday";
let isHoliday = false;

let dayOff = day === "Saturday" || day === "Sunday" || isHoliday;
console.log(`Day off: ${dayOff}`);  // true

// Is this a valid password?
let password = "Secret123";

let isValid =
    password.length >= 8 &&
    /[A-Z]/.test(password) &&
    /[0-9]/.test(password);
console.log(`Valid password: ${isValid}`);  // true

// Can this person rent a car?
int age = 22;
bool hasLicense = true;
bool hasInsurance = true;

bool canRent = age >= 21 && hasLicense && hasInsurance;
Console.WriteLine($"Can rent: {canRent}");  // True

// Is this a weekend or holiday?
string day = "Saturday";
bool isHoliday = false;

bool dayOff = day == "Saturday" || day == "Sunday" || isHoliday;
Console.WriteLine($"Day off: {dayOff}");  // True

// Is this a valid password?
string password = "Secret123";

bool isValid =
    password.Length >= 8 &&
    password.Any(char.IsUpper) &&
    password.Any(char.IsDigit);
Console.WriteLine($"Valid password: {isValid}");  // True

# AND short-circuits on the first False
x = 0
# The second condition is never checked (would cause ZeroDivisionError)
if x != 0 and 10 / x > 2:
    print("Safe division!")
else:
    print("Skipped — x is zero")   # This runs

# OR short-circuits on the first True
name = ""
display_name = name or "Anonymous"  # "" is falsy → uses "Anonymous"
print(display_name)  # Anonymous

# This pattern is very common for default values in Python:
config_value = None
setting = config_value or "default"
print(setting)  # default

// AND short-circuits on the first falsy value
let x = 0;
if (x !== 0 && 10 / x > 2) {
    console.log("Safe division!");
} else {
    console.log("Skipped — x is zero");  // This runs
}

// OR short-circuits on the first truthy value
let name = "";
let displayName = name || "Anonymous";  // "" is falsy
console.log(displayName);  // Anonymous

// Nullish coalescing (??) — a better default operator
// Only treats null and undefined as "missing" (not "" or 0)
let count = 0;
let result1 = count || 10;   // 10 (0 is falsy — oops!)
let result2 = count ?? 10;   // 0  (?? only catches null/undefined)
console.log(result1, result2);  // 10  0

// AND short-circuits on the first false
int x = 0;
if (x != 0 && 10 / x > 2)
{
    Console.WriteLine("Safe division!");
}
else
{
    Console.WriteLine("Skipped — x is zero");  // This runs
}

// C# doesn't do truthy/falsy OR defaults the same way
// Instead, use the null-coalescing operator (??)
string name = null;
string displayName = name ?? "Anonymous";
Console.WriteLine(displayName);  // Anonymous

// Null-coalescing works with any nullable type:
int? configValue = null;
int setting = configValue ?? 42;
Console.WriteLine(setting);  // 42

# Python: empty collections and zero are falsy
items = []
if items:
    print("Has items")
else:
    print("Empty list!")  # This runs

name = "Alice"
if name:
    print(f"Hello, {name}!")  # This runs — non-empty string is truthy

count = 0
if count:
    print("Has items")
else:
    print("Count is zero")  # This runs — 0 is falsy

# Very Pythonic — check for empty/None in one step:
data = None
if not data:
    print("No data available")  # Catches None AND empty collections

// JavaScript: similar to Python, but with some surprises
let items = [];
if (items.length) {
    console.log("Has items");
} else {
    console.log("Empty array!");  // This runs
}

// ⚠️ GOTCHA: empty arrays are TRUTHY in JavaScript!
if ([]) {
    console.log("Empty array is truthy!");  // This runs!
}
// Check .length instead: if (items.length)

let name = "Alice";
if (name) {
    console.log(`Hello, ${name}!`);  // Truthy — non-empty string
}

// NaN is falsy (unique to JavaScript)
let result = parseInt("hello");  // NaN
if (result) {
    console.log("Valid");
} else {
    console.log("NaN is falsy!");  // This runs
}

// C#: NO implicit truthiness — must use explicit booleans
string[] items = Array.Empty<string>();

// if (items) { }         // ❌ Compile error!
if (items.Length > 0)      // ✅ Explicit comparison required
{
    Console.WriteLine("Has items");
}
else
{
    Console.WriteLine("Empty array!");
}

string name = "Alice";
// if (name) { }          // ❌ Compile error!
if (!string.IsNullOrEmpty(name))  // ✅ Explicit check
{
    Console.WriteLine($"Hello, {name}!");
}

// C#'s strictness catches bugs at compile time:
int count = 0;
// if (count) { }         // ❌ Can't use int as bool
if (count != 0)           // ✅ Must compare explicitly
{
    Console.WriteLine("Has items");
}

# Pattern 1: Default values with "or"
username = ""
display = username or "Guest"
print(display)  # "Guest" (empty string is falsy)

# Pattern 2: Guard clause with "and"
user = {"name": "Alice", "email": "alice@example.com"}
email = user and user.get("email")
print(email)  # "alice@example.com"

# Pattern 3: Checking if a list has items
results = [1, 2, 3]
if results:
    print(f"Found {len(results)} results")

# Pattern 4: None check before use
data = None
if data is not None:   # More explicit than "if data:" 
    process(data)      # (because 0 and "" would also be falsy)

// Pattern 1: Default values with "||"
let username = "";
let display = username || "Guest";
console.log(display);  // "Guest"

// Better: use ?? for defaults (doesn't treat "" and 0 as missing)
let port = 0;
let serverPort1 = port || 3000;   // 3000 (0 is falsy — bug!)
let serverPort2 = port ?? 3000;   // 0    (?? only catches null/undefined)

// Pattern 2: Optional chaining (?.) — safe property access
let user = { name: "Alice", address: { city: "NYC" } };
let city = user?.address?.city;       // "NYC"
let zip = user?.address?.zipCode;     // undefined (no error!)

// Pattern 3: Combining ?. with ??
let country = user?.address?.country ?? "Unknown";
console.log(country);  // "Unknown"

// Pattern 1: Null-coalescing for defaults
string username = null;
string display = username ?? "Guest";
Console.WriteLine(display);  // "Guest"

// Pattern 2: Null-conditional (?.) — safe property access
// (Similar to JavaScript's optional chaining)
string[]? items = null;
int? count = items?.Length;    // null (no NullReferenceException!)

// Pattern 3: Combining ?. with ??
string? city = user?.Address?.City ?? "Unknown";

// Pattern 4: Null-coalescing assignment (??=)
string name = null;
name ??= "Default";   // Assigns "Default" only if name is null
Console.WriteLine(name);  // "Default"

// Pattern 5: String-specific checks
string input = "";
if (!string.IsNullOrEmpty(input))    // Checks null AND ""
    Console.WriteLine(input);
if (!string.IsNullOrWhiteSpace(input))  // Also checks "   "
    Console.WriteLine(input);

# What does this evaluate to?
result = True or False and False
print(result)  # True

# Why? AND binds tighter than OR:
# True or (False and False)
# True or False
# True

# Make it explicit with parentheses:
result = (True or False) and False
print(result)  # False — now OR happens first

// What does this evaluate to?
let result = true || false && false;
console.log(result);  // true

// Why? && binds tighter than ||:
// true || (false && false)
// true || false
// true

// Make it explicit:
result = (true || false) && false;
console.log(result);  // false

// Same precedence rules as JavaScript
bool result = true || false && false;
Console.WriteLine(result);  // True

// && binds tighter than ||:
// true || (false && false)
// true || false
// True

// Explicit:
result = (true || false) && false;
Console.WriteLine(result);  // False