Accediendo a los últimos x caracteres de una cadena en Bash

125

Descubrí que con ${string:0:3}uno se puede acceder a los primeros 3 caracteres de una cadena. ¿Existe un método igualmente fácil para acceder a los últimos tres caracteres?

aldorado
fuente

Respuestas:

236

Últimos tres personajes de string:

${string: -3}

o

${string:(-3)}

(tenga en cuenta el espacio entre :y -3en la primera forma).

Consulte Expansión de parámetros de Shell en el manual de referencia :

${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.

Dado que esta respuesta recibe algunas visitas regulares, permítanme agregar la posibilidad de abordar el comentario de John Rix ; como él menciona, si su cadena tiene una longitud menor que 3, se ${string: -3}expande a la cadena vacía. Si, en este caso, desea la expansión de string, puede utilizar:

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

Utiliza el ?:operador ternario if, que puede utilizarse en aritmética de Shell ; dado que, como está documentado, el desplazamiento es una expresión aritmética, esto es válido.

gniourf_gniourf
fuente
5
Tenga en cuenta que esto no funciona si su cadena es más corta que la compensación negativa que proporciona. Solo obtiene una cadena vacía en tales casos.
John Rix
2
@gniourf_gniourf ¿Cómo puedo usar esto junto con la sustitución de comandos? Estoy tratando de extraer los últimos tres caracteres de mi nombre de host deppfx@localhost:/tmp$ echo ${$(hostname): -3} -bash: ${$(hostname): -3}: bad substitution
deppfx
3
@deppfx: no puedes en Bash. Utilizar una variable temporal: temp=$(hostname); echo "${temp: -3}". Bash también tiene la HOSTNAMEvariable (que puede o no diferir de la salida de hostname). Si quieres usarlo, hazlo echo "${HOSTNAME: -3}".
gniourf_gniourf
¿Cómo puedes usar esto desde la salida de una tubería? Por ejemplo, some func | echo ${string: -3}¿cómo asigno la salida de some funca string?
Michael Hays
1
@MichaelHays: Simplemente asigne la salida de su función: string=$(some func)y luego echo "${string: -3}".
gniourf_gniourf
48

Puede utilizar tail:

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

Una forma un tanto indirecta de obtener los últimos tres caracteres sería decir:

echo $foo | rev | cut -c1-3 | rev
devnull
fuente
2
La "cola" también es útil en el tablero, cuando bash no está disponible. Por ejemplo, sección de script advenedizo.
vskubriev
13

Otra solución es usar grep -ocon un poco de magia de expresiones regulares para obtener tres caracteres seguidos del final de la línea:

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

Para que, opcionalmente, obtenga los últimos 1 a 3 caracteres, en el caso de cadenas con menos de 3 caracteres, puede usar egrepcon esta expresión regular:

$ 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

También puede usar diferentes rangos, como 5,10para obtener los últimos cinco a diez caracteres.

Aurelio Jargas
fuente
7

Para generalizar la pregunta y la respuesta de gniourf_gniourf (ya que esto es lo que estaba buscando), si desea cortar un rango de caracteres de, digamos, el séptimo desde el final al tercero desde el final, puede usar esta sintaxis:

${string: -7:4}

Donde 4 es la duración del curso (7-3).

Además, si bien la solución de gniourf_gniourf es obviamente la mejor y la más ordenada, solo quería agregar una solución alternativa usando cut :

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

Esto es más legible si lo hace en dos líneas definiendo la longitud $ {# string} como una variable separada.

Adrian Tompkins
fuente
una variante no mencionada en la otra respuesta es combinar este cutenfoque de calcular el inicio / parada primero y luego simplemente usar estas variables en la expansión de parámetros (también vale la pena mencionar que las cutcompensaciones de bash comienzan en 1 y cero, respectivamente, por lo que esto necesitaría para ser incluido en los cálculos, que no estoy haciendo aquí): start=$((${#string}-3)); stop=$((${#string}));y luego echo ${string: $start : $stop}vsecho $string | cut -c "$start"-"$stop"
Michael
(oh, no importa, veo que mi comentario no aborda el problema de que la cadena es demasiado corta y luego no genera ningún resultado, tanto la expansión del parámetro de corte como la de cadena. Aún así, dividiéndolo en variables ( sin llamar necesariamente a comandos adicionales) hace que sea más fácil de leer y aún sería una buena idea, creo.)
Michael