Comparator de Diferențe

Verificatorul de diferente compara doua bucati de text si arata exact ce linii difera. Lipeaste originalul (versiunea „inainte”) in caseta de text din stanga si varianta modificata (versiunea „dupa”) in dreapta; unealta ruleaza un diff bazat pe LCS si evidentiaza fiecare diferenta in milisecunde.

Liniile adaugate apar in verde, liniile eliminate in rosu, iar liniile modificate afiseaza o evidentiere la nivel de caracter pe subsirul care s-a schimbat efectiv. O linie de sumar in partea de sus raporteaza numarul de linii adaugate, eliminate si modificate, plus un procentaj de similitudine.

Foloseste-l pentru orice comparatie de text simplu:

• cod sursa
• configuratie JSON
• manifeste YAML
• exporturi CSV
• fisiere jurnal
• ciorne Markdown
• text simplu

Unealta gestioneaza input UTF-8 de pana la cativa megabytes pe fiecare parte fara a genera erori.

Cel mai important: fiecare octet de calcul ruleaza local in browserul tau. Nimic nu este trimis catre un server, nimic nu este inregistrat, nimic nu paraseste dispozitivul tau — sigur pentru cod proprietar, documente interne si date confidentiale.

Compararea a doua texte presupune trei pasi rapidi:

• Pasul 1: Lipeaste textul original in caseta din stanga. Aceasta este versiunea „inainte” — fisierul asa cum exista inainte de modificari, ciorna originala, configuratia precedenta. Foloseste Ctrl+A si apoi Ctrl+C din orice editor de text sau browser pentru a prelua textul, apoi Ctrl+V in verificatorul de diferente.
• Pasul 2: Lipeaste textul modificat in caseta din dreapta. Aceasta este versiunea „dupa” — fisierul editat, noua ciorna, configuratia actualizata. Diferenta este calculata automat de indata ce ambele parti au continut.
• Pasul 3: Citeste rezultatul. Liniile verzi sunt adaugari prezente in dreapta, dar nu si in stanga; liniile rosii sunt eliminari prezente in stanga, dar nu si in dreapta; liniile cu evidentiere la nivel de caracter sunt „modificate” (o pereche de stergere + adaugare pe continut similar).

Sumarul din partea de sus ofera o imagine de ansamblu: numarul de elemente adaugate, numarul de elemente eliminate si un procentaj de similitudine de la 0% (fara suprapunere) pana la 100% (identice).

Bifeaza „ignora spatiile albe” daca singurele modificari sunt de formatare; bifeaza „ignora majusculele/minusculele” daca nu te intereseaza distanta dintre Hello si hello.

Uneltele de diff functioneaza la unul dintre cele trei niveluri de granularitate: linie, cuvant sau caracter.

• Linie cu linie este valoarea implicita universala pentru cod si configurare: fiecare linie este tratata ca o unitate, iar diferenta identifica ce linii intregi au fost adaugate, eliminate sau modificate semnificativ. Aceasta este ceea ce afiseaza GNU diff, git diff, pull request-urile de pe GitHub si vizualizirile de diff din IDE-uri.
• Cuvant cu cuvant (uneori numit „word diff”) imparte textul la limitele spatiilor albe — mai bun pentru text obisnuit unde modificarile apar adesea in interiorul propozitiilor.
• Caracter cu caracter este cea mai fina granularitate, utilizata intern de majoritatea uneltelor de diff pentru a evidentia exact subsirul care difera in cadrul unei linii modificate.

Unealta de mai sus afiseaza diferenta de linii ca vizualizare principala si diferenta de caractere ca evidentiere pe liniile modificate — aceeasi abordare pe doua niveluri pe care o folosesc VS Code, JetBrains si GitHub.

Foloseste diff-ul de linii pentru revizuirea codului, diff-ul de cuvinte pentru editarea textului obisnuit si diff-ul de caractere doar pentru comparatii scurte (propozitii unice, identificatori, URL-uri).

Codul sursa este cel mai comun caz de utilizare a diff-ului — fiecare revizuire de cod, fiecare pull request, fiecare commit in git implica compararea codului.

Verificatorul de diferente gestioneaza orice limbaj de programare deoarece algoritmul LCS este independent de limbaj: JavaScript, TypeScript, Python, Go, Rust, Java, Kotlin, Swift, C, C++, C#, PHP, Ruby, Scala, Elixir, Clojure, scripturi shell, fisiere Dockerfile, Terraform HCL, SQL — toate functioneaza la fel.

Buna practica pentru diff-urile de cod: formateaza ambele parti cu acelasi formatator de cod (Prettier pentru JS/TS, Black pentru Python, gofmt pentru Go, rustfmt pentru Rust) inainte de a le lipi, astfel incat spatiile albe si diferentele de stil sa nu polueze diferenta semantica reala. Daca nu poti reformatat, foloseste optiunea „ignora spatiile albe” pentru a sari peste diferentele de spatii albe de la inceput sau sfarsit.

Pentru compararea diferitelor limbaje (de exemplu, compararea unei implementari in Python cu un port in Go), diferenta de linii functioneaza in continuare, dar procentajele de similitudine vor fi inselatoare — unitatea semnificativa este similitudinea structurala, nu suprapunerea liniilor.

