M

MLOG

O'zbek

Global miqyosda mustahkam, tip-xavfsiz ilovalar yaratish uchun TypeScript'ning andaza literal turlari va satr vositalarini chuqur o'rganing.

TypeScript Andaza Satrlari Paterni: Ilg'or Satrlarni Boshqarish Turlarini Ochish

Dasturiy ta'minot ishlab chiqishning keng va doimiy rivojlanayotgan landshaftida aniqlik va tiplar xavfsizligi birinchi o'rinda turadi. JavaScript'ning ustki to'plami bo'lgan TypeScript, ayniqsa turli global jamoalar bilan ishlashda kengaytiriladigan va qo'llab-quvvatlanadigan ilovalarni yaratish uchun muhim vositaga aylandi. TypeScript'ning asosiy kuchi uning statik tiplash imkoniyatlarida bo'lsa-da, ko'pincha e'tibordan chetda qoladigan sohalardan biri bu satrlarni, xususan, "andaza literal turlari" orqali murakkab boshqarishdir.

Ushbu keng qamrovli qo'llanma TypeScript dasturchilarga kompilyatsiya vaqtida satr paternlarini aniqlash, boshqarish va tasdiqlash imkonini berib, yanada mustahkam va xatolarga chidamli kod bazalarini yaratishga qanday yordam berishini chuqur o'rganadi. Biz asosiy tushunchalarni ko'rib chiqamiz, kuchli yordamchi turlarni tanishtiramiz va har qanday xalqaro loyihada ishlab chiqish jarayonlarini sezilarli darajada yaxshilaydigan amaliy, real hayotiy qo'llanmalarni namoyish etamiz. Ushbu maqola oxirida siz ushbu ilg'or TypeScript xususiyatlaridan yanada aniq va bashorat qilinadigan tizimlarni yaratish uchun qanday foydalanishni tushunasiz.

Andaza Literallarini Tushunish: Tiplar Xavfsizligi Uchun Asos

Tip darajasidagi sehrga sho'ng'ishdan oldin, keling, TypeScript'ning ilg'or satr turlariga sintaktik asos bo'lib xizmat qiladigan JavaScript'ning andaza literallarini (ES6 da kiritilgan) qisqacha ko'rib chiqaylik. Andaza literallari teskari tirnoq (` `) bilan o'ralgan bo'lib, ular ichiga ifodalar (${expression}) joylashtirish va ko'p qatorli satrlarga imkon beradi, bu esa an'anaviy birlashtirishga qaraganda satrlarni tuzishning qulayroq va o'qilishi osonroq usulini taklif etadi.

JavaScript/TypeScript'dagi Asosiy Sintaksis va Foydalanish

Oddiy salomlashishni ko'rib chiqaylik:

// JavaScript / TypeScript


const userName = "Alice";


const age = 30;


const greeting = `Hello, ${userName}! You are ${age} years old. Welcome to our global platform.`;


console.log(greeting); // Natija: "Hello, Alice! You are 30 years old. Welcome to our global platform."

Ushbu misolda ${userName} va ${age} ichiga joylashtirilgan ifodalardir. TypeScript greeting turini string deb aniqlaydi. Bu oddiy bo'lsa-da, ushbu sintaksis juda muhim, chunki TypeScript'ning andaza literal turlari uni aks ettiradi va sizga umumiy satrlar o'rniga ma'lum satr paternlarini ifodalovchi turlarni yaratishga imkon beradi.

Satr Literal Turlari: Aniqlik Uchun Qurilish Bloklari

TypeScript satr literal turlarini taqdim etdi, bu esa o'zgaruvchi faqat ma'lum bir, aniq satr qiymatini saqlashi mumkinligini belgilashga imkon beradi. Bu juda aniq tip cheklovlarini yaratish uchun juda foydali bo'lib, deyarli enum kabi ishlaydi, lekin to'g'ridan-to'g'ri satr ko'rinishining moslashuvchanligiga ega.

// TypeScript


type Status = "pending" | "success" | "failed";



