TypeScript saskarne (Interface) pret tipu (Type): deklarēšanas labākā prakse globāliem izstrādātājiem

TypeScript, JavaScript paplašinājums, ļauj izstrādātājiem visā pasaulē veidot robustas un mērogojamas lietojumprogrammas, izmantojot statisko tipēšanu. Divas fundamentālas konstrukcijas tipu definēšanai ir saskarnes (Interfaces) un tipi (Types). Lai gan tām ir līdzības, to nianšu un atbilstošo lietošanas gadījumu izpratne ir būtiska, lai rakstītu tīru, uzturējamu un efektīvu kodu. Šis visaptverošais ceļvedis iedziļināsies atšķirībās starp TypeScript saskarnēm un tipiem, pētot labākās prakses to efektīvai izmantošanai jūsu projektos.

Izpratne par TypeScript saskarnēm

Saskarne (Interface) TypeScript valodā ir spēcīgs veids, kā definēt līgumu objektam. Tā nosaka objekta formu, norādot, kādām īpašībām tam jābūt, to datu tipus un, pēc izvēles, jebkuras metodes, kas tam jāimplementē. Saskarnes galvenokārt apraksta objektu struktūru.

Saskarnes sintakse un piemērs

Saskarnes definēšanas sintakse ir vienkārša:

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

const user: User = {
  id: 123,
  name: "Alice Smith",
  email: "alice.smith@example.com",
  isActive: true,
};

Šajā piemērā User saskarne definē lietotāja objekta struktūru. Jebkuram objektam, kas piešķirts mainīgajam user, ir jāatbilst šai struktūrai; pretējā gadījumā TypeScript kompilators ziņos par kļūdu.

Saskarnju galvenās iezīmes

• Objekta formas definēšana: Saskarnes ir izcilas, lai definētu objektu struktūru jeb "formu".
• Paplašināmība: Saskarnes var viegli paplašināt, izmantojot atslēgvārdu extends, kas nodrošina mantošanu un koda atkārtotu izmantošanu.
• Deklarāciju apvienošana: TypeScript atbalsta saskarņu deklarāciju apvienošanu, kas nozīmē, ka varat deklarēt vienu un to pašu saskarni vairākas reizes, un kompilators tās apvienos vienā deklarācijā.

Deklarāciju apvienošanas piemērs

interface Window {
  title: string;
}

interface Window {
  height: number;
  width: number;
}

const myWindow: Window = {
  title: "My Application",
  height: 800,
  width: 600,
};

Šeit Window saskarne ir deklarēta divreiz. TypeScript apvieno šīs deklarācijas, faktiski izveidojot saskarni ar title, height un width īpašībām.

TypeScript tipu izpēte

Tips (Type) TypeScript valodā nodrošina veidu, kā definēt datu formu. Atšķirībā no saskarnēm, tipi ir daudzpusīgāki un var attēlot plašāku datu struktūru klāstu, ieskaitot primitīvos tipus, apvienojumus (unions), krustojumus (intersections) un kortežus (tuples).

Tipa sintakse un piemērs

Tipa aizstājvārda (alias) definēšanas sintakse ir šāda:

type Point = {
  x: number;
  y: number;
};

const origin: Point = {
  x: 0,
  y: 0,
};

Šajā piemērā tips Point definē punkta objekta struktūru ar x un y koordinātām.

Tipu galvenās iezīmes

• Apvienojuma tipi (Union Types): Tipi var attēlot vairāku tipu apvienojumu, ļaujot mainīgajam uzglabāt dažādu tipu vērtības.
• Krustojuma tipi (Intersection Types): Tipi var attēlot arī vairāku tipu krustojumu, apvienojot visu tipu īpašības vienā tipā.
• Primitīvie tipi: Tipi var tieši attēlot primitīvos tipus, piemēram, string, number, boolean utt.
• Kortežu tipi (Tuple Types): Tipi var definēt kortežus, kas ir fiksēta garuma masīvi ar noteiktiem tipiem katram elementam.
• Daudzpusīgāki: Var aprakstīt gandrīz jebko, sākot no primitīviem datu tipiem līdz sarežģītām objektu formām.

Apvienojuma tipa piemērs

type Result = {
  success: true;
  data: any;
} | {
  success: false;
  error: string;
};

const successResult: Result = {
  success: true,
  data: { message: "Operation successful!" },
};

const errorResult: Result = {
  success: false,
  error: "An error occurred.",
};

