ਕਲਾਉਡ ਕੋਡ ਨੇ ਚੋਰੀ-ਛਿਪੇ ਅੱਪਗ੍ਰੇਡ ਕੀਤਾ ਹੈ, ਆਖਰਕਾਰ ਹੁਣ "ਟੈਕਸਟ ਸਰਚ ਮਸ਼ੀਨ" ਨਹੀਂ ਰਿਹਾ

ਕੋਡ ਲਿਖਦੇ ਸਮੇਂ, ਕੀ ਤੁਸੀਂ ਕਦੇ ਇਹ ਸੋਚਿਆ ਹੈ:

ਤੁਸੀਂ VS Code ਵਿੱਚ Ctrl + ਕਲਿੱਕ ਕਰਕੇ ਸਿੱਧੇ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾ 'ਤੇ ਕਿਉਂ ਜਾ ਸਕਦੇ ਹੋ? ਜਦੋਂ ਤੁਸੀਂ ਫੰਕਸ਼ਨ 'ਤੇ ਮਾਊਸ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪੂਰੀ ਪੈਰਾਮੀਟਰ ਵਿਆਖਿਆ ਕਿਉਂ ਦੇਖ ਸਕਦੇ ਹੋ? ਤੁਹਾਡਾ ਕੋਡ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ, ਸੰਪਾਦਕ ਤੁਹਾਨੂੰ ਕਿੱਥੇ ਗਲਤ ਹੈ, ਇਹ ਕਿਵੇਂ ਦੱਸ ਸਕਦਾ ਹੈ?

ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਹਰ ਰੋਜ਼ ਵਰਤਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਬਹੁਤ ਖੁਸ਼ ਹੋ।

ਪਰ ਤੁਸੀਂ ਸ਼ਾਇਦ ਨਹੀਂ ਜਾਣਦੇ ਹੋਵੋਗੇ ਕਿ ਇਹ ਸਭ LSP (Language Server Protocol) ਨਾਮਕ ਚੀਜ਼ ਦੁਆਰਾ ਸਮਰਥਤ ਹੈ।

ਇਸ ਤੋਂ ਵੀ ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਇਹ ਹੈ ਕਿ ਕਲਾਉਡ ਕੋਡ 2.0.74 ਸੰਸਕਰਣ ਤੋਂ, LSP ਵੀ ਸਮਰਥਿਤ ਹੈ।

ਇਸਦਾ ਕੀ ਮਤਲਬ ਹੈ?

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਕਲਾਉਡ ਕੋਡ ਆਖਰਕਾਰ ਇੱਕ "ਟੈਕਸਟ ਸਰਚ ਮਸ਼ੀਨ" ਤੋਂ ਇੱਕ ਅਜਿਹਾ AI ਬਣ ਗਿਆ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਕੋਡ ਨੂੰ ਸਮਝਦਾ ਹੈ।

LSP ਕੀ ਹੈ? ਸਿੱਧੀ ਗੱਲ

LSP ਮਾਈਕ੍ਰੋਸਾਫਟ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਇੱਕ ਪ੍ਰੋਟੋਕੋਲ ਹੈ, ਜਿਸਦਾ ਉਦੇਸ਼ ਬਹੁਤ ਸਧਾਰਨ ਹੈ:

ਕੋਡ ਇੰਟੈਲੀਜੈਂਟ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਿਸੇ ਵੀ ਸੰਪਾਦਕ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਦੇਖੋ:

• ਟਾਈਪਸਕ੍ਰਿਪਟ ਦਾ ਭਾਸ਼ਾ ਸਰਵਰ, VS Code ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, JetBrains ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, Cursor ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ

• ਹੁਣ, ਕਲਾਉਡ ਕੋਡ ਵਿੱਚ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ

LSP ਉਹ ਚੀਜ਼ ਹੈ ਜੋ ਤੁਹਾਡੇ ਸੰਪਾਦਕ ਨੂੰ ਸਮਾਰਟ ਬਣਾਉਂਦੀ ਹੈ:

• ਫੰਕਸ਼ਨ ਨਾਮਾਂ ਅਤੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਪੂਰਾ ਕਰੋ

