Come confrontare due file di testo in PowerShell o CMD

Quando devi confrontare due testi o file per trovare le differenzeFare le cose a occhio è la ricetta perfetta per perdere. il tempo E per di più, commetti un errore. Se lavori con script, configurazioni, i registri o elenchi di dispositivi, avere uno strumento della console che segna cosa è cambiato da una versione all'altra è oro colato.

En WindowsLa cosa più pratica da fare è tirare PowerShell e il simbolo del sistema (CMD)Questi strumenti sono inclusi di serie nel sistema. Con essi, è possibile confrontare due file, due set di dati o persino risultati in memoria e vedere a colpo d'occhio cosa c'è di nuovo, cosa è andato e cosa è rimasto invariato. Diamo un'occhiata più da vicino a come sfruttarli al meglio. Compare-Object da PowerShell e il comando fc.exe di CMD, insieme ad esempi concreti e alcuni trucchi extra.

Confronta i testi con PowerShell utilizzando Compare-Object

Confronta-Oggetto È il cmdlet standard di PowerShell per confrontare due set di oggetti. Nel caso più semplice, lo userai per vedere le differenze tra il contenuto di due file di testo, ma in realtà funziona con qualsiasi tipo di oggetto: processi, TimeSpan, valori booleani, dati CSV, risultati di script e così via.

L'idea di base è molto semplice: si indica un Oggetto di riferimento (ciò che prendi come riferimento) e un DifferenceObject (ciò che si desidera confrontare con il riferimento). Il cmdlet analizza entrambi i set e restituisce quali elementi compaiono solo in uno, solo nell'altro o in entrambi.

La sintassi generale predefinita Il metodo Compare-Object è il seguente:

Compare-Object <PSObject[]> <PSObject[]> >]

In condizioni normali, Compare-Object tenta di utilizzare i propri metodi di confronto del tipo degli oggetti. Se non riesce a trovarli, ricorre al metodo Accordare() di ogni input e confronta le stringhe risultanti. Inoltre, è possibile specificare una o più proprietà con il parametro -Proprietà in modo che vengano confrontati solo quei campi specifici.

Il risultato include sempre una proprietà chiave chiamata Indicatore laterale, che indica da dove proviene ciascun valore: se si trova solo nell'oggetto di riferimento, se si trova solo nell'oggetto differenza o se si trova in entrambi quando si richiede di visualizzare l'uguaglianza.

Se passi accidentalmente $null su ReferenceObject o DifferenceObjectIl cmdlet genera un errore di terminazione, quindi è consigliabile assicurarsi che entrambi i set contengano dati prima di effettuare il confronto.

Esempi pratici con Compare-Object

Per comprendere appieno il funzionamento di Compare-Object, non c'è niente di meglio che guardare una serie di esempi tipici, dal confronto di file di testo al confronto di oggetti complessi o all'utilizzo di parametri come -IncludeEqual, -EscludiDiverso o -Passo attraverso.

Esempio 1: confronto del contenuto di due file di testo

In questo scenario, ci sono due file di testo, ciascuno con un elenco di parole su righe separateCompare-Object consente di vedere a colpo d'occhio quali elementi sono presenti solo in un file e non nell'altro.

Supponiamo che questi file:

• Testfile1.txt: cane, scoiattolo, uccello
• Testfile2.txt: gatto, uccello, procione

Un uso tipico La funzione Compare-Object si presenterebbe così:

$objects = @{
ReferenceObject = Get-Content -Path C:\Test\Testfile1.txt
DifferenceObject = Get-Content -Path C:\Test\Testfile2.txt
}
Compare-Object @objects

L'uscita sarebbe simile a questa, dove InputObject riflette il valore confrontato e SideIndicator indica da che parte si trova:

InputObject  SideIndicator
-----------  -------------
cat        =>
racoon     =>
dog        <=
squirrel   <=

In questo contesto, "=>" significa che il valore è presente solo in DifferenceObject (in questo caso, nel contenuto di Testfile2), mentre "<=" indica che è solo in ReferenceObject (Testfile1).

Esempio 2: Mostra solo le linee comuni ed escludi le differenze

