ಕ್ಲೌಡ್ ಕೋಡ್ ರಹಸ್ಯವಾಗಿ ನವೀಕರಿಸಲ್ಪಟ್ಟಿದೆ, ಅಂತಿಮವಾಗಿ "ಪಠ್ಯ ಹುಡುಕಾಟ ಯಂತ್ರ" ಅಲ್ಲ

ನೀವು ಕೋಡ್ ಬರೆಯುವಾಗ, ನೀವು ಒಂದು ಸಮಸ್ಯೆಯ ಬಗ್ಗೆ ಯೋಚಿಸಿದ್ದೀರಾ:

VS ಕೋಡ್‌ನಲ್ಲಿ Ctrl + ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ನೀವು ನೇರವಾಗಿ ಫಂಕ್ಷನ್ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಏಕೆ ಹೋಗಬಹುದು? ನಿಮ್ಮ ಮೌಸ್ ಅನ್ನು ಫಂಕ್ಷನ್ ಮೇಲೆ ಇರಿಸಿದಾಗ ನೀವು ಸಂಪೂರ್ಣ ಪ್ಯಾರಾಮೀಟರ್ ವಿವರಣೆಯನ್ನು ಏಕೆ ನೋಡಬಹುದು? ನಿಮ್ಮ ಕೋಡ್ ರನ್ ಆಗುವ ಮೊದಲೇ, ಎಡಿಟರ್ ನಿಮಗೆ ಎಲ್ಲಿ ತಪ್ಪು ಎಂದು ಏಕೆ ಹೇಳುತ್ತದೆ?

ನೀವು ಪ್ರತಿದಿನ ಈ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತೀರಿ, ಅದು ತುಂಬಾ ತಂಪಾಗಿದೆ.

ಆದರೆ ಇವೆಲ್ಲವನ್ನೂ LSP (Language Server Protocol) ಎಂಬ ವಿಷಯವು ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿರಬಹುದು.

ಮತ್ತು ಮುಖ್ಯವಾಗಿ, Claude Code 2.0.74 ಆವೃತ್ತಿಯಿಂದ, ಇದು LSP ಅನ್ನು ಸಹ ಬೆಂಬಲಿಸುತ್ತದೆ.

ಇದರ ಅರ್ಥವೇನು?

ಕ್ಲೌಡ್ ಕೋಡ್ ಅಂತಿಮವಾಗಿ "ಪಠ್ಯ ಹುಡುಕಾಟ ಯಂತ್ರ"ದಿಂದ ಕೋಡ್ ಅನ್ನು ನಿಜವಾಗಿಯೂ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ AI ಆಗಿ ಮಾರ್ಪಟ್ಟಿದೆ ಎಂದರ್ಥ.

LSP ಎಂದರೇನು? ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ

LSP ಮೈಕ್ರೋಸಾಫ್ಟ್‌ನಿಂದ ರಚಿಸಲ್ಪಟ್ಟ ಒಂದು ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದೆ, ಇದರ ಉದ್ದೇಶವು ತುಂಬಾ ಸರಳವಾಗಿದೆ:

ಯಾವುದೇ ಸಂಪಾದಕದಲ್ಲಿ ಕೋಡ್ ಬುದ್ಧಿವಂತಿಕೆಯ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಅನುಮತಿಸಿ.

ನೋಡಿ:

• TypeScript ನ ಭಾಷಾ ಸರ್ವರ್ ಅನ್ನು VS ಕೋಡ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು, JetBrains ನಲ್ಲಿ ಬಳಸಬಹುದು, ಕರ್ಸರ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು

• ಈಗ, ಕ್ಲೌಡ್ ಕೋಡ್‌ನಲ್ಲಿಯೂ ಬಳಸಬಹುದು

LSP ನಿಮ್ಮ ಸಂಪಾದಕವನ್ನು ಚುರುಕಾಗಿಸುವ ವಿಷಯವಾಗಿದೆ:

• ಫಂಕ್ಷನ್ ಹೆಸರುಗಳು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸಿ

• ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಹೋಗಿ

• ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳನ್ನು ಹುಡುಕಿ

• ತೇಲುವಾಗ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೋರಿಸಿ

• ನೈಜ-ಸಮಯದ ದೋಷಗಳು ಮತ್ತು ಎಚ್ಚರಿಕೆಗಳು

