Comment savoir si le fichier dans une boucle est le dernier?

Exemple

for FILE in $DIR/* 
do
  if(<is last File>)
    doSomethingSpecial($FILE)
  else
    doSomethingRegular($FILE)
  fi
done

Ce qu'il faut appeler pour <is last file> pour vérifier si le fichier en cours est le dernier de la matrice ?

Est-il un simple haut-check sans vérification de la longueur du tableau par moi-même ?

source d'informationauteur John Threepwood | 2012-09-06

bash loops

Ce qu'il faut appeler pour vérifier si le fichier en cours est le dernier de la matrice ?

Pour commencer, vous n'êtes pas à l'aide d'un tableau. Si vous étiez alors il serait facile:

declare -a files
files=($DIR/*)
pos=$(( ${#files[*]} - 1 ))
last=${files[$pos]}

for FILE in "${files[@]}"
do 
  if [[ $FILE == $last ]]
  then
     echo "$FILE is the last" 
     break
  else 
     echo "$FILE"
  fi 
done

8

Je ne connais aucun moyen de dire que vous traitez le dernier élément d'une liste dans une boucle for. Cependant, vous pouvez utiliser un tableau, une itération sur tous, mais le dernier élément, et ensuite traiter le dernier élément en dehors de la boucle:
```
files=($DIR/*)
for file in "${files[@]::${#files[@]}-1}" ; do
    doSomethingRegular "$file"
done
doSomethingSpecial "${files[@]: -1:1}"
```
L'expansion ${files[@]:offset:length} évalue à tous les éléments de départ à offset (ou le début si vide) pour length éléments. ${#files[@]}-1 est le nombre d'éléments dans le tableau moins 1.

${files[@]: -1:1} renvoie le dernier élément de -1 à partir de la fin d'une longueur de 1. L'espace est nécessaire que :- est traité différemment à : -.

Essayer cette

LAST_FILE=""
for f in *
do
        if [ ! -z $LAST_FILE ]
        then
                echo "Process file normally $LAST_FILE"
        fi
        LAST_FILE=$f
done
if [ ! -z $LAST_FILE ]
then
        echo "Process file as last file $LAST_FILE"
fi

Produit

bash[1051]: ls
1  2  3  4
bash[1052]: sh ../last_file.sh
Process file normally 1
Process file normally 2
Process file normally 3
Process file as last file 4

2

Ce qui rend un fichier le dernier? Est-il quelque chose de spécial à ce sujet? Est-ce le fichier avec le nom le plus quand triés par nom?

Peut-être vous pouvez prendre les noms de fichier en arrière. Puis, c'est le premier fichier que vous souhaitez traiter spéciaux et pas la dernière. déterminer la première est une tâche beaucoup plus facile que de faire le dernier:
```
for file in $(ls -r1 $dir)
do
    if [ ! $processedLast ] 
    then
        doSomethingSpecial($file)
        processedLast=1
    else
        doSomethingRegular($file)
    fi
done
```
Pas de tableaux nécessaires. En fait, j'aime chepner's réponse sur l'utilisation de paramètres positionnels.
2

Vous pouvez utiliser recherche pour trouver le nombre total de fichiers.
Puis, quand vous êtes dans la boucle de comptage du nombre total et de la mener à bien votre tâche lorsque le total est égal le comte, je.e, le dernier fichier.
```
 f=0
tot_files=`find  . -iname '*.txt' | wc -l`
 for FILE in $DIR/* 
do 
f=($f+1)
if [[ $f == $tot_files ]];then
carryout your task
fi
done
```

Vous pouvez abuser de la position des paramètres, car ils agissent de la même façon à un tableau,
mais qui sont un peu plus facile à manipuler. Vous devez enregistrer le vieux de position
paramètres, ou à exécuter dans un shell interne est exécuté.

# Method 1: use a subshell. Slightly cleaner, but you can't always
# do this (for example, you may need to affect variables in the current
# shell
files=( $DIR/* )

(
    set -- "${files[@]}"
    until (( $# == 1 )); do
        doSomethingRegular "$1"
        shift
    done    
    doSomethingSpecial "$1"
)

# Method 2: save the positional parameters. A bit uglier, but
# executes everything in the same shell.

files=( $DIR/* )
oldPP=( "$@" )
set -- "${files[@]}"
until (( $# == 1 )); do
    doSomethingRegular "$1"
    shift
done    
doSomethingSpecial "$1"
set -- "${oldPP[@]}"

1

Bâtiment sur le courant plus-voté réponse de @cdarke (https://stackoverflow.com/a/12298757/415523), si en regardant un tableau général des valeurs (plutôt que spécifiquement des fichiers sur le disque), la boucle de code serait comme suit:
```
declare -a array
declare -i length current

array=( a b c d e c )
length=${#array[@]}
current=0

for VALUE in "${array[@]}"; do 
  current=$((current + 1))

  if [[ "$current" -eq "$length" ]]; then
     echo "$VALUE is the last" 
  else 
     echo "$VALUE"
  fi 
done
```
Cela donne le résultat:
```
a
b
c
d
e
c is the last
```
Cela garantit que seuls les dernier élément dans le tableau déclenche l'action alternative et que, si tout autre élément dans le tableau reproduit la dernière valeur, l'action alternative est pas appelé au plus tôt les doublons.

Dans le cas d'un tableau de chemins de fichiers dans un répertoire spécifique, par exemple
```
array=( $DIR/* )
```
...c'est sans doute moins problématique, puisque les noms de fichiers dans le même répertoire sont presque certainement unique (sauf si vous avez un vraiment étrange système de fichiers!)
0

C'est une vieille question, mais en s'appuyant sur la réponse de @GregReynolds veuillez utiliser ce one-liner si les commandes ne diffèrent que par des paramètres sur la dernière passe. Laid, laid code pour one-liner amateurs de

( ff="" ; for f in * "" ; do [ -n "$ff" ] && echo $(${f:+false} && echo $ff alternate params here || echo normal params $ff ) ; ff=$f ; done )
normal params 1 normal params 2 normal params 3 4 alternate params here

Vous devez vous connecter pour publier un commentaire.