ਰੱਖ-ਰਖਾਅ ਯੋਗ ਕੋਡ ਲਿਖਣ ਲਈ ਸੁਝਾਅ
ਕੋਡ ਲਿਖਣਾ ਸਿਰਫ਼ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ "ਚਲਾਉਣ" ਲਈ ਨਹੀਂ ਹੈ। ਅਭਿਆਸ ਵਿੱਚ, ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਸਮੇਂ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸਾ ਮੌਜੂਦਾ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨ, ਸੋਧਣ ਅਤੇ ਵਿਕਸਤ ਕਰਨ ਵਿੱਚ ਬਿਤਾਇਆ ਜਾਂਦਾ ਹੈ - ਭਾਵੇਂ ਤੁਹਾਡਾ ਆਪਣਾ ਹੋਵੇ ਜਾਂ ਕਿਸੇ ਹੋਰ ਦਾ। ਇਸ ਲਈ, ਰੱਖ-ਰਖਾਅਯੋਗ ਕੋਡ ਲਿਖਣ ਦੀ ਯੋਗਤਾ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮਰ ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹੁਨਰ ਹੈ। ਰੱਖ-ਰਖਾਅਯੋਗ ਕੋਡ ਰੱਖ-ਰਖਾਅ ਦੀ ਲਾਗਤ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਵਿਸ਼ੇਸ਼ਤਾ ਜੋੜਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ, ਬੱਗਾਂ ਨੂੰ ਘੱਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਟੀਮ ਸਹਿਯੋਗ ਨੂੰ ਬਹੁਤ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਬਣਾਉਂਦਾ ਹੈ। ਸਾਫ਼, ਸਪਸ਼ਟ ਅਤੇ ਟਿਕਾਊ ਕੋਡ ਲਿਖਣ ਲਈ ਇੱਥੇ ਕੁਝ ਵਿਹਾਰਕ ਸੁਝਾਅ ਹਨ।
1. "ਚਲਾਕ" ਨਾਲੋਂ ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਤਰਜੀਹ ਦਿਓ
ਕੋਡ ਜੋ ਬਹੁਤ ਜ਼ਿਆਦਾ "ਚਲਾਕ" ਹੁੰਦਾ ਹੈ, ਉਸਨੂੰ ਸਮਝਣਾ ਅਕਸਰ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਣ ਵਜੋਂ, ਕੋਡ ਦੀ ਇੱਕ ਬਹੁਤ ਹੀ ਸੰਖੇਪ ਲਾਈਨ ਲਿਖਣਾ ਸ਼ਾਨਦਾਰ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਦੁਬਾਰਾ ਪੜ੍ਹਨ 'ਤੇ ਇਹ ਉਲਝਣ ਵਾਲਾ ਹੋ ਸਕਦਾ ਹੈ। ਇੱਕ ਸਪਸ਼ਟ ਹੱਲ ਚੁਣੋ, ਭਾਵੇਂ ਇਹ ਥੋੜ੍ਹਾ ਲੰਮਾ ਹੋਵੇ। ਪੜ੍ਹਨਯੋਗਤਾ ਇੱਕ ਨਿਵੇਸ਼ ਹੈ: ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਲਿਖ ਸਕਦੇ ਹੋ, ਪਰ ਤੁਸੀਂ ਇਸਨੂੰ ਕਈ ਵਾਰ ਪੜ੍ਹੋਗੇ।
ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਸਿੰਗਲ ਐਕਸਪ੍ਰੈਸ਼ਨ ਵਿੱਚ ਕਈ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਨੇਸਟ ਕਰਨ ਦੀ ਬਜਾਏ, ਉਹਨਾਂ ਨੂੰ ਅਰਥਪੂਰਨ ਵੇਰੀਏਬਲ ਨਾਵਾਂ ਵਾਲੇ ਕਦਮਾਂ ਵਿੱਚ ਵੱਖ ਕਰੋ। ਇਹ ਪਾਠਕ ਨੂੰ ਅਨੁਮਾਨ ਲਗਾਏ ਬਿਨਾਂ ਪ੍ਰੋਗਰਾਮ ਦੇ ਇਰਾਦੇ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
2. ਸਪਸ਼ਟ ਅਤੇ ਇਕਸਾਰ ਨਾਮਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਵੇਰੀਏਬਲ, ਫੰਕਸ਼ਨ, ਅਤੇ ਕਲਾਸ ਨਾਮ ਤੁਹਾਡੇ ਕੋਡ ਲਈ "ਦਸਤਾਵੇਜ਼ ਦੀ ਪਹਿਲੀ ਲਾਈਨ" ਹਨ। ਚੰਗੇ ਨਾਮ ਉਹਨਾਂ ਦੀ ਭੂਮਿਕਾ ਜਾਂ ਉਦੇਸ਼ ਦਾ ਵਰਣਨ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ, ਨਾ ਕਿ ਸਿਰਫ਼ ਉਹਨਾਂ ਦੇ ਡੇਟਾ ਦੇ ਫਾਰਮੈਟ ਦਾ। ਉਦਾਹਰਨ ਲਈ, `userList` `ul` ਨਾਲੋਂ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਭਰਪੂਰ ਹੈ, ਅਤੇ `calculateTotalPrice()` `ctp()` ਨਾਲੋਂ ਵਧੇਰੇ ਸਪਸ਼ਟ ਹੈ।
ਸਪਸ਼ਟਤਾ ਦੇ ਨਾਲ-ਨਾਲ, ਨਾਮਕਰਨ ਵੀ ਇਕਸਾਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਵੇਰੀਏਬਲ ਲਈ camelCase ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਦੌਰਾਨ ਇਸ ਨਾਲ ਜੁੜੇ ਰਹੋ। ਕਲਾਸਾਂ ਲਈ, ਜੇਕਰ ਇਹ ਤੁਹਾਡੀ ਪਸੰਦੀਦਾ ਭਾਸ਼ਾ ਪਰੰਪਰਾ ਹੈ ਤਾਂ PascalCase ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਕਸਾਰਤਾ ਕੋਡ ਨੂੰ ਇਕਸਾਰ ਮਹਿਸੂਸ ਕਰਾਉਂਦੀ ਹੈ ਅਤੇ ਪੜ੍ਹਨ ਵੇਲੇ ਮਾਨਸਿਕ ਭਾਰ ਘਟਾਉਂਦੀ ਹੈ।
3. "ਇਕੱਲੀ ਜ਼ਿੰਮੇਵਾਰੀ" ਦੇ ਸਿਧਾਂਤ ਨੂੰ ਲਾਗੂ ਕਰੋ।
ਕੋਡ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਵਿੱਚ ਮੁਸ਼ਕਲ ਆਉਣ ਦੇ ਮੁੱਖ ਕਾਰਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਜਾਂ ਕਲਾਸਾਂ ਹਨ ਜੋ ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਕਰਦੀਆਂ ਹਨ। ਸਿੰਗਲ ਰਿਸਪਾਂਸਬਿਲਿਟੀ ਸਿਧਾਂਤ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ ਕਿ ਕੋਡ ਦੀ ਇੱਕ ਇਕਾਈ ਦੀ ਸਿਰਫ਼ ਇੱਕ ਹੀ ਮੁੱਖ ਜ਼ਿੰਮੇਵਾਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਇੱਕ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲੰਬਾ ਫੰਕਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ ਇਸ ਗੱਲ ਦਾ ਸੰਕੇਤ ਹੁੰਦਾ ਹੈ ਕਿ ਇਸਨੂੰ ਤੋੜਨ ਦੀ ਲੋੜ ਹੈ।
ਉਦਾਹਰਨ ਲਈ, ਇੱਕ "ਚੈੱਕਆਉਟ ਪ੍ਰਕਿਰਿਆ" ਫੰਕਸ਼ਨ ਜੋ ਇੱਕੋ ਸਮੇਂ ਇਨਪੁਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਦਾ ਹੈ, ਕੀਮਤਾਂ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, ਭੁਗਤਾਨ ਗੇਟਵੇ ਨਾਲ ਸੰਪਰਕ ਕਰਦਾ ਹੈ, ਅਤੇ ਈਮੇਲ ਭੇਜਦਾ ਹੈ, ਇਸਦੀ ਜਾਂਚ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੋਵੇਗਾ ਅਤੇ ਇਸਨੂੰ ਬਦਲਣਾ ਮੁਸ਼ਕਲ ਹੋਵੇਗਾ। ਇਸਨੂੰ ਵੱਖਰੇ ਫੰਕਸ਼ਨਾਂ (ਪ੍ਰਮਾਣਿਕਤਾ, ਗਣਨਾ, ਭੁਗਤਾਨ, ਸੂਚਨਾ) ਵਿੱਚ ਵੰਡ ਕੇ, ਤੁਸੀਂ ਦੂਜੇ ਨੂੰ ਤੋੜੇ ਬਿਨਾਂ ਇੱਕ ਹਿੱਸੇ ਵਿੱਚ ਬਦਲਾਅ ਕਰ ਸਕਦੇ ਹੋ।
4. ਡੁਪਲੀਕੇਸ਼ਨ (DRY) ਤੋਂ ਬਚੋ, ਪਰ ਇਸਨੂੰ ਜ਼ਿਆਦਾ ਨਾ ਕਰੋ।
DRY (ਆਪਣੇ ਆਪ ਨੂੰ ਦੁਹਰਾਓ ਨਾ) ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਸਿਧਾਂਤ ਹੈ: ਜੇਕਰ ਤੁਸੀਂ ਕੋਡ ਦੇ ਇੱਕੋ ਬਲਾਕ ਨੂੰ ਕਈ ਵਾਰ ਕਾਪੀ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਤਬਦੀਲੀ ਲਈ ਤੁਹਾਨੂੰ ਹਰ ਚੀਜ਼ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇਹ ਗਲਤੀ-ਸੰਭਾਵੀ ਹੈ। ਹੱਲ ਇਹ ਹੈ ਕਿ ਦੁਹਰਾਏ ਗਏ ਤਰਕ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਜਾਂ ਮੋਡੀਊਲ ਵਿੱਚ ਐਕਸਟਰੈਕਟ ਕੀਤਾ ਜਾਵੇ।
ਹਾਲਾਂਕਿ, ਇਹ ਯਾਦ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਬਹੁਤ ਜ਼ਿਆਦਾ ਡੁਪਲੀਕੇਸ਼ਨ ਤੋਂ ਬਚਣਾ ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਵੀ ਨੁਕਸਾਨ ਪਹੁੰਚਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਕੋਡ ਦੇ ਦੋ ਟੁਕੜੇ ਇੱਕੋ ਜਿਹੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ ਪਰ ਅਸਲ ਵਿੱਚ ਵੱਖੋ-ਵੱਖਰੇ ਸੰਦਰਭ ਹਨ, ਤਾਂ "ਐਬਸਟ੍ਰਕਸ਼ਨ" ਨੂੰ ਮਜਬੂਰ ਕਰਨਾ ਕੋਡ ਨੂੰ ਹੋਰ ਗੁੰਝਲਦਾਰ ਬਣਾ ਸਕਦਾ ਹੈ। ਇੱਕ ਸੰਤੁਲਨ ਲੱਭੋ: ਜਦੋਂ ਡੁਪਲੀਕੇਸ਼ਨ ਸੱਚਮੁੱਚ ਅਰਥਪੂਰਨ ਹੋਵੇ ਅਤੇ ਇਕੱਠੇ ਬਦਲਣ ਦੀ ਸਮਰੱਥਾ ਹੋਵੇ ਤਾਂ ਰੀਫੈਕਟਰ ਕਰੋ।
5. ਇੱਕ ਸਾਫ਼-ਸੁਥਰਾ ਪ੍ਰੋਜੈਕਟ ਢਾਂਚਾ ਬਣਾਓ
ਇੱਕ ਸਪਸ਼ਟ ਫੋਲਡਰ ਢਾਂਚਾ ਰੱਖ-ਰਖਾਅ ਦੀ ਸੌਖ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ। ਫਾਈਲਾਂ ਨੂੰ ਵਿਸ਼ੇਸ਼ਤਾ ਜਾਂ ਮੋਡੀਊਲ ਦੁਆਰਾ ਸਮੂਹਬੱਧ ਕਰੋ, ਸਿਰਫ਼ ਫਾਈਲ ਕਿਸਮ ਦੁਆਰਾ ਨਹੀਂ, ਖਾਸ ਕਰਕੇ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ। ਇੱਕ ਚੰਗੀ ਬਣਤਰ ਨਵੇਂ ਆਉਣ ਵਾਲਿਆਂ ਲਈ ਪ੍ਰੋਜੈਕਟ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਸਮਝਣਾ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ।
ਉਦਾਹਰਨ ਲਈ, ਆਪਣੇ ਸਾਰੇ UI ਹਿੱਸਿਆਂ ਨੂੰ ਇੱਕ ਵੱਡੇ ਫੋਲਡਰ ਵਿੱਚ ਰੱਖਣ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੁਆਰਾ ਵੰਡ ਸਕਦੇ ਹੋ: `auth/`, `profile/`, `checkout/`, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ। ਇਹ ਪਹੁੰਚ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਵਧਣ ਦੇ ਨਾਲ-ਨਾਲ ਸਕੇਲ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ।
6. ਜਟਿਲਤਾ ਨੂੰ ਸੀਮਤ ਕਰੋ ਅਤੇ ਤਰਕ ਪ੍ਰਵਾਹ ਨੂੰ ਪਾਲਣਾ ਕਰਨਾ ਆਸਾਨ ਬਣਾਓ।
ਨੇਸਟਡ ਇਫ-ਐਲਸ ਸਟੇਟਮੈਂਟਾਂ, ਕਈ ਸ਼ਰਤਾਂ, ਅਤੇ ਵਿਸ਼ੇਸ਼ ਅਪਵਾਦਾਂ ਨਾਲ ਭਰਿਆ ਕੋਡ ਅਕਸਰ ਬਣਾਈ ਰੱਖਣਾ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ। ਆਪਣੇ ਤਰਕ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ। ਤੁਸੀਂ ਨੇਸਟਿੰਗ ਨੂੰ ਘਟਾਉਣ ਲਈ ਸ਼ੁਰੂਆਤੀ ਵਾਪਸੀ ਵਰਗੀਆਂ ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਗੁੰਝਲਦਾਰ ਤਰਕ ਨੂੰ ਛੋਟੇ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਸਕਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਨੂੰ ਢੁਕਵੇਂ ਨਾਮ ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ।
ਜੇਕਰ ਕਿਸੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਪੈਰਾਮੀਟਰ ਹਨ, ਤਾਂ ਇਹ ਜਟਿਲਤਾ ਦਾ ਸੰਕੇਤ ਵੀ ਦਿੰਦਾ ਹੈ। ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਵਿਵਸਥਿਤ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਵਧਾਉਣਾ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸੰਰਚਨਾ ਵਸਤੂ (ਜਾਂ ਡੇਟਾ ਢਾਂਚਾ) ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ।
7. ਟਿੱਪਣੀਆਂ ਲਿਖੋ ਜੋ ਨਿਸ਼ਾਨਾ 'ਤੇ ਹੋਣ
ਟਿੱਪਣੀਆਂ ਸਪੱਸ਼ਟ ਕੋਡ ਦਾ ਬਦਲ ਨਹੀਂ ਹਨ। ਜੇਕਰ ਤੁਹਾਨੂੰ "ਕੋਡ ਕੀ ਕਰਦਾ ਹੈ" ਦੀ ਵਿਆਖਿਆ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਸ਼ਾਇਦ ਹੋਰ ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਹਾਲਾਂਕਿ, ਟਿੱਪਣੀਆਂ ਅਜੇ ਵੀ ਇਹ ਸਮਝਾਉਣ ਲਈ ਉਪਯੋਗੀ ਹਨ ਕਿ ਕੁਝ "ਕਿਉਂ" ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜੇਕਰ ਡਿਜ਼ਾਈਨ ਫੈਸਲੇ, ਸਿਸਟਮ ਸੀਮਾਵਾਂ, ਜਾਂ ਖਾਸ ਕਾਰੋਬਾਰੀ ਕਾਰਨ ਹੋਣ।
ਚੰਗੀਆਂ ਟਿੱਪਣੀਆਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਇਹ ਸਮਝਾਉਣਾ ਸ਼ਾਮਲ ਹੈ ਕਿ ਪ੍ਰਦਰਸ਼ਨ ਸੀਮਾਵਾਂ ਦੇ ਕਾਰਨ ਇੱਕ ਖਾਸ ਐਲਗੋਰਿਦਮ ਕਿਉਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਾਂ ਇੱਕ ਪ੍ਰਮਾਣਿਕਤਾ ਨਿਯਮ ਅਜੀਬ ਕਿਉਂ ਲੱਗਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਨਿਯਮ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਦੂਸਰੇ ਕੋਡ ਨੂੰ "ਸਾਫ਼" ਨਹੀਂ ਕਰਨਗੇ ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਤਰਕ ਨੂੰ ਨਹੀਂ ਤੋੜਨਗੇ।
8. ਕੋਡ ਫਾਰਮੈਟਿੰਗ ਅਤੇ ਸਟਾਈਲ ਗਾਈਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ
ਇਕਸਾਰ ਫਾਰਮੈਟਿੰਗ ਕੋਡ ਨੂੰ ਪੇਸ਼ੇਵਰ ਅਤੇ ਪੜ੍ਹਨ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ। ਜੇਕਰ ਉਪਲਬਧ ਹੋਵੇ ਤਾਂ ਆਟੋਮੇਟਿਡ ਲਿੰਟਰਾਂ ਅਤੇ ਫਾਰਮੈਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ (ਜਿਵੇਂ ਕਿ, JavaScript ਲਈ ESLint + Prettier, Python ਲਈ Black, ਜਾਂ Go ਲਈ gofmt)। ਇਹਨਾਂ ਟੂਲਸ ਨਾਲ, ਟੀਮਾਂ ਨੂੰ ਸਪੇਸਿੰਗ ਅਤੇ ਇੰਡੈਂਟੇਸ਼ਨ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਸਭ ਕੁਝ ਆਪਣੇ ਆਪ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ।
ਸਟਾਈਲ ਗਾਈਡਾਂ ਵੀ ਮਦਦ ਕਰਦੀਆਂ ਹਨ: ਸਿੰਗਲ ਜਾਂ ਡਬਲ ਕੋਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੈ, ਫਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਨਾਮ ਦੇਣਾ ਹੈ, ਲੰਬੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਕਦੋਂ ਤੋੜਨਾ ਹੈ, ਆਦਿ। ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਛੋਟੇ ਮਿਆਰ ਲੰਬੇ ਸਮੇਂ ਵਿੱਚ ਵੱਡਾ ਫ਼ਰਕ ਪਾ ਸਕਦੇ ਹਨ।
9. ਰੀਫੈਕਟਰਿੰਗ ਕਰਦੇ ਸਮੇਂ ਵਿਸ਼ਵਾਸ ਬਣਾਈ ਰੱਖਣ ਲਈ ਟੈਸਟ ਲਿਖੋ।
ਰੱਖ-ਰਖਾਅਯੋਗ ਕੋਡ ਨਾ ਸਿਰਫ਼ ਸਾਫ਼ ਹੈ ਸਗੋਂ ਬਦਲਣ ਲਈ ਵੀ ਸੁਰੱਖਿਅਤ ਹੈ। ਆਟੋਮੇਟਿਡ ਟੈਸਟ (ਯੂਨਿਟ ਟੈਸਟ, ਏਕੀਕਰਨ ਟੈਸਟ) ਇਹ ਗਾਰੰਟੀ ਦਿੰਦੇ ਹਨ ਕਿ ਤੁਹਾਡੇ ਬਦਲਾਅ ਸਥਾਪਿਤ ਵਿਵਹਾਰ ਨੂੰ ਨਹੀਂ ਤੋੜਦੇ। ਟੈਸਟਾਂ ਤੋਂ ਬਿਨਾਂ, ਲੋਕ ਅਣਪਛਾਤੇ ਬੱਗਾਂ ਦੇ ਜੋਖਮ ਕਾਰਨ ਕੋਡ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਤੋਂ ਡਰਦੇ ਹਨ।
ਮਹੱਤਵਪੂਰਨ ਭਾਗਾਂ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰੋ: ਕੀਮਤ ਗਣਨਾ ਫੰਕਸ਼ਨ, ਛੋਟ ਨਿਯਮ, ਪ੍ਰਮਾਣਿਕਤਾ, ਜਾਂ ਅਕਸਰ ਬਦਲੇ ਜਾਂਦੇ ਮਾਡਿਊਲ। ਸਮੇਂ ਦੇ ਨਾਲ, ਟੈਸਟ ਕਵਰੇਜ ਵਧੇਗੀ ਅਤੇ ਰਿਗਰੈਸ਼ਨ ਦੇ ਵਿਰੁੱਧ ਮਜ਼ਬੂਤ ਸੁਰੱਖਿਆ ਪ੍ਰਦਾਨ ਕਰੇਗੀ।
10. ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਅਤੇ ਮਾਪਣਯੋਗ ਢੰਗ ਨਾਲ ਰੀਫੈਕਟਰਿੰਗ ਕਰੋ
ਰੱਖ-ਰਖਾਅ ਇੱਕ ਨਿਰੰਤਰ ਪ੍ਰਕਿਰਿਆ ਹੈ। ਰੀਫੈਕਟਰਿੰਗ ਦਾ ਮਤਲਬ "ਸਭ ਕੁਝ ਦੁਬਾਰਾ ਲਿਖਣਾ" ਨਹੀਂ ਹੈ, ਸਗੋਂ ਛੋਟੇ ਸੁਧਾਰ ਹਨ ਜੋ ਕੋਡ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਬਦਲੇ ਬਿਨਾਂ ਉਸਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੇ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ ਕੋਡ ਦੇ ਕਿਸੇ ਭਾਗ ਨੂੰ ਛੂਹੋ ਤਾਂ ਇੱਕ ਰੀਫੈਕਟਰ ਨੂੰ ਤਹਿ ਕਰੋ: ਥੋੜ੍ਹਾ ਜਿਹਾ ਸਾਫ਼ ਕਰੋ, ਨਾਮਕਰਨ ਠੀਕ ਕਰੋ, ਬਹੁਤ ਜ਼ਿਆਦਾ ਲੰਬੇ ਫੰਕਸ਼ਨ ਨੂੰ ਤੋੜੋ, ਜਾਂ ਡੈੱਡ ਕੋਡ ਨੂੰ ਹਟਾਓ।
ਛੋਟੇ, ਨਿਯਮਤ ਰੀਫੈਕਟਰਿੰਗ ਵੱਡੇ, ਕਦੇ-ਕਦਾਈਂ ਰੀਫੈਕਟਰਿੰਗਾਂ ਨਾਲੋਂ ਸੁਰੱਖਿਅਤ ਹਨ। ਅਤੇ ਹਮੇਸ਼ਾ ਤਬਦੀਲੀਆਂ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਢੁਕਵੀਂ ਜਾਂਚ, ਜਾਂ ਘੱਟੋ ਘੱਟ ਜਾਂਚ ਯਕੀਨੀ ਬਣਾਓ।
11. ਮਹੱਤਵਪੂਰਨ ਫੈਸਲਿਆਂ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਬਣਾਓ
ਕੋਡ ਟਿੱਪਣੀਆਂ ਤੋਂ ਇਲਾਵਾ, ਚੰਗੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਸੰਖੇਪ ਦਸਤਾਵੇਜ਼ ਹੁੰਦੇ ਹਨ: ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ, ਇਸਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ, ਵਾਤਾਵਰਣ ਨੂੰ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰਨਾ ਹੈ, ਅਤੇ ਇੱਕ ਉੱਚ-ਪੱਧਰੀ ਆਰਕੀਟੈਕਚਰਲ ਵਿਆਖਿਆ। ਇਹ ਦਸਤਾਵੇਜ਼ ਵਿਆਪਕ ਹੋਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ, ਪਰ ਇਹ ਸਹੀ ਅਤੇ ਲੱਭਣ ਵਿੱਚ ਆਸਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। `README.md` ਵਰਗੀ ਇੱਕ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਭਾਲੀ ਹੋਈ ਫਾਈਲ ਨਵੇਂ ਮੈਂਬਰਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਬਚਾ ਸਕਦੀ ਹੈ।
ਜੇਕਰ ਕੋਈ ਮੁੱਖ ਤਕਨੀਕੀ ਫੈਸਲਾ ਹੈ (ਜਿਵੇਂ ਕਿ, ਇੱਕ ਖਾਸ ਡੇਟਾਬੇਸ, ਆਰਕੀਟੈਕਚਰਲ ਪੈਟਰਨ, ਜਾਂ ਏਕੀਕਰਣ ਦੀ ਰੁਕਾਵਟ) ਤਾਂ ਤਰਕ ਨੂੰ ਦਸਤਾਵੇਜ਼ ਬਣਾਓ। ਇਹ ਟੀਮ ਨੂੰ ਸੰਦਰਭ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹੀ ਚਰਚਾ ਦੁਹਰਾਉਣ ਤੋਂ ਬਚਦਾ ਹੈ।
ਬੰਦ ਕੀਤਾ ਜਾ ਰਿਹਾ
ਰੱਖ-ਰਖਾਅ ਯੋਗ ਕੋਡ ਚੰਗੀਆਂ ਆਦਤਾਂ ਦਾ ਨਤੀਜਾ ਹੈ: ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖਣਾ, ਜ਼ਿੰਮੇਵਾਰੀਆਂ ਨੂੰ ਵਿਘਨ ਪਾਉਣਾ, ਇਕਸਾਰਤਾ ਬਣਾਈ ਰੱਖਣਾ, ਜਟਿਲਤਾ ਨੂੰ ਘਟਾਉਣਾ, ਅਤੇ ਟੈਸਟਾਂ ਨਾਲ ਤਬਦੀਲੀਆਂ ਦੀ ਰੱਖਿਆ ਕਰਨਾ। ਕੋਈ ਵੀ ਕੋਡ ਸੰਪੂਰਨ ਨਹੀਂ ਹੁੰਦਾ, ਪਰ ਹਰ ਪ੍ਰੋਜੈਕਟ ਨਿਰੰਤਰ ਸੁਧਾਰ ਕਰ ਸਕਦਾ ਹੈ ਜੇਕਰ ਟੀਮ ਗੁਣਵੱਤਾ ਪ੍ਰਤੀ ਵਚਨਬੱਧ ਹੈ। ਉਪਰੋਕਤ ਸੁਝਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ, ਤੁਸੀਂ ਵਧਣ-ਫੁੱਲਣ ਲਈ ਬਿਹਤਰ ਢੰਗ ਨਾਲ ਤਿਆਰ ਹੋਵੋਗੇ—ਸਿਰਫ਼ ਅੱਜ ਹੀ ਨਹੀਂ, ਸਗੋਂ ਆਉਣ ਵਾਲੇ ਮਹੀਨਿਆਂ ਅਤੇ ਸਾਲਾਂ ਵਿੱਚ ਵੀ।