Tips Result ir apvienojuma tips, kas var būt vai nu veiksmīgs iznākums ar datiem, vai neveiksmīgs ar kļūdas paziņojumu. Tas ir noderīgi, lai attēlotu operāciju rezultātu, kas var būt veiksmīgas vai neveiksmīgas.

Krustojuma tipa piemērs

type Person = {
  name: string;
  age: number;
};

type Employee = {
  employeeId: string;
  department: string;
};

type EmployeePerson = Person & Employee;

const employee: EmployeePerson = {
  name: "Bob Johnson",
  age: 35,
  employeeId: "EMP123",
  department: "Engineering",
};

Tips EmployeePerson ir krustojuma tips, kas apvieno gan Person, gan Employee īpašības. Tas ļauj jums izveidot jaunus tipus, apvienojot esošos.

Galvenās atšķirības: saskarne pret tipu

Lai gan gan saskarnes, gan tipi kalpo datu struktūru definēšanai TypeScript, pastāv būtiskas atšķirības, kas ietekmē, kad izvēlēties vienu vai otru:

1. Deklarāciju apvienošana: Saskarnes atbalsta deklarāciju apvienošanu, bet tipi nē. Ja jums ir nepieciešams paplašināt tipa definīciju vairākos failos vai moduļos, parasti priekšroka tiek dota saskarnēm.
2. Apvienojuma tipi: Tipi var attēlot apvienojuma tipus, savukārt saskarnes nevar tieši definēt apvienojumus. Ja jums ir jādefinē tips, kas var būt viens no vairākiem dažādiem tipiem, izmantojiet tipa aizstājvārdu (alias).
3. Krustojuma tipi: Tipi var izveidot krustojuma tipus, izmantojot operatoru &. Saskarnes var paplašināt citas saskarnes, panākot līdzīgu efektu, bet krustojuma tipi piedāvā lielāku elastību.
4. Primitīvie tipi: Tipi var tieši attēlot primitīvos tipus (string, number, boolean), kamēr saskarnes galvenokārt ir paredzētas objektu formu definēšanai.
5. Kļūdu paziņojumi: Daži izstrādātāji uzskata, ka saskarnes piedāvā nedaudz skaidrākus kļūdu paziņojumus salīdzinājumā ar tipiem, īpaši strādājot ar sarežģītām tipu struktūrām.

Labākā prakse: izvēle starp saskarni un tipu

Izvēle starp saskarnēm un tipiem ir atkarīga no jūsu projekta specifiskajām prasībām un personīgajām vēlmēm. Šeit ir dažas vispārīgas vadlīnijas, kuras ņemt vērā:

• Izmantojiet saskarnes objektu formas definēšanai: Ja jums galvenokārt ir nepieciešams definēt objektu struktūru, saskarnes ir dabiska izvēle. To paplašināmība un deklarāciju apvienošanas iespējas var būt noderīgas lielākos projektos.
• Izmantojiet tipus apvienojuma tipiem, krustojuma tipiem un primitīvajiem tipiem: Kad jums ir nepieciešams attēlot tipu apvienojumu, tipu krustojumu vai vienkāršu primitīvo tipu, izmantojiet tipa aizstājvārdu.
• Uzturiet konsekvenci savā koda bāzē: Neatkarīgi no tā, vai izvēlaties saskarnes vai tipus, centieties saglabāt konsekvenci visā projektā. Vienota stila izmantošana uzlabos koda lasāmību un uzturēšanu.
• Apsveriet deklarāciju apvienošanu: Ja paredzat, ka būs nepieciešams paplašināt tipa definīciju vairākos failos vai moduļos, saskarnes ir labāka izvēle to deklarāciju apvienošanas funkcijas dēļ.
• Dodiet priekšroku saskarnēm publiskajām API: Izstrādājot publiskās API, bieži tiek dota priekšroka saskarnēm, jo tās ir vieglāk paplašināmas un ļauj jūsu API patērētājiem viegli paplašināt jūsu definētos tipus.

Praktiski piemēri: globālu lietojumprogrammu scenāriji

Apskatīsim dažus praktiskus piemērus, lai ilustrētu, kā saskarnes un tipus var izmantot globālā lietojumprogrammā:

1. Lietotāju profilu pārvaldība (internalizācija)

Pieņemsim, ka jūs veidojat lietotāju profilu pārvaldības sistēmu, kas atbalsta vairākas valodas. Jūs varat izmantot saskarnes, lai definētu lietotāju profilu struktūru, un tipus, lai attēlotu dažādus valodu kodus:

