Ottieni il file più recente in una directory su Linux

Alla ricerca di un comando che restituirà il singolo file più recente in una directory.

Non vedere un parametro limite per ls...

ls -Art | tail -n 1

Non molto elegante, ma funziona.

ls -t | head -n1

Questo comando fornisce effettivamente l'ultimo file modificato nella directory di lavoro corrente.

Questa è una versione ricorsiva (ovvero trova il file aggiornato più di recente in una determinata directory o in una delle sue sottodirectory)

find $DIR -type f -printf "%T@ %p\n" | sort -n | cut -d' ' -f 2- | tail -n 1

Modifica: usa -f 2-invece di -f 2come suggerito da Kevin

Una nota sull'affidabilità:

Poiché il carattere di nuova riga è valido come qualsiasi in un nome di file, qualsiasi soluzione che si basa su linee come head/tail quelle basate su è difettosa.

Con GNU ls, un'altra opzione è usare l' --quoting-style=shell-alwaysopzione e un basharray:

eval "files=($(ls -t --quoting-style=shell-always))"
((${#files[@]} > 0)) && printf '%s\n' "${files[0]}"

(aggiungi l' -Aopzione als se vuoi considerare anche i file nascosti).

Se si desidera limitare a file regolari (ignorare directory, fifo, dispositivi, collegamenti simbolici, socket ...), è necessario ricorrere a GNU find .

Con bash 4.4 o successivo (per readarray -d versioni ) e GNU coreutils 8.25 o versioni successive (per cut -z):

readarray -t -d '' files < <(
  LC_ALL=C find . -maxdepth 1 -type f ! -name '.*' -printf '%T@/%f\0' |
  sort -rzn | cut -zd/ -f2)

((${#files[@]} > 0)) && printf '%s\n' "${files[0]}"

O ricorsivamente:

readarray -t -d '' files < <(
  LC_ALL=C find . -name . -o -name '.*' -prune -o -type f -printf '%T@%p\0' |
  sort -rzn | cut -zd/ -f2-)

Il migliore qui sarebbe usare zsh e le sue qualificazioni glob invece di bashevitare tutto questo fastidio:

File regolare più recente nella directory corrente:

printf '%s\n' *(.om[1])

Di cui quelli nascosti:

printf '%s\n' *(D.om[1])

Secondo più recente:

printf '%s\n' *(.om[2])

Controlla l'età dei file dopo la risoluzione del collegamento simbolico:

printf '%s\n' *(-.om[1])

ricorsivamente:

printf '%s\n' **/*(.om[1])

Inoltre, con il sistema di completamento (compinit e co) abilitato,Ctrl+Xm diventa un completatore che si espande nel file più recente.

Così:

VI Ctrl+Xm

Ti farebbe modificare il file più recente (avrai anche la possibilità di vedere quale prima di premere Return ).

VI Alt+2Ctrl+Xm

Per il secondo file più recente.

vi * .cCtrl+Xm

per il più recente c file .

vi * (.)Ctrl+Xm

per il file regolare più recente (non directory, né fifo / dispositivo ...) e così via.

Io uso:

ls -ABrt1 --group-directories-first | tail -n1

Mi dà solo il nome del file, escluse le cartelle.

ls -lAtr | tail -1

Le altre soluzioni non includono i file che iniziano con '.' .

Questo comando includerà anche '.'e '..', che può essere o meno quello che vuoi:

ls -latr | tail -1

Variante in corto basata sulla risposta di dmckee:

ls -t | head -1

Mi piace echo *(om[1])( zshsintassi) in quanto dà solo il nome del file e non invoca nessun altro comando.

La soluzione find / sort funziona alla grande fino a quando il numero di file diventa davvero grande (come un intero file system). Usa invece awk per tenere traccia del file più recente:

find $DIR -type f -printf "%T@ %p\n" | 
awk '
BEGIN { recent = 0; file = "" }
{
if ($1 > recent)
   {
   recent = $1;
   file = $0;
   }
}
END { print file; }' |
sed 's/^[0-9]*\.[0-9]* //'

Personalmente preferisco usare il minor numero possibile di bashcomandi non incorporati (per ridurre il numero di costose fork e exec syscalls). Per ordinare per data il lsnecessario per essere chiamato. Ma l'uso di headnon è davvero necessario. Uso il seguente one-liner (funziona solo su sistemi che supportano le pipe dei nomi):

read newest < <(ls -t *.log)

o per ottenere il nome del file più vecchio

read oldest < <(ls -rt *.log)

(Fai attenzione allo spazio tra i due segni '<'!)

Se sono necessari anche i file nascosti, potrebbe essere aggiunto un arg.

Spero che questo possa aiutare.

usando l'opzione ricorsiva R .. puoi considerare questo come un miglioramento per buone risposte qui

ls -arRtlh | tail -50

ls -t -1 | sed '1q'

Mostrerà l'ultimo elemento modificato nella cartella. Associa grepper trovare le ultime voci con le parole chiave

ls -t -1 | grep foo | sed '1q'

ricorsivamente:

find $1 -type f -exec stat --format '%Y :%y %n' "{}" \; | sort -nr | cut -d: -f2- | head

prova questo semplice comando

ls -ltq  <path>  | head -n 1

Se si desidera il nome del file - ultima modifica, percorso = /ab/cd/*.log

Se si desidera il nome della directory - ultima modifica, percorso = / ab / cd / * /

Presumendo che non ti interessi dei file nascosti che iniziano con a .

ls -rt | tail -n 1

Altrimenti

ls -Art | tail -n 1

Con solo i builtin di Bash, seguendo da vicino BashFAQ / 003 :

shopt -s nullglob

for f in * .*; do
    [[ -d $f ]] && continue
    [[ $f -nt $latest ]] && latest=$f
done

printf '%s\n' "$latest"

Tutte quelle soluzioni ls / tail funzionano perfettamente per i file in a directory, ignorando le sottodirectory.

Per includere tutti i file nella ricerca (ricorsivamente), è possibile utilizzare find. gioele ha suggerito di ordinare l'output find formattato. Ma fai attenzione agli spazi bianchi (il suo suggerimento non funziona con gli spazi bianchi).

Questo dovrebbe funzionare con tutti i nomi di file:

find $DIR -type f -printf "%T@ %p\n" | sort -n | sed -r 's/^[0-9.]+\s+//' | tail -n 1 | xargs -I{} ls -l "{}"

Ordina per mtime, vedi man find:

%Ak    File's  last  access  time in the format specified by k, which is either `@' or a directive for the C `strftime' function.  The possible values for k are listed below; some of them might not be available on all systems, due to differences in `strftime' between systems.
       @      seconds since Jan. 1, 1970, 00:00 GMT, with fractional part.
%Ck    File's last status change time in the format specified by k, which is the same as for %A.
%Tk    File's last modification time in the format specified by k, which is the same as for %A.

Quindi basta sostituire %T con %Cper ordinare per ctime.

Trovare il file più aggiornato in ogni directory secondo uno schema, ad esempio le sottodirectory della directory di lavoro che hanno un nome che termina con "tmp" (senza distinzione tra maiuscole e minuscole):

find . -iname \*tmp -type d -exec sh -c "ls -lArt {} | tail -n 1" \;

ls -Frt | grep "[^/]$" | tail -n 1

Se vuoi ottenere il file modificato più recente includendo anche tutte le sottodirectory puoi farlo con questo piccolo oneliner:

find . -type f -exec stat -c '%Y %n' {} \; | sort -nr | awk -v var="1" 'NR==1,NR==var {print $0}' | while read t f; do d=$(date -d @$t "+%b %d %T %Y"); echo "$d -- $f"; done

Se si desidera fare lo stesso non per i file modificati, ma per i file a cui si accede è necessario modificare semplicemente

% Y parametro dal stat comando per % X . E il tuo comando per i file di accesso più recenti è simile al seguente:

find . -type f -exec stat -c '%X %n' {} \; | sort -nr | awk -v var="1" 'NR==1,NR==var {print $0}' | while read t f; do d=$(date -d @$t "+%b %d %T %Y"); echo "$d -- $f"; done

Per entrambi i comandi è inoltre possibile modificare il parametro var = "1" se si desidera elencare più di un solo file.

Anch'io dovevo farlo, e ho trovato questi comandi. questi funzionano per me:

Se si desidera l'ultimo file entro la data di creazione nella cartella (ora di accesso):

ls -Aru | tail -n 1  

E se vuoi l'ultimo file che ha dei cambiamenti nel suo contenuto (modifica ora):

ls -Art | tail -n 1