Diff-ul pentru JSON este unul dintre cele mai solicitate cazuri de utilizare — compararea raspunsurilor API, a fisierelor de configurare, a fisierelor package.json si a exporturilor de date structurate.

Pas prealabil important: formateaza ambele parti in mod identic. Afiseaza formatat frumos (pretty-print) cu aceeasi indentare (de obicei 2 sau 4 spatii) si sorteaza cheile obiectului alfabetic. Fara aceasta normalizare, un document JSON structural identic poate genera un diff extrem de zgomotos doar pentru ca cheile sunt in alta ordine.

Unelte pentru normalizare:

• jq cu fanionul --sort-keys
• json.dumps din Python cu sort_keys=True
• jsonformatter.org

Pentru o comparare JSON constienta semantic (unde {a:1, b:2} si {b:2, a:1} sunt egale), uneltele dedicate precum json-diff (npm), jq sau RFC 6902 JSON Patch produc un rezultat mai bun decat diff-ul de linii.

Unealta de diff de linii de mai sus functioneaza bine pentru JSON atunci cand ambele parti sunt pre-normalizate; daca ai nevoie in mod regulat de un diff JSON semantic, ia in considerare o biblioteca orientata pe JSON in stiva ta tehnica.

YAML si CSV sunt formate orientate pe linii care se compara curat cu unelte bazate pe linii — de obicei cu mai putin zgomot decat JSON, deoarece YAML nu foloseste acolade, iar CSV are o structura de randuri consistenta.

Sfaturi pentru diff YAML: asigura-te ca ambele parti folosesc aceeasi indentare (2 sau 4 spatii conteaza; YAML este sensibil la spatiile albe), aceeasi conventie de ordonare a cheilor si acelasi stil de ghilimele pentru siruri. Pentru manifeste Kubernetes, fisiere Docker Compose si YAML pentru fluxuri CI, diff-ul de linii de mai sus este unealta standard utilizata in fiecare revizuire de cod.

Sfaturi pentru diff CSV: asigura-te ca ambele fisiere folosesc acelasi delimitator (virgula, punct si virgula, tab), aceleasi sfarsituri de linie (LF versus CRLF — multe fisiere CSV din Excel folosesc CRLF), aceeasi ordine a coloanelor si anteturi corespunzatoare.

Pentru fisiere CSV mari (>10.000 de randuri), uneltele specializate precum csvdiff (Aswinkarthik) sau daff (paulfitz) produc diferente structurate care arata ce rand si ce coloana s-au modificat; pentru fisiere mai mici, unealta de diff de linii de mai sus este rapida si simpla.

Toate uneltele moderne de diff se bazeaza pe familia de algoritmi LCS (Longest Common Subsequence - Cea mai lunga subsecventa comuna).

Algoritmul original de diff a fost publicat de James Hunt si Doug McIlroy la Bell Labs in 1976 — aceeasi lucrare care a generat comanda Unix „diff” care este inca utilizata astazi. In 1986, Eugene Myers a publicat „An O(ND) Difference Algorithm and Its Variations”, care a optimizat LCS pentru cazul comun al diferentelor mici in inputuri mari.

Algoritmul lui Myers ruleaza in timp O((N+M)D), unde N+M este dimensiunea totala a inputului, iar D este numarul de modificari — mult mai rapid decat varianta naiva O(N×M) pentru diferentele tipice din lumea reala (unde D este mic in raport cu N+M). GNU diff, git diff, libxdiff (utilizat de Mercurial, Subversion, GitHub) implementeaza toate algoritmul lui Myers sau variantele strans legate „patience diff” si „histogram diff”.

Verificatorul de diferente de mai sus utilizeaza o implementare LCS in JavaScript optimizata pentru performanta in browser — suficient de rapida pentru inputuri de pana la cativa megabytes pe fiecare parte.

Exista doua moduri principale de a afisa o diferenta: alaturat (vizualizare impartita) si unificat.

Alaturat plaseaza versiunile originala si modificata in doua coloane cu modificarile aliniate orizontal — mai usor de citit pentru oameni, deoarece poti vedea ambele versiuni in acelasi timp, iar gruparea vizuala face ca structura sa fie evidenta. Acesta este modul implicit in IDE-uri (VS Code, IntelliJ), in pull request-urile de pe GitHub (in modul „split”) si in majoritatea uneltelor de diff online.

Diff-ul unificat suprapune liniile eliminate si adaugate intr-o singura coloana cu prefixe „-” si „+”, plus 3 linii de context nemodificat deasupra si dedesubt — mai compact, scriptabil (este formatul de fisier patch pe care il consuma „git apply” si „patch”) si implicit in uneltele din linia de comanda si revizuirea de cod bazata pe e-mail (lista de corespondenta pentru kernelul Linux etc.).

Alege vizualizarea alaturata pentru revizuirea vizuala a modificarilor mici si mijlocii; alege formatul unificat pentru afisarea compacta a rescrierilor mari, pentru copiere ca fisier patch sau pentrupartajare in contexte doar text (chat, e-mail, terminal).

