AI ਨਾਲ ਬਣੀ ਐਪ ਵਿੱਚ Git ਕਿਵੇਂ ਵਰਤੀਏ

AI ਨਾਲ ਬਣੀ ਐਪ ਵਿੱਚ Git ਵਰਤਣ ਲਈ, ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇੱਕ Git ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਜੋੜੋ, ਹਰ ਕੰਮ ਵਾਲੇ ਬਦਲਾਅ ਤੋਂ ਬਾਅਦ ਕਮਿਟ ਕਰੋ, ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਲਿਖੋ ਕਿ ਕੀ ਬਦਲਿਆ, ਅਤੇ .gitignore ਨਾਲ ਗੁਪਤ ਜਾਣਕਾਰੀ ਬਾਹਰ ਰੱਖੋ। ਖ਼ਤਰੇ ਵਾਲੇ ਕੰਮ ਲਈ ਬ੍ਰਾਂਚ ਵਰਤੋ, ਜੇ ਕਿਸੇ ਹੋਰ ਨੇ ਕੋਡ ਬਦਲਿਆ ਹੋਵੇ ਤਾਂ ਅਗਲਾ ਪ੍ਰੌਮਪਟ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ pull ਕਰੋ, ਅਤੇ ਜਦੋਂ AI ਕੁਝ ਤੋੜ ਦੇਵੇ ਤਾਂ ਉਸ ਦੇ ਉੱਤੇ ਹੋਰ ਪ੍ਰੌਮਪਟ ਦੇਣ ਦੀ ਬਜਾਏ ਆਖ਼ਰੀ ਠੀਕ ਕਮਿਟ 'ਤੇ ਵਾਪਸ ਜਾਓ।

Git ਵਰਜ਼ਨ ਕੰਟਰੋਲ ਹੈ: ਤੁਹਾਡੇ ਕੋਡ ਦੇ ਹਰ ਸੰਭਾਲੇ ਹੋਏ ਵਰਜ਼ਨ ਦਾ ਇਤਿਹਾਸ। GitHub ਇੱਕ ਵੈੱਬਸਾਈਟ ਹੈ ਜੋ Git ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਆਨਲਾਈਨ ਰੱਖਦੀ ਹੈ। ਜੇ ਇਹ ਸਭ ਨਵਾਂ ਹੈ, ਤਾਂ GitHub ਕੀ ਹੈ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ। ਇਹ ਗਾਈਡ ਉਨ੍ਹਾਂ ਆਦਤਾਂ ਬਾਰੇ ਹੈ ਜੋ Git ਨੂੰ ਲਾਭਦਾਇਕ ਬਣਾਉਂਦੀਆਂ ਹਨ ਜਦੋਂ ਜ਼ਿਆਦਾਤਰ ਕੋਡ AI ਲਿਖ ਰਿਹਾ ਹੋਵੇ।

AI ਨਾਲ Git ਕਿਉਂ ਹੋਰ ਅਹਿਮ ਹੈ

ਇੱਕ AI ਇੱਕ ਵਾਰੀ ਵਿੱਚ ਵੀਹ ਫ਼ਾਈਲਾਂ ਬਦਲ ਸਕਦਾ ਹੈ। ਇਹ ਤੇਜ਼ ਹੈ, ਪਰ ਇਸ ਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ ਇੱਕ ਪ੍ਰੌਮਪਟ ਚੁੱਪਚਾਪ ਉਹ ਚੀਜ਼ ਤੋੜ ਸਕਦਾ ਹੈ ਜੋ ਕੱਲ੍ਹ ਤੁਸੀਂ ਟੈਸਟ ਕੀਤੀ ਸੀ। Git ਤੁਹਾਨੂੰ ਦਿੰਦਾ ਹੈ:

• ਵਾਪਸ ਜਾਣ ਦਾ ਰਸਤਾ। ਕੋਈ ਵੀ ਕਮਿਟ ਕੀਤਾ ਵਰਜ਼ਨ ਬਹਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
• ਬਦਲਾਅ ਦਾ ਰਿਕਾਰਡ। ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਕਿਸ ਪ੍ਰੌਮਪਟ ਨੇ ਕਿਹੜੀਆਂ ਫ਼ਾਈਲਾਂ ਅਤੇ ਲਾਈਨਾਂ ਨੂੰ ਛੂਹਿਆ।
• ਬਿਲਡਰ ਤੋਂ ਬਾਹਰ ਇੱਕ ਕਾਪੀ। ਤੁਹਾਡਾ ਕੋਡ ਉਸ ਥਾਂ 'ਤੇ ਰਹਿੰਦਾ ਹੈ ਜਿਸ 'ਤੇ ਤੁਹਾਡਾ ਕੰਟਰੋਲ ਹੈ।
• ਮਿਆਰੀ ਹੈਂਡਆਫ। ਕੋਈ ਵੀ ਡਿਵੈਲਪਰ, ਹੋਸਟ ਜਾਂ ਟੂਲ Git ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ।

