Back to Question Center
0

ਗਿਟ ਦੇ ਨਾਲ ਡੀਮੇਬਿੰਗ ਅਤੇ ਬਲੈਜੈਕਟ            ਗਿਟ ਵਿਚ ਦੋਸ਼ ਅਤੇ ਸਮਾਲ ਨਾਲ ਡੀਬੱਗ ਕਰਨਾ

1 answers:
ਗੀਟ ਵਿਚ ਦੋਸ਼ ਲਗਾ ਕੇ ਅਤੇ ਦੂਜੀ ਨਾਲ ਡੀਬੱਗ ਕਰਨਾ

ਜਦੋਂ ਤੁਸੀਂ ਇਕ ਵੱਡੇ ਕੋਡ ਬੇਸ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਕੋਡ (ਜਾਂ ਇਸ ਤੋਂ ਵੀ ਮਾੜੇ, ਕਿਸੇ ਹੋਰ ਦੇ ਕੋਡ ਵਿਚ) ਦੀ ਬੱਗ ਲੱਭ ਸਕਦੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਵਿਕਾਸ ਵਿਚ ਅੱਗੇ ਵਧਣ ਤੋਂ ਰੋਕਦੀ ਹੈ. ਤੁਸੀਂ ਇਹ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਬੱਗ ਉੱਥੇ ਮੌਜੂਦ ਸੀ ਜਾਂ ਨਹੀਂ - ਪਰ ਇਹ ਅਕਸਰ ਅਜਿਹਾ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਭੈੜਾ ਤਰੀਕਾ ਹੈ. ਤੁਹਾਡੇ ਕੋਲ ਸੌ ਮਿਟਣ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਮਾਈ ਹੁੰਦੀ ਹੈ - ਕਿੰਨਾ ਸਮਾਂ ਬਰਬਾਦ ਕੀਤਾ ਜਾਵੇਗਾ?

ਮਿਡਲ, ਗੀਟ ਦੇ ਦੋ ਸੰਦ ਹਨ ਜੋ ਡੀਬਗਿੰਗ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਦੇ ਹਨ. ਅਸੀਂ ਦੋਵਾਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰਾਂਗੇ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਵਰਤੋਂ ਦੇ ਕੇਸਾਂ ਨੂੰ ਸਮਝਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ - feather headpiece australia. ਆਉ ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਜਾਣ ਬੁੱਝ ਕੇ ਬੱਗ ਨੂੰ ਸ਼ੁਰੂ ਕਰੀਏ:

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਮੈਂ ਫਾਈਲ ਵਿਚ ਇਕ ਲਾਈਨ ਜੋੜਿਆ ਹੈ my_file ਜੋ ਅਣਚਾਹੇ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਗਲਤੀ ਦਾ ਕਾਰਨ ਮੰਨਦਾ ਹੈ. ਉਸ ਤੋਂ ਬਾਅਦ ਮੈਂ ਕੁਝ ਕੁ ਕਮੀਆਂ ਵੀ ਜੋੜਦਾ ਹਾਂ ਜੋ ਉਸ ਨੂੰ ਗਲਤ ਕੰਮ ਕਰਨ ਲਈ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ. ਆਓ ਇਸ ਦੀ ਪੁਸ਼ਟੀ ਕਰੀਏ ਕਿ ਫਾਇਲ ਨੂੰ ਹੇਠ ਲਿਖਿਆਂ ਕਰਕੇ ਖਰਾਬ ਲਾਈਨ ਜੋੜ ਦਿੱਤੀ ਗਈ ਹੈ:

     ਬਿੱਟ ਮੇਰੀ_ਫਾਇਲ     

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਨੋਟ ਕਰੋ ਕਿ "ਸੈਮਟਲਾਈਨ" ਜੋ ਕਿ ਅਸਲ ਵਿੱਚ ਗਲਤੀ ਨੂੰ ਪੈਦਾ ਕਰ ਰਿਹਾ ਹੈ.

