Cum să creezi și să depanezi scripturi pas cu pas cu Copilot

Crearea și depanarea scripturilor pas cu pas cu Copilot a devenit una dintre cele mai rapide și mai convenabile metode de lucru pentru orice dezvoltator, indiferent dacă programezi în C#, Python , JavaScript, PowerShell sau construiești API-uri cu FastAPI. Copilot nu se limitează la a sugera cod: înțelege contextul, analizează erorile și te ghidează prin întregul proces de depanare.

Departe de a fi o simplă funcție de completare automată, Copilot acționează ca un companion de programare bazat pe inteligență artificială , care se integrează cu Visual Studio, VS Code, Edge DevTools și Azure, ajutându-vă să diagnosticați probleme, să explicați excepții, să generați scripturi de la zero și să remediați automat secțiunile de cod defecte. Să aruncăm o privire clară și directă asupra modului în care puteți profita la maximum de aceasta pentru a crea și depana scripturi cu o eficiență reală.

Ce este GitHub Copilot și cum te ajută să depanezi mai bine?

GitHub Copilot este o extensie de inteligență artificială dezvoltată de GitHub și OpenAI care se conectează la IDE-urile obișnuite (Visual Studio, VS Code, JetBrains, Vim/Neovim etc.) și oferă sugestii de cod, explicații și corecții în timp real în timpul scrierii și depanării.

Marea putere a Copilot în depanare constă în înțelegerea contextului tehnic: stiva de apeluri, cadre, nume de variabile, valori curente, fișiere conexe și, atunci când este integrat cu depanatorul, poate „vedea” excepția generată, linia în care totul s-a stricat și starea programului chiar înainte de eșec.

Pe lângă sugestiile de linii sau blocuri de cod , Copilot poate explica erori, poate propune refactorizări, poate genera teste unitare, poate ajuta cu puncte de întrerupere condiționate și chiar poate programa modificări la mai multe fișiere dacă utilizați modul agent în Visual Studio.

Cu nivelul gratuit GitHub Copilot, ai acces la aproximativ 2.000 de completări de cod pe lună și aproximativ 50 de mesaje de chat, cu opțiunea de a alege modele avansate de inteligență artificială (cum ar fi GPT-4o sau Claude 3.5 Sonnet), ceea ce oferă deja o mulțime de posibilități pentru proiecte personale, automatizări mici sau învățare.

Planuri, configurare de bază și primii pași cu Copilot

Înainte de a începe să creezi și să depanezi scripturi cu Copilot, ai nevoie de un cont GitHub și de mediul de dezvoltare preferat (cum ar fi Visual Studio sau VS Code) instalat. De acolo, pur și simplu adaugă extensia oficială GitHub Copilot.

În Visual Studio Code , deschideți vizualizarea Extensii (Ctrl+Shift+X pe Windows/Linux sau Cmd+Shift+X pe macOS), căutați „GitHub Copilot” și faceți clic pe „Instalare”. După ce ați terminat, reporniți VS Code pentru a activa extensia și a vă permite să vă conectați cu contul dvs. GitHub.

În Visual Studio (2022 sau o versiune ulterioară) , veți vedea insigna GitHub Copilot în colțul din dreapta sus al IDE. De acolo, o puteți instala dacă nu este deja acolo și puteți deschide direct fereastra de chat pentru a vă conecta sau a vă înscrie la planul gratuit.

Odată conectat , Copilot va începe să ofere completări de cod în editor (acestea apar într-o nuanță de gri) și poți deschide fereastra de chat pentru a pune întrebări în limbaj natural despre codul tău, erori sau orice nelămurire tehnică.

Moduri de utilizare Copilot: Întreabă, Editează și Agent

Copilot funcționează cu mai multe moduri de interacțiune care modifică domeniul de aplicare al codului: de la răspunsul la o întrebare specifică până la executarea unui plan în mai mulți pași cu instrumente externe.

Modul Întrebare este modul clasic de chat: tastezi „De ce returnează această funcție o valoare incorectă?” sau „Explică această excepție”, iar Copilot răspunde cu o explicație și adesea cu sugestii de cod. Nu modifică fișierele decât dacă aplici în mod explicit modificările sugerate.

