ਟਾਈਪਸਕ੍ਰਿਪਟ ਜੈਨਰਿਕਸ ਨੂੰ ਸਮਝਣਾ

ਟਾਈਪਸਕ੍ਰਿਪਟ ਵਿੱਚ ਜੈਨਰਿਕਸ ਦੀ ਉਪਯੋਗਤਾ ਦੀ ਜਾਣ-ਪਛਾਣ ਅਸਲ-ਵਿਸ਼ਵ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਅਧਾਰਤ ਉਦਾਹਰਣਾਂ ਦੇ ਨਾਲ, ਜਿਵੇਂ ਕਿ ਸੰਗ੍ਰਹਿ, ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਪਹੁੰਚ, ਰਿਪੋਜ਼ਟਰੀ ਪੈਟਰਨ, ਅਤੇ ਹੋਰ. ਇਹ ਲੇਖ ਜੈਨਰਿਕਸ ਦੁਆਰਾ ਸੌਫਟਵੇਅਰ ਐਬਸਟਰੈਕਸ਼ਨ ਦੀ ਧਾਰਨਾ ਦੀ ਇੱਕ ਅਨੁਭਵੀ ਸਮਝ ਪ੍ਰਦਾਨ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ.

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਟਾਈਪਸਕ੍ਰਿਪਟ ਵਿੱਚ ਜੇਨੇਰਿਕਸ ਦੀ ਧਾਰਨਾ ਨੂੰ ਸਿੱਖ ਰਹੇ ਹਾਂ ਅਤੇ ਇਹ ਜਾਂਚ ਕਰਾਂਗੇ ਕਿ ਕਿਵੇਂ ਜੈਨਰਿਕਸ ਦੀ ਵਰਤੋਂ ਮਾਡਯੂਲਰ, ਡੀਕੌਪਲਡ ਅਤੇ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਕੋਡ ਲਿਖਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਰਸਤੇ ਵਿੱਚ, ਅਸੀਂ ਸੰਖੇਪ ਵਿੱਚ ਵਿਚਾਰ ਕਰਾਂਗੇ ਕਿ ਉਹ ਬਿਹਤਰ ਟੈਸਟਿੰਗ ਪੈਟਰਨਾਂ, ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਦੇ ਤਰੀਕਿਆਂ ਅਤੇ ਡੋਮੇਨ/ਡੇਟਾ-ਐਕਸੈਸ ਵੱਖਰੇਪਣ ਵਿੱਚ ਕਿਵੇਂ ਫਿੱਟ ਹਨ.

ਇੱਕ ਅਸਲੀ-ਸੰਸਾਰ ਉਦਾਹਰਣ

ਮੈਂ ਜੈਨਰਿਕਸ ਦੀ ਦੁਨੀਆ ਵਿੱਚ ਦਾਖਲ ਹੋਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਨਹੀਂ ਇਹ ਸਮਝਾ ਕੇ ਕਿ ਉਹ ਕੀ ਹਨ, ਬਲਕਿ ਇੱਕ ਉਪਯੋਗੀ ਉਦਾਹਰਣ ਦੇ ਕੇ ਕਿ ਉਹ ਉਪਯੋਗੀ ਕਿਉਂ ਹਨ. ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਨਾਲ ਭਰਪੂਰ ਗਤੀਸ਼ੀਲ ਸੂਚੀ ਬਣਾਉਣ ਦਾ ਕੰਮ ਸੌਂਪਿਆ ਗਿਆ ਹੈ. ਤੁਸੀਂ ਆਪਣੀ ਭਾਸ਼ਾ ਦੇ ਪਿਛੋਕੜ ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ ਇਸਨੂੰ ਇੱਕ ਐਰੇ, ਇੱਕ | _+_ |, a | _+_ |, a | _+_ |, ਜਾਂ ਕੁਝ ਵੀ ਕਹਿ ਸਕਦੇ ਹੋ. ਸ਼ਾਇਦ ਇਸ ਡੇਟਾ structureਾਂਚੇ ਵਿੱਚ ਇਨ-ਬਿਲਟ ਜਾਂ ਸਵੈਪਬਲ ਬਫਰ ਸਿਸਟਮ ਵੀ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ (ਜਿਵੇਂ ਇੱਕ ਸਰਕੂਲਰ ਬਫਰ ਸੰਮਿਲਨ ਵਿਕਲਪ). ਇਹ ਸਧਾਰਨ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਐਰੇ ਦੇ ਦੁਆਲੇ ਇੱਕ ਰੈਪਰ ਹੋਵੇਗਾ ਤਾਂ ਜੋ ਅਸੀਂ ਸਾਦੇ ਐਰੇ ਦੀ ਬਜਾਏ ਆਪਣੀ ਬਣਤਰ ਦੇ ਨਾਲ ਕੰਮ ਕਰ ਸਕੀਏ.

