What is namespace in Typescript ?

In TypeScript, a namespace is a way to organize code logically and prevent naming conflicts between identifiers. It allows developers to group related functionalities, such as interfaces, classes, functions, and variables, within a dedicated scope.

Namespaces are particularly useful for structuring large applications, avoiding global scope pollution, and maintaining a clear hierarchy.

Declaring and Using a Namespace in TypeScript

Here’s a simple example demonstrating how to create and use a namespace in TypeScript:

namespace Geometry {
  export class Circle {
    constructor(public radius: number) {}

    area(): number {
      return Math.PI * this.radius ** 2;
    }
  }
}
const circle = new Geometry.Circle(5);
console.log(circle.area());

• Namespace Declaration: The Geometry namespace encapsulates the Circle class, ensuring that its members are scoped within this namespace.
• Class Definition: The Circle class has a constructor to set the radius and a method area() to calculate the area of the circle.
• Object Instantiation: An instance of Circle is created with a radius of 5.
• Method Invocation: The area() method is called on the circle instance to compute and log the area.

Output:

78.53981633974483

More Examples of Namespace in TypeScript

Declaring and Accessing a Simple Namespace

namespace MyNamespace {
  export function myFunction() {
    console.log('This is my function in MyNamespace');
  }
}

MyNamespace.myFunction();

• Namespace Declaration: MyNamespace is defined using the namespace keyword, encapsulating the myFunction function.
• Function Definition: myFunction logs a message to the console.
• Export Keyword: The export keyword makes myFunction accessible outside the MyNamespace namespace.
• Function Invocation: myFunction is called using dot notation: MyNamespace.myFunction().

Output:

This is my function in MyNamespac

Declaring and Accessing a Nested Namespace

namespace MyNamespace {
  export namespace MySubNamespace {
    export function myFunction() {
      console.log('This is my function in MySubNamespace');
    }
  }
}

MyNamespace.MySubNamespace.myFunction();

• Nested Namespace Declaration: MySubNamespace is defined inside MyNamespace, creating a hierarchical structure.
• Function Definition: myFunction logs a message to the console.
• Export Keyword: The export keyword makes myFunction accessible outside the MySubNamespace namespace.
• Function Invocation: myFunction is called using dot notation: MyNamespace.MySubNamespace.myFunction().

Output: 

"This is my function in MySubNamespace" 

Benefits of Using Namespaces

• Organize Code: Namespaces help group related code together, making it easier to manage and maintain.
• Prevent Conflicts: They avoid naming issues by keeping your code in its own unique space.
• Hide Details: You can keep internal code hidden and only show the necessary parts to the outside world.
• Break Down Code: Namespaces let you divide a large project into smaller, easier-to-manage pieces.

Namespaces vs. Modules in TypeScript

Here are the main differences between Namespaces and Modules in TypeScript: