TypeScript ਦਾ ਨਵਾਂ const type parameter ਸਿੰਟੈਕਸ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਲਿਟਰਲ ਟਾਈਪਸ (literal types) ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਮੁਸ਼ਕਲ ਦੇ ਸਹੀ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਕਾਲਰਸ (callers) ਨੂੰ ਹਰ ਜਗ੍ਹਾ as const ਲਗਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ। ਇਹ ਟਾਈਪ-ਵਾਈਡਨਿੰਗ (type-widening) ਬੱਗਸ ਦੇ ਸਭ ਤੋਂ ਆਮ ਸਰੋਤ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

ਵਾਈਡਨਿੰਗ (widening) ਦੀ ਸਮੱਸਿਆ ਜੋ ਜੈਨਰਿਕ ਕੋਡ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ

ਜਦੋਂ ਇੱਕ ਜੈਨਰਿਕ ਫੰਕਸ਼ਨ ਇੱਕ ਆਬਜੈਕਟ ਲਿਟਰਲ (object literal) ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਤਾਂ ਕੰਪਾਈਲਰ ਕਿਸੇ ਵੀ ਲਿਟਰਲ ਪ੍ਰਾਪਰਟੀ ਨੂੰ ਉਸਦੇ ਵਿਆਪਕ ਪ੍ਰਾਇਮੇਟਿਵ ਟਾਈਪ (broader primitive type) ਵਿੱਚ ਵਧਾ (widen) ਦਿੰਦਾ ਹੈ। 

function call<T>(arg: T) {}
call({ method: "GET" })   // T is inferred as { method: string }

ਲਿਟਰਲ "GET" ਬਦਲ ਕੇ string ਹੋ ਜਾਂਦਾ ਹੈ। ਅਗਲਾ ਕੋਡ (downstream code) ਜੋ ਸਹੀ ਮੁੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ—ਜਿਵੇਂ ਕਿ discriminated unions ਜਾਂ template-literal extraction—ਟੁੱਟ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਟਾਈਪ ਹੁਣ ਸਹੀ ਲਿਟਰਲ ਨਹੀਂ ਰੱਖਦੀ। ਡਿਵੈਲਪਰ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਕਾਲ ਸਾਈਟ (call site) 'ਤੇ { method: "GET" } as const ਲਿਖ ਕੇ ਇਸਦਾ ਹੱਲ ਕਰ ਰਹੇ ਹਨ, ਜੋ ਕੰਪਾਈਲਰ ਨੂੰ ਲਿਟਰਲ ਰੱਖਣ ਲਈ ਕਹਿੰਦਾ ਹੈ, ਪਰ ਉਹ ਫਿਕਸ ਕਾਲਰ ਦੇ ਹੱਥ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਫੰਕਸ਼ਨ ਦੀ ਡੈਫੀਨੇਸ਼ਨ ਵਿੱਚ ਨਹੀਂ।

Const type parameters: ਇੱਕ signature-level ਫਿਕਸ

ਇੱਕ type parameter 'ਤੇ ਨਵਾਂ const ਮੋਡੀਫਾਇਰ ਕੰਪਾਈਲਰ ਨੂੰ ਉਸ ਜੈਨਰਿਕ ਆਰਗੂਮੈਂਟ ਲਈ ਸਭ ਤੋਂ ਤੰਗ (narrowest possible) ਟਾਈਪ ਦਾ ਅਨੁਮਾਨ (infer) ਲਗਾਉਣ ਲਈ ਕਹਿੰਦਾ ਹੈ। ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ function foo<const T>(arg: T) ਵਜੋਂ ਡਿਕਲੇਅਰ ਕਰਨ ਨਾਲ T ਆਪਣੇ ਆਪ ਉਸ ਤਰ੍ਹਾਂ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਾਲਰ ਨੇ as const ਲਿਖਿਆ ਹੋਵੇ।

  • String, number, boolean literals ਆਪਣੇ ਸਹੀ ਮੁੱਲਾਂ ਵਜੋਂ ਰਹਿੰਦੇ ਹਨ (string ਦੀ ਬਜਾਏ "GET")।
  • Arrays ਰੀਡ-ਓਨਲੀ (readonly) ਟਿਪਲਸ (tuples) ਬਣ ਜਾਂਦੇ ਹਨ ਜਿਸ ਵਿੱਚ ਹਰ ਐਲੀਮੈਂਟ ਦੀ ਟਾਈਪ ਸਹੀ ਹੁੰਦੀ ਹੈ।
  • Objects ਡੂੰਘੇ ਰੀਡ-ਓਨਲੀ (deeply readonly) ਢਾਂਚੇ ਵਿੱਚ ਬਦਲ ਜਾਂਦੇ ਹਨ, ਜੋ ਹਰ ਨੈਸਟਿੰਗ ਲੈਵਲ 'ਤੇ ਲਿਟਰਲ ਟਾਈਪਸ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹਨ।