Ciò di cui potresti aver bisogno non è rilevare cosa è cambiato, ma scopri quali linee sono identiche tra due fileEcco perché viene utilizzata una combinazione di parametri. -EscludiDiverso y -IncludeEqualTuttavia, a partire da PowerShell 7.1, quando si specifica ExcludeDifferent, IncludeEqual è implicito.

Un esempio per vedere solo il linee comuni voluto:

$objects = @{
ReferenceObject = Get-Content -Path C:\Test\Testfile1.txt
DifferenceObject = Get-Content -Path C:\Test\Testfile2.txt
}
Compare-Object @objects -ExcludeDifferent

Il risultato è più o meno questo:

InputObject  SideIndicator
-----------  -------------
bird        ==

Qui è chiaro che Viene visualizzato solo il valore "bird" con SideIndicator "==", indicando che è presente in entrambi i set. Se hai utilizzato ExcludeDifferent senza IncludeEqual nelle versioni precedenti alla 7.1, potresti scoprire che non viene restituito nulla perché vengono escluse sia le differenze che le uguaglianze.

Esempio 3: Preservare il tipo originale con il parametro PassThru

Per impostazione predefinita, Compare-Object restituisce oggetti di tipo PSCustomObject con due proprietà: InputObject e SideIndicator. Tuttavia, quando si desidera continuare a lavorare con il tipo originale (ad esempio, un valore booleano, un processo, un TimeSpan, ecc.), ciò che interessa è il parametro -Passo attraverso.

Vediamo la differenza con un valore booleano molto semplice:

$a = $true
Compare-Object -IncludeEqual $a $a
(Compare-Object -IncludeEqual $a $a) | Get-Member

Questo visualizza un output con TypeName Sistema.Gestione.Automazione.PSCustomObject e le proprietà NoteProperty InputObject e SideIndicator, oltre ai metodi tipici di Equals, GetType, ToString, ecc.

Se usi adesso Passante:

Compare-Object -IncludeEqual $a $a -PassThru
(Compare-Object -IncludeEqual $a $a -PassThru) | Get-Member

In questo caso, il tipo restituito è System.Booleano, e si può vedere che l'istanza ha un'aggiunta NotaProprietà chiamata SideIndicatorSebbene non sia direttamente visibile nell'output formattato dello schermo, questo dettaglio è importante: Il tipo reale è l'originale, ma con una proprietà in più che indica se il valore è in riferimento, differenza o entrambi.

Esempio 4: Confronto di stringhe semplici in base alle proprietà

Compare-Object non è solo per i testi completi, è utile anche quando vuoi confrontare proprietà specifiche degli oggettiAd esempio, è possibile confrontare due stringhe che hanno un contenuto completamente diverso ma la stessa lunghezza.

Un esempio voluto:

$objects = @{
ReferenceObject = 'abc'
DifferenceObject = 'xyz'
Property = 'Length'
}
Compare-Object @objects -IncludeEqual

Il risultato:

Length     SideIndicator
------    -------------
3        ==

Poiché solo il Lunghezza della proprietàIl cmdlet indica che entrambe le stringhe sono equivalenti agli occhi di quella proprietà, anche se il loro testo non ha nulla a che fare l'una con l'altra.

Esempio 5: Confronto di oggetti complessi con proprietà specifiche

Quando si passa ad oggetti più complessiPer quanto riguarda i processi Windows, le cose si fanno interessanti. Immagina di memorizzare due diversi processi di PowerShell in variabili diverse, ma che condividano lo stesso nome di processo.

Senza specificare le proprietà, Compare-Object confronta il risultato di ToString() da System.Diagnostics.Processche di solito è qualcosa del tipo "System.Diagnostics.Process (pwsh)", e li considerano la stessa cosa.

Esempio riassuntivo:

$a = Get-Process -Id 11168
$b = Get-Process -Id 17600
$a.ToString()
$b.ToString()
Compare-Object $a $b -IncludeEqual

L'uscita:

InputObject  SideIndicator
-----------  -------------
System.Diagnostics.Process (pwsh)  ==

Se vuoi davvero vedere le differenze, devi specificare proprietà specifiche come ProcessName, Id o CPU:

Compare-Object $a $b -Property ProcessName, Id, CPU

In questo caso otterrai qualcosa di simile a questo:

ProcessName  Id      CPU      SideIndicator
-----------  --     ---     -------------
pwsh       17600  11.4375  =>
pwsh       11168  36.203125 <=

Qui lo si può vedere chiaramente. quale istanza è quale e come differiscono nel loro identificatore e nel tempo di CPU impiegato.

Esempio 6: Oggetti complessi che implementano IComparable

Alcuni tipi .NET implementano l'interfaccia Comparabile, che consente Compare-Object confrontarli in modo più intelligenteSe gli oggetti da confrontare sono di tipo diverso, il cmdlet tenta di convertire DifferenceObject nel tipo ReferenceObject.

Ad esempio, il confronto di una stringa che rappresenta un TimeSpan con un oggetto TimeSpan stesso produce due casi distinti a seconda dell'ordine:

Compare-Object ("0:0:1") "0:0:1" -IncludeEqual

Data di partenza:

InputObject  SideIndicator
-----------      -------------
00:00:01   ==

In questo caso, la stringa diventa un TimeSpan ed entrambi gli oggetti sono considerati uguali. Ma se si inverte l'ordine:

Compare-Object "0:0:1" ("0:0:1")

Otterrai qualcosa del tipo:

InputObject  SideIndicator
-----------      -------------
00:00:01   =>
0:0:1     <=

In questo secondo scenario, il TimeSpan finisce per diventare una catena e il risultato del confronto considera che le rappresentazioni sono diverse.

Parametri importanti dell'oggetto di confronto

Compare-Object ha una buona manciata di parametri che dovresti padroneggiare per sfruttarlo al meglio. Passiamo in rassegna quelli più utili, con una chiara spiegazione di cosa fa ciascuno.

Parametro -CaseSensitive

Il modificatore -Maiuscole e minuscole indica che il confronto dovrebbe distinguere tra lettere maiuscole e minuscoleSenza questo parametro, per impostazione predefinita, PowerShell in molti contesti gestisce i confronti senza distinzione tra maiuscole e minuscole.

Caratteristiche:

• Tipo: Parametro di commutazione
• Valore predefinito: Falso
• Non consente caratteri jolly
• Posizione: nominato (non inquadrato)

Parametro -Cultura

Con -Cultura puoi specificare il riferimento culturale utilizzato nel confrontoCiò è molto utile quando si confrontano stringhe che dipendono dalla lingua, da un ordinamento alfabetico specifico o da regole regionali.

Le sue proprietà:

• Tipo: Corda
• Valore predefinito: Nona (usare la cultura corrente)
• Non accetta caratteri jolly
• Parametro denominato, facoltativo

Parametro -DifferenceObject

Parametro -OggettoDifferenza indica l'insieme degli oggetti che sono confrontare con il set di riferimentoÈ obbligatorio in qualsiasi chiamata che non sia puramente posizionale ed è dove si caricano i nuovi dati, dal "lato destro".

Proprietà rilevanti:

• Tipo: PSObject[]
• Obbligatorio: I veri
• Accetta input dalla pipeline: I veri
• Non consente caratteri jolly
• Posizione: 1 (quando si utilizzano parametri posizionali)

Parametro -ExcludeDifferent

L'interruttore -EscludiDiverso serve a nascondere le differenze e mostrare solo le somiglianze tra riferimento e differenza. In combinazione con IncludeEqual, riduce l'output ai valori comuni.

Aspetti chiave:

• Tipo: SwitchParameter
• Valore predefinito: Falso
• Se utilizzato senza IncludeEqual nelle versioni precedenti, l'output potrebbe essere vuoto.
• In PowerShell 7.1+, IncludeEqual implica automaticamente questo.

Parametro -IncludeEqual

Parametro -IncludeEqual consente che Dovrebbero essere mostrati anche gli elementi che sono uguali. in entrambi i set. Per impostazione predefinita, Compare-Object restituisce solo le differenze, quindi questo parametro modifica completamente il tipo di informazioni restituite.

Informazioni:

• Tipo: SwitchParameter
• Valore predefinito: Falso
• Quando attivato, l'output può includere sia differenze che uguaglianze
• Quando in SideIndicator appare "==", significa che il valore esiste in entrambi i set.

Parametro -PassThru

Come visto prima, -PassThru indica che Compare-Object non deve racchiudere gli oggetti in PSCustomObjectma piuttosto restituiscono gli oggetti originali, aggiungendo solo la proprietà SideIndicator come NoteProperty.

Punti chiave:

• Tipo: SwitchParameter
• Valore predefinito: Falso
• Ideale quando hai bisogno continuare a manipolare il tipo effettivo dell'oggetto
• La visualizzazione della console potrebbe nascondere l'esistenza di SideIndicator se il formato predefinito del tipo non lo mostra.

Parametro - Proprietà

Il modificatore -Proprietà consente di definire un insieme di proprietà specifiche da confrontare sia in ReferenceObject che DifferenceObject. Invece di confrontare l'intero oggetto, Compare-Object si limita a questi campi.

Caratteristiche:

• Tipo: Oggetto[]
• Valore predefinito: Nessuno
• Di per sé non supporta i caratteri jolly, ma è possibile utilizzare le proprietà calcolate.
• Permette di calcolare le proprietà, utilizzando blocchi di copione o tabelle hash con la chiave Espressione

Parametro -ReferenceObject

Parametro -Oggetto di riferimento identifica il insieme di oggetti che viene preso come base nel confronto. È la parte "vecchia" o di riferimento con cui viene confrontato DifferenceObject.

Le sue proprietà più importanti:

