ਸਕ੍ਰਿਪਟਿੰਗ ਅਤੇ ਆਟੋਕੰਪਲੀਟ

ਲਾਭ:

• ਇਨਲਾਈਨ ਸੰਪੂਰਨਤਾ ਦੇ ਨਾਲ ਕੰਮ ਦੀ ਕਿਸਮ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਚੈਟ ਮੋਡ ਨੂੰ ਮੈਪ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਸ਼ਕਤੀਸ਼ਾਲੀ ਉਤਪਾਦਨ ਪ੍ਰੋਂਪਟ ਲਿਖਣ ਦੀ ਸਮਰੱਥਾ ਜਿਸ ਵਿੱਚ ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਕੰਟਰੈਕਟ, ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਅਤੇ ਸ਼ੈਲੀ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਸ਼ਾਮਲ ਹਨ
• ਅਭੇਦ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਅਤੇ ਕਿਸੇ ਵੀ ਨਵੀਂ ਪ੍ਰਸਤਾਵਿਤ ਨਿਰਭਰਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

AI ਦੇ ਨਾਲ ਇੱਕ ਡਿਵੈਲਪਰ ਦਾ ਸੰਪਰਕ ਦਾ ਪਹਿਲਾ ਬਿੰਦੂ ਅਕਸਰ ਸਵੈ-ਸੰਪੂਰਨ ਹੁੰਦਾ ਹੈ - ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਜੋ ਤੁਹਾਡੇ ਦੁਆਰਾ ਟਾਈਪ ਕਰਦੇ ਸਮੇਂ ਅਗਲੀ ਲਾਈਨ ਦਾ ਸੁਝਾਅ ਦਿੰਦੀ ਹੈ - ਜਾਂ ਇੱਕ ਚੈਟ ਵਿੰਡੋ ਵਿੱਚ "ਉਹ ਫੰਕਸ਼ਨ ਟਾਈਪ ਕਰੋ" ਕਹਿਣਾ। ਉਹ ਦੋਵੇਂ ਇੱਕੋ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਪਰ ਵੱਖ-ਵੱਖ ਅਨੁਸ਼ਾਸਨਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਅਸੀਂ ਕੋਡ ਜਨਰੇਸ਼ਨ ਨੂੰ ਇੱਕ ਬੇਤਰਤੀਬੇ "ਇਸ ਨੂੰ ਲਿਖੋ" ਤੋਂ ਇੱਕ ਇੰਜਨੀਅਰਿੰਗ ਪੜਾਅ ਵਿੱਚ ਬਦਲਦੇ ਹਾਂ ਜਿਸਦਾ ਆਉਟਪੁੱਟ ਅਨੁਮਾਨਿਤ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਹੈ।

ਟੀਚਾ ਏਆਈ ਨੂੰ ਇੱਕ ਅਜਿਹੇ ਟੂਲ ਤੋਂ ਬਦਲਣਾ ਹੈ ਜੋ ਤੁਹਾਡੀ ਟਾਈਪਿੰਗ ਮਸ਼ੀਨ ਨੂੰ ਇੱਕ ਅਪ੍ਰੈਂਟਿਸ ਵਿੱਚ ਤੇਜ਼ ਕਰਦਾ ਹੈ ਜੋ ਤੁਹਾਡੇ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਰੁਕਾਵਟਾਂ ਦੇ ਅੰਦਰ ਕੰਮ ਕਰਦਾ ਹੈ। ਇੱਕ ਚੰਗੀ ਸੇਧ ਵਾਲਾ ਅਪ੍ਰੈਂਟਿਸ ਸਮਾਂ ਬਚਾਉਂਦਾ ਹੈ; ਇੱਕ ਅਪ੍ਰੈਂਟਿਸ ਇੱਕ ਗੜਬੜ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜਿਸਨੂੰ ਤੁਹਾਨੂੰ ਬਾਅਦ ਵਿੱਚ ਸਾਫ਼ ਕਰਨਾ ਪੈਂਦਾ ਹੈ।

ਦੋ ਵਰਤੋਂ ਮੋਡ: ਇਨਲਾਈਨ ਸੰਪੂਰਨਤਾ ਅਤੇ ਚੈਟ