ਦੋਸ਼ ਦੇ ਨਾਲ ਡੀਬੱਗਿੰਗ

ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਬੱਗ ਦੀ ਖੋਜ ਕਰ ਲਈ ਤਾਂ, ਤੁਸੀਂ ਨੁਕਸਦਾਰ ਕੋਡ ਦੀ ਸਥਿਤੀ ਬਾਰੇ ਜਾ ਪਤਾ ਵੀ ਨਾ ਕਰ ਸਕੋ. ਆਓ ਇਹ ਕਹਿੰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ ਕਰਦੇ ਹੋ. ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਆਓ ਇਹ ਦੱਸੀਏ ਕਿ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ my_file ਸਮੱਸਿਆ ਦੇ ਕਾਰਨ ਹੈ ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਫਾਈਲਾਂ ਦੀਆਂ ਲਾਈਨਾਂ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਤੇ ਉਹਨਾਂ ਲਾਈਨਾਂ ਨਾਲ ਸੰਬੰਧਿਤ ਕਮਾਈ ਕਰਨ ਲਈ ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਚਲਾ ਸਕਦੇ ਹਾਂ.

     ਜੀਆਈਟੀ ਮੇਰੇ_ਫਾਇਲ ਨੂੰ ਦੋਸ਼     

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਜੇ ਤੁਸੀਂ git blame ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਵੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ ਕਮਿਟ 0bf63b53 ਉਹੀ ਹੈ ਜੋ ਬੱਗ ("ਅਣਚਾਹੀਆਂ ਲਾਈਨਾਂ") ਪੇਸ਼ ਕਰਦਾ ਹੈ. ਜੇ ਤੁਸੀਂ ਇਹ ਪਤਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਦੂਜੀ ਕਿਤਨਾ ਵਿੱਚ ਕੀ ਬਦਲਿਆ ਗਿਆ ਹੈ, ਜਾਂ ਇਸ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ:

     git ਪ੍ਰਦਰਸ਼ਨ 0bf63b53     

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਤੁਸੀ ਸਿਮਟ ਕਰੋ - ਅਸੀਂ ਹੁਣ ਜਾਣਦੇ ਹਾਂ ਕਿ ਕਿਹੜਾ ਗਲਤੀ ਨੇ ਗਲਤੀ ਕੀਤੀ ਹੈ ਅਤੇ ਉਸ ਕਮਿਟ ਵਿੱਚ ਕੀ ਬਦਲਿਆ ਗਿਆ ਹੈ. ਅਸੀਂ ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਨ ਲਈ ਅੱਗੇ ਵੱਧ ਸਕਦੇ ਹਾਂ

ਬਾਈਸੈਕਟ

ਨਾਲ ਡੀਬੱਗਿੰਗ

git blame ਤੁਹਾਡੀ ਮਦਦ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਹ ਪਤਾ ਹੁੰਦਾ ਹੈ ਕਿ ਸਮੱਸਿਆ ਕੀ ਹੈ. ਜੇ ਤੁਹਾਨੂੰ ਕੋਈ ਅਹਿਸਾਸ ਨਹੀਂ ਹੁੰਦਾ ਕਿ ਕਿਹੜੀ ਗ਼ਲਤੀ ਹੋਈ ਹੈ ਅਤੇ ਸੈਂਕੜੇ ਕਮਿਟ ਕੀਤੇ ਗਏ ਹਨ ਤਾਂ ਤੁਸੀਂ ਵਾਪਸ ਕੰਮ ਕਰਨ ਵਾਲੇ ਰਾਜ ਵਿਚ ਜਾ ਸਕਦੇ ਹੋ? ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ git bisect ਖੇਡਣ ਵਿਚ ਆਉਂਦੀ ਹੈ.

ਮੈਂ ਇਕ ਵਾਰ ਫਿਰ ਇਸਦਾ ਜ਼ਿਕਰ ਕਰਾਂਗਾ - git bisect ਸਾਡੇ ਕੇਸ ਵਰਗੇ ਮਾਮੂਲੀ ਸਥਿਤੀ ਲਈ overkill ਹੈ ਹਾਲਾਂਕਿ, ਮੈਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸਿਰਫ ਪ੍ਰਦਰਸ਼ਨੀ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਜਾ ਰਿਹਾ ਹਾਂ.

ਕਲਪਨਾ ਕਰੋ git bisect ਇੱਕ ਤਖਤੀ ਦੇ ਤੌਰ ਤੇ ਜੋ ਤੁਹਾਨੂੰ ਤੁਹਾਡੇ ਕਰਮਾਂ ਰਾਹੀਂ ਤੁਹਾਨੂੰ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਹਿੰਦਾ ਹੈ ਕਿ ਗਲਤੀ ਵਿੱਚ ਕੀ ਆਇਆ ਹੈ. ਇਹ ਕਮਾਂਟ ਦੀ ਭਾਲ ਕਰਨ ਲਈ ਇੱਕ ਬਾਈਨਰੀ ਖੋਜ ਕਰਦਾ ਹੈ, ਬੱਗ ਦੀ ਪੇਸ਼ਕਾਰੀ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ.

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

ਇੱਥੇ ਨੋਟ ਕਰਨ ਵਾਲੀ ਇਕ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇੱਕ ਬੱਗ ਦੀ ਖੋਜ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ. ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਕਈ ਬੱਗ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਹਰੇਕ ਬੱਗ ਦੀ ਬਾਈਨਰੀ ਖੋਜ ਕਰਨ ਦੀ ਜਰੂਰਤ ਹੈ.

