The Simplest Method to Check for Null and Empty String on TypeScript Numbers

Problem Context and Challenges

In TypeScript development, a common scenario arises when dealing with numeric input fields in forms: the field initializes as null, but after a user enters and clears a number, the value becomes an empty string "". JavaScript's type coercion treats empty strings as 0 in numeric contexts, potentially leading to unexpected logic errors. Developers often write complex conditional checks to distinguish between actual zero values and empty strings, as shown in the original code:

if ((this.RetailPrice != null && this.RetailPrice != 0) || this.RetailPrice === 0) {
    return this.RetailPrice;
}

This approach is not only verbose but also logically redundant—it attempts to handle null, non-zero values, and zero simultaneously, yet fails to effectively differentiate between empty strings and zero values.

Core Solution: The Ingenious Use of typeof Operator

According to the best answer (score 10.0), the most concise and effective method combines the typeof operator with a dual verification:

if(typeof RetailPrice != 'undefined' && RetailPrice) {
    return this.RetailPrice;
}

The elegance of this solution lies in:

1. typeof Check: typeof RetailPrice != 'undefined' first ensures the variable is declared and not undefined. While this may seem redundant under TypeScript's strict mode, it provides runtime protection in dynamic scenarios.
2. Truthy Check: When RetailPrice is used alone as a condition, JavaScript's truthy conversion rules automatically filter out falsy values like null, 0, empty string "", and false. For number types, only non-zero numeric values pass the check.

This combination perfectly covers all cases to exclude: undefined, null, 0, and empty strings. The condition holds true when RetailPrice is a valid non-zero number; otherwise, it is skipped.

In-Depth Analysis: Type Coercion Mechanisms

Understanding this solution requires mastery of JavaScript's type coercion rules. When a number-type variable undergoes conditional evaluation:

• null → false
• undefined → false
• 0 → false
• "" (empty string) → false
• Non-zero numbers (e.g., 42, -1, 3.14) → true

Thus, if(RetailPrice) is essentially checking "is RetailPrice truthy?", naturally excluding all invalid states. The preceding typeof check adds explicit defense against undefined, making the code more robust.

Alternative Approaches and Comparisons

Other answers propose different ideas, each with limitations:

Alternative Two (score 4.6):

if(this.retailPrice && this.retailPrice.trim()) {
    // Implement logic here
}

This method attempts to exclude empty strings via the trim() method, but has significant flaws:

1. trim() is a string method; calling it on a number type throws a runtime error.
2. Even with type coercion, it fails to handle the number 0 correctly—0 converts to string "0", trim() returns a non-empty string, causing 0 to be incorrectly accepted.

In contrast, the best solution avoids method calls, relying purely on the type system, making it safer and more efficient.

Feasibility of Extending TypeScript Types

The asker envisioned adding an IsNullOrEmpty() method to the number type, achievable in TypeScript through declaration merging:

interface Number {
    isNullOrEmpty(): boolean;
}

Number.prototype.isNullOrEmpty = function(): boolean {
    return this == null || this === 0 || this === "";
};

// Usage example
if (!price.isNullOrEmpty()) {
    return price;
}

However, this approach:

1. Modifies the global prototype, potentially causing naming conflicts.
2. Adds runtime overhead.
3. Makes code dependent on specific extensions, reducing portability.

Therefore, the inline check in the best solution is more recommended, as it requires no type system modifications and remains clear and intuitive.

Practical Recommendations and Edge Cases

When applying this solution in real-world projects, consider:

1. Strict Mode: TypeScript's strictNullChecks and strict options help catch null/undefined errors at compile time, but runtime checks are still necessary.
2. Zero Value Handling: If business logic requires distinguishing between 0 and empty values, use more precise conditions, such as if (RetailPrice !== null && RetailPrice !== "" && RetailPrice !== undefined).
3. Performance Considerations: The typeof check is a native operation with excellent performance, suitable for high-frequency call scenarios.
4. Code Readability: For team projects, consider encapsulating the check into a utility function, e.g.:

function isValidNumber(value: any): value is number {
    return typeof value !== 'undefined' && value !== null && value !== "" && !isNaN(Number(value));
}

This function uses a type predicate to provide stricter validation, including NaN detection.

Conclusion

For checking null and empty string values on number-type fields in TypeScript, the simplest and most effective method is if(typeof value != 'undefined' && value). This solution leverages JavaScript's type coercion features to cover four invalid states—undefined, null, 0, and empty strings—with minimal code. Compared to prototype extensions or complex conditional logic, it maintains code clarity and performance, representing best practice for most scenarios. Developers should choose appropriate validation strategies based on specific business needs, integrating TypeScript's type system to ensure data integrity and program robustness.