DEV Community

Cover image for TypeScript Core Concepts Explained for Absolute Beginners
Amir H. Moayeri
Amir H. Moayeri

Posted on

TypeScript Core Concepts Explained for Absolute Beginners

TypeScript, a superset of JavaScript, has taken the development world by storm with its focus on static typing. While similar to JavaScript, it adds an extra layer of type annotations, empowering developers to write more robust and maintainable code. But what are the core concepts that make TypeScript tick? Let's dive in and explore them with examples!

1. Type Annotations: The heart of TypeScript lies in explicitly defining the data types of variables, functions, and other constructs. This means no more guessing what type a variable holds, leading to fewer runtime errors and better code understanding.

Example:

let name: string = "John Doe"; // name must be a string
let age: number = 30;           // age must be a number
Enter fullscreen mode Exit fullscreen mode

2. Primitive Types: TypeScript provides fundamental building blocks like string, number, boolean, and more. These represent basic data types used throughout your code.

Example:

let isDone: boolean = true;  // isDone can be true or false
let price: number = 19.99;    // price is a floating-point number
let name: string = "John" // name is a string
Enter fullscreen mode Exit fullscreen mode

3. Arrays and Objects: Similar to JavaScript, TypeScript allows working with arrays and objects. However, you can define the types of elements within an array or the properties of an object, ensuring data consistency.

Example:

let numbers: number[] = [1, 2, 3]; // numbers must be an array of numbers
let person: { name: string, age: number } = { name: "Jane", age: 25 };
// person must have properties name (string) and age (number)
Enter fullscreen mode Exit fullscreen mode

4. Functions: Define clear expectations for function inputs and outputs using type annotations. This enhances code clarity and avoids unexpected behavior.

Example:

function add(x: number, y: number): number {
  return x + y;
}

const result = add(5, 10); // result will be a number (15)
Enter fullscreen mode Exit fullscreen mode

5. Interfaces: Create blueprints for objects, outlining the properties and their types. This ensures objects adhere to a specific structure, promoting consistency and reusability.

Example:

interface Product {
  id: number;
  name: string;
  price: number;
}

const product: Product = { id: 1, name: "T-shirt", price: 15.0 };
// product must have properties id (number), name (string), and price (number)
Enter fullscreen mode Exit fullscreen mode

6. Classes: Encapsulate data and behavior using classes. Similar to interfaces, you can define the types of properties and methods, leading to well-structured and maintainable code.

Example:

class User {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, my name is ${this.name}!`);
  }
}

const user = new User("Alice", 35);
user.greet(); // Output: Hello, my name is Alice!
Enter fullscreen mode Exit fullscreen mode

7. Generics: Write flexible code that can work with different data types using generics. This reduces code duplication and promotes maintainability.

Example:

function identity<T>(value: T): T {
  return value;
}

const number = identity(5); // number will be of type number
const string = identity("hello"); // string will be of type string
Enter fullscreen mode Exit fullscreen mode

Remember, this is just a glimpse into the vast world of TypeScript! Explore these concepts further and leverage them to create robust, type-safe applications that stand the test of time. Happy coding!

Top comments (10)

Collapse
 
keyurparalkar profile image
Keyur Paralkar

Nice explanation.

A great place to practice and master typescript is this repository: github.com/type-challenges/type-ch...

It contains challenges along with the solution. Found it super helpful

Collapse
 
junlow profile image
jun

Your explanation is clear and easy to understand 😊 I like Generics, which are great for flexible code that handles various data types without repetition. I also use 'extends' to narrow down the generic value when needed!

Collapse
 
anirseven profile image
Anirban Majumdar

Thanks for sharing this, its a good starting point

Collapse
 
_ndeyefatoudiop profile image
Ndeye Fatou Diop

Great explanation ! I would also recommend the book Programming Typescript to any beginner => oreilly.com/library/view/programmi...

Collapse
 
sophyia profile image
Sophia Iroegbu

Amazing guide. Thanks for sharing this.

Collapse
 
get_pieces profile image
Pieces 🌟

Great explanation! πŸ”₯

Collapse
 
aramdata profile image
aramdata

Good article, nice job ⭐

Collapse
 
ericmasila profile image
Eric

Thank you...this is a good starting point for newbies

Collapse
 
hriztam profile image
Hritam Shrivatava

Awesome article,
some place I can connect with you?

Collapse
 
renewabristol profile image
Tom Sain

given how much TS has evolved in its own right, is it right to still call it a "superset" of JS?