Come trovare file in formato DOS in un file system linux

Question

Vorrei sapere quali dei miei file in una directory sono file di testo dos (invece di file di testo unix).

Quello che ho provato:

find . -name "*.php" | xargs grep ^M -l 

Non mi sta dando risultati affidabili ... quindi sto cercando un'alternativa migliore.

Eventuali suggerimenti, idee?

Grazie

Chiarimento

In aggiunta a ciò che ho detto in precedenza, il problema è che ho un mucchio di dos file senza^caratteri M in loro (da qui la mia nota su affidabilità).

il mio modo attualmente determinare se un file è DOS o non è attraverso Vim, dove in fondo si dice:

"filename.php" [dos] [noeol] 

Answer 1

Non sei sicuro di cosa si intende esattamente per "non affidabili", ma si consiglia di prova:

find . -name '*.php' -print0 | xargs -0 grep -l '^M$' 

Questo utilizza le più atroci -nomi di file-con-spazi-in-li-amichevoli opzioni e trova solo ritorni a capo immediatamente prima della fine della riga.

Tenete a mente che il ^M è un singolo CTRLM carattere, non due caratteri.

Ed anche che ti elenco i file in cui anche la linea uno è in modalità DOS, che è probabilmente quello che si vuole in ogni caso dal momento che quelli sarebbero i file UNIX stato storpiato da un editor non-UNIX.

---

Sulla base della vostra aggiornamento che Vim sta riportando i file come formato DOS:

Se vim è segnalazione come formato DOS, quindi ogni linea termina con CRLF. Questo è il modo in cui funziona vim. Se anche una riga non dispone di CR, allora è considerato formato UNIX e i caratterisono visibili nel buffer. Se è tutto formato DOS, non vengono visualizzate le ^M personaggi:

Vim cercherà DOS e fine riga di UNIX, ma Vim ha una preferenza built-in per il formato UNIX.

- Se tutte le righe nel file terminano con CRLF, verrà applicato il formato del file dos, ovvero ogni CRLF verrà rimosso durante la lettura delle righe in un buffer e l'opzione buffer 'ff' sarà dos.
- Se una o più righe terminano solo con LF, verrà applicato il formato del file unix, ovvero ogni LF verrà rimosso (ma ogni CR sarà presente nel buffer e verrà visualizzato come^M) e il buffer ' L'opzione ff 'sarà unix.

Se davvero volete sapere cosa c'è nel file, non si basano su uno strumento troppo intelligente come vim :-)

Usa:

od -xcb input_file_name | less 

e controllare il linea fine da soli.

Answer 2

ne dite:

find . -name "*.php" | xargs file | grep "CRLF" 

io non credo che sia affidabile per cercare di utilizzare ^M per cercare di trovare i file.

Answer 3

Questo è molto simile alla soluzione originale; Pertanto, è forse più facile da ricordare: processo

find . -name "*.php" | xargs grep "\r" -l 

pensiero:

In VIM, per rimuovere il^M si digita:

%s:/^M//g 

Dove^è la vostra Ctrl il tasto e M è il tasto INVIO. Ma non potrei mai ricordare i tasti per digitare stampare quella sequenza, così li ho sempre rimosso utilizzando:

%s:/\r//g 

Quindi la mia deduzione è che il \ r e^M sono equivalenti, con il primo è più facile ricordati di digitare

Answer 4

GNU trovare

find . -type f -iname "*.php" -exec file "{}" + | grep CRLF 

non so che cosa si vuole fare dopo aver trovato i file php DOS, ma se si desidera convertirli in formato UNIX, quindi

find . -type f -iname "*.php" -exec dos2unix "{}" +; 

sarà sufficiente. Non è necessario verificare specificamente se si tratta di file DOS o meno.

Answer 5

ho avuto buona fortuna con

find . -name "*.php" -exec grep -Pl "\r" {} \; 

Answer 6

Se si preferisce vim per dirvi quali file sono in questo formato è possibile utilizzare il seguente script:

"use this script to check which files are in dos format according to vim 
"use: in the folder that you want to check 
"create a file, say res.txt 
"> vim -u NONE --noplugins res.txt 
"> in vim: source this_script.vim 

python << EOF 
import os 
import vim 

cur_buf = vim.current.buffer 

IGNORE_START = ''.split() 
IGNORE_END = '.pyc .swp .png ~'.split() 

IGNORE_DIRS = '.hg .git dd_ .bzr'.split() 

for dirpath, dirnames, fnames in os.walk(os.curdir): 
    for dirn in dirnames: 
    for diri in IGNORE_DIRS: 
     if dirn.endswith(diri): 
     dirnames.remove(dirn) 
     break 
    for fname in fnames: 
    skip = False 
    for fstart in IGNORE_START: 
     if fname.startswith(fstart): 
     skip = True 
    for fend in IGNORE_END: 
     if fname.endswith(fend): 
     skip = True 
    if skip is True: 
     continue 
    fname = os.path.join(dirpath, fname) 
    vim.command('view {}'.format(fname)) 
    curr_ff = vim.eval('&ff') 
    if vim.current.buffer != cur_buf: 
     vim.command('bw!') 
    if curr_ff == 'dos': 
     cur_buf.append('{} {}'.format(curr_ff, fname)) 
EOF 

vostro vim deve essere compilato con python (python è usato per fare il loop dei file nella cartella, probabilmente c'è un modo più semplice per farlo, ma non lo so davvero ...