• ਪਰਿਭਾਸ਼ਾ 'ਤੇ ਜਾਓ

• ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ

• ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਦਿਖਾਉਣ ਲਈ ਹੋਵਰ ਕਰੋ

• ਰੀਅਲ-ਟਾਈਮ ਗਲਤੀਆਂ ਅਤੇ ਚੇਤਾਵਨੀਆਂ

ਤੁਸੀਂ ਹਰ ਰੋਜ਼ ਕੋਡ ਲਿਖਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਅਣਗਿਣਤ ਵਾਰ ਵਰਤਿਆ ਹੈ।

ਪਰ ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਸੋਚਿਆ ਕਿ ਇਹ ਕਿਵੇਂ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ।

ਹੁਣ ਸੋਚਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ, ਸਿਰਫ਼ ਇਹ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ: ਕਲਾਉਡ ਕੋਡ ਕੋਲ ਹੁਣ ਇਹ ਸਮਰੱਥਾਵਾਂ ਹਨ।

ਕਲਾਉਡ ਕੋਡ ਪਹਿਲਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਸੀ?

LSP ਦਾ ਸਮਰਥਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਕਲਾਉਡ ਕੋਡ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਲੱਭਣਾ ਚਾਹੁੰਦਾ ਸੀ ਕਿ ਇਹ ਕਿੱਥੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸਨੂੰ ਕੀ ਕਰਨਾ ਪਿਆ?

grep ਖੋਜ 'ਤੇ ਭਰੋਸਾ ਕਰੋ।

ਸਿੱਧੀ ਗੱਲ ਕਰੀਏ, ਇਹ ਇੱਕ ਪੂਰਾ ਟੈਕਸਟ ਖੋਜ ਹੈ, ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਿ "displayBooks" ਦੇ ਇਹ ਅੱਖਰ ਕਿੱਥੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।

ਕੀ ਇਹ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ? ਇਹ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ।

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

ਪਰ ਸਮੱਸਿਆ ਕੀ ਹੈ?

ਇਹ ਅਸਲ ਵਿੱਚ ਕੋਡ ਢਾਂਚੇ ਨੂੰ ਨਹੀਂ ਸਮਝਦਾ।

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

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

ਇਹ ਅੰਤਰ ਹੈ।

ਪਿਛਲਾ ਕਲਾਉਡ ਕੋਡ: ਇੱਕ-ਇੱਕ ਕਰਕੇ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹੋ, ਟੈਕਸਟ ਮੈਚਿੰਗ 'ਤੇ ਭਰੋਸਾ ਕਰੋ ਪਿਛਲਾ ਕਲਾਉਡ ਕੋਡ: ਸਿੱਧੇ ਭਾਸ਼ਾ ਸਰਵਰ ਨੂੰ ਪੁੱਛੋ, ਸਹੀ ਸਥਿਤੀ

ਕੁਸ਼ਲਤਾ ਥੋੜ੍ਹੀ ਜਿਹੀ ਵੀ ਨਹੀਂ ਹੈ।

LSP ਨੇ ਕਲਾਉਡ ਕੋਡ ਲਈ ਕੀ ਲਿਆਂਦਾ ਹੈ?

5 ਮੁੱਖ ਸਮਰੱਥਾਵਾਂ, ਹਰ ਇੱਕ ਕੁਸ਼ਲਤਾ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਾਧਨ ਹੈ:

1. goToDefinition - ਪਰਿਭਾਸ਼ਾ 'ਤੇ ਜਾਓ

ਤੁਸੀਂ VS Code ਵਿੱਚ Ctrl+Click ਨਾਲ ਕੀ ਕਰ ਸਕਦੇ ਹੋ? ਸਿੱਧੇ ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾ 'ਤੇ ਜਾਓ।

ਹੁਣ ਕਲਾਉਡ ਕੋਡ ਵੀ ਅਜਿਹਾ ਕਰ ਸਕਦਾ ਹੈ।

ਤੁਸੀਂ ਇਸਨੂੰ ਪੁੱਛੋ: "processRequest ਫੰਕਸ਼ਨ ਕਿੱਥੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ? LSP ਦੀ ਵਰਤੋਂ ਕਰੋ"

ਇਹ ਮੂਰਖਤਾ ਨਾਲ ਸਾਰੀਆਂ ਫਾਈਲਾਂ ਦੀ ਖੋਜ ਨਹੀਂ ਕਰੇਗਾ।

ਇਹ ਸਿੱਧੇ ਭਾਸ਼ਾ ਸਰਵਰ ਨੂੰ ਪੁੱਛਦਾ ਹੈ, ਅਤੇ ਸਕਿੰਟਾਂ ਵਿੱਚ ਜਵਾਬ ਦਿੰਦਾ ਹੈ: ਫਾਈਲ ਦਾ ਨਾਮ, ਲਾਈਨ ਨੰਬਰ, ਸਹੀ ਸਥਿਤੀ।

2. findReferences - ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ

ਇਹ ਇੱਕ ਕਾਤਲ ਫੰਕਸ਼ਨ ਹੈ।

ਤੁਸੀਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਮੁੜ ਸੰਗਠਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਪਰ ਬਦਲਣ ਤੋਂ ਡਰਦੇ ਹੋ, ਕਿਉਂਕਿ ਤੁਹਾਨੂੰ ਡਰ ਹੈ ਕਿ ਇਹ ਹੋਰ ਥਾਵਾਂ 'ਤੇ ਟੁੱਟ ਜਾਵੇਗਾ।

ਤੁਸੀਂ ਕੀ ਕਰਦੇ ਹੋ?

ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਕਲਾਉਡ ਕੋਡ ਨੂੰ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਕਹਿਣਾ ਪੈਂਦਾ ਸੀ, ਜੋ ਕਿ ਬਹੁਤ ਹੌਲੀ ਸੀ।

ਹੁਣ ਸਿੱਧੇ ਪੁੱਛੋ: "displayError ਫੰਕਸ਼ਨ ਨੂੰ ਕਿਹੜੀਆਂ ਥਾਵਾਂ 'ਤੇ ਬੁਲਾਇਆ ਗਿਆ ਹੈ? LSP ਦੀ ਵਰਤੋਂ ਕਰੋ"

ਭਾਸ਼ਾ ਸਰਵਰ ਸਿੱਧੇ ਤੁਹਾਨੂੰ ਸਾਰੇ ਹਵਾਲੇ ਸਥਾਨਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ।

ਤੇਜ਼, ਸਹੀ ਅਤੇ ਬੇਰਹਿਮ।

3. hover - ਦਸਤਾਵੇਜ਼ ਅਤੇ ਕਿਸਮ ਦੀ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰੋ

ਤੁਸੀਂ VS Code ਵਿੱਚ ਮਾਊਸ ਨੂੰ ਹੋਵਰ ਕਰਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਦਸਤਖਤ, ਪੈਰਾਮੀਟਰ ਕਿਸਮਾਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ ਵਰਣਨ ਦੇਖ ਸਕਦੇ ਹੋ।

ਕਲਾਉਡ ਕੋਡ ਹੁਣ ਵੀ ਦੇਖ ਸਕਦਾ ਹੈ।

ਇਸਨੂੰ ਪੁੱਛੋ: "displayBooks ਫੰਕਸ਼ਨ ਕਿਹੜੇ ਪੈਰਾਮੀਟਰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ? LSP ਦੀ ਵਰਤੋਂ ਕਰੋ"

ਇਸਨੂੰ ਅਨੁਮਾਨ ਲਗਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਇਹ ਸਿੱਧੇ ਭਾਸ਼ਾ ਸਰਵਰ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਦਸਤਖਤ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।

