Извлечь подстроку в Bash

Используйте резать:

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

Более общий:

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

Общее решение, в котором число может быть в любом месте имени файла, используя первую из таких последовательностей:

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

Другое решение для извлечения точно части переменной:

number=${filename:offset:length}

Если ваше имя файла всегда имеет формат stuff_digits_..., вы можете использовать awk:

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

Еще одно решение для удаления всего, кроме цифр, используйте

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

Также есть встроенная команда bash 'expr':

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

Основываясь на ответе Джора (который не работает для меня):

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

Если Икс является константой, следующее раскрытие параметра выполняет извлечение подстроки:

b=${a:12:5}

где 12 - это смещение (отсчитываемое от нуля), а 5 - длина

Если символы подчеркивания вокруг цифр - единственные во входных данных, вы можете удалить префикс и суффикс (соответственно) в два этапа:

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

Если есть другие символы подчеркивания, это, вероятно, в любом случае возможно, хотя и более сложное. Если кто-нибудь знает, как выполнить оба раскрытия в одном выражении, я тоже хотел бы знать.

Оба представленных решения представляют собой чистый bash, без необходимости создания процессов, поэтому они очень быстрые.

Без каких-либо подпроцессов вы можете:

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

Очень маленький вариант этого также будет работать в ksh93.

Вот как бы я это сделал:

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

Объяснение:

Специфично для Bash:

• [[ ]]указывает условное выражение
• =~указывает, что условие является регулярным выражением
• &&цепи команды, если предыдущая команда была успешной

Регулярные выражения (RE): _([[:digit:]]{5})_

• _ - это литералы для разграничения / привязки границ соответствия для совпадающей строки
• () создать группу захвата
• [[:digit:]] - это класс персонажей, думаю, он говорит сам за себя
• {5} означает, что ровно пять предшествующих символов, класса (как в этом примере) или группы должны соответствовать

На английском языке вы можете думать об этом так: строка FN повторяется символ за символом, пока мы не увидим _, в этот момент группа захвата - открыт, и мы пытаемся сопоставить пять цифр. Если это сопоставление успешно до этого момента, группа захвата сохраняет пять пройденных цифр. Если следующим символом является _, условие считается успешным, группа захвата становится доступной в BASH_REMATCH, и может выполняться следующий оператор NUM=. Если какая-либо часть сопоставления не удается, сохраненные данные удаляются, и посимвольная обработка продолжается после _. например если FN, где _1 _12 _123 _1234 _12345_, будет четыре фальстарта прежде, чем будет найдено совпадение.

просто попробуйте использовать cut -c startIndx-stopIndx

Вот решение с префиксом-суффиксом (аналогично решениям, данным JB и Darron), которое соответствует первому блоку цифр и не зависит от окружающих символов подчеркивания:

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

Если кому-то нужна более подробная информация, вы также можете поискать ее в man bash следующим образом

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

Результат:

${parameter:offset}
       ${parameter:offset:length}
              Substring Expansion.  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  start‐
              ing at the character specified by offset.  length and offset are
              arithmetic expressions (see ARITHMETIC  EVALUATION  below).   If
              offset  evaluates  to a number less than zero, the value is used
              as an offset from the end of the value of parameter.  Arithmetic
              expressions  starting  with  a - must be separated by whitespace
              from the preceding : to be distinguished from  the  Use  Default
              Values  expansion.   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  expan‐
              sion is the characters between the two offsets.  If parameter is
              @, the result is length positional parameters beginning at  off‐
              set.   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.  Sub‐
              string  expansion applied to an associative array produces unde‐
              fined 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, $0 is prefixed to the list.

Я удивлен, что это чистое решение bash не появилось:

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

Вероятно, вы захотите сбросить IFS до того значения, которое было раньше, или unset IFS после этого!

аналогично substr ('abcdefg', 2-1, 3) в php:

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

Следуя требованиям

I have a filename with x number of characters then a five digit sequence surrounded by a single underscore on either side then another set of x number of characters. I want to take the 5 digit number and put that into a variable.

Я нашел несколько полезных для grep способов:

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