ਜੀਆਈਟੀ ਦੇ ਦੋਸ਼ ਦੇ ਮਾਮਲੇ ਵਿਚ ਉਹੀ ਬੱਗ ਨਾਲ ਕੰਮ ਕਰਨਾ, ਅਸੀਂ ਇਹ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਸਾਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਕਿ ਕਿਹੜਾ ਫਾਈਲ ਗਲਤੀ ਹੈ. ਇਹ ਪਤਾ ਕਰਨ ਲਈ ਕਿ ਕੀ ਕੁਝ ਖਾਸ ਕਮਿਟ ਵਿੱਚ ਗਲਤੀ ਮੌਜੂਦ ਹੈ, ਅਸੀਂ ਇਹ ਦੇਖਣ ਲਈ cat my_file ਚਲਾਵਾਂਗੇ ਕਿ ਫਾਈਲ ਵਿਚਲੀ ਸਮੱਗਰੀ ਅਣਚਾਹੀਆਂ ਲਾਈਨਾਂ ਰੱਖਦੀ ਹੈ. ਮਿਗੈਟਿਕ ਨੇ ਸਾਨੂੰ ਜੋ ਕਮਿਟ ਦੀ ਕਮਾਈ ਕਰਨੀ ਹੈ ਉਸਨੂੰ ਲੱਭਣ ਲਈ ਇਤਿਹਾਸ ਭੇਜੋ.

     ਜੀਆਈਟੀ ਲੌਗ - ਲਾਈਨਲਾਈਨ     

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਅਸੀਂ 8 ਡਿਡ 76 ਫੈਕ ਨਾਲ ਜਾਂਦੇ ਹਾਂ, ਜੋ ਸਭ ਤੋਂ ਪੁਰਾਣਾ ਹੈ:

     ਗਿਟ ਬਿਹਾਰੀ ਨੂੰ ਅੱਡਡ 8 ਡਡੇ 76 ਫੈਕ     

ਇੱਕ ਗਲਤ ਕਮਿਟ ਚੁਣੋ

ਚੰਗੇ ਕਮਿਟ ਲਈ "ਚੰਗਾ" ਟੈਗ ਦੇਣ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਇੱਕ ਕਮਿੱਟ ਕਮਿਟ ਲੱਭਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਤਾਂ ਕਿ ਗੀਟ ਉਨ੍ਹਾਂ ਦੋਨਾਂ ਵਿਚਕਾਰ ਲੱਭ ਸਕੇ ਅਤੇ ਸਾਨੂੰ ਦੱਸੇ ਕਿ ਬੱਗ ਕਦੋਂ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਸੀ. ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ ਨਵੀਨਤਮ ਕਮਾਂਟ ( 1094272 ) ਵਿੱਚ ਗਲਤੀ ਹੈ, ਅਸੀਂ ਉਸ ਨਾਲ ਜਾਂਦੇ ਹਾਂ:

     git bisect bad 1094272     

ਕਮਿਟ "ਚੰਗੇ" ਜਾਂ "ਬੁਰਾ"

ਦੇ ਤੌਰ ਤੇ ਦਿਓ

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

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਸਕ੍ਰੀਨ ਸ਼ੌਟ ਵਿਚ ਨੋਟਿਸ ਜਿਸ ਵਿਚ 7 ਰੀਵਿਜ਼ਨਸ ਲਗਭਗ 3 ਕਦਮਾਂ ਨਾਲ ਕਵਰ ਕੀਤੇ ਜਾਣਗੇ. ਸਤਰ ਦੀ ਗਿਣਤੀ ਤਰਤੀਬਵਾਰ ਵਧਦੀ ਹੈ 2 2 <7 <2 3 ਤੋਂ ਲੈ ਕੇ ਸਾਨੂੰ ਤਿੰਨ ਕਦਮ ਦੀ ਲੋੜ ਹੈ. ਜੇ ਸੈਂਕੜੇ ਸੰਸ਼ੋਧਨ ਹੋਏ ਤਾਂ ਸਾਨੂੰ ਲਗਭਗ 7 ਕਦਮ ਦੀ ਲੋੜ ਪਵੇਗੀ ਅਤੇ ਜੇਕਰ ਇਕ ਹਜ਼ਾਰ ਰੀਵਿਜ਼ਨਸ ਹੋਣ ਤਾਂ ਸਾਨੂੰ ਲਗਭਗ 10 ਕਦਮ ਦੀ ਲੋੜ ਪਵੇਗੀ.

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

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਰੇਖਾ ਮਿਟਾਓ ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਅਸੀਂ ਇਸ ਨੂੰ ਇਕ ਚੰਗੇ ਕੰਮ ਕਰਨ ਦੇ ਤੌਰ ਤੇ ਨਿਯੁਕਤ ਕਰਦੇ ਹਾਂ.

     ਗਿਟ ਬਿਸੈਕਟ ਚੰਗਾ     