ਕਦਮ 1: ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਜੋੜੋ

GitHub ਜਾਂ ਕਿਸੇ ਹੋਰ ਸਮਾਨ ਸੇਵਾ 'ਤੇ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਬਣਾਓ (ਆਮ ਤੌਰ 'ਤੇ ਪ੍ਰਾਈਵੇਟ) ਅਤੇ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਉਸ ਨਾਲ ਜੋੜੋ। Git ਸਪੋਰਟ ਕਰਨ ਵਾਲੇ ਜ਼ਿਆਦਾਤਰ AI ਐਪ ਬਿਲਡਰ ਇਹ ਕੰਮ ਸੈਟਿੰਗਜ਼ ਪੇਜ 'ਤੇ "Connect GitHub" ਬਟਨ ਨਾਲ ਕਰਦੇ ਹਨ। ਜੇ ਤੁਹਾਡੇ ਬਿਲਡਰ ਵਿੱਚ ਇਹ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕੋਡ ਐਕਸਪੋਰਟ ਕਰਕੇ ਆਪ ਪੁਸ਼ ਕਰ ਸਕਦੇ ਹੋ, ਜਾਂ ਕਿਸੇ ਡਿਵੈਲਪਰ ਨੂੰ ਇੱਕ ਵਾਰ ਇਹ ਸੈੱਟ ਕਰਨ ਲਈ ਕਹਿ ਸਕਦੇ ਹੋ।

ਪਹਿਲੇ ਪੁਸ਼ ਤੋਂ ਪਹਿਲਾਂ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਰਿਪੋਜ਼ਟਰੀ ਉਹ ਚੀਜ਼ਾਂ ਨੂੰ ਅਣਡਿੱਠ ਕਰਦੀ ਹੈ ਜੋ ਉਸ ਵਿੱਚ ਨਹੀਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ:

.gitignore ਫ਼ਾਈਲ ਚੈੱਕ ਕਰੋ। ਪੱਕਾ ਕਰੋ ਕਿ ਇਹ .env ਫ਼ਾਈਲਾਂ, node_modules, ਬਿਲਡ ਆਉਟਪੁੱਟ ਫੋਲਡਰਾਂ ਅਤੇ ਕਿਸੇ ਵੀ ਫ਼ਾਈਲ ਨੂੰ ਬਾਹਰ ਰੱਖਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਗੁਪਤ ਜਾਣਕਾਰੀ ਹੋਵੇ। ਦੱਸੋ ਕਿ ਤੁਸੀਂ ਕੀ ਜੋੜਿਆ।

ਕਦਮ 2: ਹਰ ਕੰਮ ਵਾਲੇ ਬਦਲਾਅ ਤੋਂ ਬਾਅਦ ਕਮਿਟ ਕਰੋ

ਕਮਿਟ ਇੱਕ ਸੁਨੇਹੇ ਨਾਲ ਸੰਭਾਲੀ ਹੋਈ ਝਲਕ ਹੁੰਦੀ ਹੈ। ਜੋ ਆਦਤ ਸਭ ਤੋਂ ਅਹਿਮ ਹੈ: ਜਦੋਂ ਕੁਝ ਕੰਮ ਕਰੇ, ਤਾਂ ਅਗਲੀ ਚੀਜ਼ ਮੰਗਣ ਤੋਂ ਪਹਿਲਾਂ ਕਮਿਟ ਕਰੋ।

1. ਇੱਕ ਬਦਲਾਅ ਲਈ ਪ੍ਰੌਮਪਟ ਦਿਓ।
2. ਪ੍ਰੀਵਿਊ ਵਿੱਚ ਜਾਂਚੋ।
3. ਜੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ ਸੁਨੇਹੇ ਨਾਲ ਕਮਿਟ (ਜਾਂ ਸਿੰਕ) ਕਰੋ।
4. ਫਿਰ ਅੱਗੇ ਵਧੋ।

ਛੋਟੀਆਂ ਕਮਿਟਾਂ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਜਦੋਂ ਕੁਝ ਟੁੱਟੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਪਤਾ ਲੱਗ ਜਾਂਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਬਦਲਾਅ ਨੇ ਇਹ ਕੀਤਾ, ਅਤੇ ਉਸ ਨੂੰ ਵਾਪਸ ਲੈਣ ਨਾਲ ਤੁਹਾਡਾ ਹੋਰ ਕੰਮ ਨਹੀਂ ਜਾਂਦਾ।

ਕਦਮ 3: ਅਜਿਹੇ ਸੁਨੇਹੇ ਲਿਖੋ ਜੋ ਬਾਅਦ ਵਿੱਚ ਪੜ੍ਹੇ ਜਾ ਸਕਣ

ਇੱਕ ਚੰਗਾ ਸੁਨੇਹਾ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਦੱਸਦਾ ਹੈ ਕਿ ਕੀ ਬਦਲਿਆ ਅਤੇ ਕਿਉਂ:

• ਚੰਗਾ: Add CSV export to the orders page
• ਚੰਗਾ: Fix booking form rejecting times after 6pm
• ਕੰਮ ਦਾ ਨਹੀਂ: update, changes, fix stuff

ਤੁਸੀਂ AI ਨੂੰ ਇਹ ਲਿਖਣ ਲਈ ਕਹਿ ਸਕਦੇ ਹੋ:

ਆਖ਼ਰੀ ਕਮਿਟ ਤੋਂ ਬਾਅਦ ਦੇ ਬਦਲਾਅ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਸੰਖੇਪ ਕਰੋ, ਕਿਰਿਆ ਵਾਲੇ ਸ਼ਬਦ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, 70 ਅੱਖਰਾਂ ਤੋਂ ਘੱਟ।

ਕਦਮ 4: ਖ਼ਤਰੇ ਵਾਲੇ ਕੰਮ ਲਈ ਬ੍ਰਾਂਚ ਵਰਤੋ

ਬ੍ਰਾਂਚ ਕੰਮ ਦੀ ਇੱਕ ਵੱਖਰੀ ਲਾਈਨ ਹੈ। ਤੁਸੀਂ ਕਿਸੇ ਬ੍ਰਾਂਚ 'ਤੇ ਕੁਝ ਅਜ਼ਮਾ ਸਕਦੇ ਹੋ, ਅਤੇ ਜੇ ਗੱਲ ਨਾ ਬਣੇ ਤਾਂ ਮੁੱਖ ਵਰਜ਼ਨ ਨੂੰ ਛੂਹੇ ਬਿਨਾਂ ਛੱਡ ਸਕਦੇ ਹੋ।

ਬ੍ਰਾਂਚ ਕਦੋਂ ਵਰਤੋ:

• ਬਦਲਾਅ ਵੱਡਾ ਹੈ (ਨਵਾਂ ਡਿਜ਼ਾਈਨ, ਨਵਾਂ ਭੁਗਤਾਨ ਫਲੋ, ਡੇਟਾਬੇਸ ਬਦਲਾਅ)।
• ਕੋਈ ਹੋਰ ਉਸੇ ਐਪ 'ਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।
• ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕੋਈ ਬਦਲਾਅ ਲਾਈਵ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਦੀ ਸਮੀਖਿਆ ਹੋਵੇ।

ਜਦੋਂ ਕੰਮ ਪੂਰਾ ਅਤੇ ਟੈਸਟ ਹੋ ਜਾਵੇ, ਤਾਂ ਉਹ ਮੁੱਖ ਬ੍ਰਾਂਚ ਵਿੱਚ merge ਕੀਤਾ ਜਾਂਦਾ ਹੈ। GitHub 'ਤੇ ਇਹ ਆਮ ਤੌਰ 'ਤੇ pull request ਰਾਹੀਂ ਹੁੰਦਾ ਹੈ, ਜਿਹੜਾ ਸਮੀਖਿਆ ਲਈ ਬਦਲਾਅ ਵਿਖਾਉਂਦਾ ਪੰਨਾ ਹੈ। ਜੇ ਤੁਹਾਡਾ ਬਿਲਡਰ ਸਿਰਫ਼ ਇੱਕ ਬ੍ਰਾਂਚ ਸਿੰਕ ਕਰਦਾ ਹੈ, ਤਾਂ ਡਿਵੈਲਪਰ GitHub ਵਾਲੇ ਪਾਸੇ ਬ੍ਰਾਂਚਾਂ ਸੰਭਾਲ ਸਕਦਾ ਹੈ।

