DEV Community: Jeferson Eiji

How TypeScript Empowers Advanced Object-Oriented Programming: Inheritance and Polymorphism Explained

Jeferson Eiji — Wed, 29 Apr 2026 14:05:20 +0000

TypeScript expands JavaScript’s capabilities by offering robust support for object-oriented programming (OOP) principles, particularly inheritance and polymorphism. Here’s how TypeScript helps you create scalable and powerful applications using these concepts:

Inheritance in TypeScript

Inheritance enables you to build hierarchies between classes, so that child classes inherit members (fields, methods) from parent classes.

Example:

class Animal {
  speak() {
    console.log('The animal makes a sound');
  }
}

class Dog extends Animal {
  speak() {
    console.log('The dog barks');
  }
}

const dog = new Dog();
dog.speak(); // Output: The dog barks

extends keyword establishes the relationship between Dog and Animal.
Method overriding allows specialization in child classes.

Polymorphism in TypeScript

Polymorphism allows objects of different classes to be treated as objects of a common parent class, enabling flexibility and reuse.

Example:

class Cat extends Animal {
  speak() {
    console.log('The cat meows');
  }
}

function makeAnimalSpeak(animal: Animal) {
  animal.speak();
}

const animals: Animal[] = [new Dog(), new Cat()];
animals.forEach(makeAnimalSpeak); 
// Output:
// The dog barks
// The cat meows

Polymorphic behavior is achieved since makeAnimalSpeak accepts any Animal type, letting Dog and Cat specialize behavior.

Key Takeaways

TypeScript enforces OOP principles at compile time, reducing runtime errors.
Classes and interfaces further enhance OOP design, allowing solid code architectures.
TypeScript provides clear syntax for inheritance, overrides, and polymorphic method calls.

By leveraging TypeScript’s OOP features, you can write clearer, reusable, and scalable code for complex applications.

Static vs Dynamic Typing in TypeScript: Key Differences Explained

Jeferson Eiji — Mon, 27 Apr 2026 14:07:22 +0000

Static vs Dynamic Typing in TypeScript: Key Differences

Understanding the type system in programming is crucial for writing safer and more maintainable code. Let’s break down the key differences between static and dynamic typing, especially in the context of TypeScript.

Static Typing

Types are checked at compile time, before the code is run.
Errors related to mismatched types are caught early, during development.
TypeScript is a statically typed superset of JavaScript.

Example:

let age: number = 25;
age = "twenty-five"; // Error: Type 'string' is not assignable to type 'number'.

Dynamic Typing

Types are checked at runtime, while the code is running.
Type errors may only appear when the program is actually executed.
JavaScript is a dynamically typed language.

Example:

let age = 25;
age = "twenty-five"; // No error at this point; type changes to string

Why TypeScript Matters

TypeScript allows developers to catch type-related bugs during development, reducing runtime errors.
You can also opt out of static typing with any, but this removes many of TypeScript’s benefits.

Example:

let value: any = 10;
value = "now I'm a string!"; // No error

In summary:

TypeScript: statically typed (checks types at compile time)
JavaScript: dynamically typed (checks types at runtime)

Choosing between static and dynamic typing affects code safety, developer productivity, and error detection timing.

Understanding Mixins in TypeScript: Concept and Examples

Jeferson Eiji — Mon, 20 Apr 2026 14:05:22 +0000

What Are Mixins in TypeScript?

Mixins in TypeScript provide a way to reuse code across multiple classes without using traditional inheritance. A mixin is a class or function containing properties or methods that can be added to other classes, offering flexible code sharing beyond single inheritance.

Why Use Mixins?

Avoid duplication: Share common methods across different classes
Flexible composition: Combine features from multiple sources
Workaround TypeScript limitations: TypeScript (and JavaScript) only support single class inheritance

How Mixins Work

Mixins are implemented by writing functions that take a base class and extend it with new functionality. TypeScript supports this using interfaces and higher-order functions.

Example: Creating a Simple Mixin

// A generic constructor type
 type Constructor<T = {}> = new (...args: any[]) => T;

// Mixin function
function Flyer<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    fly() {
      console.log('Flying!');
    }
  };
}

