Exploring TypeOf in TypeScript

TypeScript is a language for application-scale JavaScript development, offering type-checking to developer, making it easier to find and fix errors before our apps run. Typescript gives us a much better way of describing the shape of our objects than we have in JavaScript.

One powerful feature in TypeScript is the TypeOf keyword. In this article, I will explain types and how the TypeOf keyword can be used in TypeScript.

Types in TypeScript

In TypeScript, types are simply a way of specifying what values our variables can take. Just as we can define things with interfaces or classes, we can define types using type aliases in TypeScript.

For example, suppose we’re working with an application that deals with animal objects. We can define an interface like the following:

interface Animal {
name: string;
age: number;
species: string;

This interface specifies that any animals we create must have a name, an age and a species. We could then create an object with properties that match that interface:

const dog: Animal = {
name: ‘Rex’,
age: 4,
species: ‘Dog’

This object has the correct properties (name, age, and species) with appropriate values for each one, so it is considered a valid Animal object. But what if we don’t want to manually specify each type and just want to get the type of a variable? That’s where the TypeOf keyword comes in.

The TypeOf Keyword

The TypeOf keyword allows us to get the type of a value at runtime. In TypeScript, it can be used in two ways:

  • TypeOf as a type query – to reference the type of a variable in the type system.
  • TypeOf as a value – to get the type of a value at runtime.

TypeOf as a type query

We can use TypeOf to reference the type of a variable:

const name = ‘John’;
type NameType = typeof name;

Here, we create a variable called name that is a string. We then create a type alias called NameType that is set equal to TypeOf name, which is the type of the variable. The type of name is string, so the type of NameType is also string.

TypeOf as a value

We can also use TypeOf to get the type of a value at runtime:

const age = 27;
const typeOfAge = typeof age;
console.log(typeOfAge); // logs “number”

Here, we create a variable called age that is a number. We then create a variable called typeOfAge that is set equal to TypeOf age, which is the type of the value. Since age is a number, TypeOf age evaluates to “number” and that is what is logged to the console.


What is the difference between type and interface in TypeScript?

Type and interface are used to define how TypeScript will treat a given set of values. Types and interfaces can behave in similar ways, but there are some key differences:

  • Type: A type is a way to create a new name for an existing type.
  • Interface: An interface is a way to describe the shape of an object.

When do I use TypeOf in TypeScript?

The TypeOf keyword is most commonly used when trying to get the type of a variable. This can be useful if you want to dynamically create an object that has the same types as an existing object without having to manually specify every type. It is also useful for type checking at runtime and validating data.

Can I use TypeOf with any value?

Yes, you can use TypeOf with any value. However, there are some limitations to using TypeOf with complex objects. TypeOf can only evaluate the type of the first level of an object. Nested properties will not be evaluated, so it is important to know the structure of any complex objects that you use TypeOf with.

Is TypeOf unique to TypeScript?

No, TypeOf is not unique to TypeScript. It is also available in JavaScript as a way to get the type of a value at runtime. However, TypeScript adds type-checking capabilities to this functionality, so it can be especially useful when working with larger applications.


TypeOf is a powerful tool in TypeScript, allowing us to get the type of a value at runtime, reference the type of a variable in the type system and validate data. It can be used in a variety of scenarios to make our code more efficient and easier to read. By using TypeOf, we can create objects that match the shape of existing objects without having to manually specify every type. With its type-checking capabilities, TypeScript makes TypeOf even more useful in larger applications.

Similar Posts