ક્લોડ કોડમાં ગુપ્ત રીતે અપગ્રેડ કરવામાં આવ્યું છે, આખરે તે "ટેક્સ્ટ સર્ચ મશીન" નથી રહ્યું

જ્યારે તમે કોડ લખો છો, ત્યારે શું તમે ક્યારેય આ પ્રશ્ન વિશે વિચાર્યું છે:

શા માટે તમે VS કોડમાં Ctrl + ક્લિક દબાવો છો, તો તમે સીધા જ ફંક્શન ડેફિનેશન પર જઈ શકો છો? શા માટે તમે ફંક્શન પર માઉસ ફેરવો છો, તો તમે સંપૂર્ણ પેરામીટર સમજૂતી જોઈ શકો છો? શા માટે તમારો કોડ ચાલ્યો પણ નથી, અને એડિટર તમને કહી શકે છે કે ક્યાં ભૂલ છે?

તમે આ સુવિધાઓનો દરરોજ ઉપયોગ કરો છો, અને તમને ખૂબ જ મજા આવે છે.

પરંતુ તમને કદાચ ખબર નહીં હોય કે આની પાછળ LSP (Language Server Protocol) નામની વસ્તુ સપોર્ટ કરે છે.

વધુ મહત્ત્વની વાત એ છે કે, ક્લોડ કોડનું 2.0.74 વર્ઝન પણ LSP ને સપોર્ટ કરે છે.

આનો અર્થ શું થાય છે?

આનો અર્થ એ થાય છે કે ક્લોડ કોડ આખરે "ટેક્સ્ટ સર્ચ મશીન" માંથી કોડને ખરેખર સમજતો AI બની ગયો છે.

LSP શું છે? સરળ ભાષામાં કહીએ તો

LSP એ માઇક્રોસોફ્ટ દ્વારા બનાવવામાં આવેલો પ્રોટોકોલ છે, જેનો હેતુ ખૂબ જ સરળ છે:

કોડ સ્માર્ટ સુવિધાઓ કોઈપણ એડિટરમાં વાપરી શકાય તે માટે.

જુઓ:

• TypeScript નું લેંગ્વેજ સર્વર, VS કોડમાં વાપરી શકાય છે, JetBrains માં વાપરી શકાય છે, Cursor માં વાપરી શકાય છે

• હવે, ક્લોડ કોડમાં પણ વાપરી શકાય છે

LSP એ તમારા એડિટરને સ્માર્ટ બનાવનારી વસ્તુ છે:

• ફંક્શનના નામ અને પેરામીટરને આપોઆપ પૂરા કરે છે

• ડેફિનેશન પર જાય છે

• બધા રેફરન્સ શોધે છે

• હોવર કરવાથી ડોક્યુમેન્ટ બતાવે છે

• રીઅલ-ટાઇમમાં ભૂલો અને ચેતવણીઓ બતાવે છે

તમે દરરોજ કોડ લખો છો, અને આ સુવિધાઓનો અસંખ્ય વખત ઉપયોગ કરો છો.

પરંતુ તમે ક્યારેય વિચાર્યું નથી કે તે કેવી રીતે અમલમાં આવે છે.

હવે વિચારવાની જરૂર નથી, ફક્ત એટલું જાણો કે: ક્લોડ કોડમાં હવે આ ક્ષમતાઓ છે.

ક્લોડ કોડ પહેલાં કેવી રીતે કામ કરતો હતો?

LSP ને સપોર્ટ કરતા પહેલાં, ક્લોડ કોડને કોઈ ફંક્શન ક્યાં વ્યાખ્યાયિત છે તે શોધવું હોય, તો તે શું કરતો હતો?

grep સર્ચ પર આધાર રાખતો હતો.

સરળ ભાષામાં કહીએ તો, તે ફુલ-ટેક્સ્ટ સર્ચ કરતો હતો, અને "displayBooks" આ અક્ષરો ક્યાં દેખાય છે તે શોધતો હતો.

શું આ કામ કરે છે? હા, કામ કરે છે.

AI મોડેલને અસંખ્ય કોડ પર તાલીમ આપવામાં આવી છે, અને તે ટેક્સ્ટમાંથી ઘણી વસ્તુઓ તારવી શકે છે.

પરંતુ સમસ્યા ક્યાં છે?

તે ખરેખર કોડ સ્ટ્રક્ચરને સમજતો નથી.

જેમ કે તમે કોઈ વ્યક્તિને "જયેશ" શોધવાનું કહો છો, તો તે ફક્ત પાનાં ફેરવીને "જયેશ" આ શબ્દો શોધશે.

જ્યારે તમે તમારા ફોનથી "જયેશ" સર્ચ કરો છો, તો તે સીધું ડેટાબેઝને પૂછે છે, અને તરત જ પરિણામ આપે છે.

આ જ તફાવત છે.

પહેલાંનો ક્લોડ કોડ: એક પછી એક ફાઇલ વાંચતો હતો, અને ટેક્સ્ટ મેચિંગ પર આધાર રાખતો હતો. અત્યારનો ક્લોડ કોડ: સીધું લેંગ્વેજ સર્વરને પૂછે છે, અને ચોક્કસ સ્થાન શોધે છે.

કાર્યક્ષમતામાં ઘણો મોટો તફાવત છે.

LSP ક્લોડ કોડ માટે શું લાવ્યું છે?

5 મુખ્ય ક્ષમતાઓ, દરેક કાર્યક્ષમતા માટે એક શક્તિશાળી સાધન છે:

1. goToDefinition - ડેફિનેશન પર જાઓ

તમે VS કોડમાં Ctrl+Click દબાવીને શું કરી શકો છો? સીધા જ ફંક્શન ડેફિનેશન પર જઈ શકો છો.

હવે ક્લોડ કોડ પણ આ કરી શકે છે.

તમે તેને પૂછો: "processRequest ફંક્શન ક્યાં વ્યાખ્યાયિત છે? LSP નો ઉપયોગ કરીને"

તે મૂર્ખની જેમ બધી ફાઇલોમાં શોધશે નહીં.

તે સીધું લેંગ્વેજ સર્વરને પૂછશે, અને તરત જ જવાબ આપશે: ફાઇલનું નામ, લાઇન નંબર, ચોક્કસ સ્થાન.

2. findReferences - બધા રેફરન્સ શોધો

આ એક શક્તિશાળી સુવિધા છે.

તમે કોઈ ફંક્શનને ફરીથી બનાવવા માંગો છો, પરંતુ બદલવાની હિંમત નથી, કારણ કે તમને ડર છે કે તે અન્ય જગ્યાએ તૂટી જશે.

શું કરવું?

પહેલાં તમારે ક્લોડ કોડને એક પછી એક ફાઇલ વાંચવાનું કહેવું પડતું હતું, જે ખૂબ જ ધીમું હતું.

હવે સીધું પૂછો: "displayError ફંક્શનને કઈ જગ્યાએ બોલાવવામાં આવ્યું છે? LSP નો ઉપયોગ કરીને"

લેંગ્વેજ સર્વર તમને સીધું જ બધા રેફરન્સ સ્થાનની યાદી આપશે.

ઝડપી, ચોક્કસ અને અસરકારક.

3. hover - ડોક્યુમેન્ટ અને પ્રકારની માહિતી મેળવો

તમે VS કોડમાં માઉસ ફેરવો છો, તો તમે ફંક્શન સિગ્નેચર, પેરામીટર પ્રકાર, ડોક્યુમેન્ટ સમજૂતી જોઈ શકો છો.

ક્લોડ કોડ પણ હવે જોઈ શકે છે.

તેને પૂછો: "displayBooks ફંક્શન કયા પેરામીટર સ્વીકારે છે? LSP નો ઉપયોગ કરીને"

તેને અનુમાન કરવાની જરૂર નથી, તે સીધું લેંગ્વેજ સર્વર દ્વારા આપવામાં આવેલી સિગ્નેચર વાંચે છે.

ખાસ કરીને Python જેવી ડાયનેમિક ભાષામાં, પહેલાં ક્લોડ ફક્ત સંદર્ભના આધારે પ્રકારનો અંદાજ લગાવી શકતો હતો.હવે LSP સાથે, પ્રકારની માહિતી સ્પષ્ટ છે.

4. documentSymbol - ફાઇલના તમામ પ્રતીકોની યાદી બનાવો

તમે ઝડપથી જાણવા માગો છો કે ફાઇલમાં કયા વર્ગો, કાર્યો અને ચલો છે?

ક્લોડને પૂછો: "backend/index.js માં કયા પ્રતીકો છે? LSP નો ઉપયોગ કરો"

તે તમને એક માળખાકીય યાદી પરત કરશે, જે સ્પષ્ટ અને ચોક્કસ હશે.

5. workspaceSymbol - સમગ્ર પ્રોજેક્ટ પ્રતીક શોધ

આ વધુ શક્તિશાળી છે.

આ ટેક્સ્ટ શોધતું નથી, પરંતુ પ્રતીકો શોધે છે.

તમે "innerHTML" ધરાવતી તમામ પદ્ધતિઓ શોધવા માંગો છો?

ભાષા સર્વર સીધું જ તમને તે શોધી આપશે, આ સ્ટ્રિંગ મેચિંગ નથી, પરંતુ વાસ્તવિક કોડ પ્રતીકો છે.

વાસ્તવિક દુનિયા: LSP ખરેખર કઈ સમસ્યાઓનું નિરાકરણ લાવી શકે છે?

તે બધી કાલ્પનિક બાબતોને છોડી દો, વાસ્તવિક કેસો જુઓ.

કેસ 1: ફંક્શન કોલને ટ્રેક કરો

AseBook Finder નામનો એક પ્રોજેક્ટ છે, જેમાં ફ્રન્ટએન્ડમાં displayBooks નામનું ફંક્શન છે.

તમે જાણવા માગો છો કે આ ફંક્શન ક્યાં ક્યાં કોલ કરવામાં આવ્યું છે.

પહેલાં તમે શું કરતા હતા? ક્લોડ કોડ ગ્રેપ એકવાર, કદાચ ચૂકી જાવ, કદાચ ખોટી માહિતી મળે.

હવે સીધું પૂછો: "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 માં હોવું આવશ્યક છે

જો ક્લોડ કોડ કહે છે કે "No LSP server available", તો મોટે ભાગે તમારું ભાષા સર્વર યોગ્ય રીતે ઇન્સ્ટોલ કરેલું નથી, અથવા 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 ના બધા સંદર્ભો શોધો" નું પરીક્ષણ કરો

ઇન્સ્ટોલેશન પછી, તમને જાણ થશે કે:મૂળભૂત રીતે ક્લોડ કોડ આટલું ઝડપી પણ હોઈ શકે છે.