function updateOrderStatus(orderId: string, status: Status) {


  if (status === "success") {


    console.log(`Buyurtma ${orderId} muvaffaqiyatli qayta ishlandi.`);


  } else if (status === "pending") {


    console.log(`Buyurtma ${orderId} qayta ishlanishini kutmoqda.`);


  } else {


    console.log(`Buyurtma ${orderId} qayta ishlanmadi.`);


  }


}



updateOrderStatus("ORD-123", "success"); // To'g'ri


// updateOrderStatus("ORD-456", "in-progress"); // Tip xatosi: '"in-progress"' turidagi argument 'Status' turidagi parametrga mos kelmaydi.


// updateOrderStatus("ORD-789", "succeeded"); // Tip xatosi: 'succeeded' literal turlardan biri emas.

Ushbu oddiy konsepsiya yanada murakkab satr paternlarini aniqlash uchun poydevor bo'lib xizmat qiladi, chunki u bizga andaza literal turlarimizning literal qismlarini aniq belgilash imkonini beradi. Bu katta, taqsimlangan ilovadagi turli modullar yoki xizmatlar o'rtasida izchillikni saqlash uchun bebaho bo'lgan aniq satr qiymatlariga rioya qilinishini kafolatlaydi.

TypeScript'ning Andaza Literal Turlari Bilan Tanishtirish (TS 4.1+)

Satrlarni boshqarish turlaridagi haqiqiy inqilob TypeScript 4.1 versiyasida "Andaza Literal Turlari"ning kiritilishi bilan yuz berdi. Bu xususiyat sizga ma'lum satr paternlariga mos keladigan turlarni aniqlash imkonini beradi, bu esa satr tarkibiga asoslangan kuchli kompilyatsiya vaqtidagi tekshirish va tipni aniqlashni ta'minlaydi. Muhimi, bular JavaScript'ning andaza literallarining ish vaqtidagi satr qurilishidan farqli o'laroq, tip darajasida ishlaydigan turlardir, garchi ular bir xil sintaksisga ega bo'lsalar ham.

Andaza literal turi sintaktik jihatdan ish vaqtidagi andaza literaliga o'xshaydi, lekin u faqat tip tizimi ichida ishlaydi. U satr literal turlarini boshqa turlar uchun o'rinbosarlar (masalan, string, number, boolean, bigint) bilan birlashtirib, yangi satr literal turlarini hosil qilishga imkon beradi. Bu TypeScript'ning aniq satr formatini tushunishi va tasdiqlashi mumkinligini anglatadi, bu esa noto'g'ri formatlangan identifikatorlar yoki standartlashtirilmagan kalitlar kabi muammolarning oldini oladi.

Asosiy Andaza Literal Turi Sintaksisi

Biz tip ta'rifi ichida teskari tirnoq (` `) va o'rinbosarlardan (${Type}) foydalanamiz:

// TypeScript


type UserPrefix = "user";


type ItemPrefix = "item";


type ResourceId = `${UserPrefix | ItemPrefix}_${string}`;



let userId: ResourceId = "user_12345"; // To'g'ri: "user_${string}" ga mos keladi


let itemId: ResourceId = "item_ABC-XYZ"; // To'g'ri: "item_${string}" ga mos keladi


// let invalidId: ResourceId = "product_789"; // Tip xatosi: '"product_789"' turi '"user_${string}" | "item_${string}"' turiga mos kelmaydi.


// Bu xato ishga tushirish vaqtida emas, balki kompilyatsiya vaqtida aniqlanadi va potentsial xatolikning oldini oladi.

Ushbu misolda ResourceId ikkita andaza literal turining birlashmasidir: "user_${string}" va "item_${string}". Bu shuni anglatadiki, ResourceId ga tayinlangan har qanday satr "user_" yoki "item_" bilan boshlanishi va undan keyin ixtiyoriy satr kelishi kerak. Bu sizning ID'laringiz formati haqida darhol, kompilyatsiya vaqtida kafolat beradi, bu esa katta ilova yoki taqsimlangan jamoa bo'ylab izchillikni ta'minlaydi.

infer ning Andaza Literal Turlari Bilan Quvvati

