Typescript Assertion Functions

Typescript assertion functions

Created By: chatGPT

TypeScript assertion functions are a special feature that allows you to create type guards that provide type information about a given value. This can help refine types in function parameters or return values. Assertion functions are defined using the asserts keyword, which aids in narrowing down types effectively. Let's explore how to implement these functions with some examples.

// Example of a simple assertion function

function isString(value: unknown): asserts value is string {
    if (typeof value !== 'string') {
        throw new Error('Not a string!');
    }
}

const input: unknown = 'Hello, TypeScript!';

// Use the assertion function
isString(input);

// Now TypeScript knows that 'input' is a string
console.log(input.toUpperCase());

Using assertion functions can greatly improve type safety in your TypeScript code by ensuring that values meet specific criteria before proceeding with operations that rely on those types. Here is another example demonstrating how to use assertion functions for more complex types.

// Define an interface for a User
interface User {
    name: string;
    age: number;
}

function isUser(value: unknown): asserts value is User {
    if (typeof value !== 'object' || value === null ||
        typeof (value as User).name !== 'string' ||
        typeof (value as User).age !== 'number') {
        throw new Error('Not a User!');
    }
}

const unknownValue: unknown = {
    name: 'Alice',
    age: 30
};

// Use the assertion function
isUser(unknownValue);

// At this point, TypeScript knows 'unknownValue' is of type User
console.log(`User Name: ${unknownValue.name}, Age: ${unknownValue.age}`);

Assertion functions not only help with validating data formats but can also be part of larger validation strategies in applications where you process external inputs. This practice enhances your codebase's reliability and maintainability.

// Example of an assertion function to check an array of numbers
function isArrayOfNumbers(value: unknown): asserts value is number[] {
    if (!Array.isArray(value) || !value.every(num => typeof num === 'number')) {
        throw new Error('Not an array of numbers!');
    }
}

const numbers: unknown = [1, 2, 3, 4];

// Use the assertion function
isArrayOfNumbers(numbers);

// Now TypeScript knows 'numbers' is an array of numbers
const sum = numbers.reduce((a, b) => a + b, 0);
console.log(`Sum of numbers: ${sum}`);