Mga Uri ng Intersection sa TypeScript
Ipinaliwanag ng artikulong ito ang mga uri ng intersection sa TypeScript.
YouTube Video
Mga Uri ng Intersection sa TypeScript
Sa TypeScript, ang mga uri ng intersection ay isang paraan upang pagsamahin ang maraming uri upang makabuo ng bagong uri.
Ano ang Mga Uri ng Intersection?
Ang mga uri ng intersection ay nagbibigay-daan sa iyo na pagsamahin ang maraming uri upang tukuyin ang isang bagong uri na may lahat ng mga katangian ng mga uri na iyon. Ang mga uri ng intersection ay tinutukoy gamit ang simbolong & at nangangailangan ng lahat ng mga katangian mula sa bawat bahagi ng uri.
Halimbawa:
1type A = { name: string };
2type B = { age: number };
3
4type C = A & B;
5
6const person: C = {
7 name: "John Doe",
8 age: 30
9};Sa code na ito, sa pamamagitan ng pagtukoy ng type C = A & B, ang uri na C ay nagiging isang uri ng object na may name (string type) at age (number type) na mga katangian.
Mga Benepisyo ng Mga Uri ng Intersection
Sa paggamit ng mga uri ng intersection, maaari mong muling gamitin ang mga umiiral na uri at tukuyin ang mas flexible at composite na mga uri. Pinapalakas nito ang kakayahang mapanatili at mapalawak ang iyong code. Bukod dito, ang mga uri ng intersection ay maaaring maglagay ng mga limitasyon ng maraming iba't ibang uri nang sabay-sabay, sa gayon pinapalakas ang kaligtasan ng uri.
Mga Benepisyo:
- Muling Paggamit: Sa pamamagitan ng pagsasama ng maraming uri, maari mong bawasan ang mga labis na kahulugan at muling gamitin ang mga umiiral na uri.
- Seguridad ng Uri (Type Safety): Pinapalakas ng mga uri ng intersection ang pagsusuri ng uri sa pamamagitan ng pagpayag lamang ng mga object na tumutugon sa mga kondisyon ng maraming uri.
Mga Kaso ng Paggamit para sa Mga Uri ng Intersection
Ang mga uri ng intersection ay lubhang kapaki-pakinabang kapag nagtatagal ng mga object o interface. Lalo na, ito ay kapaki-pakinabang kapag nais mong kumatawan sa mga object na may maraming katangian.
Kaso ng Paggamit 1: Mga Object na may Maramihang Interface
1interface Drivable {
2 drive(): void;
3}
4
5interface Flyable {
6 fly(): void;
7}
8
9type Vehicle = Drivable & Flyable;
10
11const car: Vehicle = {
12 drive() {
13 console.log("Driving on the road");
14 },
15 fly() {
16 console.log("Flying in the sky");
17 }
18};
19
20car.drive(); // "Driving on the road"
21car.fly(); // "Flying in the sky"
Sa halimbawang ito, ang uri na Vehicle ay tinukoy bilang isang uri ng intersection na pinagsasama ang Drivable at Flyable. Ang isang object na may uri na Vehicle ay dapat ipatupad ang parehong mga paraan na drive() at fly().
Kaso ng Paggamit 2: Pagsasama ng Mga Klase at Mga Uri ng Intersection
Sa pamamagitan ng pagsasama ng mga klase at mga uri ng intersection, posible na lumikha ng mga object na may mga katangian ng maraming interface.
1interface Person {
2 name: string;
3}
4
5interface Employee {
6 employeeId: number;
7}
8
9type PersonEmployee = Person & Employee;
10
11class CompanyWorker implements PersonEmployee {
12 constructor(public name: string, public employeeId: number) {}
13
14 getDetails() {
15 return `${this.name}, Employee ID: ${this.employeeId}`;
16 }
17}
18
19const worker = new CompanyWorker("Alice", 123);
20console.log(worker.getDetails()); // "Alice, Employee ID: 123"
Dito, ginagamit natin ang uri ng intersection na PersonEmployee ng Person at Employee upang ang klase na CompanyWorker ay magkaroon ng mga katangian ng parehong uri.
Mga Punto na Dapat Isaalang-alang sa Intersection Types
Isang mahalagang punto kapag gumagamit ng intersection types ay ang pag-alam sa posibilidad ng konflikto sa mga katangian. Kung ang mga katangian na may parehong pangalan ay may magkaibang type annotations sa iba't ibang uri, maaaring magdulot ito ng error.
Halimbawa ng Babala:
1type A = { id: number };
2type B = { id: string };
3
4type C = A & B;
5
6// Error: Type 'number' and 'string' are not compatible
7const obj: C = {
8 id: 1
9};Sa halimbawang ito, nagkakaroon ng konflik ang mga id na katangian ng A at B, na nagiging dahilan ng error kapag nagde-define ng object na may type na C. Sa ganitong mga kaso, kinakailangan ang isang design review upang maiwasan ang konflikto sa mga katangian.
Halimbawa ng Code na may Type Annotations para sa Intersection Types
Sa wakas, narito ang aktwal na halimbawa ng code na may kasamang type annotations.
Halimbawa 1: Pagpapakita ng Mga Detalye ng Object
1type ContactInfo = { phone: string; email: string };
2type Address = { city: string; postalCode: string };
3
4type PersonDetails = ContactInfo & Address;
5
6const details: PersonDetails = {
7 phone: "123-4567",
8 email: "example@mail.com",
9 city: "New York",
10 postalCode: "10001"
11};
12
13console.log(details);Halimbawa 2: Object na may Karagdagang Mga Katangian
1interface BasicInfo {
2 name: string;
3 age: number;
4}
5
6interface WorkInfo {
7 company: string;
8 position: string;
9}
10
11type FullInfo = BasicInfo & WorkInfo;
12
13const employee: FullInfo = {
14 name: "Bob",
15 age: 28,
16 company: "Tech Corp",
17 position: "Engineer"
18};
19
20console.log(`${employee.name} is a ${employee.position} at ${employee.company}`);Konklusyon
Ang intersection types sa TypeScript ay isang makapangyarihang tampok para pagsamahin ang iba't ibang uri sa isang bagong uri. Pina-iigting nito ang reusability at kaligtasan ng code, nagbibigay-daan sa masalimuot na mga type definition. Sa paggamit ng disenyo na may flexibility nang maingat sa mga type conflicts, maaari kang makagawa ng matatag at madaling basahing code.
Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.