Obiecte TypeScript simplificate pentru începători

Obiectele sunt o parte fundamentală a JavaScript și TypeScript. Acestea vă permit să grupați datele și funcțiile asociate împreună, oferind o modalitate de a modela entități din lumea reală în codul dvs. TypeScript îmbunătățește obiectele JavaScript cu siguranță de tip, făcând codul mai previzibil și mai ușor de întreținut. Acest ghid va simplifica conceptul de obiecte TypeScript pentru începători.

Ce este un obiect în TypeScript?

Un obiect este o colecție de perechi cheie-valoare, unde cheile sunt șiruri de caractere (sau simboluri) și valorile pot fi de orice tip. În TypeScript, puteți defini forma unui obiect folosind tipuri sau interfețe, asigurându-vă că obiectul urmează o structură specifică.

Definirea obiectelor simple în TypeScript

Să începem prin a defini un obiect simplu în TypeScript. Acest lucru este similar cu modul în care definiți obiectele în JavaScript, dar cu avantajul suplimentar al siguranței tipului.

Exemplu de obiect de bază

Iată cum să definiți un obiect simplu în TypeScript:

const person: { name: string; age: number } = {
  name: "Alice",
  age: 25
};

console.log(person.name); // Output: Alice
console.log(person.age);  // Output: 25

În acest exemplu, obiectul persoană are două proprietăți: nume (de tipul șir) și vârsta (de tip număr). TypeScript se va asigura că obiectul aderă la această structură.

Utilizarea interfețelor pentru a defini structura obiectului

O interfață este o caracteristică puternică în TypeScript care definește forma unui obiect. Interfețele oferă o modalitate de a defini contractele în codul tău, asigurându-se că obiectele aderă la o structură specifică.

Definirea unei interfețe

Iată cum să utilizați o interfață pentru a defini structura unui obiect:

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

const person: Person = {
  name: "Bob",
  age: 30
};

console.log(person.name); // Output: Bob
console.log(person.age);  // Output: 30

În acest exemplu, interfața Persoană definește structura unui obiect persoană. Variabila persoană trebuie să adere la această structură, altfel TypeScript va genera o eroare.

Proprietăți opționale în obiecte

TypeScript vă permite să definiți proprietăți opționale în obiecte folosind simbolul ?. Proprietățile opționale pot fi omise la crearea obiectelor, oferind flexibilitate în modul în care definiți structurile obiectelor.

Exemplu cu proprietăți opționale

Iată un exemplu în care proprietatea phoneNumber este opțională:

interface Employee {
  name: string;
  age: number;
  phoneNumber?: string; // Optional property
}

const employee1: Employee = {
  name: "John",
  age: 28
};

const employee2: Employee = {
  name: "Doe",
  age: 32,
  phoneNumber: "123-456-7890"
};

console.log(employee1.phoneNumber); // Output: undefined
console.log(employee2.phoneNumber); // Output: 123-456-7890

În acest exemplu, angajat1 nu are o proprietate phoneNumber, în timp ce angajat2 o are. Ambele sunt valide conform interfeței Angajat.

Proprietăți numai în citire în obiecte

TypeScript vă permite să creați proprietăți numai în citire, împiedicând modificarea acestora după ce obiectul este creat. Acest lucru este util pentru a crea obiecte imuabile.

Exemplu cu proprietăți numai în citire

Iată cum să definiți proprietățile numai pentru citire:

interface Car {
  readonly brand: string;
  model: string;
}

const car: Car = {
  brand: "Toyota",
  model: "Camry"
};

// car.brand = "Honda"; // Error: Cannot assign to 'brand' because it is a read-only property

car.model = "Corolla"; // Valid
console.log(car.model); // Output: Corolla

În acest exemplu, proprietatea marca este marcată ca numai în citire. Orice încercare de modificare va avea ca rezultat o eroare de compilare.

Obiecte imbricate în TypeScript

Obiectele TypeScript pot fi imbricate, ceea ce înseamnă că un obiect poate conține un alt obiect ca proprietate. Acest lucru este comun în structurile complexe de date.

Exemplu de obiecte imbricate

Iată un exemplu de obiect imbricat:

interface Address {
  street: string;
  city: string;
  zipCode: string;
}

interface User {
  name: string;
  age: number;
  address: Address; // Nested object
}

const user: User = {
  name: "Emily",
  age: 27,
  address: {
    street: "123 Main St",
    city: "New York",
    zipCode: "10001"
  }
};

console.log(user.address.city); // Output: New York

În acest exemplu, interfața Utilizator are un obiect Adresă imbricat. Obiectul utilizator urmează această structură, permițând accesul la proprietățile imbricate.

Concluzie

Obiectele din TypeScript sunt mai puternice și mai flexibile decât obiectele JavaScript simple datorită definițiilor de tip, proprietăților opționale, proprietăților numai în citire și structurilor imbricate. Prin definirea obiectelor folosind interfețe, puteți crea cod mai robust și fără erori. Începeți să utilizați obiecte TypeScript în proiectele dvs. pentru a valorifica întreaga putere a siguranței tipurilor și a datelor structurate.