Andaza literal turlarining shartli turlar bilan birgalikda eng kuchli jihatlaridan biri bu satr paternining qismlarini aniqlash (infer) qobiliyatidir. infer kalit so'zi o'rinbosarga mos keladigan satrning bir qismini ushlab, uni shartli tip ichida yangi tip o'zgaruvchisi sifatida mavjud qilishga imkon beradi. Bu sizning tip ta'riflaringiz ichida to'g'ridan-to'g'ri murakkab patern mosligini va ajratib olishni ta'minlaydi.

// TypeScript


type GetPrefix = T extends `${infer Prefix}_${string}` ? Prefix : never;



type UserType = GetPrefix<"user_data_123">


// UserType "user" ga teng



type ItemType = GetPrefix<"item_details_XYZ">


// ItemType "item" ga teng



type FallbackPrefix = GetPrefix<"just_a_string">


// FallbackPrefix "just" ga teng (chunki "just_a_string" `${infer Prefix}_${string}` ga mos keladi)



type NoMatch = GetPrefix<"simple_string_without_underscore">


// NoMatch "simple_string_without_underscore" ga teng (chunki patern kamida bitta pastki chiziqni talab qiladi)


// Tuzatish: `${infer Prefix}_${string}` paterni "ixtiyoriy satr, undan keyin pastki chiziq, undan keyin ixtiyoriy satr" degan ma'noni anglatadi.


// Agar "simple_string_without_underscore" da pastki chiziq bo'lmasa, u bu paternga mos kelmaydi.


// Shuning uchun, agar unda haqiqatan ham pastki chiziq bo'lmasa, bu holatda NoMatch `never` bo'lar edi.


// Mening oldingi misolim `infer` ning ixtiyoriy qismlar bilan qanday ishlashi haqida noto'g'ri edi. Keling, buni tuzatamiz.



// GetPrefix'ning aniqroq misoli:


type GetLeadingPart = T extends `${infer PartA}_${infer PartB}` ? PartA : T;


type UserPart = GetLeadingPart<"user_data">


// UserPart "user" ga teng


type SinglePart = GetLeadingPart<"alone">


// SinglePart "alone" ga teng (pastki chiziqli paternga mos kelmaydi, shuning uchun T ni qaytaradi)



// Keling, ma'lum prefikslar uchun aniqlashtiramiz


type KnownCategory = "product" | "order" | "customer";


type ExtractCategory = T extends `${infer Category extends KnownCategory}_${string}` ? Category : never;



type MyProductCategory = ExtractCategory<"product_details_001">


// MyProductCategory "product" ga teng


type MyCustomerCategory = ExtractCategory<"customer_profile_abc">


// MyCustomerCategory "customer" ga teng


type UnknownCategory = ExtractCategory<"vendor_item_xyz">


// UnknownCategory `never` ga teng (chunki "vendor" KnownCategory'da mavjud emas)

infer kalit so'zi, ayniqsa cheklovlar bilan birgalikda (infer P extends KnownPrefix), tip darajasida murakkab satr paternlarini tahlil qilish va tasdiqlash uchun juda kuchlidir. Bu, ish vaqtidagi tahlilchi kabi satr qismlarini tahlil qila oladigan va tushunadigan, ammo kompilyatsiya vaqtidagi xavfsizlik va mustahkam avtomatik to'ldirish afzalliklariga ega bo'lgan yuqori aqlli tip ta'riflarini yaratishga imkon beradi.

Ilg'or Satrlarni Boshqarish Uchun Yordamchi Turlar (TS 4.1+)

Andaza literal turlari bilan bir qatorda, TypeScript 4.1 shuningdek, bir qator ichki satrlarni boshqarish uchun yordamchi turlarni taqdim etdi. Bu turlar satr literal turlarini boshqa satr literal turlariga aylantirishga imkon beradi, bu esa tip darajasida satr registri va formatlash ustidan misli ko'rilmagan nazoratni ta'minlaydi. Bu, ayniqsa, turli xil kod bazalari va jamoalar bo'ylab qat'iy nomlash qoidalarini joriy etish, turli dasturlash paradigmalari yoki madaniy afzalliklar o'rtasidagi potentsial uslub farqlarini bartaraf etish uchun qimmatlidir.

