M

MLOG

O'zbek

Ish vaqtidagi xatoliklarning oldini olish va mustahkam, bashorat qilinadigan JavaScript ilovalari uchun ob'ekt turlari xavfsizligini oshirish maqsadida TypeScript-ning ortiqcha xususiyatlarini tekshirishni o'zlashtiring.

TypeScript-da ortiqcha xususiyatlarni tekshirish: Ob'ekt turlari xavfsizligini mustahkamlash

Zamonaviy dasturiy ta'minotni ishlab chiqish sohasida, ayniqsa JavaScript bilan ishlaganda, kodingizning yaxlitligi va bashorat qilinishini ta'minlash juda muhim. JavaScript juda katta moslashuvchanlikni taklif qilsa-da, ba'zida kutilmagan ma'lumotlar tuzilmalari yoki xususiyatlar nomuvofiqligi tufayli ish vaqtida xatoliklarga olib kelishi mumkin. Aynan shu yerda TypeScript o'zining afzalliklarini namoyon etadi, u statik tiplashtirish imkoniyatlarini taqdim etib, ko'plab keng tarqalgan xatoliklarni ular ishlab chiqarish muhitida paydo bo'lishidan oldin aniqlaydi. TypeScript-ning eng kuchli, ammo ba'zida noto'g'ri tushuniladigan xususiyatlaridan biri bu uning ortiqcha xususiyatlarni tekshirish mexanizmidir.

Ushbu maqola TypeScript-ning ortiqcha xususiyatlarni tekshirish mexanizmini chuqur o'rganadi, ularning nima ekanligini, ob'ekt turlari xavfsizligi uchun nima uchun muhimligini va yanada mustahkam va bashorat qilinadigan ilovalarni yaratish uchun ulardan qanday qilib samarali foydalanishni tushuntiradi. Biz turli xil stsenariylarni, umumiy xatoliklarni va eng yaxshi amaliyotlarni ko'rib chiqamiz, bu butun dunyo bo'ylab ishlab chiquvchilarga, ularning tajribasidan qat'i nazar, ushbu muhim TypeScript mexanizmini o'zlashtirishga yordam beradi.

Asosiy tushunchani anglash: Ortiqcha xususiyatlarni tekshirish nima?

Aslini olganda, TypeScript-ning ortiqcha xususiyatlarni tekshirish mexanizmi - bu kompilyator mexanizmi bo'lib, u sizga ob'ekt literalini turi o'sha qo'shimcha xususiyatlarga aniq ruxsat bermaydigan o'zgaruvchiga tayinlashni oldini oladi. Oddiyroq qilib aytganda, agar siz ob'ekt literalini aniqlasangiz va uni ma'lum bir tur ta'rifiga (masalan, interfeys yoki tur taxallusiga) ega o'zgaruvchiga tayinlashga harakat qilsangiz va ushbu literalda belgilangan turda e'lon qilinmagan xususiyatlar mavjud bo'lsa, TypeScript buni kompilyatsiya paytida xato sifatida belgilaydi.

Keling, buni oddiy misol bilan ko'rib chiqaylik:


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

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'email' 'User' turida mavjud emas.
};

Ushbu kod parchasida biz `name` va `age` deb nomlangan ikkita xususiyatga ega `User` interfeysini aniqladik. Biz qo'shimcha `email` xususiyatiga ega bo'lgan ob'ekt literalini yaratishga va uni `User` turidagi o'zgaruvchiga tayinlashga harakat qilganimizda, TypeScript darhol nomuvofiqlikni aniqlaydi. `email` xususiyati 'ortiqcha' xususiyatdir, chunki u `User` interfeysida aniqlanmagan. Ushbu tekshiruv aynan siz tayinlash uchun ob'ekt literalidan foydalanganingizda amalga oshiriladi.

Nima uchun ortiqcha xususiyatlarni tekshirish muhim?

