Extraire la sous-chaîne dans Bash

Étant donné un nom de fichier dans le formulaire someletters_12345_moreleters.ext, je veux extraire les 5 chiffres et les mettre dans une variable.

Donc, pour souligner le point, j'ai un nom de fichier avec x nombre de caractères puis une séquence de cinq chiffres entourée d'un seul trait de soulignement de chaque côté puis un autre ensemble de x nombre de caractères. Je veux prendre le nombre à 5 chiffres et le mettre dans une variable.

Je suis très intéressé par le nombre de façons différentes dont cela peut être accompli.

Utiliser la coupe :

echo 'someletters_12345_moreleters.ext' | cut -d'_' -f 2

Plus générique:

INPUT='someletters_12345_moreleters.ext'
SUBSTRING=$(echo $INPUT| cut -d'_' -f 2)
echo $SUBSTRING

Si x est constant, l'expansion de paramètre suivante effectue l'extraction de la sous-chaîne:

b=${a:12:5}

où 12 est le décalage (basé sur zéro) et 5 est la longueur

Si les traits de soulignement autour des chiffres sont les seuls dans l'entrée, vous pouvez supprimer le préfixe et le suffixe (respectivement) en deux étapes:

tmp=${a#*_}   # remove prefix ending in "_"
b=${tmp%_*}   # remove suffix starting with "_"

S'il y a d'autres soulignements, c'est probablement possible de toute façon, bien que plus délicat. Si quelqu'un sait comment effectuer les deux extensions en une seule expression, j'aimerais aussi le savoir.

Les deux solutions présentées sont purement bash, sans apparition de processus, donc très rapide.

Solution générique où le numéro peut être n'importe où dans le nom de fichier, en utilisant la première de ces séquences:

number=$(echo $filename | egrep -o '[[:digit:]]{5}' | head -n1)

Une autre solution pour extraire exactement une partie d'une variable:

number=${filename:offset:length}

Si votre nom de fichier a toujours le format, stuff_digits_...vous pouvez utiliser awk:

number=$(echo $filename | awk -F _ '{ print $2 }')

Encore une autre solution pour tout supprimer sauf les chiffres, utilisez

number=$(echo $filename | tr -cd '[[:digit:]]')

essayez d'utiliser cut -c startIndx-stopIndx

Si quelqu'un veut des informations plus rigoureuses, vous pouvez également les rechercher dans man bash comme ceci

$ man bash [press return key]
/substring  [press return key]
[press "n" key]
[press "n" key]
[press "n" key]
[press "n" key]

Résultat:

$ {paramètre: offset}
       $ {paramètre: offset: longueur}
              Extension de sous-chaîne. Se développe jusqu'à une longueur de caractères de
              paramètre commençant par le caractère spécifié par offset. Si
              la longueur est omise, s'étend à la sous-chaîne du paramètre start‐
              au caractère spécifié par offset. la longueur et le décalage sont
              expressions arithmétiques (voir ÉVALUATION ARITHMÉTIQUE ci-dessous). Si
              offset est évalué à un nombre inférieur à zéro, la valeur est utilisée
              comme décalage par rapport à la fin de la valeur du paramètre. Arithmétique
              les expressions commençant par un - doivent être séparées par des espaces
              du précédent: à distinguer du Use Default
              Expansion des valeurs. Si la longueur est évaluée à un nombre inférieur à
              zéro, et le paramètre n'est pas @ et n'est pas indexé ou associatif
              tableau, il est interprété comme un décalage par rapport à la fin de la valeur
              du paramètre plutôt que d'un certain nombre de caractères, et l'extension
              sion correspond aux caractères entre les deux décalages. Si le paramètre est
              @, le résultat est des paramètres positionnels de longueur commençant à off‐
              ensemble. Si le paramètre est un nom de tableau indexé souscrit par @ ou
              *, le résultat est la longueur des membres du tableau commençant par
              $ {paramètre [offset]}. Un décalage négatif est pris par rapport à
              un supérieur à l'index maximum du tableau spécifié. Sous-
              l'expansion de chaîne appliquée à un tableau associatif produit indé‐
              résultats amendés. Notez qu'un décalage négatif doit être séparé
              du côlon par au moins un espace pour éviter d'être confondu
              avec: - l'expansion. L'indexation des sous-chaînes est basée sur zéro sauf si
              les paramètres de position sont utilisés, auquel cas l'indexation
              commence à 1 par défaut. Si offset est 0 et que la position
              paramètres sont utilisés, $ 0 est préfixé à la liste.

Voici comment je le ferais:

FN=someletters_12345_moreleters.ext
[[ ${FN} =~ _([[:digit:]]{5})_ ]] && NUM=${BASH_REMATCH[1]}

Explication:

Spécifique à Bash:

• [[ ]] indique une expression conditionnelle
• =~ indique que la condition est une expression régulière
• && enchaîne les commandes si la commande précédente a réussi

Expressions régulières (RE): _([[:digit:]]{5})_

• _ sont des littéraux pour délimiter / ancrer les limites de correspondance pour la chaîne en correspondance
• () créer un groupe de capture
• [[:digit:]] est une classe de personnage, je pense qu'elle parle d'elle-même
• {5} signifie exactement cinq du caractère précédent, la classe (comme dans cet exemple) ou le groupe doit correspondre

En anglais, vous pouvez penser qu'elle se comporte comme ceci: la FNchaîne est itérée caractère par caractère jusqu'à ce que nous voyions un _point auquel le groupe de capture est ouvert et nous essayons de faire correspondre cinq chiffres. Si cette correspondance réussit à ce stade, le groupe de capture enregistre les cinq chiffres parcourus. Si le caractère suivant est un _, la condition réussit, le groupe de capture est rendu disponible dans BASH_REMATCHet l' NUM=instruction suivante peut s'exécuter. Si une partie de la correspondance échoue, les détails enregistrés sont supprimés et le traitement caractère par caractère se poursuit après le _. Par exemple, si FNoù _1 _12 _123 _1234 _12345_, il y aurait quatre faux départs avant qu'il ne trouve une correspondance.

Je suis surpris que cette solution pure bash ne soit pas venue:

a="someletters_12345_moreleters.ext"
IFS="_"
set $a
echo $2
# prints 12345

Vous voudrez probablement réinitialiser IFS à sa valeur avant ou unset IFSaprès!

S'appuyant sur la réponse de Jor (qui ne fonctionne pas pour moi):

substring=$(expr "$filename" : '.*_\([^_]*\)_.*')

Suivre les exigences

J'ai un nom de fichier avec x nombre de caractères puis une séquence de cinq chiffres entourée d'un seul trait de soulignement de chaque côté puis d'un autre ensemble de x nombre de caractères. Je veux prendre le nombre à 5 chiffres et le mettre dans une variable.

J'ai trouvé quelques grepmoyens qui peuvent être utiles:

$ echo "someletters_12345_moreleters.ext" | grep -Eo "[[:digit:]]+" 
12345

ou mieux

$ echo "someletters_12345_moreleters.ext" | grep -Eo "[[:digit:]]{5}" 
12345

Et puis avec la -Posyntaxe:

$ echo "someletters_12345_moreleters.ext" | grep -Po '(?<=_)\d+' 
12345

Ou si vous voulez que cela corresponde exactement à 5 caractères:

$ echo "someletters_12345_moreleters.ext" | grep -Po '(?<=_)\d{5}' 
12345

Enfin, pour le stocker dans une variable il suffit d'utiliser la var=$(command)syntaxe.

Si nous nous concentrons sur le concept de:
"Une série de (un ou plusieurs) chiffres"

Nous pourrions utiliser plusieurs outils externes pour extraire les chiffres.
Nous pourrions assez facilement effacer tous les autres personnages, sed ou tr:

name='someletters_12345_moreleters.ext'

echo $name | sed 's/[^0-9]*//g'    # 12345
echo $name | tr -c -d 0-9          # 12345

Mais si $ name contient plusieurs séries de nombres, ce qui précède échouera:

Si "name = someletters_12345_moreleters_323_end.ext", alors:

echo $name | sed 's/[^0-9]*//g'    # 12345323
echo $name | tr -c -d 0-9          # 12345323

Nous devons utiliser des expressions régulières (regex).
Pour sélectionner uniquement la première exécution (12345 et non 323) dans sed et perl:

echo $name | sed 's/[^0-9]*\([0-9]\{1,\}\).*$/\1/'
perl -e 'my $name='$name';my ($num)=$name=~/(\d+)/;print "$num\n";'

Mais on pourrait aussi bien le faire directement en bash ⁽¹⁾ :

regex=[^0-9]*([0-9]{1,}).*$; \
[[ $name =~ $regex ]] && echo ${BASH_REMATCH[1]}

Cela nous permet d'extraire la PREMIÈRE série de chiffres de n'importe quelle longueur
entourée de tout autre texte / caractère.

Remarque : regex=[^0-9]*([0-9]{5,5}).*$;ne correspondra qu'à exactement 5 séries de chiffres. :-)

⁽¹⁾ : plus rapide que d'appeler un outil externe pour chaque texte court. Pas plus rapide que de faire tout le traitement dans sed ou awk pour les gros fichiers.

Sans aucun sous-processus, vous pouvez:

shopt -s extglob
front=${input%%_+([a-zA-Z]).*}
digits=${front##+([a-zA-Z])_}

Une très petite variante de ceci fonctionnera également dans ksh93.

Voici une solution préfixe-suffixe (similaire aux solutions proposées par JB et Darron) qui correspond au premier bloc de chiffres et ne dépend pas des traits de soulignement environnants:

str='someletters_12345_morele34ters.ext'
s1="${str#"${str%%[[:digit:]]*}"}"   # strip off non-digit prefix from str
s2="${s1%%[^[:digit:]]*}"            # strip off non-digit suffix from s1
echo "$s2"                           # 12345

J'adore sedla capacité de traiter avec des groupes d'expressions régulières:

> var="someletters_12345_moreletters.ext"
> digits=$( echo $var | sed "s/.*_\([0-9]\+\).*/\1/p" -n )
> echo $digits
12345

Une option un peu plus générale serait pas supposer que vous avez un trait de soulignement _marquant le début de votre séquence de chiffres, donc , par exemple , dépouillant tous les non-chiffres que vous obtenez avant votre séquence: s/[^0-9]\+\([0-9]\+\).*/\1/p.

> man sed | grep s/regexp/replacement -A 2
s/regexp/replacement/
    Attempt to match regexp against the pattern space.  If successful, replace that portion matched with replacement.  The replacement may contain the special  character  &  to
    refer to that portion of the pattern space which matched, and the special escapes \1 through \9 to refer to the corresponding matching sub-expressions in the regexp.

Plus à ce sujet, au cas où vous ne seriez pas trop confiant avec les expressions régulières:

• s est pour _s_ubstitute
• [0-9]+ correspond à 1+ chiffres
• \1 liens vers le groupe n.1 de la sortie d'expression régulière (le groupe 0 est la correspondance complète, le groupe 1 est la correspondance entre parenthèses dans ce cas)
• p le drapeau est pour _p_rinting

Toutes les échappées \sont là pour faire fonctionner sedle traitement des expressions rationnelles.

Ma réponse aura plus de contrôle sur ce que vous voulez sortir de votre chaîne. Voici le code sur la façon d'extraire 12345de votre chaîne

str="someletters_12345_moreleters.ext"
str=${str#*_}
str=${str%_more*}
echo $str

Ce sera plus efficace si vous voulez extraire quelque chose qui a des caractères comme abcou des caractères spéciaux comme _ou -. Par exemple: si votre chaîne est comme ça et que vous voulez tout ce qui est après someletters_et avant _moreleters.ext:

str="someletters_123-45-24a&13b-1_moreleters.ext"

Avec mon code, vous pouvez mentionner exactement ce que vous voulez. Explication:

#*Il supprimera la chaîne précédente, y compris la clé correspondante. Ici, la clé que nous avons mentionnée est_ % Elle supprimera la chaîne suivante, y compris la clé correspondante. Ici, la clé que nous avons mentionnée est '_more *'

Faites vous-même des expériences et vous trouverez cela intéressant.

Étant donné que test.txt est un fichier contenant "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

cut -b19-20 test.txt > test1.txt # This will extract chars 19 & 20 "ST" 
while read -r; do;
> x=$REPLY
> done < test1.txt
echo $x
ST

Ok, voici la substitution de paramètres pure avec une chaîne vide. La mise en garde est que j'ai défini des someletters et des moreletters comme étant uniquement des personnages. S'ils sont alphanumériques, cela ne fonctionnera pas tel quel.

filename=someletters_12345_moreletters.ext
substring=${filename//@(+([a-z])_|_+([a-z]).*)}
echo $substring
12345

similaire à substr ('abcdefg', 2-1, 3) en php:

echo 'abcdefg'|tail -c +2|head -c 3

Il y a aussi la commande bash builtin 'expr':

INPUT="someletters_12345_moreleters.ext"  
SUBSTRING=`expr match "$INPUT" '.*_\([[:digit:]]*\)_.*' `  
echo $SUBSTRING

Un peu tard, mais je viens de rencontrer ce problème et j'ai trouvé ce qui suit:

host:/tmp$ asd=someletters_12345_moreleters.ext 
host:/tmp$ echo `expr $asd : '.*_\(.*\)_'`
12345
host:/tmp$ 

Je l'ai utilisé pour obtenir une résolution en millisecondes sur un système embarqué qui n'a pas% N pour la date:

set `grep "now at" /proc/timer_list`
nano=$3
fraction=`expr $nano : '.*\(...\)......'`
$debug nano is $nano, fraction is $fraction

Une solution bash:

IFS="_" read -r x digs x <<<'someletters_12345_moreleters.ext'

Cela encombrera une variable appelée x. Le var xpeut être changé en var _.

input='someletters_12345_moreleters.ext'
IFS="_" read -r _ digs _ <<<"$input"

Fin Inklusive, similaire aux implémentations JS et Java. Supprimez +1 si vous ne le souhaitez pas.

substring() {
    local str="$1" start="${2}" end="${3}"

    if [[ "$start" == "" ]]; then start="0"; fi
    if [[ "$end"   == "" ]]; then end="${#str}"; fi

    local length="((${end}-${start}+1))"

    echo "${str:${start}:${length}}"
} 

Exemple:

    substring 01234 0
    01234
    substring 012345 0
    012345
    substring 012345 0 0
    0
    substring 012345 1 1
    1
    substring 012345 1 2
    12
    substring 012345 0 1
    01
    substring 012345 0 2
    012
    substring 012345 0 3
    0123
    substring 012345 0 4
    01234
    substring 012345 0 5
    012345

Plus d'exemples d'appels:

    substring 012345 0
    012345
    substring 012345 1
    12345
    substring 012345 2
    2345
    substring 012345 3
    345
    substring 012345 4
    45
    substring 012345 5
    5
    substring 012345 6

    substring 012345 3 5
    345
    substring 012345 3 4
    34
    substring 012345 2 4
    234
    substring 012345 1 3
    123

Je vous en prie.