ਤਤਕਾਲ ਮੁੱਦਾ ਜੋ ਤੁਸੀਂ ਵੇਖੋਗੇ ਉਹ ਹੈ ਟਾਈਪ ਸਿਸਟਮ ਦੁਆਰਾ ਲਗਾਈਆਂ ਗਈਆਂ ਰੁਕਾਵਟਾਂ ਦਾ. ਤੁਸੀਂ, ਇਸ ਸਮੇਂ, ਕਿਸੇ ਵੀ ਕਿਸਮ ਨੂੰ ਜੋ ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਜਾਂ ਵਿਧੀ ਵਿੱਚ ਚਾਹੁੰਦੇ ਹੋ ਨੂੰ ਇੱਕ ਚੰਗੇ ਸਾਫ਼ acceptੰਗ ਨਾਲ ਸਵੀਕਾਰ ਨਹੀਂ ਕਰ ਸਕਦੇ (ਅਸੀਂ ਇਸ ਬਿਆਨ ਨੂੰ ਬਾਅਦ ਵਿੱਚ ਦੁਬਾਰਾ ਵੇਖਾਂਗੇ).

ਇਕੋ ਇਕ ਸਪੱਸ਼ਟ ਹੱਲ ਹੈ ਕਿ ਸਾਡੇ ਡੇਟਾ structureਾਂਚੇ ਨੂੰ ਸਾਰੀਆਂ ਵੱਖੋ ਵੱਖਰੀਆਂ ਕਿਸਮਾਂ ਲਈ ਦੁਹਰਾਉਣਾ ਹੈ:

ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਟਾਈਪਸਕ੍ਰਿਪਟ ਪ੍ਰੋਜੈਕਟ

ArrayList

ਦੇ List ਇੱਥੇ ਸੰਟੈਕਸ ਆਪਹੁਦਰਾ ਲੱਗ ਸਕਦਾ ਹੈ, ਅਤੇ ਅਸਲ ਵਿੱਚ, std::vector ਵਧੇਰੇ ਸਿੱਧਾ-ਅੱਗੇ ਹੋਵੇਗਾ, ਪਰ ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ ਇਸ ਸਥਿਰ ਫੈਕਟਰੀ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਕਰਦੇ ਹਾਂ. ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ, const intList = IntegerList.create(); intList.add(4); const stringList = StringList.create(); stringList.add('hello'); const userList = UserList.create(); userList.add(new User('Jamie')); ਵਿਧੀ ਨਿਰਮਾਤਾ ਨੂੰ ਬੁਲਾਉਂਦੀ ਹੈ.

ਇਹ ਭਿਆਨਕ ਹੈ. ਸਾਡੇ ਕੋਲ ਇਸ ਸੰਗ੍ਰਹਿ ਦੇ structureਾਂਚੇ ਦੇ ਅੰਦਰ ਬਹੁਤ ਸਾਰੇ ਤਰਕ ਹਨ, ਅਤੇ ਅਸੀਂ ਪ੍ਰਕਿਰਿਆ ਦੇ DRY ਸਿਧਾਂਤ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੋੜਦੇ ਹੋਏ, ਵਰਤੋਂ ਦੇ ਵੱਖੋ ਵੱਖਰੇ ਮਾਮਲਿਆਂ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਇਸਦੀ ਸਪਸ਼ਟ ਰੂਪ ਨਾਲ ਨਕਲ ਕਰ ਰਹੇ ਹਾਂ. ਜਦੋਂ ਅਸੀਂ ਆਪਣੇ ਲਾਗੂਕਰਨ ਨੂੰ ਬਦਲਣ ਦਾ ਫੈਸਲਾ ਕਰਦੇ ਹਾਂ, ਸਾਨੂੰ ਉਹਨਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਉਹਨਾਂ ਸਾਰੇ structuresਾਂਚਿਆਂ ਅਤੇ ਕਿਸਮਾਂ ਵਿੱਚ ਹੱਥੀਂ ਪ੍ਰਸਾਰਿਤ/ਪ੍ਰਤੀਬਿੰਬਤ ਕਰਨਾ ਪਏਗਾ, ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਉਪਯੋਗਕਰਤਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਿਸਮਾਂ ਸ਼ਾਮਲ ਹਨ, ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ. ਮੰਨ ਲਓ ਕਿ ਸੰਗ੍ਰਹਿ ਦਾ structureਾਂਚਾ ਆਪਣੇ ਆਪ 100 ਲਾਈਨਾਂ ਲੰਬਾ ਸੀ - ਕਈ ਵੱਖੋ ਵੱਖਰੀਆਂ ਸਥਾਪਨਾਵਾਂ ਨੂੰ ਕਾਇਮ ਰੱਖਣਾ ਇੱਕ ਡਰਾਉਣਾ ਸੁਪਨਾ ਹੋਵੇਗਾ ਜਿੱਥੇ ਉਨ੍ਹਾਂ ਦੇ ਵਿੱਚ ਸਿਰਫ ਅੰਤਰ ਕਿਸਮਾਂ ਹਨ.