ਜਦੋਂ ਤੁਸੀਂ ਆਪਣੇ ਸੰਪਾਦਕ ਵਿੱਚ ਟਾਈਪ ਕਰਦੇ ਹੋ ਤਾਂ ਇਨਲਾਈਨ ਮੁਕੰਮਲ ਹੋ ਜਾਂਦੀ ਹੈ; ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਹਸਤਾਖਰ ਜਾਂ ਇੱਕ ਟਿੱਪਣੀ ਲਾਈਨ ਟਾਈਪ ਕਰੋ ਅਤੇ ਇਹ ਬਾਕੀ ਦਾ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ। ਇਹ ਗਤੀ ਲਈ ਬਹੁਤ ਵਧੀਆ ਹੈ, ਪਰ ਇਸਦਾ ਇੱਕ ਤੰਗ ਸੰਦਰਭ ਹੈ: ਇਹ ਕੇਵਲ ਤੁਰੰਤ ਖੇਤਰ ਵਿੱਚ ਕੋਡ ਵੇਖਦਾ ਹੈ। ਇਸ ਲਈ ਇਹ ਸਭ ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਟਿੱਪਣੀ ਵਿੱਚ ਆਪਣਾ ਇਰਾਦਾ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਲਿਖਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਉਪਭੋਗਤਾ ਈਮੇਲ // ਪ੍ਰਮਾਣਿਤ ਕਰੋ, ਪ੍ਰਮਾਣਿਕਤਾ ਗਲਤੀ ਸੁੱਟੋ ਜੇਕਰ ਅਵੈਧ ਟਿੱਪਣੀ ਹੇਠਾਂ ਦਿੱਤੇ ਸੁਝਾਅ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਸੁਧਾਰ ਕਰਦੀ ਹੈ।

ਚੈਟ ਮੋਡ ਵੱਡੇ ਅਤੇ ਢਾਂਚਾਗਤ ਕੰਮਾਂ ਲਈ ਹੈ: "ਇਸ ਕਲਾਸ ਵਿੱਚ ਪੰਨਾ ਨੰਬਰ ਜੋੜੋ", "ਉਸ ਸੇਵਾ ਦਾ ਇੱਕ ਇੰਟਰਫੇਸ ਕੱਢੋ"। ਇੱਥੇ ਤੁਹਾਡੇ ਕੋਲ ਭੂਮਿਕਾ, ਸੰਦਰਭ ਅਤੇ ਫਾਰਮੈਟ ਦੇਣ ਦੀ ਲਗਜ਼ਰੀ ਹੈ। ਆਮ ਨਿਯਮ ਹੈ: ਛੋਟੇ ਅਤੇ ਪ੍ਰਵਾਹ ਕਾਰਜਾਂ ਲਈ ਸੰਪੂਰਨਤਾ, ਉਹਨਾਂ ਕੰਮਾਂ ਲਈ ਗੱਲਬਾਤ ਜਿਨ੍ਹਾਂ ਲਈ ਸੋਚ ਅਤੇ ਢਾਂਚੇ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਸੁਝਾਅ: "ਟੈਬ" ਨਾਲ ਮੁਕੰਮਲ ਹੋਣ ਦੇ ਸੁਝਾਅ ਨੂੰ ਅੰਨ੍ਹੇਵਾਹ ਸਵੀਕਾਰ ਨਾ ਕਰੋ। ਇੱਕ ਸਕਿੰਟ ਲਈ ਸੁਝਾਏ ਗਏ ਲਾਈਨ ਨੂੰ ਪੜ੍ਹੋ; ਇੱਕ ਗਲਤ ਵੇਰੀਏਬਲ ਨਾਮ ਜਾਂ ਇੱਕ ਉਲਟ ਸਥਿਤੀ ਆਮ ਤੌਰ 'ਤੇ ਇੱਥੋਂ ਲੀਕ ਹੁੰਦੀ ਹੈ।

ਇਰਾਦੇ ਨੂੰ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨ ਲਈ ਕਦਮ

1. ਇਕਰਾਰਨਾਮੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ. ਫੰਕਸ਼ਨ ਦਾ ਇੰਪੁੱਟ, ਆਉਟਪੁੱਟ ਅਤੇ ਐਰਰ ਵਿਵਹਾਰ ਕੀ ਹੈ? ਜਿਵੇਂ ਕਿ "ਈਮੇਲ ਪ੍ਰਾਪਤ ਕਰੋ, ਜੇ ਵੈਧ ਹੋਵੇ ਤਾਂ ਆਮ ਬਣਾਓ, ਗਲਤ ਹੋਣ 'ਤੇ ਗਲਤੀ ਸੁੱਟੋ"।
2. ਪਾਬੰਦੀਆਂ ਦੱਸੋ। ਬਾਹਰੀ ਨਿਰਭਰਤਾ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ? ਇੱਕ ਖਾਸ ਸ਼ੈਲੀ ਗਾਈਡ? ਕੀ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਕੋਈ ਸੀਮਾ ਹੈ?
3. ਇੱਕ ਉਦਾਹਰਣ ਦਿਓ। ਇੱਕ ਇਨਪੁਟ–ਆਊਟਪੁੱਟ ਜੋੜਾ (“ali@x.com → ਵੈਧ, ali@ → ਗਲਤੀ”) ਮਾਡਲ ਦੀ ਇਰਾਦੇ ਦੀ ਸਮਝ ਨੂੰ ਪੂਰਵ-ਅਨੁਮਾਨ ਤੋਂ ਸ਼ੁੱਧਤਾ ਵੱਲ ਲੈ ਜਾਂਦਾ ਹੈ।
4. ਛੋਟੇ ਟੁਕੜਿਆਂ ਲਈ ਪੁੱਛੋ. ਇੱਕ ਕਾਰਜ, ਇੱਕ ਜ਼ਿੰਮੇਵਾਰੀ। ਫਿਰ ਅਗਲੇ ਇੱਕ 'ਤੇ ਜਾਓ.
5. ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਪੜ੍ਹੋ ਅਤੇ ਚਲਾਓ। ਕੰਪਾਇਲ ਕਰਨਾ + ਇੱਕ ਤੇਜ਼ ਮੈਨੂਅਲ ਕੋਸ਼ਿਸ਼ ਸਭ ਤੋਂ ਸਸਤਾ ਭਰੋਸਾ ਕਦਮ ਹੈ।

ਤਿੰਨ ਮਿੰਨੀ ਕੇਸ

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

ਕੇਸ 2 - ਇੱਕ ਸੰਸਕਰਣ ਨਿਰਧਾਰਤ ਨਾ ਕਰਨਾ ਮਹਿੰਗਾ ਹੈ। ਇੱਕ ਟੀਮ ਨੇ Node.js ਲਈ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਵਿੱਚ fs.promises ਨੂੰ ਬਦਲਣ ਵਾਲੀ ਵਿਰਾਸਤੀ ਕਾਲਬੈਕ-ਅਧਾਰਿਤ API ਨਾਲ ਸੰਘਰਸ਼ ਕੀਤਾ। ਜਦੋਂ ਲਾਈਨ "Use Node 20, ESM, async/await" ਨੂੰ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ, ਤਾਂ ਉਤਪਾਦਨ ਨੇ ਪਹਿਲੀ ਵਾਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਅਨੁਸਰਣ ਕੀਤਾ; ਸੁਧਾਰ 'ਤੇ ਬਿਤਾਏ ਗਏ 12 ਮਿੰਟਾਂ ਦੀ ਔਸਤ ਰੀਸੈਟ ਕੀਤੀ ਗਈ ਸੀ।

ਕੇਸ 3 - ਬੋਇਲਰਪਲੇਟ ਕੋਡ ਵਿੱਚ ਅਸਲ ਲਾਭ। ਇੱਕ ਮਾਈਕ੍ਰੋਸਰਵਿਸ ਲਈ 6 ਨਵੇਂ ਡੀਟੀਓ (ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਆਬਜੈਕਟ — ਇੱਕ ਸਧਾਰਨ ਡੇਟਾ ਕਲਾਸ ਜੋ ਲੇਅਰਾਂ ਦੇ ਵਿਚਕਾਰ ਡੇਟਾ ਰੱਖਦਾ ਹੈ) ਅਤੇ ਉਹਨਾਂ ਦੇ ਪ੍ਰਮਾਣਿਕਤਾ ਨਿਯਮਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਅਤੇ ਸਮੀਖਿਆ ਕੀਤੇ ਜਾਣ 'ਤੇ ਲਗਭਗ 90 ਮਿੰਟਾਂ ਦੇ ਮੈਨੂਅਲ ਕੰਮ ਨੂੰ ਘਟਾ ਕੇ 35 ਮਿੰਟ ਕਰ ਦਿੱਤਾ ਗਿਆ ਸੀ; ਕਿਉਂਕਿ ਕੋਡ ਦੁਹਰਾਓ ਉੱਚਾ ਹੈ ਅਤੇ ਪੈਟਰਨ ਸਪਸ਼ਟ ਹੈ, ਏਆਈ ਨੇ ਇੱਥੇ ਆਪਣੇ ਸਭ ਤੋਂ ਕੁਸ਼ਲ ਖੇਤਰ ਵਿੱਚ ਕੰਮ ਕੀਤਾ ਹੈ।

ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਨਮੂਨੇ

ਕੰਟਰੈਕਟ-ਆਧਾਰਿਤ ਫੰਕਸ਼ਨ ਪੀੜ੍ਹੀ:

ਭੂਮਿਕਾ: ਤੁਸੀਂ ਇੱਕ ਮਿਹਨਤੀ {{language}} ਡਿਵੈਲਪਰ ਹੋ। ਫੰਕਸ਼ਨ ਇਕਰਾਰਨਾਮਾ:- ਨਾਮ: {{name}}- ਇਨਪੁਟ: {{ਕਿਸਮਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਰਥ}}- ਆਉਟਪੁੱਟ: {{ਕਿਸਮ ਅਤੇ ਅਰਥ}}- ਗਲਤੀ ਸਥਿਤੀ: {{what is thrown/returned when}}ਬੰਧਨਾਂ: {{no external dependences/input/input/input/input}} {{no external dependences/input}}-{_amp>> {{output_1}}- {{entry_2}} -> {{error_2}}ਪਹਿਲਾਂ ਦਸਤਖਤ + ਛੋਟਾ ਪਲਾਨ ਦਿਓ, ਫਿਰ ਕੋਡ। ਲਿਖਤੀ ਟੈਸਟ, ਸਿਰਫ਼ ਫੰਕਸ਼ਨ।

ਮੌਜੂਦਾ ਸ਼ੈਲੀ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ (ਕੋਡ ਅਧਾਰ ਦੇ ਅਨੁਕੂਲ):

ਹੇਠਾਂ ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਇੱਕ ਉਦਾਹਰਨ ਫੰਕਸ਼ਨ ਹੈ; ਇੱਥੇ ਨਾਮਕਰਨ, ਗਲਤੀ ਸੰਭਾਲਣ ਅਤੇ ਟਿੱਪਣੀ ਕਰਨ ਦੀ ਸ਼ੈਲੀ ਸਿੱਖੋ। ਇੱਕੋ ਸ਼ੈਲੀ ਨਾਲ {{new_task}} ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ। ਉਦਾਹਰਨ: {{current_code}}

ਪਿੰਜਰ ਤੋਂ ਭਰਨ ਤੱਕ (ਸਟੱਬ → ਲਾਗੂ ਕਰਨਾ):

ਟਿੱਪਣੀਆਂ ਵਿੱਚ TODOs ਦੇ ਅਨੁਸਾਰ ਹੇਠਾਂ ਫੰਕਸ਼ਨ ਪਿੰਜਰ ਭਰੋ। ਦਸਤਖਤ ਅਤੇ ਵਾਪਸੀ ਦੀ ਕਿਸਮ ਬਦਲੋ। ਕੋਈ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਨਾ ਬਣਾਓ ਜੋ ਮੌਜੂਦ ਨਹੀਂ ਹੈ; ਜੇ ਲੋੜ ਹੋਵੇ, ਮੈਨੂੰ ਦੱਸੋ "ਇਸ ਸਹਾਇਕ ਦੀ ਲੋੜ ਹੈ"। {{ਸਕਲੇਟ_ਕੋਡ}}

ਵਿਕਲਪਿਕ ਐਪ ਤੁਲਨਾ:

{{task}} ਲਈ 2 ਵੱਖ-ਵੱਖ ਲਾਗੂਕਰਨ ਦਿਓ: (a) ਪੜ੍ਹਨਯੋਗਤਾ ਨੂੰ ਤਰਜੀਹ ਦੇਣਾ, (b) ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਤਰਜੀਹ ਦੇਣਾ। ਹਰ ਇੱਕ ਦੇ ਹੇਠਾਂ 1 ਵਾਕ "ਜਦੋਂ ਤਰਜੀਹੀ ਹੋਵੇ" ਲਿਖੋ।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "ਮੈਨੂੰ ਇੱਕ ਈਮੇਲ ਤਸਦੀਕ ਫੰਕਸ਼ਨ ਲਿਖੋ।"

ਮਜ਼ਬੂਤ: "TypeScript 5, ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਸਿਰਫ਼। isValidEmail(ਇਨਪੁਟ: ਸਤਰ): ਬੁਲੀਅਨ ਲਿਖੋ। ਸਪੇਸ ਨੂੰ ਟ੍ਰਿਮ ਕਰੋ, ਇਸ ਨੂੰ ਕੇਸ ਅਸੰਵੇਦਨਸ਼ੀਲ ਬਣਾਓ, a@b.co ਵੈਧ ਹੈ, a@, @b.co, ਖਾਲੀ ਸਤਰ ਅਵੈਧ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ regex ਦੀ ਵਰਤੋਂ ਕਰਨ ਜਾ ਰਹੇ ਹੋ, ਤਾਂ ਗੁੰਝਲਦਾਰ ਟਿੱਪਣੀਆਂ 2 ਨਾ ਜੋੜੋ।"

ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੰਸਕਰਣ; ਭਾਸ਼ਾ, ਸੰਸਕਰਣ, ਹਸਤਾਖਰ, ਕਿਨਾਰੇ ਦੇ ਕੇਸ, ਅਤੇ ਇੱਕ ਸ਼ੈਲੀ ਦੀ ਰੁਕਾਵਟ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ, ਤਿਆਰ ਕੀਤਾ ਕੋਡ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿੱਟ ਕਰਦਾ ਹੈ।

ਪਹੁੰਚ

ਕਦੋਂ ਵਰਤਣਾ ਹੈ

ਧਿਆਨ

ਇਨਲਾਈਨ ਸੰਪੂਰਨਤਾ

ਵਹਾਅ ਵਿੱਚ ਛੋਟੇ ਸੰਮਿਲਨ

ਇਸ ਨੂੰ ਪੜ੍ਹੇ ਬਿਨਾਂ ਸੁਝਾਅ ਨੂੰ ਸਵੀਕਾਰ ਨਾ ਕਰੋ

ਗੱਲਬਾਤ ਵਿੱਚ ਕੰਟਰੈਕਟ ਅਧਾਰਤ ਉਤਪਾਦਨ

ਨਵਾਂ ਫੰਕਸ਼ਨ/ਕਲਾਸ

ਉਦਾਹਰਨ ਅਤੇ ਕਿਨਾਰੇ ਕੇਸ ਦਿਓ

ਸ਼ੈਲੀ ਦੇ ਨਮੂਨੇ ਦੁਆਰਾ ਉਤਪਾਦਨ

ਮੌਜੂਦਾ ਕੋਡ ਵਿੱਚ ਜੋੜਿਆ ਜਾ ਰਿਹਾ ਹੈ

ਮੌਜੂਦਾ ਨਮੂਨਾ ਕੋਡ ਚੁਣੋ

ਪਿੰਜਰ ਭਰਾਈ

ਦਸਤਖਤ ਸਥਿਰ, ਸਰੀਰ ਖਾਲੀ

ਦਸਤਖਤ ਬਦਲਣਾ

ਕੋਡ ਡੁਪਲੀਕੇਸ਼ਨ ਅਤੇ ਨਿਰਭਰਤਾ ਜਾਲ

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

ਸਾਵਧਾਨ: AI ਦੁਆਰਾ ਸੁਝਾਏ ਗਏ ਆਯਾਤ ਲਾਈਨਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰੋ। ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਪੈਕੇਜ ਨਾਮ (ਜੋ ਕਿ "ਟਾਇਪੋ-ਸਕੁਏਟਿੰਗ" ਕਹੇ ਜਾਂਦੇ ਨਕਲੀ ਪੈਕੇਜਾਂ ਦੇ ਸਮਾਨ ਵੀ ਹੋ ਸਕਦਾ ਹੈ) ਸੰਕਲਨ ਨੂੰ ਤੋੜਦਾ ਹੈ ਅਤੇ ਸੁਰੱਖਿਆ ਜੋਖਮ ਪੈਦਾ ਕਰਦਾ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

• ਮਾਡਲ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਦਸਤਖਤ ਹੋਣ। ਜੇਕਰ ਤੁਸੀਂ ਇਨਪੁਟ/ਆਉਟਪੁੱਟ ਕਿਸਮਾਂ ਨੂੰ ਠੀਕ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਹਰੇਕ ਉਤਪਾਦਨ ਦੇ ਨਾਲ ਇੱਕ ਵੱਖਰਾ ਦਸਤਖਤ ਆਉਂਦਾ ਹੈ ਅਤੇ ਏਕੀਕਰਣ ਮੁਸ਼ਕਲ ਹੋ ਜਾਂਦਾ ਹੈ।
• ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਦਾ ਜ਼ਿਕਰ ਨਾ ਕਰਨਾ. ਖਾਲੀ ਇੰਪੁੱਟ, ਨਲ, ਨਕਾਰਾਤਮਕ ਸੰਖਿਆ, ਬਹੁਤ ਵੱਡਾ ਮੁੱਲ — ਜੇਕਰ ਤੁਸੀਂ ਇਹਨਾਂ ਨੂੰ ਨਿਸ਼ਚਿਤ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਮਾਡਲ "ਖੁਸ਼ਹਾਲ ਮਾਰਗ" ਲਿਖਦਾ ਹੈ, ਕਿਨਾਰਿਆਂ ਨੂੰ ਛੱਡਦਾ ਹੈ।
• ਇਸ ਦੀ ਜਾਂਚ ਕੀਤੇ ਬਿਨਾਂ ਸੁਝਾਅ ਨੂੰ ਜੋੜਨਾ. ਕੋਡ ਜੋ ਕੰਮ ਕਰਦਾ ਜਾਪਦਾ ਹੈ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ।
• ਬੇਲੋੜੀ ਨਿਰਭਰਤਾ ਨੂੰ ਸਵੀਕਾਰ ਕਰਨਾ. ਇੱਕ-ਲਾਈਨਰ ਲਈ ਇੱਕ ਪੂਰੀ ਲਾਇਬ੍ਰੇਰੀ ਜੋੜਨ ਨਾਲ ਤਕਨੀਕੀ ਕਰਜ਼ਾ ਬਣਦਾ ਹੈ।
• ਸ਼ੈਲੀ ਦੀ ਅਸੰਗਤਤਾ। ਬਾਕੀ ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਵੱਖਰਾ ਨਾਮਕਰਨ ਅਤੇ ਗਲਤੀ ਹੈਂਡਲਿੰਗ ਕੋਡ ਬੇਸ ਨੂੰ ਖਰਾਬ ਬਣਾਉਂਦੀ ਹੈ।

ਸੰਖੇਪ ਵਿੱਚ

ਜਦੋਂ ਤੁਸੀਂ ਇਰਾਦੇ ਨੂੰ ਸਪਸ਼ਟ ਇਕਰਾਰਨਾਮੇ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦੇ ਹੋ ਤਾਂ ਕੋਡ ਬਣਾਉਣਾ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੁੰਦਾ ਹੈ। ਛੋਟੇ, ਇਨ-ਸਟ੍ਰੀਮ ਕਾਰਜਾਂ, ਅਤੇ ਗੱਲਬਾਤ ਵਿੱਚ ਢਾਂਚਾ ਸਥਾਪਤ ਕਰਨ ਵਾਲੇ ਕੰਮਾਂ ਲਈ ਇਨਲਾਈਨ ਸੰਪੂਰਨਤਾ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਤੁਸੀਂ ਇੰਪੁੱਟ/ਆਉਟਪੁੱਟ ਕਿਸਮ, ਕਿਨਾਰੇ ਦੇ ਕੇਸ, ਸੰਸਕਰਣ, ਅਤੇ ਸ਼ੈਲੀ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ; ਮਾਡਲ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਦਿਓ; ਹਰੇਕ ਨਵੀਂ ਨਿਰਭਰਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ; ਅਤੇ ਤਿਆਰ ਕੀਤੇ ਹਰ ਟੁਕੜੇ ਨੂੰ ਚਲਾਓ ਅਤੇ ਪੜ੍ਹੋ। AI ਫਾਰਮੂਲੇਕ, ਦੁਹਰਾਉਣ ਵਾਲੇ ਕੋਡ ਵਿੱਚ ਸਭ ਤੋਂ ਵਧੀਆ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ — ਇਸਨੂੰ ਤੁਹਾਡੇ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਸੀਮਾਵਾਂ ਦੇ ਅੰਦਰ, ਉੱਥੇ ਚਲਾਓ।

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚੋਂ ਇੱਕ ਅਸਲ ਛੋਟਾ ਫੰਕਸ਼ਨ ਚੁਣੋ ਜੋ ਤੁਹਾਨੂੰ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ। ਪਹਿਲਾਂ ਇਸਨੂੰ "ਕੰਟਰੈਕਟ-ਅਧਾਰਿਤ ਫੰਕਸ਼ਨ ਜਨਰੇਸ਼ਨ" ਟੈਮਪਲੇਟ ਦੇ ਨਾਲ AI 'ਤੇ ਪ੍ਰਿੰਟ ਕਰੋ, ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਕਿਸਮਾਂ, ਦੋ ਕਿਨਾਰਿਆਂ ਦੇ ਕੇਸਾਂ, ਅਤੇ ਇੱਕ ਸ਼ੈਲੀ ਦੀ ਰੁਕਾਵਟ ਦੇ ਨਾਲ। ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਕੰਪਾਇਲ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਇਨਪੁਟਸ ਨਾਲ ਅਜ਼ਮਾਓ। ਫਿਰ ਉਸੇ ਫੰਕਸ਼ਨ ਨੂੰ ਦੁਬਾਰਾ ਪੁੱਛੋ, ਇਸ ਵਾਰ "ਮੈਨੂੰ ਇਹ ਲਿਖੋ" ਬਿਨਾਂ ਕਿਸੇ ਸੰਦਰਭ ਦੇ, ਅਤੇ ਦੋ ਆਉਟਪੁੱਟ ਲਾਈਨਾਂ ਦੀ ਲਾਈਨ ਦੁਆਰਾ ਤੁਲਨਾ ਕਰੋ: ਕਿਹੜੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸ ਖੁੰਝ ਗਏ, ਕਿੰਨੇ ਸੁਧਾਰਾਂ ਦੀ ਲੋੜ ਸੀ?

ਚੈੱਕਲਿਸਟ

• [ ] ਮੈਨੂੰ ਪਤਾ ਹੈ ਕਿ ਇਨਲਾਈਨ ਸੰਪੂਰਨਤਾ ਦੇ ਨਾਲ ਚੈਟ ਮੋਡ ਕਿੱਥੇ ਵਰਤਣਾ ਹੈ।
• ਮੈਂ ਫੰਕਸ਼ਨ ਜਨਰੇਸ਼ਨ ਵਿੱਚ ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਕੰਟਰੈਕਟ ਅਤੇ ਕਿਨਾਰੇ ਦੇ ਕੇਸਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹਾਂ।
• [ ] ਮੈਂ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਭਾਸ਼ਾ ਅਤੇ ਸੰਸਕਰਣ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਆਦਤ ਬਣਾ ਦਿੱਤੀ ਹੈ।
• [ ] ਮੈਂ ਇਸ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹਰੇਕ ਉਤਪਾਦਿਤ ਟੁਕੜੇ ਨੂੰ ਕੰਪਾਇਲ ਅਤੇ ਟੈਸਟ ਕਰਦਾ ਹਾਂ।
• [ ] ਮੈਂ ਹਰ ਨਵੀਂ ਨਿਰਭਰਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹਾਂ ਜੋ AI ਦੁਆਰਾ ਪ੍ਰਸਤਾਵਿਤ ਹੈ ਇਸਦੀ ਮੌਜੂਦਗੀ ਅਤੇ ਲੋੜ ਦੀ ਪੁਸ਼ਟੀ ਕਰਕੇ।
• [ ] ਮੈਂ ਜਾਂਚ ਕਰਦਾ ਹਾਂ ਕਿ ਤਿਆਰ ਕੀਤਾ ਕੋਡ ਪ੍ਰੋਜੈਕਟ ਦੀ ਸ਼ੈਲੀ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।