Compararea documentelor acopera o gama larga: urmarirea a ceea ce a modificat un editor intr-o ciorna, compararea a doua versiuni ale unui contract, verificarea a ceea ce a fost parafrazat versus copiat (detectarea usoara a plagiatului) sau auditarea driftului de traducere.

Foloseste verificatorul de diferente pentru orice document in text simplu. Pentru diferite formate sursa:

• Pentru fisiere Microsoft Word .docx, exporta mai intai in text simplu (File > Save As > Plain Text in Word sau Format > Text simplu in LibreOffice). Vei pierde formatarea (aldin, italic, titluri), dar vei prinde fiecare modificare de text.
• Pentru documente PDF, utilizeaza mai intai un convertor din PDF in text (pdftotext din poppler-utils sau unelte bazate pe browser), apoi compara textul extras.
• Pentru Google Docs, foloseste istoricul de versiuni incorporat (Fisier > Istoricul versiunilor > Afiseaza istoricul versiunilor), care arata nativ diferentele urmarite dupa autor.

Pentru text narativ lung, unde pauzele de linie sunt arbitrare, ia in considerare uneltele de diff la nivel de cuvant (diff --word-diff in git) — acestea ignora incadrarea liniilor si scot in evidenta modificarile reale la nivel de cuvant.

Confidentialitatea conteaza atunci cand compari cod proprietar, documentatie interna, inregistrari financiare, date ale clientilor sau orice text confidential. Multe unelte de diff online incarca textul de intrare pe serverul lor pentru procesare — convenabil, dar un risc real pentru continutul sensibil.

Verificatorul de diferente de pe aceasta pagina este in intregime pe partea clientului: algoritmul LCS ruleaza in JavaScript in interiorul browserului tau, nicio cerere fetch() nu paraseste vreodata dispozitivul tau, nicio inregistrare de jurnal nu este creata pe niciun server. Verifica acest lucru singur deschizand Instrumente pentru dezvoltatori > fila Retea si lipind text — vei vedea zero cereri trimise in exterior.

Pentru o confidentialitate maxima asupra continutului extrem de sensibil, foloseste o unealta locala care nu atinge niciodata reteaua:

• GNU diff (preinstalat pe Linux/macOS)
• git diff (orice repository)
• Diff-ul incorporat din VS Code
• Diff-ul din IDE-urile JetBrains
• Beyond Compare

Pentru comparatii unice de text mai putin sensibil, o unealta verificata bazata pe browser, cum este cea de mai sus, ofera comoditatea unei unelte web cu confidentialitatea uneia locale.

Pentru dezvoltatori, diff-ul este infrastructura zilnica — revizuirea codului, revizuirea pull request-urilor, rezolvarea conflictelor de imbinare, compararea configuratiilor intre medii, depanarea regresiunilor de tip „ce s-a schimbat”.

Foloseste git diff pentru modificarile urmarite (git diff, git diff --staged, git diff main..feature, git diff HEAD~3); foloseaste verificatorul de diferente online de mai sus pentru comparatii ad-hoc (cineva lipeste un fragment in Slack, compari un dump de variabile de mediu din staging versus prod, verifici configuratia locala a unui coleg cu a ta).

Pentru rezolvarea conflictelor de imbinare, uneltele de diff in trei directii (kdiff3, p4merge, vizualizarea incorporata in trei directii din VS Code) depasesc diff-ul in doua directii, deoarece arata stramosul comun in plus fata de ambele parti.

Pentru revizuirea codului la scara larga, pull request-urile de pe GitHub, merge request-urile de pe GitLab si Gerrit folosesc toate acelasi diff LCS bazat pe linii in fundal — ceea ce vezi intr-un pull request este acelasi algoritm pe care il poti rula local cu git diff sau il poti lipi in unealta online de mai sus. Diferenta este reproductibila intre unelte: aceleasi inputuri produc intotdeauna acelasi diff.

Ambele produc diferente bazate pe LCS echivalente matematic — algoritmul de baza este acelasi.

Foloseste git diff cand:

• ai fisiere intr-un repository git
• vrei sa compari commit-uri/branch-uri/modificari puse in staging
• trebuie sa scriptezi diff-ul (verificari CI, carlige pre-commit)
• ai nevoie de o comparatie constienta de istoric (git log, git blame)
• sau creezi un fisier patch (git format-patch)

Foloseste un verificator de diferente online cand:

• ai text brut care nu se afla intr-un repository (un fragment dintr-un chat, un raspuns API, un dump de configurare)
• vrei o vizualizare rapida alaturata fara a configura un repository
• compari intre sisteme unde git nu este disponibil (cineva pe un Chromebook, o intalnire de revizuire a codului)
• sau continutul este sensibil si iti doresti o unealta verificata care ruleaza doar in browser, fara apeluri de retea

Ambele unelte isi au locul in setul de instrumente al unui dezvoltator; niciuna nu o inlocuieste pe cealalta. Caracteristicile esentiale ale uneltei online sunt lipsa configurarii si vizualizarea alaturata; caracteristicile esentiale ale git-ului sunt constientizarea istoricului si integrarea in ecosistem.