ನೀವು ಪ್ರತಿದಿನ ಕೋಡ್ ಬರೆಯುತ್ತೀರಿ, ಈ ಕಾರ್ಯಗಳನ್ನು ಲೆಕ್ಕವಿಲ್ಲದಷ್ಟು ಬಾರಿ ಬಳಸಿದ್ದೀರಿ.

ಆದರೆ ಅದು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ ಎಂದು ನೀವು ಎಂದಿಗೂ ಯೋಚಿಸಲಿಲ್ಲ.

ಈಗ ಯೋಚಿಸಬೇಕಾಗಿಲ್ಲ, ಇದನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ: ಕ್ಲೌಡ್ ಕೋಡ್ ಈಗ ಈ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿದೆ.

ಕ್ಲೌಡ್ ಕೋಡ್ ಈ ಹಿಂದೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿತ್ತು?

LSP ಅನ್ನು ಬೆಂಬಲಿಸುವ ಮೊದಲು, ಕ್ಲೌಡ್ ಕೋಡ್ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಎಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಎಂದು ಕಂಡುಹಿಡಿಯಲು ಬಯಸಿದರೆ, ಅದು ಏನು ಮಾಡಬೇಕು?

grep ಹುಡುಕಾಟವನ್ನು ಅವಲಂಬಿಸಿತ್ತು.

ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಇದು ಪೂರ್ಣ-ಪಠ್ಯ ಹುಡುಕಾಟವಾಗಿದೆ, "displayBooks" ಎಂಬ ಕೆಲವು ಅಕ್ಷರಗಳು ಎಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯುವುದು.

ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆಯೇ? ಹೌದು, ಕೆಲಸ ಮಾಡುತ್ತದೆ.

AI ಮಾದರಿಯು ಅಪಾರ ಪ್ರಮಾಣದ ಕೋಡ್ ಅನ್ನು ತರಬೇತಿ ಮಾಡಿದೆ, ಮತ್ತು ಅದು ಪಠ್ಯದಿಂದ ಬಹಳಷ್ಟು ವಿಷಯಗಳನ್ನು ಊಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಆದರೆ ಸಮಸ್ಯೆ ಎಲ್ಲಿದೆ?

ಇದು ನಿಜವಾಗಿಯೂ ಕೋಡ್ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ.

ನೀವು ಒಬ್ಬ ವ್ಯಕ್ತಿಯನ್ನು "ರಾಮು" ಅನ್ನು ಹುಡುಕಲು ಹೇಳಿದಂತೆ, ಅವನು "ರಾಮು" ಎಂಬ ಎರಡು ಪದಗಳನ್ನು ಹುಡುಕಲು ಸಂಪರ್ಕ ಪಟ್ಟಿಯನ್ನು ಪುಟದಿಂದ ಪುಟಕ್ಕೆ ತಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ.

ಮತ್ತು ನೀವು "ರಾಮು" ಗಾಗಿ ಹುಡುಕಲು ನಿಮ್ಮ ಫೋನ್ ಅನ್ನು ಬಳಸಿದರೆ, ನೀವು ನೇರವಾಗಿ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಕರೆದು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ.

ಇದು ವ್ಯತ್ಯಾಸ.

ಹಿಂದಿನ ಕ್ಲೌಡ್ ಕೋಡ್: ಪ್ರತಿ ಫೈಲ್ ಅನ್ನು ಒಂದೊಂದಾಗಿ ಓದಿ, ಪಠ್ಯ ಹೊಂದಾಣಿಕೆಯನ್ನು ಅವಲಂಬಿಸಿತ್ತು. ಈಗಿನ ಕ್ಲೌಡ್ ಕೋಡ್: ನೇರವಾಗಿ ಭಾಷಾ ಸರ್ವರ್ ಅನ್ನು ಕೇಳಿ, ನಿಖರವಾಗಿ ಪತ್ತೆ ಮಾಡಿ

ದಕ್ಷತೆಯ ವ್ಯತ್ಯಾಸವು ಸ್ವಲ್ಪವೂ ಅಲ್ಲ.

LSP ಕ್ಲೌಡ್ ಕೋಡ್‌ಗೆ ಏನು ತಂದಿದೆ?

