"Object is possibly null".
Four ways to fix it safely.

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

// ─── The error ───────────────────────────────
function greet(user: User | null): string {
// return Hello, ${user.name}`;
// ❌ 'user' is possibly 'null'
return '';
}

// ─── Fix 1: early return ─────────────────────
function greet2(user: User | null): string {
if (!user) {
return 'Hello, guest';
}
// user is User here — the null case returned
return Hello,${user.name}`; // ✅ no error
}

// ─── Early return with throw ─────────────────
function mustGreet(user: User | null): string {
if (!user) {
throw new Error('User required');
}
return Hello, ${user.name}`; // ✅ narrowed after throw
}

// ─── Guard clauses — multiple checks ─────────
function display(user: User | null, prefix?: string): string {
if (!user) return '(no user)';
if (!prefix) return user.name;
return ``${prefix} ${user.name};
}

// ─── Why it's the safest fix ─────────────────
//
// 1. No non-null assertions — the compiler knows.
// 2. No optional chaining everywhere.
// 3. No silent undefined → the caller sees the
// fallback value or a thrown error explicitly.
// 4. Idiomatic — every TypeScript style guide
// recommends this pattern.

const alice: User = { id: '1', name: 'Alice', email: 'a@x.com' };

console.log(greet2(alice), greet2(null));
console.log(display(alice, 'Hi'), display(null));
try { mustGreet(null); } catch (e) { console.log(e); }

interface User {
id: string;
name: string;
address?: { city: string; zip: string };
}

// ─── Optional chaining on nullable objects ───
function getCity(user: User | null): string | undefined {
return user?.address?.city;
// ↑ ↑
// user might be null
// address might be undefined
// Returns undefined if either is missing
}

// ─── Optional chaining on methods ────────────
function getUpperName(user: User | null): string | undefined {
return user?.name.toUpperCase(); // if user null → undefined
}

// ─── Optional chaining on arrays ─────────────
function firstTag(tags?: string[]): string | undefined {
return tags?.[0]; // if tags undefined → undefined
}

// ─── Optional chaining on function calls ─────
function callHandler(handler?: () => void): void {
handler?.(); // if handler undefined → does nothing
}

// ─── Combined with nullish coalescing ────────
function getCityOr(user: User | null, fallback = 'Unknown'): string {
return user?.address?.city ?? fallback;
// ↑ optional chain ↑ nullish fallback
// If city is undefined → fallback
}

// ─── What it compiles to ─────────────────────
// user?.address?.city
// →
// user === null || user === undefined ? undefined :
// user.address === null || user.address === undefined ? undefined :
// user.address.city
//
// Much cleaner to write, same semantics.

const alice: User = {
id: '1', name: 'Alice',
address: { city: 'Springfield', zip: '12345' }
};
const bob: User = { id: '2', name: 'Bob' };

console.log(getCity(alice), getCity(bob), getCity(null));
console.log(getCityOr(bob, 'N/A'));
console.log(getUpperName(alice));
console.log(firstTag(['a', 'b']));

interface Config {
port?: number;
host?: string;
debug?: boolean;
}

// ─── ?? provides a fallback for null/undefined
function getPort(cfg: Config): number {
return cfg.port ?? 3000;
}

// The difference between ?? and ||:
// cfg.port ?? 3000 → only null/undefined trigger the fallback
// cfg.port || 3000 → ALSO triggers on 0, '', false
//
// For config values where 0 is valid, use ??.

const cfg1: Config = { port: 0 };
console.log(cfg1.port ?? 3000); // 0 (correct!)
console.log(cfg1.port || 3000); // 3000 (probably wrong)

// ─── Combined ?? and ?. — the safe idiom ─────
function getHost(cfg: Config | null): string {
return cfg?.host ?? 'localhost';
}

// ─── Non-null assertion — trust me ───────────
// The ! operator removes null and undefined
// from the type, without any runtime check.

function processUser(user: User | null): string {
// We checked above and know it's non-null:
if (!user) throw new Error('user required');

// Now user is User — no ! needed. TypeScript
// narrows after the throw, so the following is
// just for demonstration:

return user.name; // ✅ no ! needed
}

// When ! is legitimately needed:
//
// 1. External library that returns T | null but
// you know it's T after some invariant.
// 2. After a custom check the compiler can't see:
// if (user !== null && 'name' in user) { ... }
// TypeScript narrows 'name' but not 'user'.
// 3. Immediately after an assignment in a
// synchronous block where you control the value.

function legitUse(user: User | null): string {
if (user === null) throw new Error('required');
return user.name; // compiler narrows — no ! needed
}

// ─── When NOT to use ! ───────────────────────
//
// ❌ function f(user: User | null) {
// return user!.name;
// }
// If user is null → runtime TypeError.
//
// ❌ function f(users: User[]) {
// return users[0]!.name;
// }
// If array is empty → runtime TypeError.
//
// Every ! is a promise the compiler can't verify.
// Prefer ?? or early return.

console.log(getPort({}), getPort({ port: 8080 }));
console.log(getHost(null), getHost({ host: 'example.com' }));
console.log(processUser({ id: '1', name: 'Alice', email: 'a@x.com' }));