ਖਾਸ ਤੌਰ 'ਤੇ ਪਾਈਥਨ ਵਰਗੀਆਂ ਗਤੀਸ਼ੀਲ ਭਾਸ਼ਾਵਾਂ ਲਈ, ਪਹਿਲਾਂ ਕਲਾਉਡ ਸਿਰਫ਼ ਸੰਦਰਭ ਦੇ ਆਧਾਰ 'ਤੇ ਕਿਸਮ ਦਾ ਅਨੁਮਾਨ ਲਗਾ ਸਕਦਾ ਸੀ।ਹੁਣ LSP ਦੇ ਨਾਲ, ਕਿਸਮ ਦੀ ਜਾਣਕਾਰੀ ਤੁਰੰਤ ਸਪੱਸ਼ਟ ਹੈ।

4. documentSymbol - ਫਾਈਲ ਦੇ ਸਾਰੇ ਚਿੰਨ੍ਹਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ

ਕੀ ਤੁਸੀਂ ਜਲਦੀ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਕਿਹੜੀਆਂ ਕਲਾਸਾਂ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਵੇਰੀਏਬਲ ਹਨ?

ਕਲਾਉਡ ਨੂੰ ਪੁੱਛੋ: "backend/index.js ਵਿੱਚ ਕਿਹੜੇ ਚਿੰਨ੍ਹ ਹਨ? LSP ਦੀ ਵਰਤੋਂ ਕਰੋ"

ਇਹ ਤੁਹਾਨੂੰ ਇੱਕ ਢਾਂਚਾਗਤ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਬਿਲਕੁਲ ਸਪੱਸ਼ਟ।

5. workspaceSymbol - ਪੂਰੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਚਿੰਨ੍ਹ ਖੋਜ

ਇਹ ਹੋਰ ਵੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ।

ਇਹ ਟੈਕਸਟ ਦੀ ਖੋਜ ਨਹੀਂ ਕਰਦਾ, ਇਹ ਚਿੰਨ੍ਹਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ।

ਕੀ ਤੁਸੀਂ ਉਹ ਸਾਰੇ ਤਰੀਕੇ ਲੱਭਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ "innerHTML" ਸ਼ਾਮਲ ਹੈ?

ਭਾਸ਼ਾ ਸਰਵਰ ਸਿੱਧਾ ਤੁਹਾਡੇ ਲਈ ਉਹਨਾਂ ਨੂੰ ਲੱਭਦਾ ਹੈ, ਇਹ ਸਤਰ ਮੈਚਿੰਗ ਨਹੀਂ ਹੈ, ਇਹ ਅਸਲ ਕੋਡ ਚਿੰਨ੍ਹ ਹੈ।

ਅਭਿਆਸ: LSP ਅਸਲ ਵਿੱਚ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦਾ ਹੈ?

ਉਹਨਾਂ ਨਕਲੀ ਚੀਜ਼ਾਂ ਬਾਰੇ ਗੱਲ ਨਾ ਕਰੋ, ਅਸਲ ਕੇਸਾਂ ਨੂੰ ਦੇਖੋ।

ਕੇਸ 1: ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਨੂੰ ਟਰੈਕ ਕਰੋ

ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਹੈ ਜਿਸਨੂੰ AseBook Finder ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਫਰੰਟਐਂਡ ਵਿੱਚ ਇੱਕ displayBooks ਫੰਕਸ਼ਨ ਹੈ।

ਤੁਸੀਂ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹ ਫੰਕਸ਼ਨ ਕਿੱਥੇ ਬੁਲਾਇਆ ਗਿਆ ਹੈ।

ਪਹਿਲਾਂ ਤੁਸੀਂ ਕੀ ਕਰਦੇ ਸੀ? ਕਲਾਉਡ ਕੋਡ grep ਇੱਕ ਵਾਰ, ਸੰਭਵ ਤੌਰ 'ਤੇ ਗੁੰਮ ਹੋ ਜਾਵੇ, ਸੰਭਵ ਤੌਰ 'ਤੇ ਗਲਤ ਰਿਪੋਰਟ।

ਹੁਣ ਸਿੱਧਾ ਪੁੱਛੋ: "LSP ਦੀ ਵਰਤੋਂ ਕਰਕੇ displayBooks ਦੇ ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ"

ਨਤੀਜਾ:

• ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾ ਸਥਾਨ

• fetch ਸਫਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਬੁਲਾਇਆ ਗਿਆ ਸਥਾਨ

