Satisfies operator in Typescript - Step-by-Step Execution

Concept Flow - Satisfies operator

Declare object with properties

↓

Use 'satisfies' operator with type

↓

Check if object matches type shape

Yes↓

Allow object to keep exact types

↓

Use object safely with type guarantees

↓

End

The 'satisfies' operator checks if an object matches a type without changing its exact type, ensuring safety and precision.

Execution Sample

Typescript

const user = {
  name: "Alice",
  age: 30
} satisfies { name: string; age: number };

This code creates an object 'user' and uses 'satisfies' to ensure it matches the given type shape.

Execution Table

Step	Action	Evaluation	Result
1	Declare object 'user' with name and age	user = { name: "Alice", age: 30 }	Object created with exact types: name as "Alice", age as 30
2	Apply 'satisfies' operator with type { name: string; age: number }	Check if user matches type shape	True: user matches the type shape
3	Keep 'user' exact types without widening	user.name is "Alice" (literal), user.age is 30 (literal)	Exact types preserved, not widened to string or number
4	Use 'user' safely with type guarantees	Access user.name and user.age	No type errors, properties exist as expected
5	End of execution	No errors or warnings	Execution successful

💡 Execution stops after confirming object matches type and exact types are preserved

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
user	undefined	{ name: "Alice", age: 30 } (exact types)	Matches type { name: string; age: number }	Exact types preserved (name: "Alice", age: 30)	Final object with exact types and type safety

Key Moments - 2 Insights

Why doesn't the 'name' property type widen to 'string' when using 'satisfies'?

Because the 'satisfies' operator checks compatibility but keeps the original exact types, as shown in execution_table step 3 where 'name' remains the literal "Alice".

What happens if the object does not match the type in 'satisfies'?

TypeScript will show an error at step 2 in the execution_table because the object fails the compatibility check.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the type of 'user.name'?

A string (widened type)

B "Alice" (literal type)

C any

D number

💡 Hint

Check the 'Result' column in step 3 of execution_table where exact types are preserved.

At which step does TypeScript confirm the object matches the required type?

A Step 2

B Step 4

C Step 1

D Step 5

💡 Hint

Look at the 'Evaluation' column in execution_table where the 'satisfies' operator is applied.

If the object had an extra property not in the type, what would happen in the execution_table?

A Step 3 would widen types

B Step 4 would fail to access properties

C Step 2 would show a type error

D No change, execution continues

💡 Hint

Extra properties cause compatibility errors at the type check step (step 2).

Concept Snapshot

Satisfies operator syntax:
const obj = { ... } satisfies Type;

It checks if obj matches Type shape
without widening literal types.

Use it to keep exact types
and ensure type safety.

Full Transcript

This visual trace shows how the 'satisfies' operator works in TypeScript. First, an object 'user' is declared with properties 'name' and 'age'. Then, the 'satisfies' operator checks if 'user' matches the type { name: string; age: number }. The check passes, so the object is accepted. Importantly, the exact types of the properties are kept, meaning 'name' remains the literal "Alice" and 'age' remains 30, not widened to string or number. This allows safe use of 'user' with type guarantees. If the object did not match the type, TypeScript would show an error at the check step. This operator helps keep precise types while ensuring compatibility.