TypeScript Basic Structure

A TypeScript program can consist of the following parts. Understanding these basic structures helps us organize and write clearer, more modular code.

1. Modules

In TypeScript, every file containing a top-level import or export is considered a module. Modules have their own scope, and variables, functions, classes, etc. inside a module are not visible outside unless you explicitly export them using export.

Other files can use the import statement to import exported content from a module.

math.ts (module)

// Export a constant
export const PI = 3.14;

// Export a function
export function add(x: number, y: number): number {
    return x + y;
}

app.ts (another module)

// Import PI and add from the math.ts module
import { PI, add } from './math';

console.log(PI); // 3.14
console.log(add(5, 3)); // 8

Modularization is the foundation for building large applications, helping with code organization, reuse, and dependency management.

2. Functions

Functions are code blocks that perform specific tasks. Functions in TypeScript can have parameters and return values, and you can specify types for them.

// A simple function with type annotations
function greet(name: string): string {
    return `Hello, ${name}`;
}

let message = greet("TypeScript");
console.log(message);

3. Classes

Classes are blueprints for creating objects. They encapsulate data (properties) and methods that operate on the data.

class Greeter {
    // Property
    greeting: string;

    // Constructor
    constructor(message: string) {
        this.greeting = message;
    }

    // Method
    greet() {
        return "Hello, " + this.greeting;
    }
}

// Create an object instance using the class
let greeter = new Greeter("world");
console.log(greeter.greet());

4. Interfaces

Interfaces are a powerful feature in TypeScript, used to define the "contract" or "shape" of objects. They only contain declarations of properties and methods, not implementations.

// Define an interface
interface Person {
    firstName: string;
    lastName: string;
}

// Function parameter uses interface as type
function welcome(person: Person) {
    return `Hello, ${person.firstName} ${person.lastName}`;
}

let user = { firstName: "Jane", lastName: "User" };

console.log(welcome(user));

5. Variables and Statements

The core of a program consists of variables and statements.

• Variables: Used to store data. Declared using let or const.
• Statements: Perform an action, such as variable assignment, function calls, flow control (if, for, etc.).

// Variable declaration and assignment
let a: number = 10;
const b: number = 20;

// Conditional statement
if (a < b) {
    console.log("a is less than b");
}

// Loop statement
for (let i = 0; i < 3; i++) {
    console.log(i);
}

Combining these basic structures allows you to build feature-rich TypeScript applications.