Obtener el archivo más reciente en un directorio en Linux

Buscando un comando que devolverá el archivo más reciente en un directorio.

No ver un parámetro de límite para ls...

ls -Art | tail -n 1

No muy elegante, pero funciona.

ls -t | head -n1

Este comando realmente proporciona el último archivo modificado en el directorio de trabajo actual.

Esta es una versión recursiva (es decir, encuentra el archivo actualizado más recientemente en un directorio determinado o en cualquiera de sus subdirectorios)

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

Editar: usar en -f 2-lugar de -f 2lo sugerido por Kevin

Una nota sobre confiabilidad:

Dado que el carácter de nueva línea es tan válido como cualquier otro en un nombre de archivo, cualquier solución que se base en líneas como las head/ tailbasadas son defectuosas.

Con GNU ls, otra opción es usar la --quoting-style=shell-alwaysopción y una bashmatriz:

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

(agregue la -Aopción lssi también desea considerar los archivos ocultos).

Si desea limitarse a archivos normales (ignorar directorios, fifos, dispositivos, enlaces simbólicos, sockets ...), deberá recurrir a GNU find.

Con bash 4.4 o posterior (para readarray -d) y GNU coreutils 8.25 o posterior (para 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 recursivamente:

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

Lo mejor aquí sería usar zshy sus calificadores globales en lugar de bashevitar toda esta molestia:

El archivo regular más nuevo en el directorio actual:

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

Incluidos los ocultos:

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

Segundo más nuevo:

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

Verifique la antigüedad del archivo después de la resolución del enlace simbólico:

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

Recursivamente:

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

Además, con el sistema de finalización ( compinity co) habilitado, se Ctrl+Xmconvierte en un completer que se expande al archivo más nuevo.

Entonces:

vi Ctrl+Xm

Te haría editar el archivo más nuevo (también tienes la oportunidad de verlo antes de presionar Return).

vi Alt+2Ctrl+Xm

Para el segundo archivo más nuevo.

vi * .cCtrl+Xm

para el carchivo más nuevo .

vi * (.)Ctrl+Xm

para el archivo regular más nuevo (no directorio, ni fifo / dispositivo ...), y así sucesivamente.

Yo suelo:

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

Me da solo el nombre del archivo, excluyendo las carpetas.

ls -lAtr | tail -1

Las otras soluciones no incluyen archivos que comienzan con '.'.

Este comando también incluirá '.'y '..', que puede o no ser lo que desea:

ls -latr | tail -1

Variante en corto basada en la respuesta de dmckee:

ls -t | head -1

Me gusta echo *(om[1])( zshsintaxis) ya que solo da el nombre del archivo y no invoca ningún otro comando.

La solución de búsqueda / clasificación funciona muy bien hasta que el número de archivos se vuelve realmente grande (como un sistema de archivos completo). Use awk en su lugar para realizar un seguimiento del archivo más reciente:

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, prefiero usar la menor cantidad de bashcomandos no incorporados que pueda (para reducir la cantidad de costosas bifurcaciones y syscalls de ejecutivos). Para ordenar por fecha se lsnecesita llamar. Pero el uso de headno es realmente necesario. Uso el siguiente one-liner (solo funciona en sistemas que admiten canalizaciones de nombres):

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

o para obtener el nombre del archivo más antiguo

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

(¡Cuidado con el espacio entre las dos marcas '<'!)

Si los archivos ocultos también son necesarios, se podría agregar un argumento.

Espero que esto pueda ayudar.

usando la opción recursiva R ... puede considerar esto como una mejora para buenas respuestas aquí

ls -arRtlh | tail -50

ls -t -1 | sed '1q'

Mostrará el último elemento modificado en la carpeta. Emparejar greppara encontrar las últimas entradas con palabras clave

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

Recursivamente:

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

prueba este simple comando

ls -ltq  <path>  | head -n 1

Si desea el nombre del archivo - última modificación, ruta = /ab/cd/*.log

Si desea el nombre del directorio - última modificación, ruta = / ab / cd / * /

Suponiendo que no le importan los archivos ocultos que comienzan con un .

ls -rt | tail -n 1

De otra manera

ls -Art | tail -n 1

Con solo Bash incorporados, siguiendo de cerca BashFAQ / 003 :

shopt -s nullglob

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

printf '%s\n' "$latest"

Todas esas soluciones ls / tail funcionan perfectamente bien para archivos en un directorio, ignorando subdirectorios.

Para incluir todos los archivos en su búsqueda (recursivamente), se puede usar find. gioele sugirió ordenar la salida de búsqueda formateada. Pero tenga cuidado con los espacios en blanco (su sugerencia no funciona con espacios en blanco).

Esto debería funcionar con todos los nombres de archivo:

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

Esto ordena por mtime, mira 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.

Así que simplemente reemplace %Tcon %Cpara ordenar por ctime.

Encontrar el archivo más actual en cada directorio de acuerdo con un patrón, por ejemplo, los subdirectorios del directorio de trabajo que tienen un nombre que termina con "tmp" (no distingue entre mayúsculas y minúsculas):

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

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

Si desea obtener el archivo modificado más reciente que también incluye subdirectorios, puede hacerlo con este pequeño 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

Si desea hacer lo mismo no para los archivos modificados, sino para los archivos accedidos, simplemente tiene que cambiar el

% Y parámetro de la stat comando para % X . Y su comando para los archivos accedidos más recientes se ve así:

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

Para ambos comandos, también puede cambiar el parámetro var = "1" si desea enumerar más de un solo archivo.

También necesitaba hacerlo, y encontré estos comandos. estos funcionan para mí:

Si desea el último archivo por su fecha de creación en la carpeta (hora de acceso):

ls -Aru | tail -n 1  

Y si desea el último archivo que tiene cambios en su contenido (modificar el tiempo):

ls -Art | tail -n 1