Capturando grupos de um Grep RegEx

Eu tenho esse pequeno script no sh(Mac OSX 10.6) para examinar uma variedade de arquivos. O Google parou de ser útil neste momento:

files="*.jpg"
for f in $files
    do
        echo $f | grep -oEi '[0-9]+_([a-z]+)_[0-9a-z]*'
        name=$?
        echo $name
    done

Até agora (obviamente, para você, shell gurus), $nameapenas contém 0, 1 ou 2, dependendo se for grepencontrado que o nome do arquivo corresponde ao problema fornecido. O que eu gostaria é capturar o que está dentro dos parênteses ([a-z]+)e armazenar isso em uma variável .

Eu gostaria de usar grepapenas, se possível . Se não, por favor, não Python ou Perl, etc. sedou algo parecido - eu sou novo no shell e gostaria de atacar isso do ângulo purista * nix.

Além disso, como um bônus super legal , estou curioso para saber como concatenar uma string com casca? O grupo que eu capturei era a string "somename" armazenada em $ name e eu queria adicionar a string ".jpg" ao final, não é cat $name '.jpg'?

Por favor, explique o que está acontecendo, se você tiver tempo.

Se você estiver usando o Bash, nem precisará usar grep:

files="*.jpg"
regex="[0-9]+_([a-z]+)_[0-9a-z]*"
for f in $files    # unquoted in order to allow the glob to expand
do
    if [[ $f =~ $regex ]]
    then
        name="${BASH_REMATCH[1]}"
        echo "${name}.jpg"    # concatenate strings
        name="${name}.jpg"    # same thing stored in a variable
    else
        echo "$f doesn't match" >&2 # this could get noisy if there are a lot of non-matching files
    fi
done

É melhor colocar o regex em uma variável. Alguns padrões não funcionarão se incluídos literalmente.

Isso usa =~qual é o operador de correspondência de regex do Bash. Os resultados da correspondência são salvos em uma matriz chamada $BASH_REMATCH. O primeiro grupo de captura é armazenado no índice 1, o segundo (se houver) no índice 2, etc. O índice zero é a correspondência completa.

Você deve estar ciente de que, sem âncoras, essa regex (e a que está sendo usada grep) corresponderá a qualquer um dos seguintes exemplos e mais, que pode não ser o que você está procurando:

123_abc_d4e5
xyz123_abc_d4e5
123_abc_d4e5.xyz
xyz123_abc_d4e5.xyz

Para eliminar o segundo e o quarto exemplos, faça sua regex assim:

^[0-9]+_([a-z]+)_[0-9a-z]*

que diz que a sequência deve começar com um ou mais dígitos. O quilate representa o início da string. Se você adicionar um cifrão no final da regex, faça o seguinte:

^[0-9]+_([a-z]+)_[0-9a-z]*$

o terceiro exemplo também será eliminado, pois o ponto não está entre os caracteres na regex e o cifrão representa o final da string. Observe que o quarto exemplo também falha nessa correspondência.

Se você possui o GNU grep(por volta de 2.5 ou posterior, acho, quando o \Koperador foi adicionado):

name=$(echo "$f" | grep -Po '(?i)[0-9]+_\K[a-z]+(?=_[0-9a-z]*)').jpg

O \Koperador (look-behind de comprimento variável) faz com que o padrão anterior corresponda, mas não inclui a correspondência no resultado. O equivalente de comprimento fixo é (?<=)- o padrão seria incluído antes do parêntese de fechamento. Você deve usar \Kse os quantificadores podem coincidir com cordas de comprimentos diferentes (por exemplo +, *, {2,4}).

O (?=)operador corresponde a padrões de comprimento fixo ou variável e é chamado de "antecipação". Também não inclui a sequência correspondente no resultado.

Para fazer a correspondência não diferenciar maiúsculas de minúsculas, o (?i)operador é usado. Afeta os padrões que o seguem, portanto sua posição é significativa.

