How to allow null, but forbid undefined?

In JavaScript programming, null and undefined can both represent the absence of a value, but they have different uses and meanings. null is typically used to indicate that the variable has been defined by the programmer but currently has no value. undefined typically indicates that the variable has been declared but not initialized.

If we want to allow null but disallow undefined in our code, we can achieve this through several methods:

1. Type Checking

Example:

javascript
function processValue(value) {
  if (typeof value === 'undefined') {
    throw new Error('undefined is not allowed');
  }
  // Continue processing value, which can now be null or any other type
}

try {
  processValue(undefined);
} catch (error) {
  console.error(error.message);  // Output: undefined is not allowed
}

processValue(null);  // This line executes normally because null is allowed

2. Using TypeScript

When using TypeScript, we can enable strict type checking to clearly distinguish between null and undefined.

TypeScript Configuration:

Enable strictNullChecks in tsconfig.json:

json
{
  "compilerOptions": {
    "strict": true,
    "strictNullChecks": true
  }
}

TypeScript Example:

typescript
function processValue(value: number | null) {
  // This function accepts number or null, but not undefined
}

processValue(null);  // Normal execution
processValue(123);   // Normal execution
// processValue(undefined);  // TypeScript compilation error

3. Default Parameter Values

Using default values in function parameters can prevent undefined values but allow null.

Example:

javascript
function greet(name = 'Guest') {
  console.log(`Hello, ${name}!`);
}

// Output: Hello, Guest!
// Output: Hello, null!

In the above example, when undefined is passed as an argument, it is replaced by the default parameter value 'Guest', but null is not replaced.

Summary

By using these methods, we can intentionally choose to allow null but disallow undefined in JavaScript or TypeScript projects, which helps improve the clarity and robustness of the code. Using appropriate error handling and type checking can ensure the stability of the program and reduce potential bugs.