ਕਿਉਂਕਿ ਇਹ ਕੰਟਰੈਂਟ (constraint) ਫੰਕਸ਼ਨ ਸਿਗਨੇਚਰ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਹਰ ਕਾਲਰ ਨੂੰ ਆਪਣੇ ਆਪ ਫਾਇਦਾ ਮਿਲਦਾ ਹੈ; ਕਾਸਟ (cast) ਕਰਨਾ ਭੁੱਲ ਜਾਣਾ ਹੁਣ ਗਲਤ ਟਾਈਪ ਸੁਰੱਖਿਆ ਦਾ ਕਾਰਨ ਨਹੀਂ ਬਣਦਾ।

ਇਹ ਕਲਾਸਿਕ as const ਹੈਕ ਨੂੰ ਕਿਵੇਂ ਹਰਾਉਂਦਾ ਹੈ

as const ਇੱਕ caller-side ਹੱਲ ਹੈ। ਇਸ ਲਈ ਜੈਨਰਿਕ ਫੰਕਸ਼ਨ ਦੇ ਹਰ ਵਰਤੋਂਕਾਰ (consumer) ਨੂੰ ਐਸਰਸ਼ਨ (assertion) ਜੋੜਨਾ ਯਾਦ ਰੱਖਣਾ ਪੈਂਦਾ ਹੈ। ਜੇਕਰ ਇੱਕ ਵੀ ਕਾਲ ਰਹਿ ਜਾਵੇ, ਤਾਂ ਟਾਈਪ ਸੁਰੱਖਿਆ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। Const type parameter ਇਸ ਜ਼ਿੰਮੇਵਾਰੀ ਨੂੰ ਖੁਦ API ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਲੈ ਜਾਂਦਾ ਹੈ: ਫੰਕਸ਼ਨ ਐਲਾਨਦਾ ਹੈ “ਮੈਨੂੰ ਤੁਹਾਡੇ ਦੁਆਰਾ ਭੇਜੇ ਗਏ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਦਾ ਸਭ ਤੋਂ ਤੰਗ ਰੂਪ (narrowest shape) ਚਾਹੀਦਾ ਹੈ,” ਅਤੇ ਕੰਪਾਈਲਰ ਇਸ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।

ਇਹ ਬਦਲਾਅ ਉਹਨਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਯੂਟੀਲਿਟੀਜ਼ ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੋ ਜੈਨਰਿਕ ਬਿਲਡਰਸ, ਕੌਂਫਿਗਰੇਸ਼ਨ ਫੈਕਟਰੀਜ਼, ਜਾਂ ਕਿਸੇ ਵੀ ਅਜਿਹੇ API ਨੂੰ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ ਜਿੱਥੇ ਕਿਸੇ ਫੀਲਡ ਦਾ ਲਿਟਰਲ ਮੁੱਲ ਟਾਈਪ ਲੌਜਿਕ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਲਾਇਬ੍ਰੇਰੀ ਲੇਖਕ ਡਾਊਨਸਟ੍ਰੀਮ ਕੋਡ ਦੀ ਨਿਗਰਾਨੀ ਕੀਤੇ ਬਿਨਾਂ ਸਹੀ ਅਨੁਮਾਨ (inference) ਦੀ ਗਾਰੰਟੀ ਦੇ ਸਕਦਾ ਹੈ।