Ortiqcha xususiyatlarni tekshirishning ahamiyati ularning ma'lumotlaringiz va ularning kutilgan tuzilmasi o'rtasidagi shartnomani ta'minlash qobiliyatidadir. Ular ob'ekt turlari xavfsizligiga bir necha muhim yo'llar bilan hissa qo'shadilar:

Ortiqcha xususiyatlarni tekshirish qachon qo'llaniladi?

TypeScript bu tekshiruvlarni qanday aniq sharoitlarda amalga oshirishini tushunish juda muhimdir. Ular asosan ob'ekt literallariga, ular o'zgaruvchiga tayinlanganda yoki funksiyaga argument sifatida uzatilganda qo'llaniladi.

Stsenariy 1: Ob'ekt literallarini o'zgaruvchilarga tayinlash

Yuqoridagi `User` misolida ko'rinib turganidek, ortiqcha xususiyatlarga ega bo'lgan ob'ekt literalini to'g'ridan-to'g'ri turli o'zgaruvchiga tayinlash tekshiruvni ishga tushiradi.

Stsenariy 2: Ob'ekt literallarini funksiyalarga uzatish

Funksiya ma'lum bir turdagi argumentni kutganda va siz ortiqcha xususiyatlarni o'z ichiga olgan ob'ekt literalini uzatsangiz, TypeScript buni xato deb belgilaydi.


interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Product ID: ${product.id}, Name: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Xato: '{ id: number; name: string; price: number; }' turidagi argument 'Product' turidagi parametrga tayinlanishi mumkin emas.
             // Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'price' 'Product' turida mavjud emas.
});

Bu yerda, `displayProduct` ga uzatilgan ob'ekt literalidagi `price` xususiyati ortiqcha xususiyatdir, chunki `Product` interfeysi uni aniqlamaydi.

Ortiqcha xususiyatlarni tekshirish qachon qo'llanil*maydi*?

Chalkashliklarga yo'l qo'ymaslik va qachon muqobil strategiyalarga ehtiyoj sezilishi mumkinligini bilish uchun bu tekshiruvlar qachon chetlab o'tilishini tushunish ham birdek muhimdir.

1. Tayinlash uchun ob'ekt literallaridan foydalanilmaganda

Agar siz ob'ekt literal bo'lmagan ob'ektni tayinlasangiz (masalan, allaqachon ob'ektni o'z ichiga olgan o'zgaruvchi), ortiqcha xususiyatlarni tekshirish odatda chetlab o'tiladi.


interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout set to: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // Bu 'retries' xususiyati 'Config' turiga ko'ra ortiqcha xususiyatdir
};

setupConfig(userProvidedConfig); // Xato yo'q!

// userProvidedConfig-da ortiqcha xususiyat bo'lsa ham, tekshiruv o'tkazib yuboriladi,
// chunki u to'g'ridan-to'g'ri uzatilayotgan ob'ekt literali emas.
// TypeScript userProvidedConfig turini o'zini tekshiradi.
// Agar userProvidedConfig 'Config' turi bilan e'lon qilinganida, xatolik avvalroq yuzaga kelgan bo'lardi.
// Biroq, 'any' yoki kengroq tur bilan e'lon qilingan bo'lsa, xatolik kechiktiriladi.

// O'tkazib yuborishni ko'rsatishning aniqroq usuli:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Ortiqcha xususiyat
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Ortiqcha xususiyat
  };
}

setupConfig(anotherConfig as Config); // Tur tasdig'i va o'tkazib yuborish tufayli xato yo'q

// Asosiy masala shundaki, 'anotherConfig' setupConfig-ga tayinlash nuqtasida ob'ekt literali emas.
// Agar bizda 'Config' turiga ega bo'lgan oraliq o'zgaruvchi bo'lganida, dastlabki tayinlash muvaffaqiyatsiz bo'lar edi.

// Oraliq o'zgaruvchiga misol:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'logging' 'Config' turida mavjud emas.
};

