satisfies vs. Type Annotation (:) vs. as (သုံးမျိုး နှိုင်းယှဉ်ချက်)

ရည်ရွယ်ချက်

satisfies ကို type annotations နဲ့ type assertions တို့နဲ့ ရှင်းရှင်းလင်းလင်း ခွဲခြားသိမြင်ဖို့နဲ့ တစ်ခုချင်းစီကို ဘယ်အချိန်မှာ သုံးရမယ်ဆိုတာ နားလည်ဖို့ ဖြစ်ပါတယ်။

;

ဘယ်လိုအချက်လဲ (Feature)	Type သတ်မှတ်ခြင်း (:) const x: Type = val;	Type အတည်ပြုခြင်း (as) const x = val as Type;	စစ်ဆေးကိုက်ညီခြင်း (satisfies) const x = val satisfies Type;
ရည်ရွယ်ချက် (Purpose)	x ကို ဒီ Type ပဲ ဖြစ်စေချင်တယ်။ val ကလည်း ဒီ Type နဲ့ ကိုက်ညီလား စစ်တယ်။	val ကို ဒီ Type အတိုင်း မှတ်ခိုင်းတာ။ TypeScript က မဟုတ်ဘူးပြောရင်တောင် ‘ငါ့ကို ယုံ’ လို့ ပြောတာမျိုး။	val က ဒီ Type အတိုင်း ဟုတ်မဟုတ် စစ်တယ်။ ဒါပေမယ့် x က val ရဲ့ မူရင်း အတိအကျ ပုံစံကိုပဲ ဆက်သိနေစေတယ်။
x ရဲ့ Type မှာ ဘာဖြစ်လဲ	x ကို Type လို့ မှတ်လိုက်တယ်။	x ကို Type လို့ မှတ်လိုက်တယ်။	x က val ရဲ့ မူရင်း အတိအကျ ပုံစံကိုပဲ သိနေတယ်။
အတိအကျမှု ပျောက်ဆုံးလား	များသောအားဖြင့် ပျောက်သွားတယ်။ val ရဲ့ အတိအကျ ပုံစံက ပိုကျယ်တဲ့ Type ဖြစ်သွားတယ်။	ပျောက်ချင်လည်းပျောက်၊ မပျောက်ချင်လည်း မပျောက်ဘူး။ Type ကို အတင်းပြောင်းလိုက်လို့ unsafe ဖြစ်နိုင်တယ်။	လုံးဝမပျောက်ဘူး။ val ရဲ့ အတိအကျ ပုံစံကို x က သိနေဆဲပဲ။
လုံခြုံမှု (Safety)	အများစုက လုံခြုံတယ်။	မလုံခြုံနိုင်ဘူး။ TypeScript ရဲ့ စစ်ဆေးမှုတွေကို ကျော်သွားနိုင်လို့ သတိထားပြီး သုံးပါ။	လုံခြုံတယ်။ မှန်မမှန် စစ်ပေးပြီး အတိအကျ ပုံစံကိုလည်း ထိန်းထားပေးတယ်။
Error ဘယ်မှာပြလဲ	val က Type နဲ့ မကိုက်ရင် val မှာ error ပြတယ်။	ချက်ချင်း error နည်းတယ်။ (TypeScript က ယုံပေးလို့)။ ဒါပေမယ့် program Run တဲ့အခါ (runtime မှာ) error တွေ ဖြစ်လာနိုင်တယ်။	val က Type နဲ့ မကိုက်ရင် val မှာ error ပြတယ်။
အသုံးများတဲ့ နေရာ	Function မှာ input (parameters) တွေ၊ output (return types) တွေ၊ ဒါမှမဟုတ် variable တွေကို type သတ်မှတ်ဖို့ သုံးတယ်။	TypeScript မဟုတ်တဲ့ code တွေနဲ့ အလုပ်လုပ်တဲ့အခါ၊ ဒါမှမဟုတ် library type တွေ မှားနေတာကို ပြင်တဲ့အခါ (သတိထားပြီး) သုံးတယ်။	Configuration object တွေမှာ သုံးတယ်။ object တစ်ခုက သူ့ရဲ့ ပုံစံနဲ့ ကိုက်ညီလား စစ်ပြီး၊ သူ့ရဲ့ မူရင်း အတိအကျ အချက်အလက်တွေကို ထိန်းသိမ်းချင်တဲ့အခါ သုံးတယ်။

အဓိက ကွာခြားချက်များ အကျဉ်းချုပ် (Key Distinctions Summarized):

• : (Type သတ်မှတ်ခြင်း): x ကို ဒီ Type ပဲ ဖြစ်စေချင်တယ်။ val ကလည်း ဒီ Type နဲ့ ကိုက်ညီလား စစ်တယ်။ (ဒါပေမယ့် val ရဲ့ Type က ကျယ်ပြန့်သွားနိုင်တယ်။)
• as (Type အတည်ပြုခြင်း): val ကို ဒီ Type အတိုင်း မှတ်ခိုင်းတာ။ TypeScript က မဟုတ်ဘူးပြောရင်တောင် ‘ငါ့ကို ယုံ’ လို့ ပြောတာမျိုး။ (မလုံခြုံနိုင်ဘူး)
• satisfies (စစ်ဆေးကိုက်ညီခြင်း): val က ဒီ Type အတိုင်း ဟုတ်မဟုတ် စစ်တယ်။ ဒါပေမယ့် x က val ရဲ့ မူရင်း အတိအကျ ပုံစံကိုပဲ ဆက်သိနေစေတယ်။ (လုံခြုံတယ်၊ အတိအကျ အချက်အလက်ကို ထိန်းသိမ်းပေးတယ်။)

ဥပမာများ -

index.ts

type Fruit = "apple" | "banana" | "orange";

const myFruitLiteral = "apple"; // Inferred type: "apple"

// ၁။ Type သတ်မှတ်ခြင်း (Annotation)
const fruit1: Fruit = myFruitLiteral;
// fruit1 ရဲ့ typeof က "apple" | "banana" | "orange" ဖြစ်သွားတယ်။ "apple" ဆိုတဲ့ အတိအကျ အချက်အလက်ဟာ fruit1 အတွက် widened (ကျယ်ပြန့်) သွားတယ်။

// ၂။ Type အတည်ပြုခြင်း (Assertion)
const fruit2 = myFruitLiteral as Fruit;
// fruit2 ရဲ့ typeof က "apple" | "banana" | "orange" ဖြစ်သွားတယ်။ type သတ်မှတ်တာနဲ့ ဆင်တူပါတယ်။
const fruitMaybe = "grape" as Fruit; // UNSAFE (မလုံခြုံ)! "grape" က Fruit မဟုတ်ဘူး၊ ဒါပေမယ့် TypeScript က as ကို ခွင့်ပြုတယ်။

// ၃။ စစ်ဆေးကိုက်ညီခြင်း (Satisfaction)
const fruit3 = myFruitLiteral satisfies Fruit;
// fruit3 ရဲ့ typeof က "apple" ဖြစ်တယ်။ အတိအကျ အချက်အလက် ထိန်းသိမ်းထားတယ်။
// const notFruit = "grape" satisfies Fruit; // ERROR: Type '"grape"' is not assignable to type 'Fruit'.