Comment mettre à zéro une séquence d'entiers en bash pour que tous aient la même largeur?

J'ai besoin de boucler quelques valeurs,

for i in $(seq $first $last)
do
    does something here
done

Pour $firstet $last, j'ai besoin que ce soit de longueur fixe 5. Donc, si l'entrée est 1, j'ai besoin d'ajouter des zéros devant pour qu'ils deviennent 00001. Il boucle jusqu'à 99999par exemple, mais la longueur doit être de 5.

Par exemple: 00002, 00042, 00212, 012312et ainsi de suite.

Une idée sur comment je peux faire ça?

Dans votre cas spécifique, il est probablement plus facile d'utiliser l' -findicateur seqpour obtenir un formatage des nombres lors de la sortie de la liste. Par exemple:

for i in $(seq -f "%05g" 10 15)
do
  echo $i
done

produira la sortie suivante:

00010
00011
00012
00013
00014
00015

Plus généralement, basha printfcomme intégré de sorte que vous pouvez remplir la sortie avec des zéros comme suit:

$ i=99
$ printf "%05d\n" $i
00099

Vous pouvez utiliser l' -vindicateur pour stocker la sortie dans une autre variable:

$ i=99
$ printf -v j "%05d" $i
$ echo $j
00099

Notez que printfprend en charge un format légèrement différent, seqvous devez donc utiliser à la %05dplace de %05g.

Plus simple encore, vous pouvez simplement le faire

for i in {00001..99999}; do
  echo $i
done

Si la fin de la séquence a une longueur maximale de remplissage (par exemple, si vous voulez 5 chiffres et que la commande est "seq 1 10000"), vous pouvez utiliser l'indicateur "-w" pour seq - il ajoute le remplissage lui-même.

seq -w 1 10

produire

01
02
03
04
05
06
07
08
09
10

utiliser printf avec "% 05d" par exemple

printf "%05d" 1

Utilisation très simple printf

[jaypal:~/Temp] printf "%05d\n" 1
00001
[jaypal:~/Temp] printf "%05d\n" 2
00002

Utilisez awk comme ceci:

awk -v start=1 -v end=10 'BEGIN{for (i=start; i<=end; i++) printf("%05d\n", i)}'

PRODUCTION:

00001
00002
00003
00004
00005
00006
00007
00008
00009
00010

Mise à jour:

Comme alternative bash pure, vous pouvez le faire pour obtenir la même sortie:

for i in {1..10}
do
   printf "%05d\n" $i
done

De cette façon, vous pouvez éviter d' utiliser un programme externe seqqui n'est PAS disponible sur toutes les versions de * nix.

Je remplis la sortie avec plus de chiffres (zéros) que je n'en ai besoin, puis j'utilise tail pour n'utiliser que le nombre de chiffres que je recherche. Notez que vous devez utiliser '6' en queue pour obtenir les cinq derniers chiffres :)

for i in $(seq 1 10)
do
RESULT=$(echo 00000$i | tail -c 6)
echo $RESULT
done

Si vous voulez N chiffres, ajoutez 10 ^ N et supprimez le premier chiffre.

for (( num=100; num<=105; num++ ))
do
  echo ${num:1:3}
done

Production:

01
02
03
04
05

Cela fonctionnera également:

for i in {0..9}{0..9}{0..9}{0..9}
do
  echo "$i"
done

Autre moyen:

zeroos="000"
echo 

for num in {99..105};do
 echo ${zeroos:${#num}:${#zeroos}}${num}
done

La fonction si simple pour convertir n'importe quel nombre serait:

function leading_zero(){

    local num=$1
    local zeroos=00000
    echo ${zeroos:${#num}:${#zeroos}}${num} 

}

Une façon sans utiliser de forking de processus externe est la manipulation de chaînes, dans un cas générique, cela ressemblerait à ceci:

#start value
CNT=1

for [whatever iterative loop, seq, cat, find...];do
   # number of 0s is at least the amount of decimals needed, simple concatenation
   TEMP="000000$CNT"
   # for example 6 digits zero padded, get the last 6 character of the string
   echo ${TEMP:(-6)}
   # increment, if the for loop doesn't provide the number directly
   TEMP=$(( TEMP + 1 ))
done

Cela fonctionne également très bien sur WSL, où la fourche est une opération très lourde. J'avais une liste de 110000 fichiers, en utilisant printf "%06d" $NUMplus de 1 minute, la solution ci-dessus a fonctionné en environ 1 seconde.

1.) Créez une séquence de nombres «seq» de 1 à 1000 et fixez la largeur «-w» (la largeur est déterminée par la longueur du numéro de fin, dans ce cas, 4 chiffres pour 1000).

2.) Sélectionnez également les numéros que vous souhaitez en utilisant 'sed -n' (dans ce cas, nous sélectionnons les numéros 1-100).

3.) 'écho' sur chaque numéro. Les nombres sont stockés dans la variable «i», accessible à l'aide du «$».

Avantages: Ce code est assez propre.

Inconvénients: 'seq' n'est pas natif sur tous les systèmes Linux (si je comprends bien)

for i in `seq -w 1 1000 | sed -n '1,100p'`; 
do 
    echo $i; 
done

Si vous êtes juste après le remplissage des nombres avec des zéros pour obtenir une longueur fixe, ajoutez simplement le multiple de 10 le plus proche, par exemple. pour 2 chiffres, ajoutez 10 ^ 2, puis supprimez le premier 1 avant d'afficher la sortie.

Cette solution fonctionne pour remplir / formater des nombres simples de n'importe quelle longueur, ou une séquence entière de nombres en utilisant une boucle for.

# Padding 0s zeros:
# Pure bash without externals eg. awk, sed, seq, head, tail etc.
# works with echo, no need for printf

pad=100000      ;# 5 digit fixed

for i in {0..99999}; do ((j=pad+i))
    echo ${j#?}
done

Testé sur Mac OSX 10.6.8, Bash ver 3.2.48