ਇੱਕ ਫੌਰੀ ਹੱਲ ਜੋ ਦਿਮਾਗ ਵਿੱਚ ਆ ਸਕਦਾ ਹੈ, ਖ਼ਾਸਕਰ ਜੇ ਤੁਹਾਡੀ ਓਓਪੀ ਮਾਨਸਿਕਤਾ ਹੈ, ਜੇ ਤੁਸੀਂ ਚਾਹੋ ਤਾਂ ਇੱਕ ਰੂਟ ਸੁਪਰਟਾਈਪ ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਹੈ. C#ਵਿੱਚ, ਉਦਾਹਰਣ ਵਜੋਂ, ਇੱਥੇ | _+_ |, ਅਤੇ | _+_ | ਦੇ ਨਾਂ ਨਾਲ ਇੱਕ ਕਿਸਮ ਹੁੰਦੀ ਹੈ | _+_ | ਲਈ ਉਪਨਾਮ ਹੈ ਕਲਾਸ. ਸੀ#ਦੀ ਕਿਸਮ ਪ੍ਰਣਾਲੀ ਵਿੱਚ, ਸਾਰੀਆਂ ਕਿਸਮਾਂ, ਉਹ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਜਾਂ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਤ ਹੋਣ ਅਤੇ ਉਹ ਸੰਦਰਭ ਕਿਸਮਾਂ ਜਾਂ ਮੁੱਲ ਕਿਸਮਾਂ ਹੋਣ, ਜਾਂ ਤਾਂ ਸਿੱਧੇ ਜਾਂ ਅਸਿੱਧੇ ਰੂਪ ਵਿੱਚ | _+_ | ਤੋਂ ਵਿਰਾਸਤ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ. ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਕੋਈ ਵੀ ਮੁੱਲ ਕਿਸਮ ਦੇ ਵੇਰੀਏਬਲ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ | _+_ | (ਸਟੈਕ/apੇਰ ਅਤੇ ਮੁੱਕੇਬਾਜ਼ੀ/ਅਨਬਾਕਸਿੰਗ ਅਰਥ ਸ਼ਾਸਤਰ ਵਿੱਚ ਆਉਣ ਤੋਂ ਬਿਨਾਂ).

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਾਡੀ ਸਮੱਸਿਆ ਹੱਲ ਹੋਈ ਜਾਪਦੀ ਹੈ. ਅਸੀਂ ਸਿਰਫ ਇੱਕ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ | _+_ | ਅਤੇ ਇਹ ਸਾਨੂੰ collectionਾਂਚੇ ਦੀ ਨਕਲ ਕੀਤੇ ਬਗੈਰ ਸਾਡੇ ਸੰਗ੍ਰਹਿ ਦੇ ਅੰਦਰ ਉਹ ਕੁਝ ਵੀ ਸਟੋਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ, ਅਤੇ ਸੱਚਮੁੱਚ, ਇਹ ਬਹੁਤ ਸੱਚ ਹੈ:

_.create()_

ਆਓ ਸਾਡੀ ਸੂਚੀ ਦੇ ਅਸਲ ਲਾਗੂਕਰਨ ਤੇ ਵਿਚਾਰ ਕਰੀਏ | _+_ |

_new SomethingList()_

#ਟਾਈਪਸਕ੍ਰਿਪਟ #ਜਾਵਾਸਕ੍ਰਿਪਟ #ਵੈਬ-ਵਿਕਾਸ #ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ #ਡਿਵੈਲਪਰ

www.smashingmagazine.com