Dividir uma string até um local específico

Question

Eu tenho uma pergunta e quero saber como lidar com isso com sed ? Como se corta uma variável até um local específico, no meu caso _g ?

Exemplo

variable="This_is_good_g0r0s0_continues"

Eu preciso cortar essa variável até _g . Também devo mencionar que o número de caracteres antes de _g é aleatório.

    

Answer 1

Você pode fazer isso com operadores de expansão de variáveis internas em todos os shells do POSIX:

variable="This_is_good_g0r0s0_continues"
up_to_first__g="${variable%%_g*}"
up_to_last__g="${variable%_g*}"

    

Answer 2

Se você quiser cortar por último _g , tente o seguinte:

$ sed 's/\(.*\)_g.*//' <<< 'This_is_good_g0r0s0_continues'
This_is_good

Se você quiser cortar primeiro _g , então

$ sed 's/_g.*//' <<< 'This_is_good_g0r0s0_continues'
This_is

    

Answer 3

Com um BRE - com sed - você pode dividir sequências de correspondência contando sua ocorrência. Eu não acho que sed seria uma ferramenta ideal para cortar valores de shell var - o shell fornece um meio bastante intuitivo de fazer isso já - mas isso já está coberto.

As seqüências de padrões BRE, quando multiplicadas, dividirão para a direita o máximo possível. Por exemplo:

echo 0123456789 | sed 's/\([0-9]\)*//'

... imprime 9. Ele fica um pouco mais útil quando você divide com contagens reais.

Outro exemplo:

echo _good _goroso _goes _gop |
sed 's/\(.*_g\)\{2\}//'

... que fica ...

oes _gop

Isso não funcionará como você pode pensar, embora - ou pelo menos não funcione como eu esperava quando comecei a tocar com ele. Você não pode voltar outro _g lá com \{3\} - não neste caso, de qualquer maneira. O padrão é muito variável .* corresponde a tudo - incluindo nada - e, portanto, é difícil quantificar facilmente. O que você pode fazer é continuar a dividi-lo:

echo _good _goroso _goes _gop |
sed 's/\(\(.*_g\)\{2\}\)\{2\}//'

... que imprime

oroso _goes _gop

Talvez seja melhor dizer squeeze do que split . Aqui - combinando pelo menos tantas ocorrências de um padrão de ocorrência .* zero-or-more eu limito efetivamente sua correspondência possível - que será sempre tão gananciosa quanto possível. Então eu faço o menor pedaço do menor pedaço do final do que combina com ele.

Isso é mais facilmente visto olhando para a própria correspondência - que ainda pode ser obtida em & além da correspondência que já existe em . Eu sempre achei essas excentricidades úteis, pessoalmente, embora não me surpreendesse em saber que estou sozinha nisso. Você pode, por exemplo, combinar a correspondência de cada final como:

echo _good _goroso _goes _gop |
sed 's/\(\(.*_g\)\{2\}\)\{2\}/&/

... que imprime:

_good _goroso _goes _goroso _goes _gop

... porque a correspondência inteira para .*_g está em & , mas o padrão subdividido é apenas uma parte.

... ou até mesmo ...

echo _good _goroso _goes _gop |
sed 's/\(\(.*_g\)\{2\}\)\{2\}/&/

... que embaralha todos os níveis da partida como ...

oes _g_good _goroso _goes _goroso _goes _gop