Obtenir le fichier le plus récent dans un répertoire sous Linux

Recherche d'une commande qui renverra le fichier le plus récent dans un répertoire.

Ne pas voir un paramètre de limite à ls...

ls -Art | tail -n 1

Pas très élégant, mais ça marche.

ls -t | head -n1

Cette commande donne en fait le dernier fichier modifié dans le répertoire de travail actuel.

Il s'agit d'une version récursive (c'est-à-dire qu'elle trouve le fichier le plus récemment mis à jour dans un certain répertoire ou dans l'un de ses sous-répertoires)

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

Edit: utilisez -f 2-plutôt -f 2que comme suggéré par Kevin

Une note sur la fiabilité:

Puisque le caractère de nouvelle ligne est aussi valide que n'importe quel autre dans un nom de fichier, toute solution qui repose sur des lignes comme celles basées sur head/ tailest imparfaite.

Avec GNU ls, une autre option consiste à utiliser l' --quoting-style=shell-alwaysoption et un bashtableau:

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

(ajoutez l' -Aoption à lssi vous souhaitez également prendre en compte les fichiers cachés).

Si vous voulez vous limiter aux fichiers normaux (ne pas tenir compte des répertoires, des fifos, des périphériques, des liens symboliques, des sockets ...), vous devez recourir à GNU find.

Avec bash 4.4 ou plus récent (pour readarray -d) et GNU coreutils 8.25 ou plus récent (pour 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]}"

Ou récursivement:

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

Le mieux ici serait d'utiliser zshet ses qualificatifs glob au lieu d' bashéviter tous ces tracas:

Le fichier régulier le plus récent dans le répertoire courant:

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

Y compris les cachés:

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

Deuxième plus récent:

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

Vérifiez l'âge du fichier après la résolution du lien symbolique:

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

Récursivement:

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

En outre, avec le système de complétion ( compinitet co) activé, Ctrl+Xmdevient un complément qui se développe au fichier le plus récent.

Alors:

vi Ctrl+Xm

Vous ferait éditer le fichier le plus récent (vous aurez également une chance de voir lequel il avant d'appuyer sur Return).

vi Alt+2Ctrl+Xm

Pour le deuxième fichier le plus récent.

vi * .cCtrl+Xm

pour le cfichier le plus récent .

vi * (.)Ctrl+Xm

pour le fichier régulier le plus récent (pas de répertoire, ni de fifo / périphérique ...), et ainsi de suite.

J'utilise:

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

Il me donne juste le nom du fichier, à l'exclusion des dossiers.

ls -lAtr | tail -1

Les autres solutions n'incluent pas les fichiers commençant par '.'.

Cette commande comprendra également '.'et '..', qui peut ou non être ce que vous voulez:

ls -latr | tail -1

Variante raccourcie basée sur la réponse de dmckee:

ls -t | head -1

J'aime echo *(om[1])(la zshsyntaxe) car cela donne simplement le nom du fichier et n'invoque aucune autre commande.

La solution de recherche / tri fonctionne très bien jusqu'à ce que le nombre de fichiers devienne vraiment important (comme un système de fichiers entier). Utilisez plutôt awk pour garder une trace du fichier le plus récent:

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]* //'

bashPersonnellement, je préfère utiliser le moins de commandes non intégrées que possible (pour réduire le nombre d'appels système coûteux de fork et exec). Pour trier par date le lsbesoin d'être appelé. Mais l'utilisation de headn'est pas vraiment nécessaire. J'utilise le one-liner suivant (fonctionne uniquement sur les systèmes prenant en charge les tuyaux de nom):

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

ou pour obtenir le nom du fichier le plus ancien

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

(Attention à l'espace entre les deux marques '<'!)

Si les fichiers cachés sont également nécessaires, un argument peut être ajouté.

J'espère que cela pourrait aider.

en utilisant l'option récursive R .. vous pouvez considérer cela comme une amélioration pour de bonnes réponses ici

ls -arRtlh | tail -50

ls -t -1 | sed '1q'

Affiche le dernier élément modifié dans le dossier. Associer avec greppour trouver les dernières entrées avec des mots-clés

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

Récursivement:

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

essayez cette simple commande

ls -ltq  <path>  | head -n 1

Si vous voulez un nom de fichier - dernière modification, chemin = /ab/cd/*.log

Si vous voulez le nom du répertoire - dernière modification, chemin = / ab / cd / * /

En supposant que vous ne vous souciez pas des fichiers cachés commençant par un .

ls -rt | tail -n 1

Autrement

ls -Art | tail -n 1

Avec uniquement des fonctions intégrées Bash, suivant de près BashFAQ / 003 :

shopt -s nullglob

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

printf '%s\n' "$latest"

Toutes ces solutions ls / tail fonctionnent parfaitement bien pour les fichiers dans un répertoire - en ignorant les sous-répertoires.

Afin d'inclure tous les fichiers dans votre recherche (récursivement), find peut être utilisé. gioele a suggéré de trier la sortie de recherche formatée. Mais soyez prudent avec les espaces (sa suggestion ne fonctionne pas avec les espaces).

Cela devrait fonctionner avec tous les noms de fichiers:

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

Cela trie par mtime, voir 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.

Donc, remplacez simplement %Tpar %Cpour trier par ctime.

Recherche du fichier le plus récent dans chaque répertoire selon un modèle, par exemple les sous-répertoires du répertoire de travail dont le nom se termine par "tmp" (insensible à la casse):

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

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

Si vous souhaitez obtenir le fichier modifié le plus récent, y compris tous les sous-répertoires, vous pouvez le faire avec ce petit 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 vous ne voulez pas faire de même pour les fichiers modifiés, mais pour les fichiers accédés, vous devez simplement changer le

% Y paramètre de la stat commande à X% . Et votre commande pour les fichiers consultés les plus récents ressemble à ceci:

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

Pour les deux commandes, vous pouvez également modifier le paramètre var = "1" si vous souhaitez répertorier plusieurs fichiers.

J'avais besoin de le faire aussi, et j'ai trouvé ces commandes. ceux-ci fonctionnent pour moi:

Si vous voulez le dernier fichier par sa date de création dans le dossier (temps d'accès):

ls -Aru | tail -n 1  

Et si vous voulez le dernier fichier dont le contenu a changé (heure de modification):

ls -Art | tail -n 1