How to fix Argument of type 'undefined' is not assignable to parameter of type 'string | undefined' in TypeScript

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user = getName(); // returns string | undefined
greet(user); // ERROR: undefined not assignable to string

function greet(name: string | undefined) {
  console.log(`Hello, ${name}`);
}

const user = getName(); // returns string | undefined
greet(user); // OK - function accepts undefined

// These are equivalent:
function greet(name?: string) { }
function greet(name: string | undefined) { }

// Both allow calling with undefined or omitting the argument
greet(undefined); // OK
greet(); // OK
greet("Alice"); // OK

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user = getName(); // returns string | undefined

if (user !== undefined) {
  greet(user); // OK - TypeScript knows user is string here
}

const user = getName();

if (user) { // Also checks for empty strings
  greet(user); // OK
}

const user = getName();
user && greet(user); // Executes greet only if user is truthy

const user = getName() ?? "Guest";
greet(user); // OK - user is guaranteed to be string

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user = getName(); // returns string | undefined
greet(user!); // OK - ! tells TypeScript to trust you

// Good use case - you know the DOM element exists
const button = document.getElementById("submit")!;
button.addEventListener("click", () => { });

// Bad use case - you're not sure the value exists
const user = getUserFromAPI();
greet(user!); // May crash at runtime if user is undefined

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user = getName(); // returns string | undefined
greet(user ?? "Guest"); // OK - user is string | undefined, ?? returns string

interface User {
  name?: string;
}

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user: User = getUser();
greet(user.name ?? "Anonymous"); // OK

// || replaces falsy values (0, empty string, false, null, undefined)
const count = getCachedCount() || 0; // "0" becomes 0

// ?? only replaces null/undefined
const count = getCachedCount() ?? 0; // "0" stays "0"

{
  "compilerOptions": {
    "strict": true,
    // or explicitly:
    "strictNullChecks": true
  }
}

find . -name "tsconfig*.json" -type f

function assertDefined<T>(value: T): asserts value is NonNullable<T> {
  if (value === null || value === undefined) {
    throw new Error("Value is null or undefined");
  }
}

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user = getName(); // string | undefined
assertDefined(user);
greet(user); // OK - TypeScript knows user is string now

function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== "string") {
    throw new Error(`Expected string, got ${typeof value}`);
  }
}

const user: unknown = getUserInput();
assertIsString(user);
greet(user); // OK - user is string

import { z } from "zod";

const UserSchema = z.object({
  name: z.string(),
});

const data = getDataFromAPI(); // unknown
const user = UserSchema.parse(data); // throws if invalid
greet(user.name); // OK - user.name is guaranteed string

interface User {
  name?: string;
}

function greet(name: string) {
  console.log(`Hello, ${name}`);
}

const user: User = getUser();
greet(user.name); // ERROR - name might be undefined

const user: User = getUser();
greet(user?.name ?? "Guest"); // OK

const { name = "Guest" } = getUser();
greet(name); // OK - name is guaranteed string

function greet(name?: string) {
  console.log(`Hello, ${name ?? "Guest"}`);
}

const user: User = getUser();
greet(user.name); // OK - function accepts undefined

interface User {
  name: string; // Remove ? - name is required
}

const user: User = getUser();
greet(user.name); // OK - guaranteed to exist