Birinchi `setupConfig(userProvidedConfig)` misolida, `userProvidedConfig` ob'ektni saqlaydigan o'zgaruvchidir. TypeScript `userProvidedConfig` ning o'zi `Config` turiga mos kelishini tekshiradi. U `userProvidedConfig` ning o'ziga qat'iy ob'ekt literal tekshiruvini qo'llamaydi. Agar `userProvidedConfig` `Config` ga mos kelmaydigan tur bilan e'lon qilinganida, uning e'lon qilinishi yoki tayinlanishi paytida xatolik yuzaga kelgan bo'lardi. Cheklab o'tish ob'ekt allaqachon yaratilgan va funksiyaga uzatilishidan oldin o'zgaruvchiga tayinlanganligi sababli sodir bo'ladi.

2. Tur tasdiqlari (Type Assertions)

Siz tur tasdiqlaridan foydalanib ortiqcha xususiyatlarni tekshirishni chetlab o'tishingiz mumkin, ammo bu ehtiyotkorlik bilan amalga oshirilishi kerak, chunki u TypeScript-ning xavfsizlik kafolatlarini bekor qiladi.


interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Ortiqcha xususiyat
} as Settings;

// Tur tasdig'i tufayli bu yerda xato yo'q.
// Biz TypeScript-ga aytmoqdamiz: "Menga ishon, bu ob'ekt 'Settings' turiga mos keladi."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Agar fontSize haqiqatdan ham mavjud bo'lmasa, bu ish vaqtida xatolikka olib kelishi mumkin.

3. Tur ta'riflarida indeks imzolari yoki Spread sintaksisidan foydalanish

Agar sizning interfeysingiz yoki tur taxallusingiz ixtiyoriy xususiyatlarga aniq ruxsat bersa, ortiqcha xususiyatlarni tekshirish qo'llanilmaydi.

Indeks imzolaridan foydalanish:


interface FlexibleObject {
  id: number;
  [key: string]: any; // Har qanday qiymatga ega har qanday satrli kalitga ruxsat beradi
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// Xato yo'q, chunki 'name' va 'version' ga indeks imzosi orqali ruxsat berilgan.
console.log(flexibleItem.name);

Tur ta'riflarida Spread sintaksisidan foydalanish (tekshiruvlarni to'g'ridan-to'g'ri chetlab o'tishdan ko'ra, mos turlarni aniqlash uchun ko'proq ishlatiladi):

To'g'ridan-to'g'ri chetlab o'tish bo'lmasa-da, yoyish (spreading) mavjud xususiyatlarni o'z ichiga olgan yangi ob'ektlarni yaratishga imkon beradi va tekshiruv hosil bo'lgan yangi literalga qo'llaniladi.

4. `Object.assign()` yoki Spread sintaksisidan birlashtirish uchun foydalanish

Ob'ektlarni birlashtirish uchun `Object.assign()` yoki spread sintaksisidan (`...`) foydalanganingizda, ortiqcha xususiyatlarni tekshirish boshqacha ishlaydi. U hosil bo'layotgan ob'ekt literaliga qo'llaniladi.


interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // BaseConfig ga nisbatan ortiqcha xususiyat, lekin birlashtirilgan tur tomonidan kutilgan
};

// ExtendedConfig ga mos keladigan yangi ob'ekt literaliga yoyish
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Bu odatda normal holat, chunki 'finalConfig' 'ExtendedConfig' sifatida e'lon qilingan
// va xususiyatlar mos keladi. Tekshiruv 'finalConfig' turiga nisbatan amalga oshiriladi.

// Keling, u muvaffaqiyatsizlikka uchraydigan stsenariyni ko'rib chiqaylik:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' bu yerda ortiqcha
const data2 = { key: 'xyz', status: 'active' }; // 'status' bu yerda ortiqcha

