تایپ‌اسکریپت

# Global installation of TypeScript
bun add -g typescript

# Or install locally in your project
bun add -D typescript

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

// Basic types
let name: string = "Alireza";
let age: number = 25;
let isStudent: boolean = true;
let hobbies: string[] = ["read", "write"];
let tuple: [string, number] = ["Alireza", 25];

// The 'any' type (avoid using unless absolutely necessary)
let anything: any = "anything";

// The 'unknown' type (safer than 'any')
let userInput: unknown;

let id: string | number;
id = "abc123";
id = 123;

// Literal types
type Status = "pending" | "approved" | "rejected";
let currentStatus: Status = "pending";

// Optional type
interface User {
  name: string;
  email?: string; // optional
  age: number | null; // can be null
}

// Non-null assertion operator
let userInput: string | null = getUserInput();
let userInputLength = userInput!.length; // ! means we are sure it's not null

interface Person {
  readonly id: number;
  name: string;
  age: number;
  email?: string;

  // Methods
  greet(): string;
}

// Interface implementation
class Student implements Person {
  constructor(
    public readonly id: number,
    public name: string,
    public age: number
  ) {}

  greet(): string {
    return `Hello, I am ${this.name}`;
  }
}

interface Animal {
  name: string;
  makeSound(): void;
}

interface Dog extends Animal {
  breed: string;
  bark(): void;
}

class GermanShepherd implements Dog {
  constructor(public name: string, public breed: string) {}

  makeSound(): void {
    console.log("Woof!");
  }

  bark(): void {
    this.makeSound();
  }
}

class Vehicle {
  // Properties
  private brand: string;
  protected model: string;
  public year: number;

  // constructor
  constructor(brand: string, model: string, year: number) {
    this.brand = brand;
    this.model = model;
    this.year = year;
  }

  // Methods
  public getInfo(): string {
    return `${this.brand} ${this.model} ${this.year}`;
  }

  // Static Methods
  static createFromYear(year: number): Vehicle {
    return new Vehicle("Unknown", "Unknown", year);
  }
}

// Inheritance
class Car extends Vehicle {
  private color: string;

  constructor(brand: string, model: string, year: number, color: string) {
    super(brand, model, year);
    this.color = color;
  }

  getInfo(): string {
    return `${super.getInfo()} - Color: ${this.color}`;
  }
}

class Example {
  public publicProperty: string; // accessible from everywhere
  private privateProperty: string; // only accessible within the class
  protected protectedProperty: string; // accessible within the class and subclasses
  readonly readonlyProperty: string; // read-only
}

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

// Usage
let output1 = identity<string>("hello");
let output2 = identity("hello"); // type inference

// Generic Interface
interface GenericIdentityFn<T> {
  (arg: T): T;
}

// Generic Class
class GenericNumber<T> {
  zeroValue: T;
  add: (x: T, y: T) => T;
}

// Generic Constraints
interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

interface HasName {
  name: string;
}

interface HasAge {
  age: number;
}

type Person = HasName & HasAge;

let person: Person = {
  name: "Alireza",
  age: 25,
};

type NonNullable<T> = T extends null | undefined ? never : T;

type T0 = NonNullable<string | number | null>; // string | number
type T1 = NonNullable<string[] | null | undefined>; // string[]

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

type Partial<T> = {
  [P in keyof T]?: T[P];
};

// Usage
interface Todo {
  title: string;
  description: string;
}

type ReadonlyTodo = Readonly<Todo>;
type PartialTodo = Partial<Todo>;

type EmailLocaleIDs = "welcome_email" | "email_heading";
type FooterLocaleIDs = "footer_title" | "footer_sendoff";

type AllLocaleIDs = `${EmailLocaleIDs | FooterLocaleIDs}_id`;
// "welcome_email_id" | "email_heading_id" | "footer_title_id" | "footer_sendoff_id"

// Partial<T> - all properties optional
interface Todo {
  title: string;
  description: string;
}

type PartialTodo = Partial<Todo>;
// { title?: string; description?: string; }

// Required<T> - all properties required
type RequiredTodo = Required<PartialTodo>;

// Pick<T, K> - select specific properties
type TodoTitle = Pick<Todo, "title">;

// Omit<T, K> - remove specific properties
type TodoWithoutDescription = Omit<Todo, "description">;

// Record<K, T> - create an object with specific keys
type CatInfo = {
  age: number;
  breed: string;
};

