Typescript Type Aliases
Tags: typescript, webdev, javascript, beginners
Published: 2024-03-10 12:47:48

In TypeScript, type aliases create type definitions that can be reused throughout the code. This is unlike type unions and intersections, where the explicit type information is used repetitively.

## 1. Syntax
Type aliases require the type keyword and a name. They can be created in two ways.

They can be set as an object that describes the members and their respective types.

Define types based on conditions within the type definition itself
Useful for creating types that vary depending on properties or values.



```
type myType = {
  memberOne: string;
  memberTwo?: number;
}
```

let favoriteNum: myType = {"my favorite number is ", 42}

They can also refer to other known types, like a union type.
```Typescript
type myType = string | number;
let favoriteNum: myType = '42';
```

Later on, whenever the name is used, TypeScript will assume this refers to the aliased value. Type aliases are similar to interfaces in terms of syntax and behavior. However, a key difference is that an interface can have members added later on whereas type aliases can’t be changed after being defined.

## 2. Type Guards and Type Assertions
In this example, the StringsIsh type alias can be used in place of the type union with several members. When applied to the logAllStrings() function:
```Typescript
type StringsIsh = string | string[] | null | undefined;

function logAllStrings(values: StringsIsh) {
  if (values === null || typeof values === 'undefined') return;

  if (typeof values === 'string') {
    console.log(values);
  } else {
    values.forEach(logAllStrings);
  }
}

logAllStrings('hello'); // Ok
logAllStrings(['hello', 'world']); // Also Ok

function isString(value: string | number): value is string {
  return typeof value === "string";
}

let userInput: string | number = prompt("Enter your name");

if (isString(userInput)) {
  console.log(`Hello, ${userInput}!`); // Now we know userInput is a string
}
```Typescript
The first type guard checks to see if values matches either null or undefined in the StringIsh type alias. Next, the if/else-statement checks for a base case of values being of type string. Otherwise, it recursively invokes logAllStrings again.

## 3. Type Aliases as Generics
Type aliases may be generic and may contain any type description, including:

Primitives
Literals
Object types
The following Result<T> type may contain a value, T, or an object containing the value, { value: T }:
```Typescript
type Result<T> = T | { value: T };

let value: Result<string> = 'hello'; // Ok
let other: Result<string> = { value: 'world' }; // Also Ok
```

## Utility Types
Predefined types that provide common operations on other types.
Examples include Partial<T>, Pick<T, K>, Record<K, T>, and more.
```Typescript
type Todo = {
  title: string;
  completed: boolean;
};

type PartialTodo = Partial<Todo>; // All properties optional

let partialTodo: PartialTodo = { title: "Finish this task" };
```

## 5. Key Points:

Type aliases don't create new types; they just provide alternative names.
Use aliases strategically for frequently used complex types.
Aliases can't be used for primitive types like number or string when type inference is already clear.
Beyond the Basics:

You can create nested type aliases for even more complex scenarios.
Aliases can be used with generics to create reusable components that work with various data types.