Ushbu yordamchi vositalar nomlash qoidalarini joriy etish, API ma'lumotlarini o'zgartirish yoki global ishlab chiqish jamoalarida tez-tez uchraydigan turli nomlash uslublari bilan ishlash uchun juda foydali bo'lib, jamoa a'zosi camelCase, PascalCase, snake_case yoki kebab-case'ni afzal ko'rishidan qat'i nazar, izchillikni ta'minlaydi.

Satrlarni Boshqarish Uchun Yordamchi Turlar Misollari

// TypeScript


type ProductName = "global_product_identifier";



type UppercaseProductName = Uppercase;


// UppercaseProductName "GLOBAL_PRODUCT_IDENTIFIER" ga teng



type LowercaseServiceName = Lowercase<"SERVICE_CLIENT_API">


// LowercaseServiceName "service_client_api" ga teng



type FunctionName = "initConnection";


type CapitalizedFunctionName = Capitalize;


// CapitalizedFunctionName "InitConnection" ga teng



type ClassName = "UserDataProcessor";


type UncapitalizedClassName = Uncapitalize;


// UncapitalizedClassName "userDataProcessor" ga teng

Andaza Literal Turlarini Yordamchi Turlar Bilan Birlashtirish

Haqiqiy qudrat bu xususiyatlar birlashtirilganda namoyon bo'ladi. Siz ma'lum bir harf registri talab qiladigan turlarni yaratishingiz yoki mavjud satr literal turlarining o'zgartirilgan qismlariga asoslanib yangi turlarni yaratishingiz mumkin, bu esa juda moslashuvchan va mustahkam tip ta'riflarini yaratishga imkon beradi.

// TypeScript



type HttpMethod = "get" | "post" | "put" | "delete";


type EntityType = "User" | "Product" | "Order";



// 1-misol: Tip-xavfsiz REST API so'nggi nuqtasi amallari nomlari (masalan, GET_USER, POST_PRODUCT)


type ApiAction = `${Uppercase}_${Uppercase}`;



let getUserAction: ApiAction = "GET_USER";


let createProductAction: ApiAction = "POST_PRODUCT";


// let invalidAction: ApiAction = "get_user"; // Tip xatosi: 'get' va 'user' uchun harflar registri mos kelmaydi.


// let unknownAction: ApiAction = "DELETE_REPORT"; // Tip xatosi: 'REPORT' EntityType'da mavjud emas.



// 2-misol: Kelishuv asosida komponent hodisalari nomlarini yaratish (masalan, "OnSubmitForm", "OnClickButton")


type ComponentName = "Form" | "Button" | "Modal";


type EventTrigger = "submit" | "click" | "close" | "change";



type ComponentEvent = `On${Capitalize}${ComponentName}`;


// ComponentEvent "OnSubmitForm" | "OnClickForm" | ... | "OnChangeModal" ga teng



let formSubmitEvent: ComponentEvent = "OnSubmitForm";


let buttonClickEvent: ComponentEvent = "OnClickButton";


// let modalOpenEvent: ComponentEvent = "OnOpenModal"; // Tip xatosi: 'open' EventTrigger'da mavjud emas.



// 3-misol: Maxsus prefiks va camelCase o'zgartirish bilan CSS o'zgaruvchilari nomlarini belgilash


type CssVariableSuffix = "primaryColor" | "secondaryBackground" | "fontSizeBase";


type CssVariableName = `--app-${Uncapitalize}`;


// CssVariableName "--app-primaryColor" | "--app-secondaryBackground" | "--app-fontSizeBase" ga teng



let colorVar: CssVariableName = "--app-primaryColor";


// let invalidVar: CssVariableName = "--app-PrimaryColor"; // Tip xatosi: 'PrimaryColor' uchun harflar registri mos kelmaydi.

Global Dasturiy Ta'minot Ishlab Chiqishdagi Amaliy Qo'llanmalar

TypeScript'ning satrlarni boshqarish turlarining kuchi nazariy misollardan ancha kengroqdir. Ular izchillikni saqlash, xatolarni kamaytirish va ishlab chiquvchi tajribasini yaxshilash uchun sezilarli afzalliklarni taqdim etadi, ayniqsa turli vaqt zonalari va madaniy kelib chiqishga ega bo'lgan taqsimlangan jamoalarni o'z ichiga olgan yirik loyihalarda. Satr paternlarini kodlashtirish orqali jamoalar tip tizimining o'zi orqali samaraliroq muloqot qilishlari mumkin, bu esa murakkab loyihalarda tez-tez yuzaga keladigan noaniqliklar va noto'g'ri talqinlarni kamaytiradi.

1. Tip-Xavfsiz API So'nggi Nuqtasi Ta'riflari va Kliyent Yaratish

Mustahkam API kliyentlarini yaratish mikroservis arxitekturalari yoki tashqi xizmatlar bilan integratsiya qilish uchun juda muhimdir. Andaza literal turlari yordamida siz API so'nggi nuqtalaringiz uchun aniq paternlar belgilashingiz mumkin, bu esa dasturchilarning to'g'ri URL manzillarini tuzishini va kutilayotgan ma'lumotlar turlarining mos kelishini ta'minlaydi. Bu tashkilot bo'ylab API chaqiruvlarining qanday amalga oshirilishi va hujjatlashtirilishini standartlashtiradi.

// TypeScript



type BaseUrl = "https://api.mycompany.com";


type ApiVersion = "v1" | "v2";


type Resource = "users" | "products" | "orders";


type UserPathSegment = "profile" | "settings" | "activity";


type ProductPathSegment = "details" | "inventory" | "reviews";



// Mumkin bo'lgan so'nggi nuqta yo'llarini maxsus paternlar bilan belgilash


type EndpointPath = 


  `${Resource}` | 


  `${Resource}/${string}` | 


  `users/${string}/${UserPathSegment}` | 


  `products/${string}/${ProductPathSegment}`;



// Baza, versiya va yo'lni birlashtiruvchi to'liq API URL turi


type ApiUrl = `${BaseUrl}/${ApiVersion}/${EndpointPath}`;



function fetchApiData(url: ApiUrl) {


  console.log(`Ma'lumotlarni olishga urinish: ${url}`);


  // ... haqiqiy tarmoqdan ma'lumot olish mantig'i shu yerda bo'ladi ...


  return Promise.resolve(`Ma'lumotlar ${url} dan olindi`);


}



fetchApiData("https://api.mycompany.com/v1/users"); // To'g'ri: Asosiy resurslar ro'yxati


fetchApiData("https://api.mycompany.com/v2/products/PROD-001/details"); // To'g'ri: Maxsus mahsulot tafsiloti


fetchApiData("https://api.mycompany.com/v1/users/user-123/profile"); // To'g'ri: Maxsus foydalanuvchi profili



// Tip xatosi: Yo'l belgilangan paternlarga mos kelmaydi yoki asosiy URL/versiya noto'g'ri


// fetchApiData("https://api.mycompany.com/v3/orders"); // 'v3' yaroqli ApiVersion emas


// fetchApiData("https://api.mycompany.com/v1/users/user-123/dashboard"); // 'dashboard' UserPathSegment'da mavjud emas


// fetchApiData("https://api.mycompany.com/v1/reports"); // 'reports' yaroqli Resource emas

Bu yondashuv ishlab chiqish jarayonida darhol fikr-mulohaza berib, umumiy API integratsiyasi xatolarining oldini oladi. Global miqyosda taqsimlangan jamoalar uchun bu noto'g'ri sozланган URL'larni tuzatishga kamroq vaqt sarflash va ko'proq vaqtni yangi funksiyalarni yaratishga sarflashni anglatadi, chunki tip tizimi API iste'molchilari uchun universal yo'riqnoma bo'lib xizmat qiladi.

2. Tip-Xavfsiz Hodisalarni Nomlash Qoidalari

Katta ilovalarda, ayniqsa mikroservislar yoki murakkab foydalanuvchi interfeysi (UI) o'zaro ta'sirlariga ega bo'lganlarda, izchil hodisalarni nomlash strategiyasi aniq muloqot va nosozliklarni tuzatish uchun juda muhimdir. Andaza literal turlari ushbu paternларни joriy etishi mumkin, bu esa hodisa yaratuvchilari va iste'molchilarining yagona shartnomaga rioya qilishini ta'minlaydi.

// TypeScript



type EventDomain = "USER" | "PRODUCT" | "ORDER" | "ANALYTICS";


type EventAction = "CREATED" | "UPDATED" | "DELETED" | "VIEWED" | "SENT" | "RECEIVED";


type EventTarget = "ACCOUNT" | "ITEM" | "FULFILLMENT" | "REPORT";



// Standart hodisa nomi formatini belgilash: DOMEN_HARAKAT_MAQSAD (masalan, USER_CREATED_ACCOUNT)


type SystemEvent = `${Uppercase}_${Uppercase}_${Uppercase}`;



function publishEvent(eventName: SystemEvent, payload: unknown) {


  console.log(`Hodisa e'lon qilinmoqda: "${eventName}" yuklama bilan:`, payload);


  // ... haqiqiy hodisani e'lon qilish mexanizmi (masalan, xabarlar navbati) ...


}



publishEvent("USER_CREATED_ACCOUNT", { userId: "uuid-123", email: "test@example.com" }); // To'g'ri


publishEvent("PRODUCT_UPDATED_ITEM", { productId: "item-456", newPrice: 99.99 }); // To'g'ri



// Tip xatosi: Hodisa nomi talab qilingan paternga mos kelmaydi


// publishEvent("user_created_account", {}); // Noto'g'ri harflar registri


// publishEvent("ORDER_SHIPPED", {}); // Maqsad suffiksi yo'q, 'SHIPPED' EventAction'da mavjud emas


// publishEvent("ADMIN_LOGGED_IN", {}); // 'ADMIN' belgilangan EventDomain emas

Bu barcha hodisalarning oldindan belgilangan tuzilishga mos kelishini ta'minlaydi, bu esa dasturchining ona tili yoki kodlash uslubi afzalliklaridan qat'i nazar, nosozliklarni tuzatish, monitoring va jamoalararo muloqotni sezilarli darajada osonlashtiradi.

3. UI Ishlab Chiqishda CSS Yordamchi Klass Paternlarini Joriy Etish

Dizayn tizimlari va yordamchi-birinchi CSS freymvorklari uchun klasslar uchun nomlash qoidalari qo'llab-quvvatlanuvchanlik va kengaytiriluvchanlik uchun juda muhimdir. TypeScript ishlab chiqish jarayonida bularni joriy etishga yordam berishi mumkin, bu esa dizaynerlar va dasturchilarning nomuvofiq klass nomlarini ishlatish ehtimolini kamaytiradi.

// TypeScript



type SpacingSize = "xs" | "sm" | "md" | "lg" | "xl";


type Direction = "top" | "bottom" | "left" | "right" | "x" | "y" | "all";


type SpacingProperty = "margin" | "padding";



// Misol: Muayyan yo'nalishda va o'lchamdagi margin yoki padding uchun klass


// masalan, "m-t-md" (margin-top-medium) yoki "p-x-lg" (padding-x-large)


type SpacingClass = `${Lowercase}-${Lowercase}-${Lowercase}`;



function applyCssClass(elementId: string, className: SpacingClass) {


  const element = document.getElementById(elementId);


  if (element) {


    element.classList.add(className);
    console.log(`'${className}' klassi '${elementId}' elementiga qo'llanildi`);


  } else {


    console.warn(`IDsi '${elementId}' bo'lgan element topilmadi.`);


  }


}



applyCssClass("my-header", "m-t-md"); // To'g'ri


applyCssClass("product-card", "p-x-lg"); // To'g'ri


applyCssClass("main-content", "m-all-xl"); // To'g'ri



// Tip xatosi: Klass paternga mos kelmaydi


// applyCssClass("my-footer", "margin-top-medium"); // Noto'g'ri ajratuvchi va qisqartma o'rniga to'liq so'z


// applyCssClass("sidebar", "m-center-sm"); // 'center' yaroqli Direction literal emas

Bu patern noto'g'ri yoki xato yozilgan CSS klassidan tasodifan foydalanishni imkonsiz qiladi, bu esa mahsulotning foydalanuvchi interfeysi bo'ylab UI izchilligini oshiradi va vizual xatolarni kamaytiradi, ayniqsa bir nechta dasturchi uslub mantig'iga hissa qo'shganda.

4. Xalqarolashtirish (i18n) Kalitlarini Boshqarish va Tasdiqlash