type CatName = "miffy" | "boris" | "mordred";
const cats: Record<CatName, CatInfo> = {
  miffy: { age: 10, breed: "Persian" },
  boris: { age: 5, breed: "Maine Coon" },
  mordred: { age: 16, breed: "British Shorthair" },
};

// Decorator Factory
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const method = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`Calling ${propertyKey} with:`, args);
    const result = method.apply(this, args);
    console.log(`Result:`, result);
    return result;
  };

  return descriptor;
}

class Calculator {
  @log
  add(a: number, b: number): number {
    return a + b;
  }
}

// Class Decorator
function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }
  greet() {
    return "Hello, " + this.greeting;
  }
}

// math.ts
export const PI = 3.14159;
export function add(a: number, b: number): number {
  return a + b;
}

export default class Calculator {
  add(a: number, b: number): number {
    return a + b;
  }
}

// main.ts
import Calculator, { PI, add } from "./math";
import * as MathUtils from "./math";

// Usage
const calc = new Calculator();
const result = add(5, 3);
console.log(PI);

namespace Validation {
  export interface StringValidator {
    isValid(s: string): boolean;
  }

  export class LettersOnlyValidator implements StringValidator {
    isValid(s: string): boolean {
      return /^[A-Za-z]+$/.test(s);
    }
  }
}

// Usage
let validators: { [s: string]: Validation.StringValidator } = {};
validators["Letters only"] = new Validation.LettersOnlyValidator();

// typeof type guard
function processValue(value: string | number) {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else {
    return value.toFixed(2);
  }
}

// instanceof type guard
function processVehicle(vehicle: Vehicle | Car) {
  if (vehicle instanceof Car) {
    return vehicle.getInfo();
  } else {
    return vehicle.getInfo();
  }
}

// Custom type guard
function isString(value: any): value is string {
  return typeof value === "string";
}

function processInput(input: unknown) {
  if (isString(input)) {
    return input.toUpperCase();
  }
  return "Invalid input";
}

class CustomError extends Error {
  constructor(
    message: string,
    public statusCode: number,
    public code?: string
  ) {
    super(message);
    this.name = "CustomError";
  }
}

function divide(a: number, b: number): number {
  if (b === 0) {
    throw new CustomError("Division by zero", 400, "DIVIDE_BY_ZERO");
  }
  return a / b;
}

// Usage with try-catch
try {
  const result = divide(10, 0);
} catch (error) {
  if (error instanceof CustomError) {
    console.error(`Error ${error.code}: ${error.message}`);
  } else {
    console.error("Unknown error occurred");
  }
}

// ❌ Bad
let data: any = getData();

// ✅ Good
interface UserData {
  id: number;
  name: string;
  email: string;
}
let data: UserData = getData();

// ❌ Bad
const colors = ["red", "green", "blue"]; // string[]

// ✅ Good
const colors = ["red", "green", "blue"] as const; // readonly ["red", "green", "blue"]

// in tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true
  }
}

interface Todo {
  id: number;
  title: string;
  completed: boolean;
  createdAt: Date;
}

class TodoManager {
  private todos: Todo[] = [];

  addTodo(title: string): Todo {
    const todo: Todo = {
      id: Date.now(),
      title,
      completed: false,
      createdAt: new Date(),
    };
    this.todos.push(todo);
    return todo;
  }

  getTodos(): Todo[] {
    return [...this.todos];
  }

  toggleTodo(id: number): void {
    const todo = this.todos.find((t) => t.id === id);
    if (todo) {
      todo.completed = !todo.completed;
    }
  }

  deleteTodo(id: number): boolean {
    const index = this.todos.findIndex((t) => t.id === id);
    if (index !== -1) {
      this.todos.splice(index, 1);
      return true;
    }
    return false;
  }
}

interface ApiResponse<T> {
  data: T;
  status: number;
  message: string;
}

interface User {
  id: number;
  name: string;
  email: string;
}

class ApiClient {
  private baseUrl: string;

  constructor(baseUrl: string) {
    this.baseUrl = baseUrl;
  }

  async get<T>(endpoint: string): Promise<ApiResponse<T>> {
    const response = await fetch(`${this.baseUrl}${endpoint}`);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
  }

  async post<T>(endpoint: string, data: any): Promise<ApiResponse<T>> {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(data),
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
  }
}

// Usage
const apiClient = new ApiClient("https://api.example.com");
const users = await apiClient.get<User[]>("/users");