// Ortiqcha xususiyatlarni qabul qilmaydigan turga tayinlashga urinish

// const combined: SmallConfig = {
//   ...data1, // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'value' 'SmallConfig' turida mavjud emas.
//   ...data2  // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'status' 'SmallConfig' turida mavjud emas.
// };

// Xato yuzaga kelishining sababi, spread sintaksisi tomonidan hosil qilingan ob'ekt literalida
// 'SmallConfig' turida mavjud bo'lmagan xususiyatlar ('value', 'status') mavjud.

// Agar biz kengroq turdagi oraliq o'zgaruvchi yaratsak:

const temp: any = {
  ...data1,
  ...data2
};

// Keyin SmallConfig ga tayinlasak, ortiqcha xususiyat tekshiruvi dastlabki literal yaratilishida chetlab o'tiladi,
// lekin agar temp-ning turi qat'iyroq aniqlansa, tayinlashda tur tekshiruvi baribir sodir bo'lishi mumkin.
// Biroq, agar temp 'any' bo'lsa, 'combined' ga tayinlangunicha hech qanday tekshiruv bo'lmaydi.

// Spread bilan ortiqcha xususiyat tekshiruvlarini tushunishni aniqlashtiramiz:
// Tekshiruv spread sintaksisi tomonidan yaratilgan ob'ekt literali
// o'zgaruvchiga tayinlanganda yoki aniqroq tur kutadigan funksiyaga uzatilganda sodir bo'ladi.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Agar SpecificShape 'extra1' yoki 'extra2' ga ruxsat bermasa, bu muvaffaqiyatsiz bo'ladi:
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// Muvaffaqiyatsizlikning sababi shundaki, spread sintaksisi samarali ravishda yangi ob'ekt literalini yaratadi.
// Agar objA va objB bir-biriga mos keladigan kalitlarga ega bo'lsa, keyingisi g'olib bo'ladi. Kompilyator
// bu natijaviy literalni ko'radi va uni 'SpecificShape' ga nisbatan tekshiradi.

// Buni ishlashi uchun sizga oraliq qadam yoki kengroq tur kerak bo'lishi mumkin:

const tempObj = {
  ...objA,
  ...objB
};

// Endi, agar tempObj SpecificShape da bo'lmagan xususiyatlarga ega bo'lsa, tayinlash muvaffaqiyatsiz bo'ladi:
// const mergedCorrected: SpecificShape = tempObj; // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin...

// Asosiy masala shundaki, kompilyator hosil bo'layotgan ob'ekt literalining shaklini tahlil qiladi.
// Agar ushbu literalda maqsadli turda aniqlanmagan xususiyatlar mavjud bo'lsa, bu xatodir.

// Spread sintaksisi bilan ortiqcha xususiyat tekshiruvlarining odatiy qo'llanilish holati:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// Bu yerda ortiqcha xususiyat tekshiruvi dolzarbdir:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'lastLogin' 'AdminProfile' turida mavjud emas.
// };

// Spread orqali yaratilgan ob'ekt literalida 'AdminProfile' turida mavjud bo'lmagan 'lastLogin' xususiyati bor.
// Buni tuzatish uchun 'adminData' ideal holda AdminProfile ga mos kelishi yoki ortiqcha xususiyat bilan ishlash kerak.

// Tuzatilgan yondashuv:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

Ortiqcha xususiyatlarni tekshirish spread sintaksisi tomonidan yaratilgan natijaviy ob'ekt literaliga qo'llaniladi. Agar bu natijaviy literal maqsadli turda e'lon qilinmagan xususiyatlarni o'z ichiga olsa, TypeScript xato haqida xabar beradi.

Ortiqcha xususiyatlar bilan ishlash strategiyalari

Ortiqcha xususiyatlarni tekshirish foydali bo'lsa-da, siz kiritmoqchi bo'lgan yoki boshqacha tarzda qayta ishlamoqchi bo'lgan qo'shimcha xususiyatlarga ega bo'lgan qonuniy stsenariylar mavjud. Quyida umumiy strategiyalar keltirilgan:

1. Tur taxalluslari yoki interfeyslar bilan qoldiq xususiyatlar (Rest Properties)

Siz aniq belgilanmagan qolgan barcha xususiyatlarni qamrab olish uchun tur taxalluslari yoki interfeyslar ichida qoldiq parametr sintaksisidan (`...rest`) foydalanishingiz mumkin. Bu ortiqcha xususiyatlarni tan olish va yig'ishning toza usuli.


interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// Yoki ko'proq tur taxallusi va rest sintaksisi bilan:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Xato yo'q, chunki 'email' va 'isAdmin' UserProfileWithMetadata-dagi indeks imzosi tomonidan qabul qilinadi.
console.log(user1.email);
console.log(user1.isAdmin);

// Tur ta'rifida rest parametrlaridan foydalanishning yana bir usuli:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Boshqa barcha xususiyatlarni 'extraConfig' ga jamlash
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

`[key: string]: any;` yoki shunga o'xshash indeks imzolaridan foydalanish ixtiyoriy qo'shimcha xususiyatlar bilan ishlashning idiomatik usulidir.

2. Rest sintaksisi bilan destrukturizatsiya qilish

Ob'ektni qabul qilganingizda va qolganini saqlab, ma'lum xususiyatlarni ajratib olishingiz kerak bo'lganda, rest sintaksisi bilan destrukturizatsiya qilish bebaho yordam beradi.


interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Employee ID: ${employeeId}`);
  console.log(`Department: ${department}`);
  console.log('Other details:', otherDetails);
  // otherDetails 'salary', 'startDate' kabi aniq destrukturizatsiya qilinmagan barcha xususiyatlarni o'z ichiga oladi.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// employeeInfo dastlab ortiqcha xususiyatga ega bo'lsa ham, agar funksiya imzosi uni qabul qilsa (masalan, indeks imzosi yordamida),
// ortiqcha xususiyatlarni tekshirish o'tkazib yuboriladi.
// Agar processEmployeeData qat'iy 'Employee' turi bilan belgilangan bo'lsa va employeeInfo 'salary' ga ega bo'lsa,
// agar employeeInfo to'g'ridan-to'g'ri uzatilgan ob'ekt literali bo'lsa, xatolik yuzaga keladi.
// Ammo bu yerda employeeInfo o'zgaruvchi va funksiya turi ortiqcha xususiyatlarni qabul qiladi.

3. Barcha xususiyatlarni aniq belgilash (agar ma'lum bo'lsa)

Agar siz potentsial qo'shimcha xususiyatlarni bilsangiz, eng yaxshi yondashuv ularni interfeysingizga yoki tur taxallusingizga qo'shishdir. Bu eng yuqori tur xavfsizligini ta'minlaydi.


interface UserProfile {
  id: number;
  name: string;
  email?: string; // Ixtiyoriy email
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Agar UserProfile-da bo'lmagan xususiyatni qo'shishga harakat qilsak:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'phoneNumber' 'UserProfile' turida mavjud emas.

4. `as` dan tur tasdiqlari uchun foydalanish (ehtiyotkorlik bilan)

Avval ko'rsatilganidek, tur tasdiqlari ortiqcha xususiyatlarni tekshirishni bostirishi mumkin. Bundan tejamkorlik bilan va faqat ob'ekt shakliga to'liq amin bo'lganingizda foydalaning.


interface ProductConfig {
  id: string;
  version: string;
}

// Tasavvur qiling, bu tashqi manbadan yoki kamroq qat'iy moduldan keladi
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Ortiqcha xususiyat
};

// Agar siz 'externalConfig' har doim 'id' va 'version' ga ega bo'lishini bilsangiz va uni ProductConfig sifatida ishlatmoqchi bo'lsangiz:
const productConfig = externalConfig as ProductConfig;

// Bu tasdiq `externalConfig` ning o'zida ortiqcha xususiyat tekshiruvini chetlab o'tadi.
// Biroq, agar siz ob'ekt literalini to'g'ridan-to'g'ri uzatganingizda:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Xato: Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'debugMode' 'ProductConfig' turida mavjud emas.

5. Tur himoyachilari (Type Guards)

Murakkabroq stsenariylar uchun tur himoyachilari turlarni toraytirishga va xususiyatlarni shartli ravishda boshqarishga yordam beradi.


interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // TypeScript bu yerda 'shape' ning Circle ekanligini biladi
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // TypeScript bu yerda 'shape' ning Square ekanligini biladi
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Literal turini aniqlash uchun 'as const' dan foydalanish
  radius: 10,
  color: 'red' // Ortiqcha xususiyat
};

// calculateArea ga uzatilganda, funksiya imzosi 'Shape' ni kutadi.
// Funksiyaning o'zi 'kind' ga to'g'ri kiradi.
// Agar calculateArea to'g'ridan-to'g'ri 'Circle' ni kutganida va circleData ni
// ob'ekt literali sifatida qabul qilganida, 'color' muammo bo'lardi.

// Keling, ma'lum bir quyi turni kutayotgan funksiya bilan ortiqcha xususiyat tekshiruvini ko'rsatamiz:

function processCircle(circle: Circle) {
  console.log(`Processing circle with radius: ${circle.radius}`);
}

// processCircle(circleData); // Xato: '{ kind: "circle"; radius: number; color: string; }' turidagi argument 'Circle' turidagi parametrga tayinlanishi mumkin emas.
                         // Ob'ekt literali faqat ma'lum xususiyatlarni ko'rsatishi mumkin va 'color' 'Circle' turida mavjud emas.

// Buni tuzatish uchun, siz destrukturizatsiya qilishingiz yoki circleData uchun kengroq turdan foydalanishingiz mumkin:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// Yoki circleData ni kengroq turni o'z ichiga oladigan tarzda aniqlang:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Endi ishlaydi.

Umumiy xatolar va ulardan qanday qochish kerak

Hatto tajribali dasturchilar ham ba'zan ortiqcha xususiyatlarni tekshirishda xatoga yo'l qo'yishlari mumkin. Quyida keng tarqalgan xatolar keltirilgan:

Global mulohazalar va eng yaxshi amaliyotlar

Global, turli xil ishlab chiqish muhitida ishlaganda, tur xavfsizligi bo'yicha izchil amaliyotlarga rioya qilish juda muhimdir:

Xulosa

TypeScript-ning ortiqcha xususiyatlarni tekshirish mexanizmi uning mustahkam ob'ekt turlari xavfsizligini ta'minlash qobiliyatining asosidir. Bu tekshiruvlar qachon va nima uchun sodir bo'lishini tushunish orqali dasturchilar yanada bashorat qilinadigan, kamroq xatoliklarga ega kod yozishlari mumkin.

Butun dunyodagi dasturchilar uchun bu xususiyatni o'zlashtirish ish vaqtida kamroq kutilmagan holatlarni, osonroq hamkorlikni va qo'llab-quvvatlanishi osonroq kod bazalarini anglatadi. Kichik yordamchi dastur yoki yirik korporativ ilova yaratayotganingizdan qat'i nazar, ortiqcha xususiyatlarni tekshirishni o'zlashtirish, shubhasiz, JavaScript loyihalaringizning sifati va ishonchliligini oshiradi.

Asosiy xulosalar:

Ushbu printsiplarni ongli ravishda qo'llash orqali siz TypeScript kodingizning xavfsizligi va qo'llab-quvvatlanishini sezilarli darajada oshirishingiz mumkin, bu esa dasturiy ta'minotni ishlab chiqishda yanada muvaffaqiyatli natijalarga olib keladi.