A regex pode precisar ser ajustada, dependendo da existência de outros caracteres no nome do arquivo. Você notará que, neste caso, mostro um exemplo de concatenação de uma sequência de caracteres ao mesmo tempo em que a substring é capturada.

Isso não é realmente possível com o puro grep, pelo menos geralmente não.

Mas se o seu padrão for adequado, você poderá usar grepvárias vezes em um pipeline para reduzir sua linha para um formato conhecido e, em seguida, extrair o pouco que desejar. (Embora ferramentas gostem cute sedsejam muito melhores nisso).

Suponha, por uma questão de argumento, que seu padrão seja um pouco mais simples: [0-9]+_([a-z]+)_você pode extrair isso da seguinte maneira:

echo $name | grep -Ei '[0-9]+_[a-z]+_' | grep -oEi '[a-z]+'

O primeiro grepremoveria todas as linhas que não correspondessem ao seu padrão geral; o segundo grep(que --only-matchingespecificou) exibirá a parte alfa do nome. Isso funciona apenas porque o padrão é adequado: "parte alfa" é específica o suficiente para extrair o que você deseja.

(Além disso: pessoalmente, eu usaria grep+ cutpara obter o que você procura:. echo $name | grep {pattern} | cut -d _ -f 2Isso cutanalisa a linha em campos dividindo o delimitador _e retorna apenas o campo 2 (os números dos campos começam em 1)).

A filosofia do Unix é ter ferramentas que fazem uma coisa, e fazê-lo bem, e combiná-las para realizar tarefas não triviais, então eu diria que grep+ sedetc é uma maneira mais Unixy de fazer as coisas :-)

Percebo que uma resposta já foi aceita para isso, mas, de um "ângulo estritamente * nix purista", parece que é a ferramenta certa para o trabalho pcregrep, que parece não ter sido mencionada ainda. Tente alterar as linhas:

    echo $f | grep -oEi '[0-9]+_([a-z]+)_[0-9a-z]*'
    name=$?

para o seguinte:

    name=$(echo $f | pcregrep -o1 -Ei '[0-9]+_([a-z]+)_[0-9a-z]*')

para obter apenas o conteúdo do grupo de captura 1.

A pcregrepferramenta utiliza a mesma sintaxe com a qual você já usou grep, mas implementa a funcionalidade necessária.

O parâmetro -ofunciona exatamente como a grepversão, se estiver vazio, mas também aceita um parâmetro numérico pcregrep, que indica qual grupo de captura você deseja mostrar.

Com esta solução, há um mínimo de mudanças necessárias no script. Você simplesmente substitui um utilitário modular por outro e ajusta os parâmetros.

Nota interessante: Você pode usar vários argumentos -o para retornar vários grupos de captura na ordem em que aparecem na linha.

Não é possível apenas em grep eu acredito

para sed:

name=`echo $f | sed -E 's/([0-9]+_([a-z]+)_[0-9a-z]*)|.*/\2/'`

Vou dar uma facada no bônus:

echo "$name.jpg"

Esta é uma solução que usa gawk. É algo que eu acho que preciso usar com frequência, então criei uma função para ele

function regex1 { gawk 'match($0,/'$1'/, ary) {print ary['${2:-'1'}']}'; }

usar apenas fazer

$ echo 'hello world' | regex1 'hello\s(.*)'
world

Uma sugestão para você - você pode usar a expansão de parâmetros para remover a parte do nome do último sublinhado em diante e da mesma forma no início:

f=001_abc_0za.jpg
work=${f%_*}
name=${work#*_}

Então nameterá o valor abc.

Consulte os documentos para desenvolvedores da Apple , procure 'Expansão de parâmetros'.

se você tem bash, pode usar globbing estendido

shopt -s extglob
shopt -s nullglob
shopt -s nocaseglob
for file in +([0-9])_+([a-z])_+([a-z0-9]).jpg
do
   IFS="_"
   set -- $file
   echo "This is your captured output : $2"
done

ou

ls +([0-9])_+([a-z])_+([a-z0-9]).jpg | while read file
do
   IFS="_"
   set -- $file
   echo "This is your captured output : $2"
done