• ਹੋਰ ਸਾਰੇ ਹਵਾਲੇ

ਸਟੀਕ, ਤੇਜ਼, ਕੋਈ ਗੁੰਮ ਨਹੀਂ।

ਕੇਸ 2: ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸਮਝੋ

ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕਲਾਉਡ ਕੋਡ ਦਾ ਇੱਕ ਟੁਕੜਾ ਤਿਆਰ ਕਰੇ, displayError ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ।

ਪਰ ਤੁਸੀਂ ਯਕੀਨੀ ਨਹੀਂ ਹੋ ਕਿ ਇਹ ਫੰਕਸ਼ਨ ਕਿਹੜੇ ਪੈਰਾਮੀਟਰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।

ਇਸਨੂੰ ਪੁੱਛੋ: "displayError ਕਿਹੜੇ ਪੈਰਾਮੀਟਰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ? LSP ਦੀ ਵਰਤੋਂ ਕਰੋ"

ਭਾਸ਼ਾ ਸਰਵਰ ਸਿੱਧਾ ਵਾਪਸ ਕਰਦਾ ਹੈ: ਇੱਕ message ਪੈਰਾਮੀਟਰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।

ਕਲਾਉਡ ਜਾਣਦਾ ਹੈ, ਤਿਆਰ ਕੀਤਾ ਕੋਡ ਗਲਤ ਨਹੀਂ ਹੋਵੇਗਾ।

ਕੇਸ 3: API ਕਾਲਾਂ ਲੱਭੋ

ਤੁਸੀਂ ਇਹ ਲੱਭਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕਿਹੜੀ ਥਾਂ /api/recommendations ਇੰਟਰਫੇਸ ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ।

ਕਲਾਉਡ ਨੂੰ ਪੁੱਛੋ: "LSP ਦੀ ਵਰਤੋਂ ਕਰਕੇ /api/recommendations ਦੇ ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ"

ਇਹ fetch ਕਾਲ ਦੇ ਸਥਾਨ ਨੂੰ ਲੱਭਦਾ ਹੈ, ਲਾਈਨ ਤੱਕ ਸਟੀਕ।

API ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ, ਡਾਟਾ ਪ੍ਰਵਾਹ ਨੂੰ ਟਰੈਕ ਕਰਨਾ, ਬਹੁਤ ਲਾਭਦਾਇਕ।

ਕੇਸ 4: ਪਹਿਲਾਂ ਤੋਂ ਗਲਤੀਆਂ ਲੱਭੋ

ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਰੀਫੈਕਟਰ ਕਰ ਰਹੇ ਹੋ, ਅਤੇ ਗਲਤੀ ਨਾਲ ਇੱਕ ਵੇਰੀਏਬਲ ਨਾਮ ਦੀ ਸਪੈਲਿੰਗ ਗਲਤ ਕਰ ਦਿੱਤੀ ਹੈ।

ਆਮ ਹਾਲਤਾਂ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਗਲਤੀ ਲੱਭਣ ਲਈ ਕੋਡ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਪਰ LSP ਦੇ ਨਾਲ, ਭਾਸ਼ਾ ਸਰਵਰ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਮੱਸਿਆ ਲੱਭਣ 'ਤੇ ਤੁਰੰਤ ਕਲਾਉਡ ਕੋਡ ਨੂੰ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ।

ਕਲਾਉਡ ਤੁਹਾਨੂੰ ਕੋਡ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਦੱਸ ਦਿੰਦਾ ਹੈ: ਇੱਥੇ ਇੱਕ ਗਲਤੀ ਹੈ।

ਕਿਵੇਂ ਸੈੱਟ ਕਰੀਏ? 5 ਕਦਮਾਂ ਵਿੱਚ ਪੂਰਾ ਕਰੋ

ਘਬਰਾਓ ਨਾ, ਸੈੱਟਅੱਪ ਬਹੁਤ ਸੌਖਾ ਹੈ।

ਕਦਮ 1: LSP ਟੂਲ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ

ਆਪਣੀ ਸ਼ੈੱਲ ਕੌਂਫਿਗਰੇਸ਼ਨ ਫਾਈਲ ਵਿੱਚ (.bashrc ਜਾਂ .zshrc) ਇੱਕ ਲਾਈਨ ਸ਼ਾਮਲ ਕਰੋ:

exportENABLE_LSP_TOOLS=1ਫਿਰ ਪ੍ਰਭਾਵੀ ਹੋਣ ਲਈ source ~/.zshrc ਚਲਾਓ।

ਕਦਮ 2: ਭਾਸ਼ਾ ਸਰਵਰ ਪਲੱਗਇਨ ਸਥਾਪਤ ਕਰੋ

ਕਲਾਉਡ ਕੋਡ ਖੋਲ੍ਹੋ, ਦਾਖਲ ਕਰੋ:

/pluginਆਪਣੀ ਵਰਤੀ ਜਾ ਰਹੀ ਭਾਸ਼ਾ ਲਈ ਸੰਬੰਧਿਤ ਪਲੱਗਇਨ ਲੱਭੋ:

• Python: pyright-lsp ਚੁਣੋ

• TypeScript/JavaScript: vtsls ਜਾਂ typescript-lsp ਚੁਣੋ

• Go: gopls ਚੁਣੋ

• Rust: rust-analyzer ਚੁਣੋ

"Install for me only" ਚੁਣੋ, ਸਥਾਪਤ ਕਰੋ।

ਕਦਮ 3: ਭਾਸ਼ਾ ਸਰਵਰ ਬਾਈਨਰੀ ਫਾਈਲ ਸਥਾਪਤ ਕਰੋ

ਪਲੱਗਇਨ ਸਿਰਫ਼ ਇੱਕ ਇੰਟਰਫੇਸ ਹੈ, ਅਸਲ ਵਿੱਚ ਕੰਮ ਕਰਨ ਵਾਲਾ ਭਾਸ਼ਾ ਸਰਵਰ ਖੁਦ ਹੈ।

Python:

pip install pyrightTypeScript/JavaScript:

npm install -g @vtsls/language-server typescriptGo:

go install golang.org/x/tools/gopls@latestRust:

rustup component add rust-analyzer

ਕਦਮ 4: ਕਲਾਉਡ ਕੋਡ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋਇੰਸਟਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕਲਾਉਡ ਕੋਡ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋ।

claude

ਕਦਮ 5: ਜਾਂਚ ਕਰੋ ਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ

/plugin ਟਾਈਪ ਕਰੋ, "Installed" ਟੈਬ ਦੀ ਜਾਂਚ ਕਰੋ, ਅਤੇ ਤੁਹਾਨੂੰ ਆਪਣਾ ਪਲੱਗਇਨ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ।

ਇੱਕ ਟੈਸਟ ਕਰੋ:

LSP ਦੀ ਵਰਤੋਂ ਕਰਕੇ someFunction ਦੇ ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ ਜੇਕਰ ਕਲਾਉਡ ਕੋਡ grep ਦੀ ਬਜਾਏ find_references ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ ਸਫਲ ਹੋ ਗਿਆ ਹੈ।

LSP ਦੀ ਵਰਤੋਂ ਕਦੋਂ ਕਰਨੀ ਹੈ? ਅਤੇ ਕਦੋਂ ਨਹੀਂ ਕਰਨੀ?

LSP ਕੋਈ ਜਾਦੂ ਦੀ ਛੜੀ ਨਹੀਂ ਹੈ।

LSP ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਢੁਕਵੇਂ ਦ੍ਰਿਸ਼:

• ਵੱਡੇ ਪ੍ਰੋਜੈਕਟ (ਸੈਂਕੜੇ ਫਾਈਲਾਂ)

• ਫਾਈਲਾਂ ਵਿੱਚ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਨੂੰ ਟਰੈਕ ਕਰਨਾ

• ਸਹੀ ਫੰਕਸ਼ਨ ਦਸਤਖਤਾਂ ਦੀ ਲੋੜ ਹੈ (ਖਾਸ ਕਰਕੇ ਗਤੀਸ਼ੀਲ ਭਾਸ਼ਾਵਾਂ)