Modul de editare vă permite să selectați un bloc de cod și să-i cereți lui Copilot să îl modifice conform instrucțiunilor dvs.: refactorizare, optimizare, remediere erori, adăugare jurnale etc. Modelul generează o propunere de editare pe care o puteți accepta sau respinge parțial.

Modul Agent (în Visual Studio 17.14 sau o versiune ulterioară) este locul în care Copilot funcționează ca un adevărat „agent autonom” de dezvoltare: analizează solicitarea dvs., generează un plan, apelează instrumente (compilator, teste, terminal , MCP etc.), face modificări la diverse fișiere și iterează până se apropie de obiectivul dorit.

Modul agent nu se oprește după un singur mesaj ; în schimb, continuă să funcționeze, verificând erorile de compilare, rezultatele testelor și ieșirile de la instrumentele externe, propunând noi modificări și solicitând confirmare când va executa comenzi sensibile pe mașina dvs.

Comenzi și scurtături de taste pentru crearea și depanarea scripturilor cu Copilot

Una dintre cele mai rapide metode de a ghida Copilot este prin utilizarea comenzilor speciale în chat sau în modul inline, mai ales când selectați o porțiune de cod și doriți să concentrați ajutorul pe ceva anume.

Printre cele mai utile comenzi pentru crearea și depanarea scripturilor se numără:

• /doc: generează sau extinde documentația codului selectat.
• / edita: rescrie blocul de cod conform unei instrucțiuni (de exemplu, „fă-l mai lizibil” sau „convertește-l în programare funcțională”).
• /explica: explică ce face codul sau de ce se comportă într-un anumit fel.
• /repare: analizează fragmentul selectat, localizează erorile și propune corecții specifice.
• /Genera: creează cod nou (funcții, clase, module sau chiar fișiere întregi) dintr-o specificație.
• /testeGenerează teste unitare sau de integrare adaptate codului selectat.

Lângă butonul de trimitere din Copilot Chat puteți schimba și tipul de sarcină: „Întrebare” pentru solicitări, „Editare” pentru modificări de cod și „Agent” pentru sarcini complexe, cu mai mulți pași, cum ar fi migrarea unei API sau crearea unei arhitecturi complete de proiect.

Opțiunea „Adăugați context…” din partea de sus a ferestrei de chat vă permite să atașați fișiere, foldere, probleme de cod sau simboluri , astfel încât Copilot să aibă mai multe informații și să poată genera răspunsuri și scripturi adaptate proiectului dumneavoastră.

Tipuri de erori și cum să le depanați cu Copilot

Când vorbim despre depanarea scripturilor pas cu pas , este important să facem distincția între diferitele tipuri de erori care pot apărea într-un program, deoarece modul de a solicita ajutorul Copilot se schimbă ușor în funcție de caz.

Erorile lexicale apar atunci când compilatorul sau interpretorul întâlnește caractere sau token-uri pe care nu le recunoaște: simboluri plasate greșit, cuvinte cheie scrise greșit sau șiruri de caractere închise incorect.

O strategie eficientă cu Copilot este să selectați linia problematică, să lansați comanda /fix și să o lăsați să propună corecția precisă sau să o rugați să „explique de ce această linie conține o eroare lexicală și să o corecteze, păstrând în același timp intenția comentariului”.

Erorile de sintaxă apar atunci când structura codului încalcă regulile limbajului: paranteze lipsă, blocuri indentate incorect, funcții declarate incorect etc. Aici excelează Copilot, rescriind blocuri întregi cu sintaxa corectă dacă îi spui într-un comentariu ce ar trebui să facă codul.

Erorile semantice sunt deosebit de periculoase deoarece programul „compilează și rulează”, dar rezultatul este incorect. Copilot vă poate ajuta să le descoperiți cerându-i să explice pas cu pas logica funcției, să compare comportamentul real cu comportamentul așteptat sau să genereze cazuri de testare care demonstrează eșecul.

În cele din urmă, erorile de execuție (IndexError, NullReferenceException, ZeroDivisionError etc.) sunt perfecte pentru modul de depanare asistată: Copilot citește excepția, examinează stiva de apeluri și starea variabilelor și sugerează modificări structurale (cum ar fi adăugarea de blocuri try/except, verificări ale indexului sau validarea datelor).

Depanare pas cu pas cu Copilot în Visual Studio