5 ಪ್ರಮುಖ ಸಾಮರ್ಥ್ಯಗಳು, ಪ್ರತಿಯೊಂದೂ ದಕ್ಷತೆಯ ಸಾಧನವಾಗಿದೆ:

1. goToDefinition - ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಹೋಗಿ

VS ಕೋಡ್‌ನಲ್ಲಿ Ctrl+Click ಏನು ಮಾಡಬಹುದು? ನೇರವಾಗಿ ಫಂಕ್ಷನ್ ವ್ಯಾಖ್ಯಾನದ ಸ್ಥಳಕ್ಕೆ ಹೋಗಿ.

ಈಗ ಕ್ಲೌಡ್ ಕೋಡ್ ಸಹ ಹಾಗೆ ಮಾಡಬಹುದು.

ನೀವು ಅದನ್ನು ಕೇಳುತ್ತೀರಿ: "processRequest ಫಂಕ್ಷನ್ ಅನ್ನು ಎಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ? LSP ಬಳಸಿ"

ಇದು ಎಲ್ಲಾ ಫೈಲ್‌ಗಳನ್ನು ಹುಡುಕಲು ಮೂರ್ಖತನದಿಂದ ವರ್ತಿಸುವುದಿಲ್ಲ.

ಇದು ನೇರವಾಗಿ ಭಾಷಾ ಸರ್ವರ್ ಅನ್ನು ಕೇಳುತ್ತದೆ ಮತ್ತು ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಉತ್ತರವನ್ನು ನೀಡುತ್ತದೆ: ಫೈಲ್ ಹೆಸರು, ಸಾಲು ಸಂಖ್ಯೆ, ನಿಖರವಾದ ಸ್ಥಳ.

2. findReferences - ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳನ್ನು ಹುಡುಕಿ

ಇದು ಕೊಲೆಗಡುಕ ಕಾರ್ಯವಾಗಿದೆ.

ನೀವು ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಮರುರೂಪಿಸಲು ಬಯಸುತ್ತೀರಿ, ಆದರೆ ಬದಲಾಯಿಸಲು ಧೈರ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಇತರ ಸ್ಥಳಗಳಲ್ಲಿ ಅದು ಕುಸಿಯುತ್ತದೆ ಎಂದು ನೀವು ಹೆದರುತ್ತೀರಿ.

ಏನು ಮಾಡಬೇಕು?

ಹಿಂದೆ ನೀವು ಕ್ಲೌಡ್ ಕೋಡ್ ಅನ್ನು ಒಂದೊಂದಾಗಿ ಫೈಲ್‌ಗಳನ್ನು ಓದಲು ಬಿಡಬೇಕಾಗಿತ್ತು, ಅದು ತುಂಬಾ ನಿಧಾನವಾಗಿತ್ತು.

ಈಗ ನೇರವಾಗಿ ಕೇಳಿ: "displayError ಫಂಕ್ಷನ್ ಅನ್ನು ಯಾವ ಸ್ಥಳಗಳಲ್ಲಿ ಕರೆಯಲಾಗಿದೆ? LSP ಬಳಸಿ"

ಭಾಷಾ ಸರ್ವರ್ ನೇರವಾಗಿ ಎಲ್ಲಾ ಉಲ್ಲೇಖದ ಸ್ಥಳಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.

ವೇಗವಾಗಿ, ನಿಖರವಾಗಿ ಮತ್ತು ನಿರ್ದಯವಾಗಿ.

3. hover - ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳು ಮತ್ತು ಪ್ರಕಾರದ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಿರಿ

VS ಕೋಡ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಮೌಸ್ ಅನ್ನು ತೇಲಿಸಿದಾಗ, ನೀವು ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್, ಪ್ಯಾರಾಮೀಟರ್ ಪ್ರಕಾರ ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟ್ ವಿವರಣೆಯನ್ನು ನೋಡಬಹುದು.

ಕ್ಲೌಡ್ ಕೋಡ್ ಈಗ ಸಹ ನೋಡಬಹುದು.

ಅದನ್ನು ಕೇಳಿ: "displayBooks ಫಂಕ್ಷನ್ ಯಾವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ? LSP ಬಳಸಿ"

ಅದು ಊಹಿಸುವ ಅಗತ್ಯವಿಲ್ಲ, ನೇರವಾಗಿ ಭಾಷಾ ಸರ್ವರ್‌ನಿಂದ ಹಿಂತಿರುಗಿದ ಸಿಗ್ನೇಚರ್ ಅನ್ನು ಓದುತ್ತದೆ.

ವಿಶೇಷವಾಗಿ ಪೈಥಾನ್‌ನಂತಹ ಡೈನಾಮಿಕ್ ಭಾಷೆಗಳಿಗೆ, ಈ ಹಿಂದೆ ಕ್ಲೌಡ್ ಪ್ರಕಾರವನ್ನು ಊಹಿಸಲು ಸಂದರ್ಭವನ್ನು ಮಾತ್ರ ಅವಲಂಬಿಸಬೇಕಾಗಿತ್ತು.LSP ಈಗ ಲಭ್ಯವಿದ್ದು, ಟೈಪ್ ಮಾಹಿತಿಯು ತಕ್ಷಣವೇ ಲಭ್ಯವಿದೆ.

4. documentSymbol - ಫೈಲ್‌ನ ಎಲ್ಲಾ ಚಿಹ್ನೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ

ಫೈಲ್‌ನಲ್ಲಿರುವ ಕ್ಲಾಸ್‌ಗಳು, ಫಂಕ್ಷನ್‌ಗಳು, ವೇರಿಯೇಬಲ್‌ಗಳು ಯಾವುವು ಎಂದು ತ್ವರಿತವಾಗಿ ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಾ?

ಕ್ಲೌಡ್‌ಗೆ ಕೇಳಿ: "backend/index.js ನಲ್ಲಿ ಯಾವ ಚಿಹ್ನೆಗಳಿವೆ? LSP ಬಳಸಿ"

ಇದು ನಿಮಗೆ ರಚನಾತ್ಮಕ ಪಟ್ಟಿಯನ್ನು ನೀಡುತ್ತದೆ, ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗಿ ಕಾಣಿಸುತ್ತದೆ.

5. workspaceSymbol - ಸಂಪೂರ್ಣ ಪ್ರಾಜೆಕ್ಟ್ ಚಿಹ್ನೆ ಹುಡುಕಾಟ

ಇದು ಇನ್ನೂ ಪ್ರಬಲವಾಗಿದೆ.

ಇದು ಪಠ್ಯವನ್ನು ಹುಡುಕುವುದಿಲ್ಲ, ಆದರೆ ಚಿಹ್ನೆಗಳನ್ನು ಹುಡುಕುತ್ತದೆ.

"innerHTML" ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಎಲ್ಲಾ ವಿಧಾನಗಳನ್ನು ನೀವು ಹುಡುಕಲು ಬಯಸುತ್ತೀರಾ?

ಭಾಷಾ ಸರ್ವರ್ ನೇರವಾಗಿ ನಿಮಗೆ ಹುಡುಕುತ್ತದೆ, ಇದು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಾಣಿಕೆಯಲ್ಲ, ಆದರೆ ನಿಜವಾದ ಕೋಡ್ ಚಿಹ್ನೆ.

ಪ್ರಾಯೋಗಿಕ ಬಳಕೆ: LSP ನಿಜವಾಗಿ ಯಾವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ?

ಅಸ್ಪಷ್ಟ ವಿಷಯಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಿ, ನೈಜ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಿ.

ಉದಾಹರಣೆ 1: ಫಂಕ್ಷನ್ ಕರೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಿ

AseBook Finder ಎಂಬ ಪ್ರಾಜೆಕ್ಟ್ ಇದೆ, ಮುಂಭಾಗದಲ್ಲಿ displayBooks ಫಂಕ್ಷನ್ ಇದೆ.

ಈ ಫಂಕ್ಷನ್ ಅನ್ನು ಎಲ್ಲಿ ಕರೆಯಲಾಗಿದೆ ಎಂದು ನೀವು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ.

ಮೊದಲು ಏನು ಮಾಡಬೇಕು? Claude Code grep ಅನ್ನು ಬಳಸಿ ಹುಡುಕಬೇಕು, ತಪ್ಪಿಹೋಗುವ ಅಥವಾ ತಪ್ಪು ವರದಿ ಮಾಡುವ ಸಾಧ್ಯತೆಯಿದೆ.

