TypeScript Basic Types
TypeScript data types are the foundation of every program you will write. They describe what kind of value a variable holds, such as text, numbers, or true/false. Understanding them early makes your code safer and easier to read. In real projects, correct types prevent bugs before they reach users.
This tutorial walks you through each primitive type with a short example. You will learn how to write type annotations, why strictNullChecks matters, and the difference between lowercase string and uppercase String. By the end, you will know how to declare variables with confidence.
What Are TypeScript Data Types?
TypeScript data types are labels that tell the compiler what kind of value a variable, function parameter, or function return holds. The main primitive types are string, number, boolean, bigint, symbol, null, undefined, and void. The compiler uses these labels to catch mistakes before your code runs.
Here is a quick look at a typed variable:
const studentName: string = "Riya";
console.log(studentName);
// Output: Riya
The : string part is a type annotation. It tells TypeScript that studentName will only ever hold text. If you later try to assign a number, the compiler will stop you.
How Do You Annotate Variables with TypeScript Data Types?
A type annotation is a colon followed by the type name, written after the variable name. It is optional because TypeScript can often infer the type, but writing it makes your intention clear. You will learn about inference in the Type Inference & Annotations tutorial.
const title: string = "TypeScript Basics";
const year: number = 2024;
const isActive: boolean = true;
console.log(title, year, isActive);
// Output: TypeScript Basics 2024 true
How it works: Each line declares a constant with an explicit type. TypeScript checks the assigned value against the annotation. If the value does not match, the compiler reports an error. This check happens before any JavaScript is generated, which is why TypeScript catches bugs early.
What Is the string Type?
The string type holds text. Text can be written with single quotes, double quotes, or backticks. Backticks allow template literals, which let you insert variables inside a string using ${}.
const firstName: string = "Arjun";
const greeting: string = `Hello, ${firstName}!`;
console.log(greeting);
// Output: Hello, Arjun!
How it works: The ${firstName} inside the backtick string is replaced with the value of firstName. The result is a new string. TypeScript knows that greeting is a string because the template literal always produces a string.
What Is the number Type?
The number type holds both whole numbers and decimals. Unlike some other languages, TypeScript does not separate integers and floats. All numeric values use number.
const price: number = 499.99;
const quantity: number = 3;
const total: number = price * quantity;
console.log(total);
// Output: 1499.97
How it works: price and quantity are both numbers, so multiplication is allowed. The result is also a number, and TypeScript infers its type. If you tried to multiply a number by a string, TypeScript would report an error.
What Is the boolean Type?
The boolean type holds only two values: true or false. It is used for yes/no flags, like whether a user is logged in or a feature is enabled.
const isLoggedIn: boolean = false;
const hasPaid: boolean = true;
console.log(isLoggedIn || hasPaid);
// Output: true
How it works: The || operator returns true if either side is true. Since hasPaid is true, the result is true. TypeScript knows the result is a boolean and will flag any attempt to assign a string to isLoggedIn.
What Are the bigint and symbol Types?
The bigint type holds integers larger than the safe limit of number. You create a bigint by adding n after a number. The symbol type creates a unique identifier that is never equal to any other symbol.
const hugeNumber: bigint = 9007199254740993n;
const uniqueId: symbol = Symbol("id");
console.log(typeof hugeNumber);
console.log(typeof uniqueId);
// Output: bigint
// Output: symbol
How it works: The n suffix tells TypeScript this is a bigint, not a number. The Symbol("id") call creates a new symbol with a description. Both types are less common in day-to-day code but matter when you work with large integers or unique keys.
What Are null, undefined, and void?
null means "no value on purpose." undefined means "no value assigned yet." void is used for functions that return nothing. With strictNullChecks on, TypeScript treats null and undefined as separate types that you must handle.
let middleName: string | null = null;
middleName = "Kumar";
function logMessage(message: string): void {
console.log(message);
}
logMessage("Done");
// Output: Done
How it works: The string | null annotation is a union type, which means the value can be a string or null. The void return type on logMessage says the function returns nothing. Under strict mode, if you tried to call middleName.toUpperCase() while it could be null, TypeScript would warn you to check for null first.
Why Does strictNullChecks Matter?
strictNullChecks is a compiler option that, when on, prevents you from using null or undefined where a real value is expected. It is part of "strict": true. Without it, null and undefined are allowed everywhere, which hides bugs.
function getLength(text: string): number {
return text.length;
}
// getLength(null);
// Error: Argument of type 'null' is not assignable to parameter of type 'string'.
console.log(getLength("TypeScript"));
// Output: 10
How it works: With strictNullChecks on, null is not a valid string. The compiler blocks the call before it runs. This prevents the common runtime crash "Cannot read properties of null." In real projects, this one option catches many bugs.
Summary Table of TypeScript Data Types
| Type | Example Value | Typical Use |
|---|---|---|
string |
"hello" |
Names, messages, text |
number |
42 or 3.14 |
Counts, prices, scores |
boolean |
true or false |
Flags, yes/no states |
bigint |
9007199254740993n |
Very large integers |
symbol |
Symbol("id") |
Unique keys |
null |
null |
Intentional empty value |
undefined |
undefined |
Not yet assigned |
void |
(no value) | Functions that return nothing |
Common Mistakes and Best Practices
- Using uppercase
String,Number,Boolean. These refer to object wrapper types, not primitives. Always use lowercasestring,number,boolean, because the lowercase versions are what TypeScript checks for and what your code actually holds. - Turning off
strictNullChecksto "fix" errors. This hides real problems. Instead, handlenullwith a check likeif (value !== null)before using the value. - Using
numberfor very large integers. Values beyondNumber.MAX_SAFE_INTEGERlose precision. Usebigintwhen you need exact large integers. - Forgetting that
undefinedcan still appear at runtime. Even with strict checks, a value from an API or a missing object property may beundefined. Always guard against it. - Declaring a variable as
void.voidis for function return types only. Using it on a variable is a mistake the compiler will reject.
Real-World Example: A User Profile
Here is a small, realistic example that uses several primitive types together.
type UserProfile = {
id: number;
name: string;
isActive: boolean;
balance: bigint;
nickname: string | null;
};
function displayUser(user: UserProfile): void {
const nick = user.nickname ?? "no nickname";
console.log(`User #${user.id}: ${user.name}`);
console.log(`Active: ${user.isActive}`);
console.log(`Balance: ${user.balance}`);
console.log(`Nickname: ${nick}`);
}
const profile: UserProfile = {
id: 101,
name: "Anaya",
isActive: true,
balance: 5000000000000001n,
nickname: null,
};
displayUser(profile);
// Output:
// User #101: Anaya
// Active: true
// Balance: 5000000000000001
// Nickname: no nickname
How it works, line by line. The UserProfile type groups several primitive types into one shape. id is a number, name is a string, isActive is a boolean, balance is a bigint, and nickname is a union of string and null. The displayUser function accepts a UserProfile and returns void. Inside, user.nickname ?? "no nickname" uses the nullish coalescing operator, which returns the right side when the left is null or undefined. The template literals build readable output. When you run this code, TypeScript checks every field against the type. If you set id: "101" instead of 101, the compiler would report an error before the code runs.
Summary
- TypeScript data types describe what kind of value a variable holds and help catch bugs early.
- The primitive types are
string,number,boolean,bigint,symbol,null,undefined, andvoid. - Use lowercase type names like
string, notString, because uppercase versions are object wrappers. - A type annotation is written as
: typeafter the variable name. strictNullCheckskeepsnullandundefinedfrom slipping into places that expect real values.- The
voidtype is for functions that return nothing.
Now that you know the basic types, continue to the Type Inference & Annotations tutorial to learn when TypeScript can figure out types for you and when to write them explicitly.
Frequently Asked Questions
What is the difference between string and String in TypeScript?
Lowercase string is a primitive type and is what you should always use. Uppercase String refers to the object wrapper created by new String("text"). TypeScript treats them differently, and primitive string is the correct choice for annotations. Using String can lead to confusing type errors.
Do I need to annotate every variable in TypeScript?
No. TypeScript can infer types from the assigned value, so const name = "Riya" is already known to be a string. Annotations are helpful when the type is not obvious, when you declare a variable without a value, or when you want to document your intention clearly. Use them where they add value.
What does the void type mean in TypeScript?
void is the return type for functions that do not return a value. For example, a function that only calls console.log returns nothing, so you write : void. It cannot be used for variable declarations. It signals that the function's purpose is to perform an action, not produce a result.
Why does TypeScript complain when I assign null to a string variable?
Because strictNullChecks is on, null is treated as a separate type that is not assignable to string. This is intentional: it forces you to handle the empty case before using the value. To allow null, use a union type like string | null and check for null before using the value.
What happens if I use number for a value larger than Number.MAX_SAFE_INTEGER?
The value may lose precision because JavaScript numbers are floating-point. TypeScript will not stop you at compile time, but the runtime result may be wrong. Use bigint for very large integers by adding n after the number, such as 9007199254740993n, to keep exact precision.
Practice Exercises
Exercise 1 (Easy): Declare Variables with Types
Declare one variable for each primitive type: string, number, boolean, and bigint. Print each value.
Show solution
const city: string = "Mumbai";
const population: number = 20000000;
const isCapital: boolean = false;
const bigValue: bigint = 9007199254740993n;
console.log(city, population, isCapital, bigValue);
// Output: Mumbai 20000000 false 9007199254740993n
Each variable uses a lowercase type annotation, and bigint uses the n suffix to keep precision.
Exercise 2 (Easy): Use a Template Literal
Create two string variables called firstName and lastName. Combine them into a full name using a template literal.
Show solution
const firstName: string = "Kiran";
const lastName: string = "Patel";
const fullName: string = `${firstName} ${lastName}`;
console.log(fullName);
// Output: Kiran Patel
Template literals use backticks and ${} to insert variables. The result is a new string typed automatically.
Exercise 3 (Medium): Handle null with a Union Type
Declare a variable that can be string | null. Assign null, then assign a string. Print both states.
Show solution
let nickname: string | null = null;
console.log(nickname ?? "no nickname");
nickname = "Avi";
console.log(nickname ?? "no nickname");
// Output:
// no nickname
// Avi
The ?? operator returns the right side when the value is null or undefined, keeping the code safe under strict mode.
Exercise 4 (Challenge): Write a void Function and a Type Error
Write a function that accepts a string and returns void. Then show an intentional type error by passing a number.
Show solution
function printLabel(label: string): void {
console.log(`Label: ${label}`);
}
printLabel("Grocery");
// printLabel(99);
// Error: Argument of type 'number' is not assignable to parameter of type 'string'.
// Output: Label: Grocery
The void return type means the function produces no value. The commented line shows the real compiler error for passing a number.
Written by Shaikh Abdul Shahid
A Full-Stack Developer with experience in PHP, Laravel, JavaScript, and React.
Founder of Online Learner, sharing practical knowledge and programming tutorials.
Building and maintaining real-world web applications since 2017.
Your Feedback
Help us improve by sharing your thoughts.
Online Learner helps developers master programming, database concepts, interview preparation, and real-world implementation through structured learning paths.
Quick Links
© 2023 - 2026 OnlineLearner.in | All Rights Reserved.
