TypeScript Types: string, number, boolean and More

TypeScript types describe what kind of value a variable can hold. You write a type after a colon, let name: string, and the compiler rejects any code that puts the wrong kind of value there. The basic types are the seven JavaScript primitives plus object types for arrays and objects.

let title: string = "TypeScript";
let version: number = 7;
let isStrict: boolean = true;
let big: bigint = 9007199254740993n;
let id: symbol = Symbol("id");
let nothing: null = null;
let notSet: undefined = undefined;

let scores: number[] = [90, 72, 85];
let user: { name: string; age: number } = { name: "Ada", age: 36 };

console.log(title, version, isStrict, big, id);
console.log(nothing, notSet);
console.log(scores, user);

The annotations are checked at compile time and then removed. The program that runs is plain JavaScript.

The Primitive Types

The type names are lowercase. typeof at runtime returns the same words for most of them, so typeof x === "number" is how you check a value's primitive type while the program runs.

Type Annotations

An annotation is : Type after a variable, a parameter or a function's parameter list. Parameters are where annotations matter most, because TypeScript cannot guess what a caller will pass.

function describe(name: string, age: number, admin: boolean): string {
    return `${name} (${age})${admin ? " [admin]" : ""}`;
}

let label: string = describe("Ada", 36, true);
console.log(label); // Ada (36) [admin]

// Without an annotation, TypeScript infers the type from the value:
let count = 10; // count: number
count = count + 1;
console.log(count); // 11

When a variable is initialized on the same line, the annotation is usually redundant: let count = 10 already has type number. The rules for leaving types out are on the type inference page.

A Wrong Type Is a Compile Error

Assign a value of the wrong type and the compiler stops before anything runs:

// This does not compile: a string is not a number.
let port: number = 8080;
port = "3000";
console.log(port);

The compiler prints:

index.ts(3,1): error TS2322: Type 'string' is not assignable to type 'number'.

The fix is to convert the value, port = Number("3000"), or to change the annotation if the variable really should hold text.

number: There Is No Integer Type

JavaScript stores every number as a 64-bit floating point value, so TypeScript has a single number type. Integers are exact up to Number.MAX_SAFE_INTEGER (2 ** 53 - 1). Past that, use bigint.

let price: number = 19.99;
let quantity: number = 3; // also number: no int type

console.log(Number.isInteger(quantity)); // true
console.log(Number.isInteger(price));    // false
console.log(Math.trunc(7 / 2));          // 3 (integer division)
console.log(0.1 + 0.2);                  // 0.30000000000000004

console.log(Number.MAX_SAFE_INTEGER);     // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 2); // 9007199254740992 (wrong)

let exact: bigint = 9007199254740991n + 2n;
console.log(exact); // 9007199254740993n

// @ts-expect-error: bigint and number cannot be mixed
const mixed = () => exact + 1;
console.log(exact + BigInt(1), Number(exact)); // 9007199254740994n 9007199254740992

bigint and number do not mix: exact + 1 is a compile error (TS2365: Operator '+' cannot be applied to types 'bigint' and '1'., where '1' is the literal type of the 1) and, if it ever ran, a TypeError at runtime too. Convert one side explicitly with BigInt(1) or Number(exact), knowing that Number rounds values past the safe range.

If you want a type that only accepts whole numbers, TypeScript cannot express it for arbitrary values. Validate with Number.isInteger where the value enters your program.

boolean

boolean has exactly two values, true and false. Values that are merely truthy (1, "yes") are not booleans, so turn them into one with Boolean(x) or x !== 0.

let loggedIn: boolean = false;
const items: string[] = ["a", "b"];

const hasItems: boolean = items.length > 0;
const hasName: boolean = Boolean("Ada");

console.log(loggedIn, hasItems, hasName); // false true true

null and undefined

With strict on (the default since TypeScript 6.0), null and undefined are separate types and are not part of string, number or any other type. A variable that may be empty says so with a union:

let nickname: string | undefined;
console.log(nickname); // undefined

nickname = "Ace";
console.log(nickname.toUpperCase()); // ACE

let middleName: string | null = null;
console.log(middleName ?? "(none)"); // (none)

Reading a property of a value that might be undefined is a compile error until you check it. The null and undefined page covers the checks, ?. and ??.

Arrays and Objects at a Glance

Anything that is not a primitive is an object type. The three shapes you meet first:

let tags: string[] = ["ts", "js"];               // array of strings
let point: { x: number; y: number } = { x: 1, y: 2 }; // object with two number properties
let greet: (name: string) => string = (n) => `hi ${n}`; // function type

Each has its own page: arrays, tuples (fixed-length arrays), object types and function types.

string, number, boolean vs String, Number, Boolean

The capitalized names are the types of JavaScript's wrapper objects (new String("x")), not of ordinary values. Annotate with the lowercase names.

// This does not compile: String (the wrapper) is not string (the primitive).
const wrapped: String = "text";
const plain: string = wrapped;
console.log(plain);

index.ts(3,7): error TS2322: Type 'String' is not assignable to type 'string'.
  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.

Change String to string on the first line and the block runs. The same applies to Number, Boolean, Symbol and BigInt. (Object is a different case: it accepts almost any value, primitives included; see object types.)

Other Built-in Types

A few more types come up early. Each has its own page.