Global ilovalarda mahalliylashtirish kalitlarini boshqarish juda murakkablashishi mumkin, bu ko'pincha bir nechta tillar bo'ylab minglab yozuvlarni o'z ichiga oladi. Andaza literal turlari iyerarxik yoki tavsiflovchi kalit paternlarini joriy etishga yordam berishi mumkin, bu esa kalitlarning izchil va qo'llab-quvvatlanishi osonroq bo'lishini ta'minlaydi.

// TypeScript



type PageKey = "home" | "dashboard" | "settings" | "auth";


type SectionKey = "header" | "footer" | "sidebar" | "form" | "modal" | "navigation";


type MessageType = "label" | "placeholder" | "button" | "error" | "success" | "heading";



// i18n kalitlari uchun patern belgilash: sahifa.bo'lim.xabarTuri.tavsiflovchi


type I18nKey = `${PageKey}.${SectionKey}.${MessageType}.${string}`;



function translate(key: I18nKey, params?: Record): string {


  console.log(`Kalit tarjima qilinmoqda: "${key}" parametrlar bilan:`, params);


  // Haqiqiy ilovada bu tarjima xizmatidan yoki mahalliy lug'atdan ma'lumot olishni o'z ichiga oladi


  let translatedString = `[${key}_tarjima_qilingan]`;


  if (params) {


    for (const p in params) {


      translatedString = translatedString.replace(`{${p}}`, params[p]);


    }


  }


  return translatedString;


}



console.log(translate("home.header.heading.welcomeUser", { user: "Global Sayohatchi" })); // To'g'ri


console.log(translate("dashboard.form.label.username")); // To'g'ri


console.log(translate("auth.modal.button.login")); // To'g'ri



// Tip xatosi: Kalit belgilangan paternga mos kelmaydi


// console.log(translate("home_header_greeting_welcome")); // Noto'g'ri ajratuvchi (nuqta o'rniga pastki chiziq ishlatilgan)


// console.log(translate("users.profile.label.email")); // 'users' yaroqli PageKey emas


// console.log(translate("settings.navbar.button.save")); // 'navbar' yaroqli SectionKey emas ('navigation' yoki 'sidebar' bo'lishi kerak)

Bu mahalliylashtirish kalitlarining izchil tuzilishini ta'minlaydi, bu esa turli tillar va hududlar bo'ylab yangi tarjimalarni qo'shish va mavjudlarini saqlash jarayonini soddalashtiradi. Bu kalitlardagi imlo xatolari kabi umumiy xatolarning oldini oladi, bu esa UI'da tarjima qilinmagan satrlarga olib kelishi mumkin, bu xalqaro foydalanuvchilar uchun asabiylashtiruvchi tajribadir.

infer bilan Ilg'or Texnikalar

infer kalit so'zining haqiqiy kuchi satrning bir nechta qismini ajratib olish, ularni birlashtirish yoki dinamik ravishda o'zgartirish kerak bo'lgan murakkabroq stsenariylarda namoyon bo'ladi. Bu juda moslashuvchan va kuchli tip darajasidagi tahlil qilish imkonini beradi.

Bir Nechta Segmentlarni Ajratib Olish (Rekursiv Tahlil)

Siz infer ni rekursiv ravishda yo'llar yoki versiya raqamlari kabi murakkab satr tuzilmalarini tahlil qilish uchun ishlatishingiz mumkin:

// TypeScript



type SplitPath = 


  T extends `${infer Head}/${infer Tail}`


    ? [Head, ...SplitPath] 


    : T extends '' ? [] : [T];



type PathSegments1 = SplitPath<"api/v1/users/123">


// PathSegments1 ["api", "v1", "users", "123"] ga teng



type PathSegments2 = SplitPath<"product-images/large">


// PathSegments2 ["product-images", "large"] ga teng



type SingleSegment = SplitPath<"root">


// SingleSegment ["root"] ga teng



type EmptySegments = SplitPath<"">


// EmptySegments [] ga teng