ಈಗ ನೇರವಾಗಿ ಕೇಳಿ: "LSP ಬಳಸಿ displayBooks ನ ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳನ್ನು ಹುಡುಕಿ"

ಫಲಿತಾಂಶ:

• ಫಂಕ್ಷನ್ ವ್ಯಾಖ್ಯಾನದ ಸ್ಥಳ

• fetch ಯಶಸ್ವಿಯಾದ ನಂತರ ಕರೆಯುವ ಸ್ಥಳ

• ಇತರ ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳ ಸ್ಥಳ

ನಿಖರ, ವೇಗ ಮತ್ತು ಯಾವುದೇ ಲೋಪವಿಲ್ಲ.

ಉದಾಹರಣೆ 2: ಫಂಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ

displayError ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಯುವ ಕೋಡ್ ಅನ್ನು ರಚಿಸಲು ನೀವು Claude ಅನ್ನು ಬಯಸುತ್ತೀರಿ.

ಆದರೆ ಈ ಫಂಕ್ಷನ್ ಯಾವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಎಂದು ನಿಮಗೆ ಖಚಿತವಿಲ್ಲ.

ಅದನ್ನು ಕೇಳಿ: "displayError ಯಾವ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ? LSP ಬಳಸಿ"

ಭಾಷಾ ಸರ್ವರ್ ನೇರವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ: ಇದು message ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.

Claude ಗೆ ತಿಳಿದಿದೆ, ರಚಿಸಲಾದ ಕೋಡ್ ತಪ್ಪಾಗುವುದಿಲ್ಲ.

ಉದಾಹರಣೆ 3: API ಕರೆಯನ್ನು ಹುಡುಕಿ

ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ /api/recommendations ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಎಲ್ಲಿ ಕರೆಯಲಾಗಿದೆ ಎಂದು ನೀವು ಹುಡುಕಲು ಬಯಸುತ್ತೀರಿ.

Claude ಗೆ ಕೇಳಿ: "LSP ಬಳಸಿ /api/recommendations ನ ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳನ್ನು ಹುಡುಕಿ"

ಇದು fetch ಕರೆಯುವ ಸ್ಥಳವನ್ನು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ, ಸಾಲಿಗೆ ನಿಖರವಾಗಿರುತ್ತದೆ.

API ಸಮಸ್ಯೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು, ಡೇಟಾ ಹರಿವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು, ಇದು ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಉದಾಹರಣೆ 4: ಮೊದಲೇ ದೋಷಗಳನ್ನು ಪತ್ತೆ ಮಾಡಿ

ನೀವು ಕೋಡ್ ಅನ್ನು ಮರುರೂಪಿಸುತ್ತಿದ್ದೀರಿ, ಮತ್ತು ಆಕಸ್ಮಿಕವಾಗಿ ವೇರಿಯೇಬಲ್ ಹೆಸರನ್ನು ತಪ್ಪಾಗಿ ಬರೆದಿದ್ದೀರಿ.

ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು ದೋಷವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ಆದರೆ LSP ಯೊಂದಿಗೆ, ಭಾಷಾ ಸರ್ವರ್ ನೈಜ ಸಮಯದಲ್ಲಿ ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಸಮಸ್ಯೆಯನ್ನು ತಕ್ಷಣವೇ Claude Code ಗೆ ವರದಿ ಮಾಡುತ್ತದೆ.

ನೀವು ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುವ ಮೊದಲು Claude ನಿಮಗೆ ಹೇಳುತ್ತದೆ: ಇಲ್ಲಿ ದೋಷವಿದೆ.

ಹೇಗೆ ಹೊಂದಿಸುವುದು? 5 ಹಂತಗಳಲ್ಲಿ ಮುಗಿಸಿ

ಹೆದರಬೇಡಿ, ಸೆಟಪ್ ತುಂಬಾ ಸರಳವಾಗಿದೆ.

ಹಂತ 1: LSP ಟೂಲ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ

ನಿಮ್ಮ ಶೆಲ್ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನಲ್ಲಿ (.bashrc ಅಥವಾ .zshrc) ಒಂದು ಸಾಲನ್ನು ಸೇರಿಸಿ:

exportENABLE_LSP_TOOLS=1 ನಂತರ source ~/.zshrc ಅನ್ನು ರನ್ ಮಾಡಿ.

