TypeScript Record tipas supaprastina objektų struktūrų valdymą su nuosekliais reikšmių tipais. Šis vadovas apima esminius dalykus Recordįskaitant jo apibrėžimą, sintaksę ir kuo ji skiriasi nuo kitų tipų, pvz., kortelių. Išmoksime apibrėžti ir naudoti Record praktiniais scenarijais, pvz., užtikrinant išsamų bylų tvarkymą ir sąrašų sudarymą. Be to, derindami išnagrinėsime išplėstinius naudojimo būdus Record su tokiais komunalinių paslaugų tipais kaip Partial, Pickir Readonly.
Įvadas
The Record tipas yra naudingumo tipas, leidžiantis sukurti objekto tipą su nurodytais raktais ir vienodu vertės tipu. Šis tipas ypač naudingas nustatant atvaizdus ir užtikrinant, kad visos objekto reikšmės atitiktų vieną tipą.
Įrašo tipo apibrėžimas
Oficialus „TypeScript“ dokumentacijos apibrėžimas yra toks:
Record<Keys, Type>
Čia:
Keysreiškia įrašo raktų rinkinį, kuris gali būti eilučių literalų junginys arba tipas, gautas iš sąjungos.Typeyra su tais raktais susietų reikšmių tipas.
Pavyzdžiui, Record<string, number> apibrėžia objektą, kuriame kiekvienas raktas yra eilutė, o kiekviena reikšmė yra skaičius. Šis tipas užtikrina, kad visos objekto savybės turi tą patį reikšmių tipą, tačiau raktai gali būti įvairūs.
Įrašo ir tuple palyginimas
Abu Record ir korteliai naudojami duomenų rinkiniams tvarkyti, tačiau jie tarnauja skirtingiems tikslams. Net jei jose saugomos kelios vertės, jos skiriasi struktūra ir naudojimu. Įrašas turi fiksuoto tipo pavadintas ypatybes, o eilė yra sutvarkytas elementų sąrašas, identifikuojamas pagal jų padėtį. Štai paprastas palyginimas:
- Įrašas. Sukuria objekto tipą, kuriame visos reikšmės turi tą patį tipą, tačiau raktai gali būti lankstūs. Tai naudinga norint susieti raktus su reikšmėmis ir užtikrinti, kad visi raktai atitiktų konkretų tipą.
- Tuple. Apibrėžia masyvą su fiksuotu elementų skaičiumi, kur kiekvienas elementas gali turėti skirtingą tipą. Kortelės naudojamos, kai mums reikia fiksuoto dydžio kolekcijos su konkrečiais tipais kiekvienai pozicijai.
Pavyzdžiui, apsvarstykite šiuos dalykus.
Štai a Record tipas, kuris susieja eilučių raktus su skaičių reikšmėmis:
type AgeMap = Record<string, number>;
Kortelės tipas reiškia masyvą su eilute (pavadinimu) ir skaičiumi (amžius) fiksuotoje pozicijoje:
type Person = (string, number);
Pagrindinis įrašo tipo naudojimas
The Record tipas yra paprastas ir efektyvus būdas susieti raktus su reikšmėmis. Tai ypač naudinga, kai reikia apibrėžti objektus su konkrečiomis raktų ir reikšmių poromis, kai raktai yra tam tikro tipo, o reikšmės yra kito tipo.
Štai keletas pagrindinių būdų, kaip naudoti Record tipo, kad apibrėžtumėte ir sukurtumėte struktūrinius duomenis.
Įrašo apibrėžimas
Norėdami apibrėžti a Recordnurodome raktų ir reikšmių tipus. Toliau pateiktame pavyzdyje apibrėžiamas objektas, kuriame kiekvienas raktas yra eilutė, o kiekviena reikšmė taip pat yra eilutė. Tai gali būti naudojama bendram vartotojo duomenų žemėlapiui:
type User = Record<string, string>;
Kuriant a Record Tipo pavyzdys
Kai kurios svetainės turi įvairius padomenius. Tarkime, kad kiekvienam iš šių padomenių reikia tam tikro lygio administratoriaus prieigos ir sukurkite a Record tipas, skirtas skirtingiems administratoriaus vaidmenims ir atitinkamiems jų prieigos lygiams saugoti. Čia UserRoles ir UserStatus yra Record tipai, kai klavišai yra tam tikros eilutės literalai (admin, blogAdmin, docsAdmin, active, inactive, suspended), o reikšmės yra eilutės, apibūdinančios kiekvieną vaidmenį ir būseną.
Pirmiausia apibrėžiame a Record tipo UserRoles su specifiniais administratoriaus vaidmenimis kaip raktais ir jų aprašymais kaip vertybėmis. The UserRoles tipas užtikrina, kad bet kuris tokio tipo objektas turės raktus admin, blogAdminir docsAdminsu eilutės reikšmėmis, apibūdinančiomis kiekvieną vaidmenį. The roles objektas atitinka šį tipą, pateikdamas kiekvieno administratoriaus vaidmens aprašymus:
type UserRoles = Record<'admin' | 'blogAdmin' | 'docsAdmin', string>;
const roles: UserRoles = {
admin: 'General Administrator with access to all areas.',
blogAdmin: 'Administrator with access to blog content.',
docsAdmin: 'Administrator with access to documentation.'
};
Toliau apibrėžiame a Record tipo UserStatus su konkrečiomis būsenomis kaip raktais ir jų aprašymais kaip reikšmėmis. The UserStatus tipas užtikrina, kad bet kuris tokio tipo objektas turės raktus active, inactiveir suspendedsu eilutės reikšmėmis, apibūdinančiomis kiekvieną būseną. The userStatus objektas atitinka šį tipą, pateikdamas kiekvienos būsenos aprašus:
type UserStatus = Record<'active' | 'inactive' | 'suspended', string>;
const userStatus: UserStatus = {
active: 'User is currently active and can use all features.',
inactive: 'User is currently inactive and cannot access their account.',
suspended: 'User account is suspended due to policy violations.'
};
Kurdamas Record Tokiu būdu užtikriname, kad administratoriaus vaidmenys ir vartotojo būsenos būtų gerai apibrėžti ir nuoseklūs visoje programoje.
Praktiniai įrašo tipo naudojimo atvejai
Šiame skyriuje apžvelgsime kelis praktinio naudojimo atvejus Record tipą, kad parodytų jo universalumą ir efektyvumą įvairiuose scenarijuose.
1 naudojimo atvejis: visiško atvejo tvarkymo vykdymas
Naudojant Record Norėdami apibrėžti atvejo reikšmių ir pranešimų susiejimą, kiekvieną galimą atvejį galime tvarkyti aiškiai. Taip užtikrinama, kad visi atvejai būtų padengti ir dėl bet kokių trūkstamų atvejų bus kompiliavimo laiko klaidų.
Toliau pateiktame pavyzdyje statusMessages yra a Record kur klavišai yra specifiniai Status vertės ('pending', 'completed', 'failed'), ir kiekvienas klavišas susiejamas su atitinkamu pranešimu. The getStatusMessage funkcija naudoja šį įrašą, kad grąžintų atitinkamą pranešimą, pagrįstą status parametras. Šis metodas garantuoja, kad visos būsenos yra tvarkomos teisingai ir nuosekliai.
Pavyzdys:
type Status = 'pending' | 'completed' | 'failed';
interface StatusInfo {
message: string;
severity: 'low' | 'medium' | 'high';
retryable: boolean;
}
const statusMessages: Record<Status, StatusInfo> = {
pending: {
message: 'Your request is pending.',
severity: 'medium',
retryable: true,
},
completed: {
message: 'Your request has been completed.',
severity: 'low',
retryable: false,
},
failed: {
message: 'Your request has failed.',
severity: 'high',
retryable: true,
},
};
function getStatusMessage(status: Status): string {
const info = statusMessages(status);
return `${info.message} Severity: ${info.severity}, Retryable: ${info.retryable}`;
}
console.log(getStatusMessage('completed'));
2 naudojimo atvejis: tipo tikrinimo įvedimas programose naudojant generikus
„TypeScript“ bendrieji elementai leidžia lanksčiai ir pakartotinai naudoti kodą. Kai derinama su Recordbendrieji vaistai gali padėti atlikti tipo tikrinimą ir užtikrinti, kad objektai atitiktų konkrečias struktūras.
Naudojant generinius vaistus su Recordgalime sukurti funkcijas ar priemones, kurios generuoja objektus su konkrečiu raktų rinkiniu ir nuosekliu vertės tipu. Šis metodas padidina tipų saugą ir pakartotinį naudojimą mūsų kodų bazėje.
Toliau pateiktame pavyzdyje createRecord funkcija paima raktų masyvą ir reikšmę ir grąžina a Record kur kiekvienas raktas atitinka pateiktą vertę. Ši funkcija naudoja bendruosius žodžius (K raktams ir T vertės tipui), kad būtų užtikrinta, jog gauta Record turi teisingą struktūrą.
Pavyzdys:
function createRecord<K extends string, T>(keys: K(), value: T): Record<K, T> {
const record: Partial<Record<K, T>> = {};
keys.forEach(key => record(key) = value);
return record as Record<K, T>;
}
interface RoleInfo {
description: string;
permissions: string();
}
const userRoles = createRecord(('admin', 'editor', 'viewer'), {
description: 'Default role',
permissions: ('read'),
});
console.log(userRoles);
3 naudojimo atvejis: Enums susiejimas su duomenimis
Naudojant Record enums susiejimas su duomenimis leidžia sukurti paieškos lentelę, kurioje kiekviena sąrašo reikšmė susieta su konkrečia informacija. Tai ypač naudinga tokiais atvejais, kaip konfigūruoti nustatymus pagal enum reikšmes.
Šiame pavyzdyje colorHex yra a Record kad žemėlapiai kiekvieną Color enum reikšmę į atitinkamą šešioliktainį spalvos kodą. Šis metodas suteikia aiškų ir tipo saugų būdą tvarkyti su spalvomis susijusius duomenis, pagrįstus sąrašo reikšmėmis.
Pavyzdys:
enum Color {
Red = 'RED',
Green = 'GREEN',
Blue = 'BLUE',
Yellow = 'YELLOW'
}
interface ColorInfo {
hex: string;
rgb: string;
complementary: string;
}
const colorHex: Record<Color, ColorInfo> = {
(Color.Red): {
hex: '#FF0000',
rgb: 'rgb(255, 0, 0)',
complementary: '#00FFFF',
},
(Color.Green): {
hex: '#00FF00',
rgb: 'rgb(0, 255, 0)',
complementary: '#FF00FF',
},
(Color.Blue): {
hex: '#0000FF',
rgb: 'rgb(0, 0, 255)',
complementary: '#FFFF00',
},
(Color.Yellow): {
hex: '#FFFF00',
rgb: 'rgb(255, 255, 0)',
complementary: '#0000FF',
},
};
console.log(colorHex(Color.Green));
4 naudojimo atvejis: peržvalgos lentelių kūrimas
Peržvalgos lentelė naudojant Record padeda susieti raktus (pvz., identifikatorius, pavadinimus) su konkrečiomis reikšmėmis (pvz., aprašymais, kodais). Tai gali būti naudinga įvairioms programoms, įskaitant konfigūracijas, vertimus ir daugelį kitų dalykų.
Čia countryCode yra a Record kuri susieja šalių kodus su atitinkamų šalių pavadinimais, gyventojais, sostinėmis ir žemynais. Ši paieškos lentelė leidžia greitai ir saugiai pagal tipą gauti šalių pavadinimus ir populiacijas pagal šalių kodus.
Pavyzdys:
type CountryCode = "US" | "CA" | "MX" | "JP";
interface CountryInfo {
name: string;
population: number;
capital: string;
continent: string;
}
const countryLookup: Record<CountryCode, CountryInfo> = {
US: {
name: "United States",
population: 331000000,
capital: "Washington D.C.",
continent: "North America",
},
CA: {
name: "Canada",
population: 37700000,
capital: "Ottawa",
continent: "North America",
},
MX: {
name: "Mexico",
population: 128000000,
capital: "Mexico City",
continent: "North America",
},
JP: {
name: "Japan",
population: 126300000,
capital: "Tokyo",
continent: "Asia",
},
};
console.log(countryLookup.US);
console.log(countryLookup.US.population);
Iteravimas baigtas Record Tipai
Kartojimas baigtas Record tipai yra svarbūs norint pasiekti duomenis ir juos manipuliuoti duomenų struktūrose. Sukurkime pavyzdinius duomenis ir parodykime įvairius metodus, kaip galime kartoti „TypeScript“. Record tipai.
Duomenų pavyzdžiai:
interface Course {
professor: string;
credits: number;
students: string();
}
interface Courses {
(key: string): Course;
}
const courses: Courses = {
Math101: {
professor: "Dr. Eze",
credits: 3,
students: ("Emmanuel", "Bob", "Charlie"),
},
History201: {
professor: "Dr. Jones",
credits: 4,
students: ("Dave", "Eve"),
},
};
Naudojant forEach. Norėdami naudoti forEach su a Recordkonvertuokite jį į rakto-reikšmių porų masyvą:
Object.entries(courses).forEach(((key, value)) => {
console.log(`${key}: ${value.professor}, ${value.credits}`);
value.students.forEach(student => {
console.log(`Student: ${student}`);
});
});
Naudojant for...in. The for...in ciklas kartojasi per a klavišus Record:
for (const key in courses) {
if (courses.hasOwnProperty(key)) {
const course = courses(key);
console.log(`${key}: ${course.professor}, ${course.credits}`);
course.students.forEach(student => {
console.log(`Student: ${student}`);
});
}
}
Naudojant Object.keys(). Object.keys() grąžina masyvą Recordraktai:
Object.keys(courses).forEach((key) => {
const course = courses(key);
console.log(`${key}: ${course.professor}, ${course.credits}`);
course.students.forEach(student => {
console.log(`Student: ${student}`);
});
});
Naudojant Object.values(). Object.values() grąžina masyvą Recordvertybės:
Object.values(courses).forEach((course) => {
console.log(`${course.professor}, ${course.credits}`);
course.students.forEach(student => {
console.log(`Student: ${student}`);
});
});
Išplėstiniai naudojimo ir naudingumo tipai su Record
The Record tipas gali būti derinamas su kitais komunalinių paslaugų tipais, kad būtų pasiektas didesnis lankstumas ir tipo saugumas. Šiame skyriuje pateikiami išplėstiniai naudojimo modeliai ir parodoma, kaip tai padaryti Record gali dirbti su tokiais paslaugų tipais kaip Pick, Readonlyir Partial.
Sujungimas Record su Pick atrankinio tipo atvaizdavimui
The Pick naudingumo tipas leidžia sukurti naują tipą, pasirenkant konkrečias ypatybes iš esamo tipo. Tai naudinga, kai norime dirbti tik su didesnio tipo savybių poaibiu.
Čia mes sukūrėme naują tipą SelectedProductInfo renkantis tik name ir price savybės iš ProductInfo sąsaja, tada naudokite Record norėdami priskirti skirtingus produktus šiam naujam tipui:
interface ProductInfo {
name: string;
price: number;
category: string;
}
type SelectedProductInfo = Pick<ProductInfo, "name" | "price">;
type Product = 'Laptop' | 'Smartphone' | 'Tablet';
const products: Record<Product, SelectedProductInfo> = {
"Laptop": { name: "Dell XPS 15", price: 1500 },
"Smartphone": { name: "iPhone 12", price: 999 },
"Tablet": { name: "iPad Pro", price: 799 }
};
Sujungimas Record su Readonly Nekintamoms savybėms
The Readonly naudingumo tipas užtikrina, kad ypatybės negalėtų būti pakeistos jas nustačius. Tai naudinga kuriant nekintamas duomenų struktūras.
The ReadonlyProductInfo Įveskite toliau pateiktame pavyzdyje visas savybes ProductInfo nekintamas, užtikrinant, kad kiekvieno produkto detalės negalėtų būti pakeistos, kai jos bus apibrėžtos:
type ReadonlyProductInfo = Readonly<ProductInfo>;
const readonlyProducts: Record<Product, ReadonlyProductInfo> = {
"Laptop": { name: "Dell XPS 15", price: 1500, category: "Electronics" },
"Smartphone": { name: "iPhone 12", price: 999, category: "Electronics" },
"Tablet": { name: "iPad Pro", price: 799, category: "Electronics" }
};
Sujungimas Record su Partial pasirenkamosioms savybėms
The Partial naudingumo tipas padaro visas tipo savybes neprivalomas. Tai naudinga scenarijuose, kai ne visos savybės gali būti žinomos arba reikalingos vienu metu.
Čia, PartialProductInfo tipas leidžia mums sukurti produktus, turinčius kai kurias arba nė viena iš nurodytų savybių ProductInfosuteikiant lankstumo, kaip nurodoma produkto informacija:
type PartialProductInfo = Partial<ProductInfo>;
const partialProducts: Record<Product, PartialProductInfo> = {
"Laptop": { name: "Dell XPS 15" },
"Smartphone": { price: 999 },
"Tablet": {}
};
Sujungimas Record su Record skirtas įdėtajam žemėlapiui
Kitas pažangus naudojimas apima derinimą Record tipai, kad būtų sukurti įdėtieji atvaizdai, kurie gali būti ypač naudingi tvarkant sudėtingas duomenų struktūras.
Šiame pavyzdyje storeInventory naudoja įdėtą Record tipus, norėdami susieti skyrius su atitinkamais produktais ir informacija, parodydami, kaip tai padaryti Record Galima derinti sudėtingesniam duomenų valdymui:
type Department = 'Electronics' | 'Furniture';
type ProductDetails = Record<Product, ProductInfo>;
const storeInventory: Record<Department, ProductDetails> = {
"Electronics": {
"Laptop": { name: "Dell XPS 15", price: 1500, category: "Electronics" },
"Smartphone": { name: "iPhone 12", price: 999, category: "Electronics" },
"Tablet": { name: "iPad Pro", price: 799, category: "Electronics" }
},
"Furniture": {
"Chair": { name: "Office Chair", price: 200, category: "Furniture" },
"Table": { name: "Dining Table", price: 500, category: "Furniture" },
"Sofa": { name: "Living Room Sofa", price: 800, category: "Furniture" }
}
};
Išvada
The Record tipas yra universalus įrankis objektų tipams valdyti ir struktūrizuoti, nes jis leidžia mums apibrėžti aiškius raktų ir reikšmių susiejimus, užtikrinant tipo saugumą ir nuoseklumą mūsų kode.
Norėdami gauti išsamesnės informacijos, žr. „TypeScript“ dokumentaciją ir peržiūrėkite kitus papildomus išteklius, pvz., „Total TypeScript“ ir „TypeScript“ mokymo programą, kad geriau suprastumėte „TypeScript“. Record tipo sistema.