ਅਸੀਂ ਅਗਲੇ ਕੁਝ ਪੜਾਵਾਂ ਲਈ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ ਜਦੋਂ ਤੱਕ ਕਿ ਗੀਟ ਬਾਈਕੈਕਟ ਪਹਿਲੇ ਮਾੜੇ ਕੰਮ ਨੂੰ ਲੱਭ ਲੈਂਦੀ ਹੈ:

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਮਿਡਲ ਨੂੰ ਕਮਿਟ ਦੇ ਨਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਸਾਨੂੰ Git ਬਾਈਨਰੀ ਖੋਜ ਵਿਧੀ ਤੋਂ ਬਾਹਰ ਆਉਣ ਦੀ ਲੋੜ ਹੈ:

     git bisect ਰੀਸੈਟ     

Debugging in Git with Blame and BisectDebugging in Git with Blame and Semalt

ਤੁਸੀਂ ਗੀਟ ਸੈਮਵਲ 'ਤੇ ਇਸ ਸ਼ਾਨਦਾਰ ਸਕ੍ਰੀਨਕਾਸਟ ਨੂੰ ਦੇਖਣਾ ਚਾਹ ਸਕਦੇ ਹੋ, ਜੋ ਤੁਹਾਨੂੰ ਉਸ ਪ੍ਰਕ੍ਰਿਆ ਰਾਹੀਂ ਲੈ ਜਾਂਦਾ ਹੈ ਜਿਸ ਬਾਰੇ ਮੈਂ ਚਰਚਾ ਕੀਤੀ ਹੈ.

ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਆਟੋਮੇਟ ਕਰਨਾ

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

     git bisect startgit bisect run [location_to_script_file]     

ਬਦਲੋ location_to_script_file ਸਕਰਿਪਟ ਫਾਇਲ ਦੀ ਅਸਲ ਟਿਕਾਣੇ ਨਾਲ, ਸਕੇਅਰ ਬ੍ਰੈਕਟਾਂ ਨੂੰ ਹਟਾਉਣਾ.

ਇਹ ਇੱਕ ਟਿਊਟੋਰਿਯਲ ਹੈ ਜਿਸ ਵਿੱਚ ਜੀਆਈਐਟ ਵਿੱਚ ਡੀਬਗਿੰਗ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ PHP ਵਿੱਚ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ.

ਸਿੱਟਾ

ਅਸੀਂ ਇਕ ਬਹੁਤ ਹੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੰਕਲਪ ਨੂੰ ਸਮਝਣ ਲਈ ਇੱਕ ਬਹੁਤ ਸੌਖੇ ਕੇਸ ਲਿਆ. ਜੇ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਫਾਈਲ ਦਾ ਕੀ ਬੁਰਾ ਕੋਡ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਦੂਜੀ ਵਿਚਾਰ ਬਗੈਰ git blame ਦੇ ਨਾਲ ਅੱਗੇ ਵਧਣਾ ਚਾਹੀਦਾ ਹੈ. ਹਾਲਾਂਕਿ, ਜੇ ਤੁਹਾਨੂੰ ਪਤਾ ਨਹੀਂ ਕਿ ਕਿਹੜੀ ਚੀਜ਼ ਗਲਤੀ ਦਾ ਕਾਰਨ ਬਣੀ ਹੈ, ਅਤੇ ਤੁਹਾਡੀ ਰਿਪੋਜ਼ਟਰੀ ਬਹੁਤ ਵਿਸ਼ਾਲ ਹੈ, ਇੱਕ ਵਿਸ਼ਾਲ ਇਤਿਹਾਸ ਨਾਲ, git bisect ਨਿਸ਼ਚਿਤ ਰੂਪ ਵਿੱਚ ਜਾਣ ਦਾ ਰਸਤਾ ਹੈ.

ਤੁਸੀਂ ਆਪਣਾ ਕੋਡ ਡੀਬੱਗ ਕਿਵੇਂ ਕਰਦੇ ਹੋ? ਕੀ ਤੁਸੀਂ ਗਿਟ ਵਿੱਚ ਬਾਈਨਰੀ ਖੋਜ ਨੂੰ ਪਸੰਦ ਕਰਦੇ ਹੋ? ਕੀ ਤੁਹਾਡੇ ਕੋਲ ਅਜਿਹਾ ਕਰਨ ਦਾ ਵਧੀਆ ਤਰੀਕਾ ਹੈ? ਸਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੀ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਦੱਸੋ.

March 7, 2018