ಹಂತ 2: ಭಾಷಾ ಸರ್ವರ್ ಪ್ಲಗಿನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ

Claude Code ಅನ್ನು ತೆರೆಯಿರಿ, ನಮೂದಿಸಿ:

/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 Code ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿclaude

ಹಂತ 5: ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ

/plugin ಎಂದು ಟೈಪ್ ಮಾಡಿ ಮತ್ತು "ಸ್ಥಾಪಿಸಲಾಗಿದೆ" ಟ್ಯಾಬ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ, ನಿಮ್ಮ ಪ್ಲಗಿನ್ ಅನ್ನು ನೀವು ನೋಡಿದರೆ ಅದು ಸರಿ.

ಪರೀಕ್ಷಿಸಿ:

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 ಕೋಡ್‌ನಂತೆ, ಕ್ಲೌಡ್ ಕೋಡ್ LSP ಸರ್ವರ್ ಚಾಲನೆಯಲ್ಲಿದೆಯೇ ಎಂದು ನಿಮಗೆ ತಿಳಿಸುವುದಿಲ್ಲ.

ಸ್ಥಿತಿ ಪಟ್ಟಿ ಐಕಾನ್ ಇಲ್ಲ, ಯಾವುದೇ ಅಧಿಸೂಚನೆಗಳಿಲ್ಲ.

ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇರುವ ಏಕೈಕ ಮಾರ್ಗ: ನಿಜವಾದ ಪರೀಕ್ಷೆ.

ಕೊನೆಯಲ್ಲಿ ಎರಡು ಮಾತುಗಳು

ಕ್ಲೌಡ್ ಕೋಡ್ LSP ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಇದು ಸಣ್ಣ ನವೀಕರಣವಲ್ಲ, ಇದು ಗುಣಾತ್ಮಕ ಬದಲಾವಣೆ.

ಮೊದಲು ಇದು "ಪಠ್ಯ ಹುಡುಕಾಟ + AI ತೀರ್ಮಾನ" ಆಗಿತ್ತು.

ಈಗ ಇದು "ಭಾಷಾ ಸರ್ವರ್ + AI ತಿಳುವಳಿಕೆ" ಆಗಿದೆ.

ನೀವು ದೂರವಾಣಿ ಪುಸ್ತಕವನ್ನು ತಿರುಗಿಸುವುದರಿಂದ ಸರ್ಚ್ ಇಂಜಿನ್ ಅನ್ನು ಬಳಸುವಂತಿದೆ.

ದಕ್ಷತೆಯ ಅಂತರವು ಅಗಾಧವಾಗಿದೆ.

ನೀವು ಕ್ಲೌಡ್ ಕೋಡ್ ಅನ್ನು ಗಂಭೀರ ಯೋಜನೆಗಾಗಿ ಬಳಸುತ್ತಿದ್ದರೆ, LSP ಅನ್ನು ಹೊಂದಿಸಲು 5 ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ.

ಈ 5 ನಿಮಿಷಗಳು ಯೋಗ್ಯವಾಗಿವೆ.

ಕ್ರಿಯಾ ಪಟ್ಟಿ:

• ಶೆಲ್ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ export ENABLE_LSP_TOOLS=1 ಅನ್ನು ಸೇರಿಸಿ

• ಕ್ಲೌಡ್ ಕೋಡ್ ತೆರೆಯಿರಿ ಮತ್ತು ನಿಮ್ಮ ಭಾಷಾ ಪ್ಲಗಿನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು /plugin ಅನ್ನು ಚಲಾಯಿಸಿ

• ಅನುಗುಣವಾದ ಭಾಷಾ ಸರ್ವರ್ ಬೈನರಿ ಫೈಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ

• ಕ್ಲೌಡ್ ಕೋಡ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ

• "LSP ಬಳಸಿ XXX ನ ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳನ್ನು ಹುಡುಕಿ" ಎಂದು ಪರೀಕ್ಷಿಸಿ

ಅನುಸ್ಥಾಪನೆಯ ನಂತರ, ನೀವು ಕಂಡುಕೊಳ್ಳುತ್ತೀರಿ: ಕ್ಲಾಡ್ ಕೋಡ್ ಇಷ್ಟು ಬೇಗ ಆಗುತ್ತೆ ಅಂತ ಗೊತ್ತಿರಲಿಲ್ಲ.