• ਕੋਡ ਨੂੰ ਮੁੜ ਸੰਗਠਿਤ ਕਰਨਾ, ਬੱਗ ਪੈਦਾ ਹੋਣ ਤੋਂ ਡਰਨਾ

LSP ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਢੁਕਵੇਂ ਨਾ ਹੋਣ ਵਾਲੇ ਦ੍ਰਿਸ਼:

• ਛੋਟੇ ਪ੍ਰੋਜੈਕਟ, ਤੇਜ਼ ਸਕ੍ਰਿਪਟਾਂ

• ਸਧਾਰਨ ਟੈਕਸਟ ਖੋਜ

• ਸਿਰਫ਼ ਇਹ ਪਤਾ ਕਰਨਾ ਕਿ ਇੱਕ ਸਤਰ ਕਿੱਥੇ ਹੈ

ਸੰਖੇਪ ਵਿੱਚ, ਜਦੋਂ grep ਤੇਜ਼ ਹੋਵੇ ਤਾਂ grep ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਜਦੋਂ LSP ਸਹੀ ਹੋਵੇ ਤਾਂ LSP ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਟੂਲ ਲੋਕਾਂ ਦੀ ਸੇਵਾ ਲਈ ਹਨ, ਨਾ ਕਿ ਸਿਰਫ਼ ਵਰਤੋਂ ਲਈ।

ਕੁਝ ਖੱਡੇ, ਮੈਂ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਹੀ ਦੱਸ ਦਿੰਦਾ ਹਾਂ

ਖੱਡਾ 1: ਭਾਸ਼ਾ ਸਰਵਰ PATH ਵਿੱਚ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ

ਜੇਕਰ ਕਲਾਉਡ ਕੋਡ ਕਹਿੰਦਾ ਹੈ "ਕੋਈ LSP ਸਰਵਰ ਉਪਲਬਧ ਨਹੀਂ ਹੈ", ਤਾਂ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਤੁਹਾਡਾ ਭਾਸ਼ਾ ਸਰਵਰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਿਤ ਨਹੀਂ ਹੈ, ਜਾਂ PATH ਵਿੱਚ ਨਹੀਂ ਹੈ।

ਟਰਮੀਨਲ ਵਿੱਚ which pyright (ਜਾਂ ਤੁਹਾਡਾ ਭਾਸ਼ਾ ਸਰਵਰ) ਚਲਾਓ, ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਇਹ ਲੱਭਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਖੱਡਾ 2: ਪਲੱਗਇਨ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਬਾਅਦ ਮੁੜ ਚਾਲੂ ਕਰੋ

ਨਵੇਂ ਪਲੱਗਇਨ ਸਥਾਪਿਤ ਕਰਨ ਜਾਂ ਭਾਸ਼ਾ ਸਰਵਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਕਲਾਉਡ ਕੋਡ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ।

ਭਾਸ਼ਾ ਸਰਵਰ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਲੋਡ ਹੁੰਦਾ ਹੈ।

ਖੱਡਾ 3: ਕਈ ਵਾਰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ "LSP ਦੀ ਵਰਤੋਂ ਕਰੋ" ਕਹਿਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ

ਜੇਕਰ ਤੁਸੀਂ ਦੇਖਦੇ ਹੋ ਕਿ ਕਲਾਉਡ ਕੋਡ ਅਜੇ ਵੀ grep ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ ਨਾ ਕਿ LSP ਦੀ, ਤਾਂ ਇੱਕ ਵਾਕੰਸ਼ "LSP ਦੀ ਵਰਤੋਂ ਕਰੋ" ਸ਼ਾਮਲ ਕਰੋ:

LSP ਦੀ ਵਰਤੋਂ ਕਰਕੇ authenticateUser ਦੇ ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ ਇਸ ਤਰ੍ਹਾਂ ਇਸਨੂੰ ਪਤਾ ਲੱਗ ਜਾਵੇਗਾ ਕਿ ਭਾਸ਼ਾ ਸਰਵਰ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਹੈ।