// Using the mixin
class Animal {
  move() {
    console.log('Moving!');
  }
}

// Apply the Flyer mixin to Animal
class Bird extends Flyer(Animal) {}

const sparrow = new Bird();
sparrow.move(); // Output: Moving!
sparrow.fly();  // Output: Flying!

Key Points to Remember

Mixins allow combining behaviors from multiple sources, solving the single inheritance issue.
Use interface to declare what mixin methods will be available.
Always use constructor signatures for mixin functions.

Another Example: Multiple Mixins

function Swimmer<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    swim() {
      console.log('Swimming!');
    }
  };
}

class Fish extends Swimmer(Flyer(Animal)) {}

const goldfish = new Fish();
goldfish.move(); // Output: Moving!
goldfish.fly();  // Output: Flying!
goldfish.swim(); // Output: Swimming!

Conclusion

Mixins are a powerful pattern in TypeScript for reusing functionality without complex inheritance chains. They help organize code more clearly and encourage composition over inheritance.

Understanding Utility Types in TypeScript: Partial, Readonly, Pick, and Record Explained with Examples

Jeferson Eiji — Wed, 15 Apr 2026 14:13:20 +0000

What are Utility Types in TypeScript?

Utility types in TypeScript are built-in generic types that help transform or construct new types based on existing ones. They simplify type manipulations, making your code safer and more expressive. Here are some of the most commonly used utility types:

1. `Partial<Type>`

Purpose: Makes all properties of a type optional.
When to use: When you want to update part of an object or have optional fields temporarily.

Example:

type User = { id: number; name: string; age: number };
let userUpdate: Partial<User> = { name: "Alice" };
// userUpdate only needs to provide any subset of User's fields

2. `Readonly<Type>`

Purpose: Makes all properties of a type immutable.
When to use: When you want to prevent object properties from being changed after creation.

Example:

type Config = { apiKey: string; timeout: number };
const config: Readonly<Config> = { apiKey: "123", timeout: 500 };
// config.apiKey = "456"; // Error: cannot assign to 'apiKey' because it is a read-only property

3. `Pick<Type, Keys>`

Purpose: Constructs a type by picking a set of properties from another type.
When to use: When you only need a subset of object properties.

Example:

type User = { id: number; name: string; age: number };
type UsernameOnly = Pick<User, "name">;
// UsernameOnly is { name: string }

4. `Record<Keys, Type>`

Purpose: Constructs a type with a set of properties Keys, each of type Type.
When to use: When you want to map keys to values of a consistent type, like dictionaries or lookup tables.

Example:

type ErrorMessages = Record<string, string>;
const errors: ErrorMessages = {
  "404": "Not Found",
  "500": "Server Error"
};

Summary Table

Utility	Use Case Example
Partial	Optional update objects
Readonly	Prevent mutation after creation
Pick	Selecting some fields from a type
Record	Dictionaries with typed values

Mastering these utility types will help you write cleaner, more flexible, and type-safe TypeScript code.

Understanding Decorators in TypeScript: A Clear and Practical Guide

Jeferson Eiji — Mon, 13 Apr 2026 14:04:18 +0000

What Are Decorators in TypeScript?

Decorators are a special kind of declaration in TypeScript that can be attached to classes, methods, accessors, properties, or parameters. They allow you to add annotations or meta-programming syntax for class declarations and members.

Think of decorators as functions that wrap or modify pieces of your code.

How Decorators Work

A decorator is a function applied to the thing it decorates (class, method, property, etc).
Decorators receive information about the decorated element, such as the target, key, and descriptor.
You can use them to alter behavior, add metadata, or even replace functionality.

Note: Decorators are an experimental feature and require "experimentalDecorators": true in tsconfig.json.

Types of Decorators

Class Decorators
Property Decorators
Method Decorators
Parameter Decorators

Example: Class and Method Decorators

// A simple class decorator
function Logger(constructor: Function) {
  console.log(`New instance created: ${constructor.name}`);
}

@Logger
class ExampleClass {
  sayHello() {
    console.log('Hello!');
  }
}

What happens: When an instance of ExampleClass is created, the Logger function logs the class name.

Method Decorator Example:

function LogMethod(target: Object, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function (...args: any[]) {
    console.log(`Called ${propertyKey} with`, args);
    return originalMethod.apply(this, args);
  };
}

class Calculator {
  @LogMethod
  add(a: number, b: number) {
    return a + b;
  }
}
// When you call new Calculator().add(1,2), it logs: "Called add with [1,2]"

Summary

Decorators are a powerful way to modify or annotate code in TypeScript.
They help with logging, validation, dependency injection, and more.
Always enable experimentalDecorators in your configuration file to use them.

Mastering Classes and Access Modifiers in TypeScript: Public, Private, Protected Explained

Jeferson Eiji — Wed, 08 Apr 2026 14:10:23 +0000

TypeScript offers robust support for object-oriented programming with classes, interfaces, and access modifiers. Understanding how to define and secure your class properties is key to writing maintainable and safe code.

Access Modifiers in TypeScript

public (default): Property or method can be accessed from anywhere.
private: Access is limited to within the class itself.
protected: Accessible in the class and its subclasses, but not from outside.

Example: Defining a Class with Access Modifiers

class Animal {
    public name: string;      // Accessible anywhere
    private age: number;      // Only inside Animal
    protected type: string;   // Animal and subclasses

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

    public getName() {
        return this.name;
    }

    private getAge() {
        return this.age;
    }
}

class Dog extends Animal {
    constructor(name: string, age: number) {
        super(name, age, "Dog");
    }

    public describeDog(): string {
        // Can use this.type (protected), not this.age (private)
        return `${this.name} is a ${this.type}`;
    }
}

const myDog = new Dog("Buster", 5);
console.log(myDog.name);          // Accessible (public)
// console.log(myDog.age);       // Error! age is private
// console.log(myDog.type);      // Error! type is protected
console.log(myDog.describeDog()); // Buster is a Dog

Key Takeaways

Use private for sensitive data.
Use protected if subclasses need access.
Use public for properties/methods that can be exposed.

Remember: Clearly marking your class fields helps enforce intended usage and prevents bugs!

What Are Declaration Files (.d.ts), and Why Are They Important in TypeScript?

Jeferson Eiji — Mon, 06 Apr 2026 14:10:25 +0000

What Are Declaration Files (.d.ts)?

In TypeScript, declaration files are files with the extension .d.ts. They provide type information about JavaScript code so that TypeScript can understand how existing JavaScript libraries or modules should be typed.

Why Are They Important?

Type Safety for JavaScript Libraries: Many popular JavaScript libraries do not come with TypeScript type definitions by default. Declaration files bridge this gap by describing the shape of modules, functions, classes, and variables in those libraries.
IntelliSense & Editor Support: Declaration files allow editors (like VS Code) to provide features such as code completion, parameter hints, and documentation popups even for plain JavaScript libraries.
Documentation: They serve as a form of live documentation for code, making it clearer how to use APIs, functions, or objects properly.
Compilation Checks: With accurate declaration files, TypeScript's compiler can catch errors early, before your code even runs.

How Are Declaration Files Used?

For libraries:
- TypeScript looks for a @types package (like @types/lodash) or a local .d.ts file.
- These files might be included with the library, but they are often installed separately for popular libraries.
For your own code:
- Create .d.ts files to describe global variables, extend existing modules, or share type information without exposing implementation details.

Example

Suppose you have a JavaScript module, math-utils.js:

// math-utils.js
function add(a, b) { return a + b; }
module.exports = { add };

You can write a corresponding declaration file:

// math-utils.d.ts
declare module "math-utils" {
  export function add(a: number, b: number): number;
}

Now, when you import math-utils in TypeScript, you get full type support.

Summary: Declaration files are critical for bringing static type checking and developer tooling to JavaScript libraries and codebases when using TypeScript. They ensure safer, more reliable, and more productive development.

How TypeScript Handles Type Compatibility

Jeferson Eiji — Mon, 30 Mar 2026 14:01:29 +0000

TypeScript uses a structural type system to check type compatibility, which means it focuses on the shape and structure of data, rather than explicit declarations. Here’s how it works:

Key Points:

Structural vs Nominal Typing: Unlike nominally typed languages (like Java or C#), TypeScript cares about what members an object has, not its name.
Compatibility Rules:
- If an object has at least the required properties and their types, it is considered compatible.
- Extra properties do not cause errors when assigning objects (known as ‘duck typing’).

Example: Object Compatibility

interface Point { x: number; y: number; }
let p: Point = { x: 1, y: 2 };
let q = { x: 1, y: 2, z: 3 };
p = q; // OK: q has at least the properties of Point (x, y)

Function Compatibility Example:

let a = (x: number) => 1;
let b = (x: number, y: string) => 1;
a = b; // Error: parameter count mismatch
b = a; // OK: extra parameters in b are ignored

Assignment Compatibility:

Functions: Can assign a function with fewer parameters to one expecting more (optional/extra parameters are allowed on the right side).
Classes: Instance members are checked, but private/protected members can restrict assignment.

Summary Table
| Feature | TypeScript compatibility rule |
|------------|--------------------------------------------------|
| Object | Shape-based (members must match) |
| Functions | Parameter count and types; extra params ignored |
| Classes | Instance members checked (private/protected count) |

Practically, TypeScript makes working with types flexible by looking at data structure rather than requiring strict inheritance or declarations.

Mastering unknown vs never Types in TypeScript: Differences and Use Cases

Jeferson Eiji — Wed, 25 Mar 2026 14:07:24 +0000

unknown Type

Represents any value, but is safer than any—you cannot use its value directly without type-checking or type assertion
Use when you want to accept any type but enforce type-safety downstream

Example:

function logValue(value: unknown) {
  if (typeof value === "string") {
    console.log(value.toUpperCase());
  }
}

Key Points:

Forces you to perform a type check before using the value
Useful in libraries for handling user input, JSON parsing, etc.

never Type

Represents values that never occur
Used as the return type for functions that never return (e.g., throw exceptions or have infinite loops)

Example:

function fail(message: string): never {
  throw new Error(message);
}

Key Points:

Helpful for exhaustive checks (e.g., switch statements)
Informs TypeScript that code after a never function is unreachable

When to Use Which?

Use unknown for any value you want type-checked later
Use never for impossible states or functions never meant to return

Understanding Generics in TypeScript for Improved Code Reusability

Jeferson Eiji — Mon, 23 Mar 2026 14:05:17 +0000

What Are Generics in TypeScript?

Generics are a feature in TypeScript that allow you to create reusable components that work with a variety of data types, rather than a single one. They enable you to write functions, interfaces, and classes that can operate with different data types while still maintaining type safety.

Why Use Generics?

Code Reusability: Write a function or a class once and use it for any data type.
Type Safety: TypeScript keeps track of the types used, avoiding runtime errors.
Flexibility: Functions and classes become more flexible and adaptable to changing requirements.

Example: Generic Function

Suppose you want a function to return the same argument passed to it:

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

const num = identity(5);        // num is of type number
const str = identity("hello"); // str is of type string

In this example, the type T is a placeholder that will be replaced with the actual type when the function is used. This means you can use identity with any data type.

Example: Generic Interface

interface Box<T> {
  value: T;
}

const numberBox: Box<number> = { value: 123 };
const stringBox: Box<string> = { value: "TypeScript" };

Summary

Generics make your code more reusable, safer, and adaptable. They are especially useful in utility libraries, data structures, and APIs where flexibility across multiple data types is needed.

Mastering Union and Intersection Types in TypeScript: Quick Guide with Examples

Jeferson Eiji — Wed, 18 Mar 2026 14:08:25 +0000

Union Types:

Use union types when a variable or parameter can hold values of multiple types.
Syntax: typeA | typeB
Example:

let value: string | number;
value = "hello"; // valid
value = 42;      // valid
value = true;    // invalid

Intersection Types:

Use intersection types to combine multiple types into one.
The resulting type has all properties from each type.
Syntax: typeA & typeB
Example:

type A = { a: number };
type B = { b: string };
let obj: A & B = { a: 1, b: "hello" };

Key Differences:

Union (|): Accepts values that match any member type.
Intersection (&): Requires values to satisfy all member types.

Practical Example:
Suppose you have user types:

type Admin = { name: string; admin: true };
type User = { name: string; admin?: false };

type AnyUser = Admin | User;
// Can be either Admin or User

function greet(user: AnyUser) {
  console.log(`Hello, ${user.name}`);
}

When to Use Them:

Use unions when data can be of different shapes.
Use intersections to combine multiple requirements into a single type.

Understanding the Difference Between Interface and Type in TypeScript: When to Use Each

Jeferson Eiji — Mon, 16 Mar 2026 14:14:25 +0000

When working with TypeScript, developers often encounter two ways to define shapes for objects: interface and type. While they can look similar, there are important differences and best-use cases.

Key Differences

Extensibility:
- interface can be extended multiple times by declaration merging or by using the extends keyword.
- type is closed after its definition. You can't merge or reopen a type, but you can create new types by intersecting them.
Declaration:
- Use interface for defining the shape of objects, especially when you expect the structure to grow.
- Use type for composing types, unions, primitives, and tuples.
Implements:
- Classes can implement both interfaces and types, but interfaces work more naturally with class implementation.
Union and Intersection:
- Only type can create union types (type AorB = A | B) and intersection types (type AB = A & B).

Examples

Interface Example

interface User {
  name: string;
  age: number;
}

interface User {
  email: string;
}

// Merged into:
// { name: string; age: number; email: string }

Type Example

type User = {
  name: string;
  age: number;
};
// type User = { email: string } // Error: Cannot redeclare 'User'

type StringOrNumber = string | number;

When to Use Each

Use interface when:
- You want to model the shape of objects and classes
- You expect extensions (from libraries or other code)
- Declaration merging is desirable
Use type when:
- You need to use unions or intersections
- You want to alias primitives or tuples (e.g., type Name = string or type Point = [number, number])
- Complex type composition is required

Summary Table

Feature	`interface`	`type`
Extensible/mergeable	Yes	No
Supports unions	No	Yes
Suitable for objects	Yes	Yes
Use with primitives	No	Yes
Best for classes	Yes	Yes (but `interface` best)

In practice: Use interface for data shapes and type for type transformations and combinations.

DEV Community: Jeferson Eiji

How TypeScript Empowers Advanced Object-Oriented Programming: Inheritance and Polymorphism Explained

Inheritance in TypeScript

Polymorphism in TypeScript

Key Takeaways

Static vs Dynamic Typing in TypeScript: Key Differences Explained

Static vs Dynamic Typing in TypeScript: Key Differences

Static Typing

Dynamic Typing

Why TypeScript Matters

Understanding Mixins in TypeScript: Concept and Examples

What Are Mixins in TypeScript?

Why Use Mixins?

How Mixins Work

Example: Creating a Simple Mixin

Key Points to Remember

Another Example: Multiple Mixins

Conclusion

Understanding Utility Types in TypeScript: Partial, Readonly, Pick, and Record Explained with Examples

What are Utility Types in TypeScript?

1. Partial<Type>

2. Readonly<Type>

3. Pick<Type, Keys>

4. Record<Keys, Type>

Summary Table

Understanding Decorators in TypeScript: A Clear and Practical Guide

What Are Decorators in TypeScript?

How Decorators Work

Types of Decorators

Example: Class and Method Decorators

Summary

Mastering Classes and Access Modifiers in TypeScript: Public, Private, Protected Explained

Access Modifiers in TypeScript

Example: Defining a Class with Access Modifiers

Key Takeaways

What Are Declaration Files (.d.ts), and Why Are They Important in TypeScript?

What Are Declaration Files (.d.ts)?

Why Are They Important?

How Are Declaration Files Used?

Example

How TypeScript Handles Type Compatibility

Mastering unknown vs never Types in TypeScript: Differences and Use Cases

unknown Type

never Type

When to Use Which?

Understanding Generics in TypeScript for Improved Code Reusability

What Are Generics in TypeScript?

Why Use Generics?

Example: Generic Function

Example: Generic Interface

Summary

Mastering Union and Intersection Types in TypeScript: Quick Guide with Examples

Understanding the Difference Between Interface and Type in TypeScript: When to Use Each

Key Differences

Examples

Interface Example

Type Example

When to Use Each

Summary Table

1. `Partial<Type>`

2. `Readonly<Type>`

3. `Pick<Type, Keys>`

4. `Record<Keys, Type>`