Visual Studio integrează Copilot profund în depanator , astfel încât să puteți lansa o sesiune tradițională de depanare (puncte de întrerupere, F5, F10, F11) și, în orice moment, să deschideți chatul pentru a pune întrebări despre linia curentă, stiva de apeluri sau o anumită excepție.

Un exemplu tipic în C# Pornește o aplicație consolă, setând un punct de întrerupere pe o linie care analizează argumentele (de exemplu int value = Int32.Parse(args);) și verificați dacă variabila args Are lungime zero. De acolo, puteți face clic dreapta în editor și alege „Întreabă Copilot” pentru a deschide o conversație legată direct de acea linie.

Punând întrebări precum „De ce variabila args are valoarea șir de caractere?”, Copilot examinează contextul depanatorului (valori, stivă, fișier) și returnează o explicație argumentată a motivului pentru care programul a rămas fără argumente, cu sugestii pentru validarea datelor introduse de utilizator sau furnizarea valorilor implicite.

Dacă acceptați o corecție sugerată , Visual Studio poate aplica automat modificările fișierului. Dacă preferați să aflați mai multe, puteți adăuga întrebări ulterioare în lanț, cum ar fi „Cum gestionez cazul în care nu sunt transmise argumente programului?”, iar Copilot va adăuga gestionarea corespunzătoare a erorilor.

Când apare o excepție (de exemplu, o IndexOutOfRangeException), depanatorul întrerupe execuția și apare de obicei un buton „Întreabă Copilot”. Dacă dai clic pe acesta, se deschide chatul cu excepția, mesajul și stiva deja injectate ca și context, deci nu trebuie să copiezi și să lipești nimic.

Din acea fereastră, Copilot generează o explicație, propune o corecție, oferă un buton de previzualizare pentru a vizualiza diferența și, dacă ești convins, poți aplica patch-ul și reporni depanatorul pentru a verifica dacă eroarea a dispărut.

Utilizarea avansată a modului agent și a planificării în Visual Studio

Modul de agent al Copilot din Visual Studio merge cu un pas mai departe: nu numai că răspunde la interogarea dvs., dar se organizează și intern cu un plan de lucru în mai mulți pași, care poate include editări de cod, comenzi de terminal, rularea de teste și utilizarea de instrumente suplimentare precum MCP.

Când activezi opțiunea „planificare” în setările GitHub Copilot, agentul creează două artefacte: un plan într-un format markdown lizibil pentru tine și un fișier JSON intern în care înregistrează obiectivele, pașii și starea fiecărei sarcini, permițându-i să mențină consecvența pe parcursul întregii sesiuni.

Pentru tine, ca dezvoltator , asta înseamnă că îi poți solicita să facă lucruri precum „Adăugați autentificarea JWT la această API și creați teste de bază” și să vedeți cum propune Copilot un plan: ce fișiere să atingă, ce dependențe să adauge, ce comenzi de compilare și testare să ruleze și cum va valida fiecare pas.

Agentul folosește un set de instrumente interne (plan, adaptare a planului, actualizare a progresului, înregistrare a observațiilor și finalizare a planului) care îi permit să reacționeze dacă, de exemplu, compilarea eșuează după o anumită editare sau un test unitar începe să se întrerupă.

În orice moment, puteți menține controlul : puteți revizui modificările listate în „Modificări totale”, puteți păstra doar unele fișiere, puteți elimina întregul lot sau chiar puteți restaura starea soluției la un punct de control anterior dacă nu sunteți mulțumit de direcția urmată de agent.

Creați și depanați scripturi în VS Code cu Copilot (Python și altele)

În Visual Studio Code, Copilot se combină foarte bine cu proiectele Python , unde erorile de tip, concatenările sau buclele prost proiectate sunt foarte frecvente atunci când începi sau scrii scripturi rapide.

Un caz clasic este un scenariu ca bugged_dice_battle.pyAceasta simulează o bătălie cu zaruri, dar eșuează cu o eroare TypeError de genul „can only concatenate str (not 'int') to str”. Copilot detectează rapid că încercați să concatenați numere în șiruri de caractere fără a le converti mai întâi și sugerează utilizarea str() sau formatarea șirurilor de caractere.

Pentru a beneficia de acest tip de ajutor , pur și simplu deschideți fișierul în VS Code (sau într-un mediu WSL 2 ), rulați scriptul din terminalul integrat, copiați mesajul de eroare și lipiți-l în chat-ul Copilot împreună cu întrebarea: „Ce înseamnă această eroare și cum o remediez în acest fișier?”.

