> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript null
In TypeScript, `null` is both a primitive runtime value and a distinct literal type representing the intentional absence of any object value. It explicitly indicates that a variable has been declared and initialized, but currently holds no meaningful data.
The behavior of the `null` type within the TypeScript type system is fundamentally governed by the `strictNullChecks` compiler option in `tsconfig.json`.
## Type System Behavior
### Strict Null Checks Enabled (`strictNullChecks: true`)
When strict null checking is enabled, `null` is treated as a distinct, standalone type. It is only assignable to `null`, `any`, `unknown`, or a union type that explicitly includes `null`. It cannot be implicitly assigned to other concrete types.
```typescript theme={"dark"}
// Explicitly typed as the literal type `null`
let emptyValue: null = null;
// Error: Type 'null' is not assignable to type 'string'.
// let name: string = null;
// Valid: Using a union type to allow null
let age: number | null = null;
```
### Strict Null Checks Disabled (`strictNullChecks: false`)
When strict null checking is disabled, `null` effectively acts as a subtype of all other types (except `never`). It bypasses type safety, allowing `null` to be assigned to variables expecting concrete types.
```typescript theme={"dark"}
// Valid only when strictNullChecks is false
let username: string = null;
let isActive: boolean = null;
```
## Type Narrowing
Because `null` is a distinct type in strict mode, TypeScript's control flow analysis requires explicit type narrowing to safely extract a non-null value from a union type before performing operations on it. Strict equality (`===` or `!==`) is the standard mechanism for this.
```typescript theme={"dark"}
function processLength(text: string | null) {
// Error: Object is possibly 'null'.
// console.log(text.length);
// Type Narrowing via strict inequality
if (text !== null) {
// TypeScript narrows 'text' to 'string' in this block
console.log(text.length);
}
}
```
## The Non-Null Assertion Operator (`!`)
If a developer can guarantee through external means that a value typed with `null` will not be `null` at runtime, TypeScript provides the postfix `!` operator. This instructs the compiler to strip `null` and `undefined` from the type during static analysis.
```typescript theme={"dark"}
declare function getIdentifier(): string | null;
let identifier: string | null = getIdentifier();
// The '!' asserts that identifier is strictly 'string' here, bypassing the null check
let exactLength: number = identifier!.length;
```
## Runtime Type Evaluation Quirk
TypeScript inherits JavaScript's legacy behavior where the `typeof` operator applied to `null` evaluates to `"object"`. TypeScript's control flow analysis actively accounts for this behavior when narrowing types.
If a union contains types that do not evaluate to `"object"` (such as `string | null`), checking for `"object"` successfully narrows the type to `null`. However, if the union contains object types (such as `{ id: number } | null`), the `typeof` check cannot eliminate `null`, requiring strict equality checks instead.
```typescript theme={"dark"}
let data: string | null = null;
if (typeof data === "object") {
// TypeScript eliminates 'string' (which evaluates to "string")
// and narrows 'data' strictly to 'null' here.
let empty: null = data;
}
let record: { id: number } | null = null;
if (typeof record === "object") {
// 'record' remains '{ id: number } | null' because both evaluate to "object" at runtime.
if (record !== null) {
// 'record' is now narrowed to '{ id: number }'
console.log(record.id);
}
}
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