ਅਸਲ-ਦੁਨੀਆ ਦੇ ਦ੍ਰਿਸ਼ਟਾਂਤ ਜਿਨ੍ਹਾਂ ਨੂੰ ਫਾਇਦਾ ਹੁੰਦਾ ਹੈ

  • Configuration builders – ਐਨਵਾਇਰਨਮੈਂਟ ਦੇ ਨਾਮ ("dev" | "prod") ਲਿਟਰਲ ਰਹਿੰਦੇ ਹਨ, ਜੋ ਵਾਧੂ ਕਾਸਟਸ ਤੋਂ ਬਿਨਾਂ discriminated-union ਚੈੱਕ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ।
  • API route definitions – ਪਾਥ ਸਟ੍ਰਿੰਗਸ ਸਹੀ ਰਹਿੰਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ template-literal ਟਾਈਪਸ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਕੱਢ ਸਕਦੇ ਹਨ ("/users/:id" → \/users/${string}``)।
  • State-machine helpers – ਮੈਥਡ ਚੇਨਿੰਗ (method chaining) ਰਾਹੀਂ ਸਟੇਟ ਆਈਡੈਂਟੀਫਾਇਰ ਫਿਕਸਡ ਲਿਟਰਲ ਰਹਿੰਦੇ ਹਨ, ਜੋ ਅਚਾਨਕ ਸਟੇਟ ਮਿਸਮੈਚ ਨੂੰ ਰੋਕਦੇ ਹਨ।

ਹਰੇਕ ਮਾਮਲੇ ਵਿੱਚ, const ਪੈਰਾਮੀਟਰ ਵਾਰ-ਵਾਰ ਵਰਤੇ ਜਾਣ ਵਾਲੇ as const ਬੋਇਲਰਪਲੇਟ (boilerplate) ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ ਅਤੇ ਬਾਰੀਕ ਬੱਗਸ ਦੇ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।

satisfies ਓਪਰੇਟਰ ਦੇ ਨਾਲ ਜੋੜਨਾ

satisfies ਓਪਰੇਟਰ ਇਹ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਮੁੱਲ ਉਸਦੀ ਅਸਲ ਲਿਟਰਲ ਜਾਣਕਾਰੀ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੇ ਹੋਏ ਇੱਕ ਸਟ੍ਰਕਚਰਲ ਟਾਈਪ ਦੇ ਅਨੁਕੂਲ ਹੈ। ਦੋਵਾਂ ਨੂੰ ਇਕੱਠੇ ਵਰਤਣ ਨਾਲ ਦੋਵਾਂ ਦੇ ਫਾਇਦੇ ਮਿਲਦੇ ਹਨ: const ਪੈਰਾਮੀਟਰ ਤੰਗ ਅਨੁਮਾਨ (narrow inference) ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਅਤੇ satisfies ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਮੁੱਲ ਲੋੜੀਂਦੇ ਰੂਪ (shape) ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ।

function makeConfig<const C>(cfg: C) {
  // cfg is inferred with exact literals
}
const cfg = {
  env: "staging",
  ports: [8080, 8443],
} satisfies { env: string; ports: number[] };
makeConfig(cfg); // works, literals stay intact

as const ਕਦੋਂ ਰੱਖਣਾ ਹੈ

Const ਪੈਰਾਮੀਟਰ ਉਦੋਂ ਸ਼ਾਨਦਾਰ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਡਾ ਫੰਕਸ਼ਨ ਸਿਗਨੇਚਰ 'ਤੇ ਕੰਟਰੋਲ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਤੀਜੀ-ਪਾਰਟੀ (third-party) ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਇਹ ਮੋਡੀਫਾਇਰ ਨਹੀਂ ਹੈ, ਜਾਂ ਤੁਹਾਨੂੰ ਕਿਸੇ ਸਥਾਨਕ ਵੇਰੀਏਬਲ (local variable) ਲਈ ਇੱਕ ਵਾਰ ਲਿਟਰਲ ਪ੍ਰੀਜ਼ਰਵੇਸ਼ਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ as const ਸਹੀ ਸਾਧਨ ਹੈ। ਇਹ ਅਜੇ ਵੀ ਕਾਲ ਕੀਤੀ ਗਈ API ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ ਕਿਸੇ ਮੁੱਲ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਹੈ।

ਅੱਗੇ ਕੀ ਦੇਖਣਾ ਹੈ

ਇਹ ਫੀਚਰ ਅਜੇ ਨਵਾਂ ਹੈ, ਇਸ ਲਈ ਟੂਲਿੰਗ ਅਤੇ ਕਮਿਊਨਿਟੀ ਪੈਟਰਨ ਵਿਕਸਿਤ ਹੋ ਰਹੇ ਹਨ। IDE ਸਪੋਰਟ ਵਿੱਚ ਅਪਡੇਟਸ ਦੀ ਉਮੀਦ ਰੱਖੋ ਜੋ ਆਟੋ-ਕੰਪਲੀਟ (autocomplete) ਅਤੇ ਕੁਇੱਕ-ਫਿਕਸ ਸੁਝਾਵਾਂ ਵਿੱਚ ਨਵੇਂ ਸਿੰਟੈਕ