Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/typescript/typescript-literal-types/ below:

TypeScript Literal Types - GeeksforGeeks

Last Updated : 21 Jan, 2025

TypeScript's literal types allow developers to specify exact values for variables, function parameters, or properties, enhancing type safety by ensuring variables can only hold predefined values.

• Allow variables to have specific, exact values.
• Enhance code reliability by restricting permissible values.

Here are the types of literal types in TypeScript:

String literal types allow a variable to accept only a specific set of string values.

type Direction = "Up" | "Down" | "Left" | "Right";

let move: Direction;

move = "Up"; // Valid assignment
// move = "Forward"; // Error: Type '"Forward"' is not assignable to type 'Direction'.

• The Direction type can only be one of the specified string literals: "Up", "Down", "Left", or "Right".
• Assigning any value outside this set results in a compile-time error.

move = "Up"; // No error
move = "Forward"; // Compile-time error

Numeric literal types restrict a variable to a specific set of numeric values..

type DiceRoll = 1 | 2 | 3 | 4 | 5 | 6;

function rollDice(): DiceRoll {
    return 4; // Valid return value
    // return 7; // Error: Type '7' is not assignable to type 'DiceRoll'.
}

• The DiceRoll type allows only the numbers 1 through 6.
• Returning a number outside this range causes a compile-time error.

Output :

rollDice(); // Returns 4 without error
rollDice(); // Returning 7 causes a compile-time error

Boolean literal types constrain a variable to the boolean values true or false.

type Success = true;

function operation(): Success {
    return true; // Valid return value
    // return false; // Error: Type 'false' is not assignable to type 'true'.
}

• The Success type is strictly true.
• Returning false would result in a compile-time error.

Output:

operation(); // Returns true without error
operation(); // Returning false causes a compile-time error

• Use Literal Types for Exact Values: Define variables with literal types to restrict them to specific, predetermined values, enhancing code predictability.
• Combine with Union Types: Utilize union types to allow variables to accept a finite set of literal values, improving type safety.
• Leverage Type Aliases: Create type aliases for complex literal type combinations to simplify code and enhance readability.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4