ਖੱਡਾ 4: ਕੋਈ ਵਿਜ਼ੂਅਲ ਪ੍ਰੋਂਪਟ ਨਹੀਂ ਹੈ

VS Code ਦੇ ਉਲਟ, ਕਲਾਉਡ ਕੋਡ ਤੁਹਾਨੂੰ ਇਹ ਨਹੀਂ ਦੱਸੇਗਾ ਕਿ LSP ਸਰਵਰ ਚੱਲ ਰਿਹਾ ਹੈ ਜਾਂ ਨਹੀਂ।

ਕੋਈ ਸਥਿਤੀ ਬਾਰ ਆਈਕਨ ਨਹੀਂ ਹੈ, ਕੋਈ ਸੂਚਨਾ ਨਹੀਂ ਹੈ।

ਇਸਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦਾ ਇੱਕੋ ਇੱਕ ਤਰੀਕਾ ਹੈ: ਅਸਲ ਵਿੱਚ ਟੈਸਟ ਕਰੋ।

ਅੰਤ ਵਿੱਚ ਕੁਝ ਸ਼ਬਦ

ਕਲਾਉਡ ਕੋਡ LSP ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਇਹ ਇੱਕ ਛੋਟਾ ਅੱਪਡੇਟ ਨਹੀਂ ਹੈ, ਇਹ ਇੱਕ ਗੁਣਾਤਮਕ ਤਬਦੀਲੀ ਹੈ।

ਪਹਿਲਾਂ ਇਹ "ਟੈਕਸਟ ਖੋਜ + AI ਅਨੁਮਾਨ" ਸੀ।

ਹੁਣ ਇਹ "ਭਾਸ਼ਾ ਸਰਵਰ + AI ਸਮਝ" ਹੈ।

ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੈ ਜਿਵੇਂ ਤੁਸੀਂ ਇੱਕ ਫ਼ੋਨ ਬੁੱਕ ਨੂੰ ਫਲਿਪ ਕਰਨ ਤੋਂ ਇੱਕ ਖੋਜ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਿੱਚ ਬਦਲ ਗਏ ਹੋ।

ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਅੰਤਰ ਬਹੁਤ ਵੱਡਾ ਹੈ।

ਜੇਕਰ ਤੁਸੀਂ ਕਲਾਉਡ ਕੋਡ ਦੀ ਵਰਤੋਂ ਇੱਕ ਗੰਭੀਰ ਪ੍ਰੋਜੈਕਟ ਲਈ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ LSP ਨੂੰ ਸੈੱਟਅੱਪ ਕਰਨ ਲਈ 5 ਮਿੰਟ ਬਿਤਾਓ।

ਇਹ 5 ਮਿੰਟ ਕੀਮਤੀ ਹਨ।

ਕਾਰਵਾਈ ਸੂਚੀ:

• ਸ਼ੈੱਲ ਕੌਂਫਿਗਰੇਸ਼ਨ ਵਿੱਚ export ENABLE_LSP_TOOLS=1 ਸ਼ਾਮਲ ਕਰੋ

• ਕਲਾਉਡ ਕੋਡ ਖੋਲ੍ਹੋ, ਅਤੇ ਆਪਣੇ ਭਾਸ਼ਾ ਪਲੱਗਇਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ /plugin ਚਲਾਓ

• ਸੰਬੰਧਿਤ ਭਾਸ਼ਾ ਸਰਵਰ ਬਾਈਨਰੀ ਫਾਈਲ ਸਥਾਪਿਤ ਕਰੋ

• ਕਲਾਉਡ ਕੋਡ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋ

• ਟੈਸਟ ਕਰੋ "LSP ਦੀ ਵਰਤੋਂ ਕਰਕੇ XXX ਦੇ ਸਾਰੇ ਹਵਾਲੇ ਲੱਭੋ"

ਇੰਸਟਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ:ਅਸਲ ਵਿੱਚ ਕਲਾਉਡ ਕੋਡ ਇੰਨੀ ਤੇਜ਼ੀ ਨਾਲ ਵੀ ਹੋ ਸਕਦਾ ਹੈ।