ਕਦਮ 5: ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਵਾਪਸ ਲਓ

ਜਦੋਂ ਕੋਈ ਪ੍ਰੌਮਪਟ ਐਪ ਤੋੜ ਦੇਵੇ, ਤਾਂ ਉਸ ਦੇ ਉੱਤੇ ਪੰਜ ਹੋਰ ਪ੍ਰੌਮਪਟ ਦੇਣ ਦੀ ਇੱਛਾ ਨੂੰ ਰੋਕੋ। ਆਖ਼ਰੀ ਠੀਕ ਵਰਜ਼ਨ 'ਤੇ ਵਾਪਸ ਜਾਓ ਅਤੇ ਹੋਰ ਸਾਫ਼ ਪ੍ਰੌਮਪਟ ਅਜ਼ਮਾਓ।

• ਬਿਲਡਰ ਵਿੱਚ: ਜੇ ਉਸ ਕੋਲ ਚੈੱਕਪੌਇੰਟ ਜਾਂ ਰੀਸਟੋਰ ਦੀ ਸੁਵਿਧਾ ਹੈ, ਤਾਂ ਉਹ ਵਰਤੋ।
• Git ਵਿੱਚ: git revert ਇੱਕ ਨਵੀਂ ਕਮਿਟ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਪੁਰਾਣੀ ਕਮਿਟ ਨੂੰ ਉਲਟਾਉਂਦੀ ਹੈ, ਅਤੇ ਇਤਿਹਾਸ ਸਾਬਤ ਰਹਿੰਦਾ ਹੈ। ਜਿਨ੍ਹਾਂ ਕੋਡ ਨੂੰ ਹੋਰ ਲੋਕਾਂ ਨੇ ਪੁੱਲ ਕੀਤਾ ਹੋਵੇ, ਉਸ ਲਈ ਇਹ ਸੁਰੱਖਿਅਤ ਚੋਣ ਹੈ।
• ਸਾਂਝੀ ਬ੍ਰਾਂਚ 'ਤੇ git push --force ਤੋਂ ਬਚੋ, ਜਦ ਤੱਕ ਤੁਹਾਨੂੰ ਪੂਰਾ ਪਤਾ ਨਾ ਹੋਵੇ ਕਿ ਕਿਉਂ। ਇਹ ਸਭ ਦਾ ਇਤਿਹਾਸ ਦੁਬਾਰਾ ਲਿਖ ਦਿੰਦਾ ਹੈ।

ਜੇ ਤੁਹਾਨੂੰ ਪੱਕਾ ਨਾ ਹੋਵੇ, ਤਾਂ ਪੁੱਛੋ:

ਆਖ਼ਰੀ ਬਦਲਾਅ ਨੇ ਲੌਗਇਨ ਪੰਨਾ ਤੋੜ ਦਿੱਤਾ ਹੈ। ਦੱਸੋ ਕਿ ਪਿਛਲੀ ਕਮਿਟ ਦੇ ਮੁਕਾਬਲੇ ਕਿਹੜੀਆਂ ਫ਼ਾਈਲਾਂ ਬਦਲੀਆਂ ਗਈਆਂ, ਅਤੇ ਹਰ ਬਦਲਾਅ ਨੇ ਕੀ ਕੀਤਾ। ਹਾਲੇ ਕੁਝ ਵੀ ਨਾ ਬਦਲੋ।

ਕਦਮ 6: ਪ੍ਰੌਮਪਟ ਤੋਂ ਪਹਿਲਾਂ pull ਕਰੋ

ਜੇ ਕੋਈ ਡਿਵੈਲਪਰ ਜਾਂ ਹੋਰ ਟੂਲ GitHub 'ਤੇ ਕੋਡ ਬਦਲਦਾ ਹੈ, ਤਾਂ AI ਬਿਲਡਰ ਉਸ ਬਾਰੇ ਉਦੋਂ ਤੱਕ ਨਹੀਂ ਜਾਣਦਾ ਜਦ ਤੱਕ ਤੁਸੀਂ ਉਹ ਬਦਲਾਅ pull ਨਹੀਂ ਕਰਦੇ। ਪੁਰਾਣੇ ਕੋਡ 'ਤੇ ਪ੍ਰੌਮਪਟ ਦੇਣ ਨਾਲ ਟਕਰਾਅ ਅਤੇ ਕੰਮ ਦਾ ਨੁਕਸਾਨ ਹੁੰਦਾ ਹੈ।

