TypeScript Variables

Variables in TypeScript allow you to store and manage data with the added advantage of static typing. TypeScript introduces type safety, helping to catch errors at compile-time and ensuring variable declarations are well-structured.

 

Declaring Variables in TypeScript

You can declare variables using let, const, or var, just like in JavaScript. However, TypeScript allows you to explicitly define the type.

Syntax:

let variableName: type = value;  

 

Types of Variable Declarations

let Declaration (Block-Scoped)

• let is block-scoped and prevents redeclaration within the same scope.

const Declaration (Constant Variable)

• const variables must be initialized and cannot be reassigned.

var Declaration (Function-Scoped)

• var has function scope and can be redeclared, which can lead to unexpected results.

Type Annotations

You can explicitly define the type of a variable using type annotations.

let name: string = "John";  
let age: number = 30;  
let isActive: boolean = true;  

console.log(name, age, isActive); // Output: John 30 true  

Type Inference

If no type annotation is provided, TypeScript infers the type based on the assigned value.

let greeting = "Hello, World!"; // Type inferred as string  
let count = 42;                // Type inferred as number  

console.log(greeting, count);  

Union Types

Union types allow variables to hold values of more than one type.

let id: string | number;  
id = "1234";  
console.log(id); // Output: 1234  

id = 1234;  
console.log(id); // Output: 1234  

any Type

The any type allows variables to hold values of any type. It bypasses TypeScript's type checking.

let value: any = "Hello";  
value = 42;  
value = true;  

console.log(value); // Output: true  

unknown Type

The unknown type is similar to any but requires a type assertion before using it.

let input: unknown = "Some data";  

if (typeof input === "string") {  
  console.log((input as string).toUpperCase()); // Output: SOME DATA  
}  

Template Strings and Variables

You can use variables inside template strings with backticks ` for better readability.

let firstName: string = "Alice";  
let lastName: string = "Smith";  

let fullName: string = `${firstName} ${lastName}`;  
console.log(fullName); // Output: Alice Smith  

Example: Variable Declarations

let username: string = "John";  
const age: number = 25;  
let isLoggedIn: boolean = true;  
let skills: string[] = ["TypeScript", "JavaScript"];  
let mixedValue: string | number = "ID123";  

console.log(username, age, isLoggedIn, skills, mixedValue);  

Output:

John 25 true [ 'TypeScript', 'JavaScript' ] ID123  

 

Summary

In TypeScript, variables can be declared using let, const, or var with the added benefit of type safety through type annotations and inference. TypeScript supports union types, any, unknown, and template strings, offering flexibility while maintaining type safety. Always prefer let and const over var to avoid scope-related issues.