TypeScript中数字与null相乘返回null而非0的通用实现方案咨询

Short answer: No, you can't achieve this purely through tsconfig.json compiler options.

Why tsconfig won't work #

TypeScript is a superset of JavaScript, and all its compiler options focus on type checking strictness, output targets, module resolution rules, and similar type-related behaviors—they don’t alter JavaScript’s runtime logic. The fact that null * 12 returns 0 is a native JavaScript behavior: when you perform arithmetic operations on null, it gets coerced to 0 automatically. Since TypeScript compiles down to standard JavaScript, compiler flags can’t override this built-in coercion rule.

Universal solutions without ternary checks #

Since we can’t change runtime behavior via config, we need to implement null-propagating arithmetic logic ourselves. Here are two clean, reusable approaches:

1. Generic utility function

Create a type-safe multiply function that handles nullable numbers and propagates null automatically. This encapsulates the null check once, so you don’t have to write ternaries everywhere:

function multiply(a: number | null | undefined, b: number | null | undefined): number | null {
  if (a == null || b == null) return null;
  return a * b;
}

// Usage:
const x: number | null = null;
const y: number = 12;
const c = multiply(x, y); // c is null
const d = multiply(5, y); // d is 60

TypeScript will correctly infer the return type as either number or null based on your inputs, keeping type safety intact.

2. Wrapped nullable number type (for stricter safety)

If you want to avoid even the possibility of accidental raw arithmetic on nullable values, create a wrapper class that handles null propagation in its methods:

class NullableNumber {
  private value: number | null;

  constructor(value: number | null | undefined) {
    this.value = value ?? null;
  }

  multiply(other: NullableNumber | number | null | undefined): NullableNumber {
    const otherValue = other instanceof NullableNumber ? other.value : other;
    if (this.value == null || otherValue == null) {
      return new NullableNumber(null);
    }
    return new NullableNumber(this.value * otherValue);
  }

  getValue(): number | null {
    return this.value;
  }
}

// Usage:
const x = new NullableNumber(null);
const y = new NullableNumber(12);
const c = x.multiply(y).getValue(); // c is null
const d = new NullableNumber(5).multiply(y).getValue(); // d is 60

This approach enforces that all arithmetic on nullable numbers goes through controlled methods, eliminating unintended coercion bugs.

Key takeaway #

TypeScript’s compiler options don’t control runtime arithmetic behavior. To match C#’s nullable value type arithmetic, you need to implement custom logic that explicitly handles null propagation—either via utility functions or wrapper types.

内容的提问来源于stack exchange，提问作者gary