Copilot răspunde explicând sursa erorii , indicând linia specifică a scriptului și returnând o versiune corectată a funcției afectate, pe care o puteți copia sau aplica ca patch folosind /edit dacă aveți extensia configurată pentru modificări inline.

Același lucru este valabil și pentru scripturi precum bugged_factorial_finder.pyunde programul rulează, dar ieșirea este prea mare deoarece formula factorială este incorectă. Copilot analizează bucla și detectează că înmulțiți cu o valoare suplimentară (utilizarea greșită a *=) și sugerează logica adecvată pentru acumularea corectă a factorialului.

Copilot în browser: Depanarea JavaScript cu Edge DevTools

Când depanați JavaScript în browser , Microsoft Edge integrează Copilot în DevTools, astfel încât să puteți înțelege mai bine codul sursă, mai ales dacă aveți de-a face cu fișiere minimizate sau biblioteci complexe.

În fila „Surse” puteți încărca fișierul JavaScript, puteți utiliza butonul „Formatare” pentru a înfrumuseța codul minimizat și apoi puteți seta puncte de întrerupere a liniei pentru a întrerupe execuția exact acolo unde suspectați că provine eroarea.

În timp ce este în pauză la un punct de întrerupere, puteți inspecta variabile, modifica valori din mers, parcurge funcțiile pas cu pas (enter, pas peste, ieșire) și puteți utiliza Copilot pentru a „explica aceste linii de cod” dacă nu înțelegeți exact ce face o funcție sau un fragment deosebit de complicat.

DevTools oferă și alte tipuri de asistență cum ar fi lista de scripturi pentru ocolirea bibliotecilor terțe despre care știți că nu sunt cauza eșecului sau posibilitatea de a redenumi blocurile de cod încorporate folosind # sourceURLAcest lucru facilitează navigarea prin stivele de apeluri și jurnalele de erori.

Pentru depanarea aplicațiilor web moderne , această combinație de instrumente (puncte de întrerupere, inspecție a stivei, editare directă în browser și asistență Copilot pentru explicarea și sugerarea codului) facilitează mult găsirea și corectarea erorilor logice sau DOM.

Generarea și depanarea scripturilor PowerShell cu Azure Copilot

Azure Copilot extinde conceptul dincolo de IDE și vă permite să generați scripturi PowerShell pentru gestionarea resurselor cloud, direct din experiența Azure.

Pe baza unei solicitări în limbaj natural, cum ar fi „Cum listez mașinile virtuale pe care le rulez în Azure folosind PowerShell?” sau „Creați un script care oprește toate mașinile virtuale dintr-un anumit grup de resurse”, Azure Copilot returnează unul sau mai multe cmdlet-uri gata de lipit în consolă.

Scripturile generate includ de obicei valori substitutive clar identificate (de exemplu, nume de abonamente, grupuri de resurse sau locații), pe care trebuie să le înlocuiți cu valorile reale înainte de a rula orice în producție.

Pentru scenarii mai lungi, puteți întreba „Scrieți un script Azure PowerShell care creează un grup de resurse, configurează un cont de stocare și implementează o mașină virtuală”, iar Copilot va asambla mai mulți pași înlănțuiți în secvența logică corespunzătoare, inclusiv comentarii explicative.

Dacă scriptul nu se comportă conform așteptărilor , îl puteți copia în VS Code, îl puteți rula într-un terminal integrat și, dacă apar erori, puteți utiliza Copilot Chat pentru a vă explica mesajul și a sugera corecțiile minime necesare pentru cmdlet-urile sau parametrii utilizați.

Creați un chatbot cu FastAPI și OpenAI folosind Copilot

Copilot este, de asemenea, foarte util atunci când configurați API-uri cu framework-uri precum FastAPI , mai ales dacă doriți să îl combinați cu API-ul OpenAI pentru a crea un chatbot simplu și nu doriți să pierdeți timpul cu elementele de bază.

Un exemplu tipic de punct final este un @app.post("/chat") care primește un mesaj al utilizatorului, apelează clientul OpenAI și returnează conținutul răspunsului generat de modelul configurat (de exemplu, gpt-4), cu gestionarea de bază a erorilor, încărcarea variabilelor de mediu dintr-un fișier .env și posibilitatea de trimite alerte către Teams/Slack.