Ushbu rekursiv shartli tip satr yo'lini uning segmentlaridan iborat kortejga qanday tahlil qilishingiz mumkinligini ko'rsatadi, bu URL marshrutlari, fayl tizimi yo'llari yoki boshqa har qanday slash bilan ajratilgan identifikator ustidan nozik tip nazoratini ta'minlaydi. Bu tip-xavfsiz marshrutlash tizimlari yoki ma'lumotlarga kirish qatlamlarini yaratish uchun juda foydalidir.

Aniqlangan Qismlarni O'zgartirish va Qayta Qurish

Siz shuningdek yordamchi turlarni aniqlangan qismlarga qo'llashingiz va yangi satr literal turini qayta qurishingiz mumkin:

// TypeScript



type ConvertToCamelCase = 


  T extends `${infer FirstPart}_${infer SecondPart}`


    ? `${Uncapitalize}${Capitalize}`


    : Uncapitalize;



type UserDataField = ConvertToCamelCase<"user_id">


// UserDataField "userId" ga teng



type OrderStatusField = ConvertToCamelCase<"order_status">


// OrderStatusField "orderStatus" ga teng



type SingleWordField = ConvertToCamelCase<"firstName">


// SingleWordField "firstName" ga teng



type RawApiField = 


  T extends `API_${infer Method}_${infer Resource}`


    ? `${Lowercase}-${Lowercase}`


    : never;



type GetUsersPath = RawApiField<"API_GET_USERS">


// GetUsersPath "get-users" ga teng



type PostProductsPath = RawApiField<"API_POST_PRODUCTS">


// PostProductsPath "post-products" ga teng


// type InvalidApiPath = RawApiField<"API_FETCH_DATA">; // Xato, chunki agar `DATA` `Resource` bo'lmasa, u qat'iy 3 qismli strukturaga mos kelmaydi


type InvalidApiFormat = RawApiField<"API_USERS">


// InvalidApiFormat `never` ga teng (chunki API_ dan keyin uchta emas, faqat ikkita qism bor)

Bu bir konventsiyaga (masalan, API'dan kelgan snake_case) mos keladigan satrni olib, uni avtomatik ravishda boshqa konventsiyadagi (masalan, ilovangiz uchun camelCase) ko'rinishi uchun tip yaratishingiz mumkinligini ko'rsatadi, barchasi kompilyatsiya vaqtida. Bu tashqi ma'lumotlar tuzilmalarini ichki tuzilmalarga qo'lda tip tasdiqlashlari yoki ish vaqtidagi xatolarsiz bog'lash uchun bebaho.

Global Jamoalar Uchun Eng Yaxshi Amaliyotlar va Mulohazalar

TypeScript'ning satrlarni boshqarish turlari kuchli bo'lsa-da, ulardan oqilona foydalanish muhim. Ularni global ishlab chiqish loyihalaringizga kiritish uchun ba'zi eng yaxshi amaliyotlar:

Xulosa

TypeScript'ning andaza literal turlari, Uppercase, Lowercase, Capitalize va Uncapitalize kabi ichki satrlarni boshqarish yordamchi vositalari bilan birgalikda, tip-xavfsiz satrlar bilan ishlashda sezilarli yutuqni ifodalaydi. Ular bir paytlar ish vaqtidagi muammo bo'lgan narsani – satr formatlash va tasdiqlashni – kompilyatsiya vaqtidagi kafolatga aylantiradi, bu esa kodingizning ishonchliligini tubdan yaxshilaydi.

Murakkab, hamkorlikdagi loyihalar ustida ishlaydigan global ishlab chiqish jamoalari uchun ushbu paternларни qabul qilish sezilarli va chuqur afzalliklarni taqdim etadi:

Ushbu kuchli xususiyatlarni o'zlashtirib, dasturchilar yanada mustahkam, qo'llab-quvvatlanadigan va bashorat qilinadigan ilovalarni yaratishlari mumkin. Satrlarni boshqarishni yangi darajadagi tip xavfsizligi va aniqlikka ko'tarish uchun TypeScript'ning andaza satrlari paternlarını qabul qiling, bu esa global ishlab chiqish harakatlaringizning yanada katta ishonch va samaradorlik bilan rivojlanishiga imkon beradi. Bu haqiqatan ham mustahkam va global miqyosda kengaytiriladigan dasturiy yechimlarni yaratish yo'lidagi muhim qadamdir.