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

ဘယ်လိုအချက်လဲ (Feature)	Type သတ်မှတ်ခြင်း (`:`)<br />`const x: Type = val;`	Type အတည်ပြုခြင်း (`as`)<br/>`const x = val as Type;`	စစ်ဆေးကိုက်ညီခြင်း (`satisfies`)<br/>`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 (Widened) ဖြစ်သွားတယ်။	ပျောက်ချင်လည်း ပျောက်မယ်၊ မပျောက်ချင်လည်း မပျောက်ဘူး။ Type ကို အတင်းအကျပ် ပြောင်းလိုက်လို့ Unsafe (အန္တရာယ်) ဖြစ်နိုင်တယ်။	လုံးဝ မပျောက်ဆုံးပါဘူး။ `val` ရဲ့ အတိအကျ ပုံစံကို `x` က အပြည့်အဝ သိရှိနေဆဲပါပဲ။
လုံခြုံမှု (Safety)	အများစုမှာ လုံခြုံပါတယ်။	မလုံခြုံနိုင်ပါဘူး။ TypeScript ရဲ့ အမှားစစ်ဆေးမှုတွေကို ကျော်လွှားသွားနိုင်လို့ အထူး သတိထားပြီး သုံးရပါမယ်။	လုံခြုံပါတယ်။ မှန်/မမှန် သေချာ စစ်ဆေးပေးပြီး၊ အတိအကျ ပုံစံကိုလည်း ထိန်းသိမ်းပေးထားပါတယ်။
Error ဘယ်မှာပြလဲ	`val` က Type နဲ့ မကိုက်ညီရင် `val` နေရာမှာ Error ပြပါတယ်။	ချက်ချင်း Error ပြလေ့ မရှိပါဘူး (TypeScript က သင့်ကို ယုံကြည်ပေးလိုက်လို့ပါ)။ ဒါပေမဲ့ Program Run တဲ့အခါ (Runtime မှာ) မှားယွင်းမှုတွေ ဖြစ်လာနိုင်ပါတယ်။	`val` က Type နဲ့ မကိုက်ညီရင် `val` နေရာမှာ ချက်ချင်း Error ပြပေးပါတယ်။
အသုံးများတဲ့ နေရာ	Function မှာ Input (Parameters) တွေ၊ Output (Return Types) တွေ၊ ဒါမှမဟုတ် သာမန် Variables တွေကို Type အတိအကျ သတ်မှတ်ဖို့ အများဆုံး သုံးပါတယ်။	TypeScript မဟုတ်တဲ့ Code တွေနဲ့ အလုပ်လုပ်တဲ့အခါ၊ ဒါမှမဟုတ် Library တွေရဲ့ Type မှားယွင်းနေတာကို ယာယီ ပြင်ဆင်ချင်တဲ့အခါမျိုးမှာ (သတိထားပြီး) သုံးပါတယ်။	Configuration Objects တွေ တည်ဆောက်တဲ့ နေရာတွေမှာ သုံးပါတယ်။ Object တစ်ခုက သတ်မှတ်ထားတဲ့ ပုံစံနဲ့ ကိုက်ညီလား စစ်ဆေးပြီး၊ သူ့ရဲ့ မူရင်း အတိအကျ အချက်အလက်တွေကိုပါ ထိန်းသိမ်းချင်တဲ့အခါ သုံးပါတယ်။

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

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

ဥပမာများ -

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

const myFruitLiteral = "apple"; // Inferred type ဟာ အတိအကျ "apple" ဖြစ်ပါတယ်

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

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

// ၃။ စစ်ဆေးကိုက်ညီခြင်း (Satisfaction)
const fruit3 = myFruitLiteral satisfies Fruit;
// fruit3 ရဲ့ Type က "apple" အတိအကျ ဖြစ်ပါတယ်။
// မူရင်း အတိအကျ အချက်အလက်ကို ထိန်းသိမ်းထားနိုင်သလို၊ Fruit နဲ့ ကိုက်ညီကြောင်းလည်း စစ်ဆေးပြီးသား ဖြစ်သွားပါတယ်။

// const notFruit = "grape" satisfies Fruit;
// ERROR: Type '"grape"' is not assignable to type 'Fruit'.
// satisfies က မှားယွင်းနေတာကို ချက်ချင်း ဖမ်းမိပါတယ်။