или лучше

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

А затем с синтаксисом -Po:

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

Или, если вы хотите, чтобы в нем поместилось ровно 5 символов:

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

Наконец, чтобы сохранить его в переменной, достаточно использовать синтаксис var=$(command).

Немного поздно, но я столкнулся с этой проблемой и обнаружил следующее:

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

Я использовал его, чтобы получить разрешение в миллисекундах во встроенной системе, в которой на данный момент нет% N:

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

Если сосредоточиться на концепции:
«Серия (одна или несколько) цифр»

Мы могли бы использовать несколько внешних инструментов для извлечения чисел. Мы можем легко стереть все остальные символы, sed или tr:

name='someletters_12345_moreleters.ext'

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

Но если $ name содержит несколько серий чисел, приведенное выше не будет выполнено:

Если "name = someletters_12345_moreleters_323_end.ext", то:

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

Нам нужно использовать регулярные выражения (regex) .
Чтобы выбрать только первый запуск (12345, а не 323) в sed и perl:

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

Но мы могли бы сделать это напрямую в баше⁽¹⁾:

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

Это позволяет нам извлекать ПЕРВУЮ серию цифр любой длины. окруженный любым другим текстом / символами.

Примечание: regex=[^0-9]*([0-9]{5,5}).*$; будет соответствовать только 5-значным пробегам. :-)

⁽¹⁾: быстрее, чем вызов внешнего инструмента для каждого короткого текста. Не быстрее, чем выполнять всю обработку в sed или awk для больших файлов.

Хорошо, вот и чистая подстановка параметров с пустой строкой. Предостережение: я определил Someletters и письма только как символы. Если они буквенно-цифровые, это не сработает.

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

Решение bash:

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

Это приведет к сбою переменной с именем x. Вариант x можно заменить на переменную _.

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

В моем ответе будет больше контроля над тем, что вы хотите от своей строки. Вот код того, как вы можете извлечь 12345 из своей строки

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

Это будет более эффективно, если вы хотите извлечь что-то с любыми символами, такими как abc, или любыми специальными символами, такими как _ или -. Например: если ваша строка такая, и вы хотите все, что находится после someletters_ и до _moreleters.ext:

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

В моем коде вы можете указать, что именно вам нужно. Объяснение:

#* Удаляет предыдущую строку, включая соответствующий ключ. Здесь мы упомянули ключ _. % Он удалит следующую строку, включая соответствующий ключ. Здесь ключ, который мы упомянули, - это '_more *'.

Проведите несколько экспериментов самостоятельно, и вам это будет интересно.

Данный test.txt - это файл, содержащий "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

Мне нравится возможность sed работать с группами регулярных выражений:

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

Чуть более общий вариант - нет, предполагающий, что у вас есть подчеркивание _, обозначающее начало вашей последовательности цифр, отсюда, например, удаление всех нечисловых чисел, которые вы получаете перед вашей последовательностью: 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.

Подробнее об этом, если вы не слишком уверены в регулярных выражениях:

• s предназначен для _s_ubstitute
• [0-9]+ соответствует 1+ цифрам
• \1 ссылается на группу n.1 вывода регулярного выражения (группа 0 - это полное совпадение, группа 1 - это совпадение в круглых скобках в этом случае)
• Флаг p предназначен для _p_rinting

Все escape-последовательности \ нужны для того, чтобы заставить работать обработку регулярных выражений sed.

Инклюзивный конец, аналогичный реализациям JS и Java. Удалите +1, если вы этого не хотите.

function 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}}"
} 

Пример:

    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

Еще примеры вызовов:

    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

shell cut - вывести определенный диапазон символов или заданную часть из строки

# method1) с использованием bash

 str=2020-08-08T07:40:00.000Z
 echo ${str:11:8}

# method2) с использованием cut

 str=2020-08-08T07:40:00.000Z
 cut -c12-19 <<< $str

# method3) при работе с awk

 str=2020-08-08T07:40:00.000Z
 awk '{time=gensub(/.{11}(.{8}).*/,"\\1","g",$1); print time}' <<< $str