TypeScript ਆਖਰੀ Overload ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ
ਜਦੋਂ ਤੁਸੀਂ overloaded functions ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ TypeScript ਦਾ ਇੱਕ ਖਾਸ ਵਿਵਹਾਰ ਹੁੰਦਾ ਹੈ।
ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ overloaded function ਤੋਂ ਕਿਸੇ type ਦਾ ਅਨੁਮਾਨ (infer) ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ TypeScript ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਆਖਰੀ signature ਹੀ ਦਿੰਦਾ ਹੈ।
ਮੈਨੂੰ ਇਹ i18next ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਮਿਲੀ। ਮੈਂ string keys ਨੂੰ ਕੁਝ ਬਿਹਤਰ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਸੀ। ਮੈਂ autocomplete ਅਤੇ ਬਿਹਤਰ developer experience ਚਾਹੁੰਦਾ ਸੀ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਮੈਨੂੰ ਮੌਜੂਦਾ function types ਨੂੰ ਬਦਲਣ (transform ਕਰਨ) ਦੀ ਲੋੜ ਸੀ।
ਸਮੱਸਿਆ: ਮੈਨੂੰ ਇੱਕ overloaded type ਵਿੱਚੋਂ ਹਰ ਇੱਕ call signature ਕੱਢਣ ਦੀ ਲੋੜ ਸੀ।
Standard TypeScript ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਕਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਦਿੰਦਾ। ਜ਼ਿਆਦਾਤਰ ਹੱਲ hardcoded tables ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਜਿਵੇਂ ਕਿ ਸਿਰਫ਼ 5 ਜਾਂ 10 overloads ਦਾ ਸਮਰਥਨ ਕਰਨਾ। ਮੈਂ ਕਿਸੇ ਵੀ ਗਿਣਤੀ ਦੇ signatures ਨੂੰ ਸੰਭਾਲਣ ਦਾ ਤਰੀਕਾ ਚਾਹੁੰਦਾ ਸੀ।
ਮੈਨੂੰ intersections ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਕੇ ਇੱਕ ਹੱਲ ਮਿਲਿਆ।
ਇੱਥੇ ਤਰਕ (logic) ਦਿੱਤਾ ਗਿਆ ਹੈ:
- TypeScript ਆਖਰੀ signature ਤੋਂ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ।
- Intersections (&) signatures ਦੇ ਕ੍ਰਮ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਨ।
- ਜੇਕਰ ਤੁਸੀਂ ਕ੍ਰਮ ਬਦਲਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉਹ ਬਦਲ ਦਿੰਦੇ ਹੋ ਜੋ TypeScript ਅਨੁਮਾਨ ਲਗਾਉਂਦੇ ਸਮੇਂ ਦੇਖਦਾ ਹੈ।
ਮੈਂ ਖੋਜਿਆ ਕਿ ਇੱਕ overloaded type ਨੂੰ ਉਸਦੇ ਆਪਣੇ ਹੀ ਇੱਕ signature ਨਾਲ intersect ਕਰਨ ਨਾਲ ਉਹ signature ਸੂਚੀ ਦੇ ਅੱਗੇ ਆ ਜਾਂਦਾ ਹੈ।
ਇਸ ਨੇ ਮੈਨੂੰ ਇੱਕ recursive type ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ।
ਪ੍ਰਕਿਰਿਆ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ:
- ਆਖਰੀ ਦਿਖਾਈ ਦੇਣ ਵਾਲੇ signature ਦਾ ਅਨੁਮਾਨ ਲਗਾਓ।
- alignment ਬਦਲਣ ਲਈ ਇੱਕ intersection ਦੀ ਵਰਤੋਂ ਕਰੋ।
- ਇਹ ਅਗਲੇ signature ਨੂੰ ਨਵਾਂ ਆਖਰੀ signature ਬਣਨ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ।
- ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਓ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇੱਕ union ਵਿੱਚ ਹਰ ਇੱਕ signature ਨੂੰ ਕੈਪਚਰ ਨਹੀਂ ਕਰ ਲੈਂਦੇ।
ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ overloads ਨੂੰ union ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਨਾਲ data ਵਾਂਗ ਪੇਸ਼ ਕਰ ਸਕਦੇ ਹੋ। ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ transform ਕਰ ਸਕਦੇ ਹੋ, return types ਨੂੰ Promises ਵਿੱਚ ਲਪੇਟ (wrap) ਸਕਦੇ ਹੋ, ਜਾਂ arguments ਦਾ ਨਾਮ ਬਦਲ ਸਕਦੇ ਹੋ। ਤਬਦੀਲੀ (transformation) ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ overloaded function ਨੂੰ ਬਹਾਲ ਕਰਨ ਲਈ union ਨੂੰ ਵਾਪਸ intersection ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।
ਪੂਰੀ pipeline ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ: Overloads -> Union -> Transform -> Intersection -> Overloads.
ਇਹ ਇੱਕ type-system ਟ੍ਰਿਕ ਹੈ। ਇਹ ਕੋਈ ਅਧਿਕਾਰਤ API ਨਹੀਂ ਹੈ। ਇਹ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ TypeScript intersections ਅਤੇ call signatures ਦਾ ਮੁਲਾਂਕਣ ਕਿਵੇਂ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਦੀ ਵਰਤੋਂ ਕਿਸੇ library ਵਿੱਚ ਕਰਦੇ ਹੋ, ਤਾਂ ਵੱਖ-ਵੱਖ TypeScript versions ਵਿੱਚ ਇਸਦੀ ਜਾਂਚ ਕਰੋ।
ਕਦੇ-ਕਦੇ TypeScript ਦੇ ਅਜੀਬ ਹਿੱਸੇ ਸਭ ਤੋਂ ਵੱਧ ਉਪਯੋਗੀ ਹੁੰਦੇ ਹਨ।
ਸਰੋਤ: https://dev.to/svs-nickm/typescript-infers-the-last-overload-so-i-changed-the-order-3018