• Tipo: PSObject[]
• Obbligatorio: Vero
• Non accetta input di canale diretto (anche se accetta input per nome, a seconda dell'utilizzo)
• Non consente caratteri jolly
• Posizione: 0 se si utilizza la sintassi posizionale

Parametro -SyncWindow

Parametro -Finestra di sincronizzazione ControlA Quanti oggetti adiacenti controlla Compare-Object quando tenta di risincronizzare le raccolte? quando non c'è corrispondenza nella stessa posizione. Questo è particolarmente importante quando si lavora con liste lunghe in cui potrebbero esserci inserimenti o eliminazioni intermedie.

Proprietà:

• Tipo: Int32
• Valore predefinito: ::MaxValue (ovvero, scorre l'intera raccolta)
• Valori più piccoli possono migliorare le prestazioni, ma Riducono la precisione di risincronizzazione

Parametri comuni

Compare-Object supporta anche parametri comuni di PowerShell-Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutBuffer, -OutVariable, -PipelineVariable, -ProgressAction, -Verbose, -WarningAction e -WarningVariable. Queste non modificano la logica di confronto, ma consentono di regolare il comportamento di output, debug e gestione degli errori.

Input e output di Compare-Object

Quando si lavora con Compare-Object, è importante essere chiari quali tipi di input accetta e cosa restituisceperché determina come collegare il risultato con altri cmdlet o script.

Input

L'ingresso principale della tubazione è ricevuto DifferenceObject, che accetta oggetti di tipo PSObjectIn questo modo è possibile fare qualcosa come ottenere dati con un cmdlet e passarli direttamente al confronto senza variabili intermedie.

Risultati

Per quanto riguarda l'uscita, si distinguono due casi nettamente distinti:

Da un lato, quando ReferenceObject e DifferenceObject sono esattamente la stessa cosa e non stai utilizzando IncludeEqual, il cmdlet Non restituisce nulla.Ciò è utile per utilizzare Compare-Object negli script che agiscono solo se ci sono modifiche.

D'altra parte, quando vengono rilevate delle differenze, Compare-Object restituisce oggetti PSCustomObject con la proprietà SideIndicator. Se viene utilizzato anche IncludeEqual e gli oggetti sono uguali, vengono restituiti anch'essi, ma con l'indicatore "==". Se viene aggiunto PassThru, il tipo effettivo non cambia, ma ogni istanza incorpora la proprietà NoteProperty SideIndicator, sebbene la vista formattata potrebbe non visualizzarla.

Alias ​​e note su Compare-Object

In Windows, PowerShell include diversi alias utili per chiamare Compare-Object più rapidamente, come confrontare o diffQuesti alias sono molto utili quando si vogliono esplorare rapidamente le differenze nella console senza digitare il nome completo del cmdlet.

È importante tenere presente che, quando si utilizza PassanteL'output visualizzato nella console potrebbe non mostrare la proprietà SideIndicator perché il formato predefinito per quel tipo di oggetto non la include nella vista. Ciò non significa che la proprietà non esista: puoi verificarlo facilmente utilizzando Ottieni-Membro oppure selezionando esplicitamente la proprietà con Select-Object.

Esempio pratico: confronto di due elenchi di indirizzi MAC in Excel utilizzando PowerShell

Un caso molto comune negli ambienti di rete è quello di ricevere un elenco settimanale di indirizzi MAC sconosciuti e dover controllare quali sono già stati esaminati e quali sono nuovi. Per evitare di impazzire, è meglio mantenere un file master con tutti gli indirizzi MAC già controllati e confrontare il nuovo elenco con quello storico.

Immaginiamo di utilizzare due fogli di calcolo:

• Unknown_Devices.xlsx: un elenco cumulativo con tutti gli indirizzi MAC noti e la loro giustificazione.
• test.xlsx: Nuovo elenco della settimana, con una colonna "Dispositivo Mac".

Un modo inefficiente per affrontare questo problema sarebbe quello di scorrere ogni nuovo indirizzo MAC e controllare se appare nell'elenco sopra utilizzando semplici confronti come -Ne. Il problema è che Il confronto di un valore scalare con un'intera colonna di un set di dati Excel non funziona come previsto.e finisci per stampare quasi l'intero nuovo elenco.

Invece, ha molto più senso caricare entrambi i file con Importa-Excel Quindi usa Compare-Object, specificando la proprietà "Device Mac" per confrontare solo quella colonna. Qualcosa del genere:

$PreviousData = Import-Excel -Path 'H:\Unknown_Devices.xlsx'
$NewData = Import-Excel -Path 'C:\Users\usuario\Downloads\test.xlsx'
Compare-Object -ReferenceObject $PreviousData -DifferenceObject $NewData -Property 'Device Mac' |
Where-Object { $_.SideIndicator -eq '=>' }

Ecco come si ottengono Solo gli indirizzi MAC elencati nel nuovo elenco e non in quello vecchio.Questi sono quelli che devono essere esaminati e, una volta giustificati, aggiunti al file master. Se si desidera visualizzare anche quelli scomparsi, è possibile cercare quelli con SideIndicator "<=".

Genera report HTML e registri delle differenze con PowerShell

Oltre a una semplice differenza di testo sullo schermo, PowerShell consente Automatizza report HTML e registri dettagliati utilizzando Compare-Object come nucleo. Un esempio ben sviluppato potrebbe combinare:

• Ottenere il formato di data e ora corrente per la denominazione dei file.
• Uso di Start-Transcript e Stop-Transcript per salvare l'intera sessione in un registro.
• Definizione di stili CSS per formattare il report HTML (caratteri, colori, tabelle, righe alternate, ecc.).
• Tour della macchina o della cartella utilizzando tabelle hash e cicli foreach.
• Estrazione dei file dai fornitori A e B con Get-ChildItem, filtrando per date ed estensioni diverse (txs, txt, pdf).
• Confronto processo per processo con Compare-Object e interpretazione di SideIndicator per identificare i problemi.
• Conversione dei risultati in HTML con Converti in HTML e personalizzazione di intestazioni e colonne.
• Invio di report tramite e-mail utilizzando Invia-Messaggio-Mail e allegando l'HTML generato.

In questo tipo di scrittura più complessa, è comune:

Applica proprietà come InputObject e SideIndicator Per creare messaggi di registro come "Trovato il giorno X in entrambe le cartelle" o "Trovata differenza tra origine e destinazione", vengono utilizzati valori speciali come "0000" o "0001" per indicare che una macchina non genera file.

Il risultato viene quindi formattato con ConvertTo-Html, sostituendo i nomi delle colonne utilizzando -sostituire (ad esempio, modificando InputObject in PROCESS e SideIndicator in STATE) e sostituendo i codici "==", "=>" o "<=" con testi più leggibili come "OK", "PROBLEM SUPPLIER-X" o "PROBLEM SUPPLIER-A".

Infine, tutto viene raggruppato in un unico file HTML, compresi i titoli con E, una tabella riepilogativa del numero di macchine e un piè di pagina con la data di creazione, prima di inviare il report via e-mail ai destinatari desiderati.

Operatori ed espressioni utili per completare Compare-Object

In molti script di confronto di PowerShell, è anche fondamentale padroneggiare operatori aritmetici, logici, di confronto, di appartenenza e di tipo, oltre a utilità come -split e -join per la manipolazione delle stringhe.

A livello aritmetico, oltre a +, -, *, /, l'operatore modulo (%) Restituisce il resto di una divisione intera. Ad esempio, 5%3 restituisce 2, perché 5 è 1 per 3 con resto 2. Questi operatori si applicano sia ai valori letterali che alle variabili (ad esempio, $var1 + $var2 somma il contenuto di entrambi se sono numerici, oppure concatena le stringhe).

Con gli operatori relazionali, PowerShell offre varianti con distinzione tra maiuscole e minuscole (-like / -clike, -eq / -ceq, ecc.). Ad esempio, 'Powershell' -like '*shell' restituisce True, mentre 'Powershell' -clike 'p*shell' restituisce False perché la versione "c" distingue tra maiuscole e minuscole.

Operatori di appartenenza come -in e -contiene Sono molto utili per filtrare gli elementi: 'shell' -in 'Console','shell' restituisce True, mentre 'Console','powershell' -contains 'shell' restituisce False. Ognuna viene utilizzata in modo opposto all'altra, quindi puoi scegliere quella che meglio si adatta alla logica della tua condizione.

Esistono anche operatori di tipo, come -è, con cui è possibile verificare se un valore è di un dato tipo: 'Hello' -is o 20 -is restituiscono True, mentre 'B' -is restituisce False.

Nella parte logica, hai -e, -o e -non (o la loro forma abbreviata!)Ad esempio, (5 -eq 5) -e (8 -eq 9) è Falso perché una delle condizioni non è soddisfatta, mentre (5 -eq 5) -o (8 -eq 9) è Vero. E -non (8 -eq 9) è anche Vero perché 8 è chiaramente diverso da 9.

Infine, operatori come -dividi e -unisci Consentono di dividere e ricostruire le stringhe. `-split 'PowerShell is simple'` restituisce i tre termini separatamente, mentre `-split ':'` utilizza il carattere due punti come delimitatore. Al contrario, `-join` può unire gli elementi di un array in un'unica stringa con o senza separatore.

Confronta testi e file con CMD utilizzando fc.exe

Se preferisci il classico prompt dei comandi o ti trovi in ​​un ambiente in cui hai solo CMD, puoi usare fc.exeLo storico comando di Windows per il confronto dei file. Sebbene il suo output sia meno flessibile di quello di PowerShell, rimane molto utile per confronti rapidi in modalità testo o binaria.

La sintassi di base FC è:

fc /a ] <filename1> <filename2>
fc /b <filename1> <filename2>

In modalità testo (ASCII), fc confronta riga per riga e tenta di risincronizzare i file quando trova discrepanze. In modalità binaria, esegue un confronto byte per byte senza nuovi tentativi di sincronizzazione ed è quello utilizzato di default per estensioni come .exe, .com, .sys, .obj, .lib o .bin.

Parametri principali di fc.exe

I modificatori più utili FC include:

• /a: abbrevia l'output di un confronto ASCII, mostrando solo la prima e l'ultima riga di ciascun gruppo di differenze.
• /b: forza il confronto binario byte per byte, utile per file eseguibili o dati binari.
• /c: ignora le lettere maiuscole e minuscole.
• /l: indica la modalità ASCII (testo), confrontando riga per riga.
• /libbre: imposta la dimensione del buffer interno delle righe an (predefinito 100); se ci sono più differenze consecutive, fc potrebbe interrompersi con un messaggio di file troppo diversi.
• /n: visualizza i numeri di riga nei confronti ASCII.
• / spento: non scarta i file con l'attributo "offline".
• /t: evita di convertire le tabulazioni in spazi; se non lo si utilizza, le tabulazioni vengono trattate come spazi ogni ottava posizione.
• /u: confronta i file come testo Unicode.
• /w: comprime gli spazi vuoti (tabulazioni e spazi), trattandoli come un unico spazio e ignorando gli spazi iniziali e finali.
• /nnnn: imposta quante righe consecutive devono corrispondere dopo una discrepanza per essere considerate risincronizzate; il valore predefinito è 2.

Inoltre, è possibile utilizzare caratteri jolly come * e ? nei nomi dei file per confrontare interi set. Se si inserisce un carattere jolly nel primo nome file, fc confronta ogni file specificato con il file o il set specificato in filename2; se il carattere jolly è presente in filename2, fc utilizza il nome corrispondente dal primo set.

codici di uscita fc.exe

Dopo l'esecuzione, fc stabilisce un codice di uscita che puoi utilizzare in script batch o automazioni:

• 0: i file sono identici.
• 1: I file sono diversi.
• 2: Si è verificato un errore durante il confronto.

Esempi di utilizzo di fc.exe

Per eseguire un confronto ASCII abbreviato da due resoconti:

fc /a monthly.rpt sales.rpt

Per confrontare in binario due file batch:

fc /b profits.bat earnings.bat

Se ci sono differenze, vedrai indirizzi esadecimali e byte diversi per ogni file. Qualcosa del genere:

00000002: 72 43
00000004: 65 3A
0000000E: 56 92
000005E8: 00 6E
FC: earnings.bat longer than profits.bat

Se sono identici, il messaggio sarà più diretto:

Comparing files profits.bat and earnings.bat
FC: no differences encountered

È anche possibile confrontare tutti i file .bat nella directory corrente con un file specifico:

fc *.bat new.bat

Oppure confronta i file new.bat su unità diverse:

fc c:new.bat d:*.bat

E confronta tutti i file .bat da C:\ con gli stessi nomi su D:\:

fc c:*.bat d:*.bat

Quando fc esegue confronti ASCII su file molto lunghi, utilizza un buffer interno di 100 righe Per impostazione predefinita, se trova più di quel numero di righe diverse in una riga, potrebbe restituire il messaggio "Risincronizzazione non riuscita. I file sono troppo diversi". Nei confronti binari di file molto grandi, fc sovrappone in modo trasparente i blocchi in memoria finché non termina.

Dettagli sottili quando si confrontano file di testo "identici"

Un caso curioso che si verifica spesso è l'incontro due file di testo che sembrano identici Questi valori appaiono diversi in un editor o in uno strumento di confronto, ma non si comportano allo stesso modo per una specifica applicazione. Anche selezionando tutto in entrambi i casi, potresti vedere un conteggio dei caratteri diverso, ad esempio 6502 rispetto a 6501.

Questo tipo di discrepanza è solitamente dovuta a personaggi invisibili: un carattere di controllo, un BOM (Byte Order Mark) nelle codifiche Unicode, un'interruzione di riga aggiuntiva alla fine del file, differenze tra CRLF e LF o uno spazio vuoto che lo strumento di confronto ignora se è impostato per non mostrare le modifiche di spazio.

Quando un software richiede un formato di testo molto specifico, questi dettagli fanno la differenza. Ecco perché, se qualcosa "non torna", è consigliabile controllare la codifica del file, le terminazioni di riga e utilizzare un... confronto in modalità binaria (con strumenti simili fc /bo) per scovare eventuali byte extra o mancanti.

così Compare-Object in PowerShell come fc.exe in CMD Forniscono un potente arsenale per confrontare testi, file e raccolte di oggetti. Utilizzandoli in modo efficace, è possibile rilevare modifiche tra le versioni, generare report HTML leggibili, filtrare solo ciò di cui si ha bisogno (ad esempio, nuove voci in un elenco MAC) e persino integrare queste informazioni in processi automatizzati di monitoraggio o convalida dei dati, risparmiando ore di revisione manuale e riducendo drasticamente l'errore umano.