interface UserProfile {
  id: number;
  name: string;
  email: string;
  preferredLanguage: LanguageCode;
  address: Address;
}

interface Address {
    street: string;
    city: string;
    country: string;
    postalCode: string;
}

type LanguageCode = "en" | "fr" | "es" | "de" | "zh"; // Valodu kodu piemēri

const userProfile: UserProfile = {
  id: 1,
  name: "John Doe",
  email: "john.doe@example.com",
  preferredLanguage: "en",
  address: { street: "123 Main St", city: "Anytown", country: "USA", postalCode: "12345" }
};

Šeit UserProfile saskarne definē lietotāja profila struktūru, ieskaitot viņa vēlamo valodu. Tips LanguageCode ir apvienojuma tips, kas attēlo atbalstītās valodas. Saskarne Address definē adreses formātu, pieņemot vispārīgu globālo formātu.

2. Valūtas konvertēšana (globalizācija)

Apsveriet valūtas konvertēšanas lietojumprogrammu, kurai jāapstrādā dažādas valūtas un maiņas kursi. Jūs varat izmantot saskarnes, lai definētu valūtas objektu struktūru, un tipus, lai attēlotu valūtu kodus:

interface Currency {
  code: CurrencyCode;
  name: string;
  symbol: string;
}

interface ExchangeRate {
  baseCurrency: CurrencyCode;
  targetCurrency: CurrencyCode;
  rate: number;
}


type CurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD"; // Valūtu kodu piemēri

const usd: Currency = {
  code: "USD",
  name: "United States Dollar",
  symbol: "$",
};

const exchangeRate: ExchangeRate = {
  baseCurrency: "USD",
  targetCurrency: "EUR",
  rate: 0.85,
};

Saskarne Currency definē valūtas objekta struktūru, ieskaitot tā kodu, nosaukumu un simbolu. Tips CurrencyCode ir apvienojuma tips, kas attēlo atbalstītos valūtu kodus. Saskarne ExchangeRate tiek izmantota, lai attēlotu konversijas kursus starp dažādām valūtām.

3. Datu validācija (starptautiskais formāts)

Apstrādājot datu ievadi no lietotājiem dažādās valstīs, ir svarīgi validēt datus atbilstoši pareizajam starptautiskajam formātam. Piemēram, tālruņa numuriem ir dažādi formāti atkarībā no valsts koda. Tipus var izmantot, lai attēlotu variācijas.

type PhoneNumber = {
  countryCode: string;
  number: string;
  isValid: boolean; // Pievienojiet Būla vērtību, lai attēlotu derīgus/nederīgus datus.
};

interface Contact {
   name: string;
   phoneNumber: PhoneNumber;
   email: string;
}


function validatePhoneNumber(phoneNumber: string, countryCode: string): PhoneNumber {
  // Validācijas loģika, pamatojoties uz valsts kodu (piem., izmantojot bibliotēku, piemēram, libphonenumber-js)
  // ... Šeit implementācija numura validācijai.
  const isValid = true; //aizstājējvērtība

  return { countryCode, number: phoneNumber, isValid };
}

const contact: Contact = {
    name: "Jane Doe",
    phoneNumber: validatePhoneNumber("555-123-4567", "US"), //piemērs
    email: "jane.doe@email.com",
};


console.log(contact.phoneNumber.isValid); //izvada validācijas pārbaudi.

Noslēgums: TypeScript deklarāciju apgūšana

TypeScript saskarnes un tipi ir spēcīgi rīki datu struktūru definēšanai un koda kvalitātes uzlabošanai. To atšķirību izpratne un efektīva izmantošana ir būtiska, lai veidotu robustas, uzturējamas un mērogojamas lietojumprogrammas. Ievērojot šajā ceļvedī izklāstītās labākās prakses, jūs varat pieņemt pamatotus lēmumus par to, kad izmantot saskarnes un kad tipus, galu galā uzlabojot savu TypeScript izstrādes darbplūsmu un veicinot savu projektu panākumus.

Atcerieties, ka izvēle starp saskarnēm un tipiem bieži ir personīgo vēlmju un projekta prasību jautājums. Eksperimentējiet ar abām pieejām, lai atrastu to, kas vislabāk der jums un jūsu komandai. TypeScript tipu sistēmas jaudas pieņemšana neapšaubāmi novedīs pie uzticamāka un vieglāk uzturama koda, sniedzot labumu izstrādātājiem visā pasaulē.