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

            
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.
};

            

              
                Copy
              
            
          

            
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.
});

            

              
                Copy
              
            
          

            
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.
};

            

              
                Copy
              
            
          

            
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.

            

              
                Copy
              
            
          

            
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);

            

              
                Copy
              
            
          

            
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);

            

              
                Copy
              
            
          

            
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);

            

              
                Copy
              
            
          

            
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.

            

              
                Copy
              
            
          

            
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.

            

              
                Copy
              
            
          

            
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.

            

              
                Copy
              
            
          

            
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.

            

              
                Copy