Accéder aux x derniers caractères d'une chaîne dans Bash

125

J'ai découvert qu'avec ${string:0:3}on peut accéder aux 3 premiers caractères d'une chaîne. Existe-t-il une méthode tout aussi simple pour accéder aux trois derniers caractères?

aldorado
la source

Réponses:

236

Trois derniers caractères de string:

${string: -3}

ou

${string:(-3)}

(attention à l'espace entre :et -3dans la première forme).

Veuillez vous référer à l' extension des paramètres du shell dans le manuel de référence :

${parameter:offset}
${parameter:offset:length}

Expands to up to length characters of parameter starting at the character
specified by offset. If length is omitted, expands to the substring of parameter
starting at the character specified by offset. length and offset are arithmetic
expressions (see Shell Arithmetic). This is referred to as Substring Expansion.

If offset evaluates to a number less than zero, the value is used as an offset
from the end of the value of parameter. If length evaluates to a number less than
zero, and parameter is not ‘@’ and not an indexed or associative array, it is
interpreted as an offset from the end of the value of parameter rather than a
number of characters, and the expansion is the characters between the two
offsets. If parameter is ‘@’, the result is length positional parameters
beginning at offset. If parameter is an indexed array name subscripted by ‘@’ or
‘*’, the result is the length members of the array beginning with
${parameter[offset]}. A negative offset is taken relative to one greater than the
maximum index of the specified array. Substring expansion applied to an
associative array produces undefined results.

Note that a negative offset must be separated from the colon by at least one
space to avoid being confused with the ‘:-’ expansion. Substring indexing is
zero-based unless the positional parameters are used, in which case the indexing
starts at 1 by default. If offset is 0, and the positional parameters are used,
$@ is prefixed to the list.

Puisque cette réponse obtient quelques vues régulières, permettez - moi d 'ajouter une possibilité de répondre au commentaire de John Rix ; comme il le mentionne, si votre chaîne a une longueur inférieure à 3, se ${string: -3}développe en une chaîne vide. Si, dans ce cas, vous souhaitez l'extension de string, vous pouvez utiliser:

${string:${#string}<3?0:-3}

Cela utilise l' ?:opérateur ternaire if, qui peut être utilisé dans Shell Arithmetic ; puisque comme documenté, le décalage est une expression arithmétique, ceci est valide.

gniourf_gniourf
la source
5
Notez que cela ne fonctionne pas si votre chaîne est plus courte que le décalage négatif que vous fournissez. Vous obtenez juste une chaîne vide dans de telles instances.
John Rix
2
@gniourf_gniourf Comment utiliser ceci avec la substitution de commandes? deppfx@localhost:/tmp$ echo ${$(hostname): -3} -bash: ${$(hostname): -3}: bad substitution
J'essaye
3
@deppfx: vous ne pouvez pas dans Bash. Utilisez une variable temporaire: temp=$(hostname); echo "${temp: -3}". Bash a également la HOSTNAMEvariable (qui peut ou non différer de la sortie de hostname). Si vous voulez l'utiliser, faites-le echo "${HOSTNAME: -3}".
gniourf_gniourf
Comment pouvez-vous utiliser cela à partir de la sortie d'un tuyau? Par exemple, some func | echo ${string: -3}- comment attribuer la sortie de some funcà string?
Michael Hays
1
@MichaelHays: Attribuez simplement la sortie de votre fonction: string=$(some func)et ensuite echo "${string: -3}".
gniourf_gniourf
48

Vous pouvez utiliser tail:

$ foo="1234567890"
$ echo -n $foo | tail -c 3
890

Une façon quelque peu détournée d'obtenir les trois derniers caractères serait de dire:

echo $foo | rev | cut -c1-3 | rev
devnull
la source
2
La "queue" aussi utile en dash, quand bash n'est pas disponible. Par exemple, une section de script upstart.
vskubriev
13

Une autre solution de contournement consiste à utiliser grep -oavec un peu de magie regex pour obtenir trois caractères suivis de la fin de la ligne:

$ foo=1234567890
$ echo $foo | grep -o ...$
890

Pour obtenir éventuellement les 1 à 3 derniers caractères, dans le cas de chaînes de moins de 3 caractères, vous pouvez utiliser egrepavec cette expression régulière:

$ echo a | egrep -o '.{1,3}$'
a
$ echo ab | egrep -o '.{1,3}$'
ab
$ echo abc | egrep -o '.{1,3}$'
abc
$ echo abcd | egrep -o '.{1,3}$'
bcd

Vous pouvez également utiliser différentes plages, par exemple 5,10pour obtenir les cinq à dix derniers caractères.

Aurelio Jargas
la source
7

Pour généraliser la question et la réponse de gniourf_gniourf (car c'est ce que je cherchais), si vous voulez couper une plage de caractères de, disons, 7e de la fin au 3e de la fin, vous pouvez utiliser cette syntaxe:

${string: -7:4}

Où 4 est la longueur du cours (7-3).

De plus, alors que la solution de gniourf_gniourf est évidemment la meilleure et la plus soignée, je voulais juste ajouter une solution alternative utilisant cut :

echo $string | cut -c $((${#string}-2))-$((${#string}))

Ceci est plus lisible si vous le faites en deux lignes en définissant la longueur $ {# string} comme une variable séparée.

Adrian Tompkins
la source
une variante non mentionnée dans l'autre réponse consiste à combiner cette cutapproche consistant à calculer d'abord le démarrage / l'arrêt, puis à utiliser simplement ces variables dans l'expansion des paramètres (il convient également de mentionner que les cutdécalages et bash commencent à 1 et zéro, respectivement, donc cela aurait besoin à figurer dans les calculs, ce que je ne fais pas ici): start=$((${#string}-3)); stop=$((${#string}));puis echo ${string: $start : $stop}vsecho $string | cut -c "$start"-"$stop"
michael
(oh, peu importe - je vois que mon commentaire ne résout pas le problème de la chaîne trop courte, puis ne provoque aucune sortie du tout - à la fois la coupe et l'expansion des paramètres de chaîne. Pourtant, la décomposition en variables ( sans nécessairement appeler à des commandes supplémentaires) facilite la lecture et serait toujours une bonne idée, je pense.)
michael