• ਹਰ ਸੈਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ pull ਕਰੋ।
• ਤੈਅ ਕਰੋ ਕਿ ਕੌਣ ਕੀ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਇੱਕੋ ਸਮੇਂ ਦੋਵੇਂ ਪਾਸਿਆਂ ਤੋਂ ਇੱਕੋ ਫ਼ਾਈਲਾਂ ਨਾ ਬਦਲੋ।
• ਜੇ merge conflict ਆਵੇ (ਇੱਕੋ ਲਾਈਨਾਂ 'ਤੇ ਦੋ ਬਦਲਾਅ), ਤਾਂ ਡਿਵੈਲਪਰ ਜਾਂ AI ਨੂੰ ਕਹੋ ਕਿ ਇਸ ਨੂੰ ਸੁਲਝਾਏ ਅਤੇ ਚੋਣ ਦੀ ਵਜ੍ਹਾ ਦੱਸੇ।

ਉਦਾਹਰਨ ਪ੍ਰੌਮਪਟ

ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ: ਮੇਰੇ ਆਖ਼ਰੀ ਸੈਸ਼ਨ ਤੋਂ ਬਾਅਦ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਕੀ ਬਦਲਿਆ ਹੈ? ਕਮਿਟਾਂ ਦਾ ਸੰਖੇਪ ਦਿਓ।

ਅਗਲਾ ਬਦਲਾਅ ਇਕੱਲਾ ਕਰੋ: ਹਰ ਇਨਵੌਇਸ ਵਿੱਚ "Duplicate" ਬਟਨ ਜੋੜੋ। ਹੋਰ ਕੁਝ ਨਾ ਬਦਲੋ, ਤਾਂ ਜੋ ਮੈਂ ਇਸ ਨੂੰ ਵੱਖਰੀ ਕਮਿਟ ਕਰ ਸਕਾਂ।

ਚੈੱਕ ਕਰੋ ਕਿ ਕੋਈ API ਕੀ, ਪਾਸਵਰਡ ਜਾਂ .env ਫ਼ਾਈਲ Git ਵਿੱਚ ਟਰੈਕ ਨਹੀਂ ਹੋ ਰਹੀ, ਪਿਛਲੀਆਂ ਕਮਿਟਾਂ ਸਮੇਤ। ਸਿਰਫ਼ ਫ਼ਾਈਲਾਂ ਦੇ ਨਾਂ ਦੱਸੋ, ਮੁੱਲ ਨਹੀਂ।

ਆਮ ਗ਼ਲਤੀਆਂ

• ਗੁਪਤ ਜਾਣਕਾਰੀ ਕਮਿਟ ਕਰਨਾ। ਇੱਕ ਵਾਰ ਕੀ Git ਇਤਿਹਾਸ ਵਿੱਚ ਆ ਜਾਵੇ, ਤਾਂ ਫ਼ਾਈਲ ਮਿਟਾਉਣ ਤੋਂ ਬਾਅਦ ਵੀ ਉਹ ਜ਼ਾਹਿਰ ਹੋ ਜਾਂਦੀ ਹੈ। ਉਸ ਨੂੰ ਬਦਲੋ।
• ਹਫ਼ਤੇ ਵਿੱਚ ਇੱਕ ਵੱਡੀ ਕਮਿਟ। ਤੁਸੀਂ ਇੱਕ ਬਦਲਾਅ ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਲੈ ਸਕਦੇ, ਬਿਨਾਂ ਸਾਰੇ ਬਦਲਾਅ ਵਾਪਸ ਲਏ।
• "update" ਵਰਗੇ ਸੁਨੇਹੇ। ਇਤਿਹਾਸ ਇਹ ਲੱਭਣ ਲਈ ਬੇਕਾਰ ਹੋ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਟੁੱਟਿਆ।
• ਪੁਰਾਣੇ ਕੋਡ 'ਤੇ ਪ੍ਰੌਮਪਟ ਦੇਣਾ। ਜਦੋਂ ਕੋਈ ਹੋਰ ਵੀ ਬਦਲ ਰਿਹਾ ਹੋਵੇ, ਤਾਂ ਪਹਿਲਾਂ pull ਕਰੋ।
• ਗ਼ਲਤੀ ਠੀਕ ਕਰਨ ਲਈ force-push ਕਰਨਾ। ਇਹ ਹੋਰਾਂ ਦਾ ਕੰਮ ਮਿਟਾ ਸਕਦਾ ਹੈ। ਇਸ ਦੀ ਬਜਾਏ revert ਕਰੋ।
• node_modules ਕਮਿਟ ਕਰਨਾ। ਇਹ ਬਹੁਤ ਵੱਡਾ ਹੁੰਦਾ ਹੈ ਅਤੇ ਲਾਕ ਫ਼ਾਈਲ ਤੋਂ ਵਾਪਸ ਬਣ ਜਾਂਦਾ ਹੈ।

ਚੈੱਕਲਿਸਟ

• ਪ੍ਰੋਜੈਕਟ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਜੁੜਿਆ ਹੈ।
• .gitignore .env, node_modules, ਬਿਲਡ ਆਉਟਪੁੱਟ ਅਤੇ ਗੁਪਤ ਜਾਣਕਾਰੀ ਨੂੰ ਬਾਹਰ ਰੱਖਦਾ ਹੈ।
• ਮੈਂ ਹਰ ਕੰਮ ਵਾਲੇ ਬਦਲਾਅ ਤੋਂ ਬਾਅਦ ਕਮਿਟ ਕਰਦਾ ਹਾਂ।
• ਕਮਿਟ ਸੁਨੇਹੇ ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਦੱਸਦੇ ਹਨ ਕਿ ਕੀ ਬਦਲਿਆ।
• ਵੱਡੇ ਜਾਂ ਖ਼ਤਰੇ ਵਾਲੇ ਬਦਲਾਅ ਬ੍ਰਾਂਚ 'ਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਸਮੀਖਿਆ ਹੁੰਦੀ ਹੈ।
• ਜਦੋਂ ਕੋਈ ਹੋਰ ਕੋਡ ਬਦਲਦਾ ਹੈ, ਮੈਂ ਪ੍ਰੌਮਪਟ ਤੋਂ ਪਹਿਲਾਂ pull ਕਰਦਾ ਹਾਂ।
• ਮੈਂ ਚੈੱਕਪੌਇੰਟ ਜਾਂ git revert ਨਾਲ ਵਾਪਸ ਲੈਂਦਾ ਹਾਂ, force-push ਨਾਲ ਨਹੀਂ।
• ਜੇ ਕੋਈ ਕੀ ਕਦੇ ਕਮਿਟ ਹੋਈ ਸੀ, ਤਾਂ ਉਸ ਨੂੰ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ।

Mythex 'ਤੇ Git

Mythex ਹਰ ਸਫ਼ਲ ਏਜੰਟ ਵਾਰੀ ਤੋਂ ਬਾਅਦ git ਚੈੱਕਪੌਇੰਟ ਸੰਭਾਲਦਾ ਹੈ, ਅਤੇ Revert to this point ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਉਸ ਥਾਂ 'ਤੇ ਵਾਪਸ ਲੈ ਜਾਂਦਾ ਹੈ। ਇਹ ਉਹੀ ਬਿਲਡਰ ਵਾਲੇ ਪਾਸੇ ਦਾ ਅਣਡੂ ਹੈ ਜੋ ਕਦਮ 5 ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ। ਵੇਖੋ Iterate without rebuilding।

Pro 'ਤੇ, GitHub sync ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਜ਼ ਤੋਂ ਰਿਪੋਜ਼ਟਰੀ ਜੋੜਦਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਉਸ ਨਾਲ push ਅਤੇ pull ਕਰ ਸਕੋ, ਅਤੇ export ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਗੁਪਤ ਜਾਣਕਾਰੀ ਅਤੇ node_modules ਬਾਹਰ ਰਹਿੰਦੇ ਹਨ। ਵੇਖੋ GitHub, export, and import। ਕਿਸੇ ਡਿਵੈਲਪਰ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਸੌਂਪਣ ਤੋਂ ਪਹਿਲਾਂ GitHub ਜੋੜਨਾ ਹੈਂਡਆਫ ਨੂੰ ਬਹੁਤ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ। ਵੇਖੋ AI ਨਾਲ ਬਣੀ ਐਪ 'ਤੇ ਡਿਵੈਲਪਰ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰੀਏ ਅਤੇ AI ਨਾਲ ਬਣੀ ਐਪ ਨੂੰ ਐਕਸਪੋਰਟ ਅਤੇ ਆਪਣੇ ਸਰਵਰ 'ਤੇ ਕਿਵੇਂ ਚਲਾਈਏ।

ਸਵਾਲ