Copilot poate genera aproape întregul schelet dacă îi oferi o specificație clară: „Creează un endpoint în FastAPI numit /chat, care primește un text, apelează API-ul OpenAI cu cheia stocată în OPENAI_API_KEY și returnează textul de răspuns al asistentului, gestionând posibilele excepții cu HTTPException 500.”

După ce scriptul funcționează , dacă descoperiți că acesta eșuează în anumite cazuri (de exemplu, când mesajul este gol sau cheia nu este definită), puteți solicita Copilot să revizuiască codul, să identifice punctele slabe și să adauge validări de intrare sau o gestionare mai robustă a excepțiilor.

Aceeași dinamică se aplică oricărui tip de script: îi dai un obiectiv (automatizarea unui proces, crearea unui microserviciu, configurarea unei interfețe de comandă), iar Copilot produce o primă versiune pe care o poți rafina cu ajutorul chat-ului și al depanatorului.

Cele mai bune practici pentru afișarea de solicitări la depanare cu Copilot

Eficacitatea Copilot în crearea și depanarea scripturilor depinde în mare măsură de modul în care formulezi întrebările și de cât de mult context oferi, mai ales atunci când eroarea nu este evidentă sau implică mai multe fișiere.

Este esențial să fii specific în prompt : în loc să scrii „remediază asta”, indică ce ar trebui să facă codul, ce rezultat obții și ce te aștepți. Ceva de genul „Această funcție ar trebui să returneze media unei liste de numere întregi pozitive, dar returnează o valoare mult mai mare. Unde este problema?” este mult mai util.

Utilizarea comentariilor ca mini-specificații în cadrul codului este, de asemenea, foarte utilă: dacă scrii chiar deasupra „# Următoarea funcție ar trebui să calculeze aria unui triunghi având în vedere baza și înălțimea sa” și apoi ceri o /fix, modelul are o referință clară la intenția ta.

Pentru erori complexe sau semantice , merită să-l invităm pe Copilot să raționeze pas cu pas: „Explică linie cu linie ce face această funcție și în ce moment are loc depășirea limitei” sau „Explică pas cu pas de ce această funcție generează o eroare de execuție atunci când lista este goală”.

Când modelul devine confuz sau nu înțelege modelul , puteți recurge la instrucțiuni în câteva momente: oferiți unul sau două exemple de input/output așteptate în comentarii, astfel încât Copilot să înțeleagă ce comportament doriți să generalizați și să își ajusteze propunerea la acel model.

Cele mai bune practici pentru utilizare, personalizare și revizuire a codului

Deși Copilot automatizează multe sarcini , este important să se mențină un echilibru între încrederea în inteligența artificială și exercitarea unei judecăți critice asupra codului generat sau modificat, în special în mediile de producție.

Personalizați Copilot pentru proiectul dvs. folosind fișiere precum .github/copilot-instructions.md și solicitări salvate în .github/prompts Îți permite să-i adaptezi răspunsurile la stilul tău de codare, convențiile de denumire, framework-urile și constrângerile interne.

În echipele de lucru , este recomandabil să se convină asupra unor linii directoare privind modul de utilizare a Copilot în timpul revizuirii codului: de exemplu, să se accepte sugestii de stil și refactorizare atâta timp cât acestea trec printr-un proces de relații publice și o revizuire umană și să nu se îmbine modificările generate automat fără o analiză prealabilă.

Colaborarea beneficiază și de feedback-ul comun și de documentația generată de Copilot, deoarece ajută noii membri ai echipei să înțeleagă mai bine modulele complexe, fluxurile de business sau deciziile de design care ar putea să nu fie clare la prima vedere.

Dacă echilibrezi bine automatizarea și codarea manuală , Copilot devine un instrument care îți accelerează munca fără a reduce înțelegerea sistemului, eliberându-te de sarcini repetitive pentru a te concentra pe design, arhitectură și rezolvarea problemelor complexe.

Crearea și depanarea scripturilor pas cu pas cu Copilot înseamnă să te bazezi pe inteligența artificială care înțelege codul, mediul și obiectivele tale, pentru a face depanarea un proces mai ghidat, mai puțin frustrant și mult mai productiv, indiferent dacă abia începi să programezi sau scrii software profesional de ani de zile.