Início / unix / Perguntas / 790456
Accepted
user648855
Asked: 2025-02-02 03:39:03 +0800 CST

Como posso extrair strings entre aspas dentro de uma variável?

  • 772

Reconheço que há perguntas superficialmente semelhantes feitas aqui antes, mas todas as que vi são mais simples do que o que estou tentando alcançar. Soluções somente Bash são preferidas.

Tenho uma variável contendo uma string que parece uma comparação de algum tipo, e gostaria de dividi-la em um array. A seguir estão alguns exemplos, incluindo como gostaria que fossem divididos:

var='name="value"'                # arr=([0]=name [1]='=' [2]=value)
var="name != '!value='"           # arr=([0]=name [1]='!=' [2]='!value=')
var='"na=me" = value'             # arr=([0]=na=me [1]='=' [2]=value)
var='name >= value'               # arr=([0]=name [1]='>=' [2]=value)
var='name'                        # arr=([0]=name)
var='name = "escaped \"quotes\""' # arr=([0]=name [1]='=' [2]=escaped\ \"quotes\")
var="name = \"nested 'quotes'\""  # arr=([0]=name [1]='=' [2]=nested\ \'quotes\')
var="name = 'nested \"quotes\"'"  # arr=([0]=name [1]='=' [2]=nested\ \"quotes\")

Você entendeu. Qualquer um dos lados (ou nenhum) pode ser citado, com aspas simples ou duplas. Pode haver aspas de escape ou aninhadas. O operador entre elas pode ser qualquer um de um conjunto predefinido, mas também pode ser incluído dentro das strings citadas. Pode haver ou não espaços. Pode não haver operador algum.

Tenho que analisar muitas linhas e, portanto, prefiro não bifurcar um novo processo a cada vez, e é por isso que soluções somente Bash são preferidas. Esta é uma adição a um script Bash existente que não precisa ser portátil para outros shells e está sendo executado no Bash 5.2, então tenho acesso a recursos Bash modernos que podem ser úteis.

IFS=\" read -a arr <<<"$var"é legal porque entende como lidar com aspas de escape, e se eu tivesse que lidar apenas com aspas simples ou duplas e não ambas , eu poderia fazer isso funcionar. Do jeito que está, só espero não ter que escrever um algoritmo tokenizador inteiro em script de shell, e que haja alguma combinação de recursos que eu não tenha considerado que possa analisar isso de forma confiável.

bash

2 respostas

  1. Você precisa escrever um parser: leia a string caractere por caractere, com base no caractere atual, estenda a palavra atual ou comece uma nova. Mantenha um sinalizador para indicar que o parser está dentro de uma string entre aspas.

    Algo como isto:

    #!/bin/bash
set -eu

validate() {
    size=$1
    shift

    if ((size != $#)) ; then
        echo "Not OK # Wrong size: $size $#"
        return
    fi

    ok=1
    for ((j=1; j <= size; ++j)) ; do
        [[ ${!j} = ${arr[j-1]} ]] || ok=0
    done
    if ((ok)) ; then
        echo $i OK
    else
        echo $i Not OK
    fi
}


i=0
for var in 'name="value"'                \
           "name != '!value='"           \
           '"na=me" = value'             \
           'name >= value'               \
           'name'                        \
           'name = "escaped \"quotes\""' \
           "name = \"nested 'quotes'\""  \
           "name = 'nested \"quotes\"'"  \
; do
    arr=()
    left=""
    quoted=""
    while ! (( ${#arr[@]} )) && [[ $var ]] ; do
        char=${var:0:1}
        var=${var:1}
        if [[ $char = [\'\"] ]] ; then
            if [[ -z $left ]] ; then
                quoted=$char
            elif [[ $quoted = $char ]] ; then
                quoted=${quoted:0:-1}
                arr=("$left")
            else
                echo 'Unexpected quote' >&2
                exit 1
            fi
        elif [[ $char = [\ =!\>] && -z $quoted ]] ; then
            arr=("$left")
            if [[ $char != ' ' ]] ; then
                var=$char$var
            fi
        else
            left+=$char
        fi
    done
    arr=("$left")

    op=""
    arr[1]=""
    while [[ $var && ! ${arr[1]} ]] ; do
        char=${var:0:1}
        var=${var:1}
        if [[ $char = [=\<\>\!] ]] ; then
            op+=$char
        elif [[ $char = ' ' ]] ; then
            if [[ $op ]] ; then
                arr[1]=$op
            else
                :
            fi
        else
            arr[1]=$op
            var=$char$var
        fi
    done
    [[ -z ${arr[1]} ]] && unset arr[1]

    if [[ $var ]] ; then
        quoted=""
        right=""
        while [[ $var ]] ; do
            char=${var:0:1}
            var=${var:1}
            if [[ $quoted ]] ; then
                if [[ $char = ${quoted: -1} ]] ; then
                    quoted=${quoted:0:-1}
                elif [[ $char = \\ ]] ; then
                    nextchar=${var:0:1}
                    if [[ $nextchar = ${quoted: -1} ]] ; then
                        right+=$nextchar
                        var=${var:1}
                    fi
                else
                    right+=$char
                fi
            elif [[ $char = [\"\'] ]] ; then
                quoted+=$char
            else
                right+=$char
            fi
        done
        arr+=("$right")
    fi

    case $i in
        (0) exp=(name = value) ;;
        (1) exp=(name '!=' '!value=') ;;
        (2) exp=(na=me = value) ;;
        (3) exp=(name '>=' value) ;;
        (4) exp=(name) ;;
        (5) exp=(name = 'escaped "quotes"') ;;
        (6) exp=(name = "nested 'quotes'") ;;
        (7) exp=(name = 'nested "quotes"') ;;
        (*) exit 1 ;;
    esac

    validate ${#arr[@]} "${exp[@]}"

    ((++i))
done

    Ele analisa corretamente todos os exemplos que você deu, mas está longe de terminar (não verifica aspas não fechadas etc.)

    • 8
  2. Best Answer

    Como @choroba apontou, você provavelmente não pode evitar escrever um lexer para dividir suas strings de entrada. Felizmente, "escanear" token por token com um ERE é o suficiente. Eu diria que usar uma linguagem com grupos "não-capturantes" e "nomeados" seria a melhor escolha, mas se você estiver preso ao Bash, aqui está como você pode fazer isso:

    #!/bin/bash

vn='[[:alnum:]_]+'                    # a varname token
sq="'[^']*'"                          # a single-quoted string token
dq='"(\\.|[^"\\])*"'                  # a double-quoted string token
op='[^[:space:][:alnum:]_"'"']+"      # an operator token

for var in ...; do

arr=()
while [[ $var =~ ^[[:space:]]*($vn|$sq|$dq|$op) ]]
do
    var=${var:${#BASH_REMATCH[0]}}    # remove the matched part from $var
    tok=${BASH_REMATCH[1]}            # get the matched token
    case ${tok:0:1} in
    ( \" ) tok=${tok//\\\"/\"} ;&     # decode the double-quoted strings
    ( \' ) tok=${tok:1:-1}     ;;     # unquote the quoted strings
    esac
    arr+=("$tok")
done

[[ $var =~ ^[[:space:]]*$ ]] || exit  # exit on parsing error

declare -p arr

done

    nota: requer bash 4.3+

    saída:

    declare -a arr=([0]="name" [1]="=" [2]="value")
declare -a arr=([0]="name" [1]="!=" [2]="!value=")
declare -a arr=([0]="na=me" [1]="=" [2]="value")
declare -a arr=([0]="name" [1]=">=" [2]="value")
declare -a arr=([0]="name")
declare -a arr=([0]="name" [1]="=" [2]="escaped \"quotes\"")
declare -a arr=([0]="name" [1]="=" [2]="nested 'quotes'")
declare -a arr=([0]="name" [1]="=" [2]="nested \"quotes\"")

    Para o leitor corrigir:

    • Fiz algumas suposições sobre o que são um "varname" e um "operador". Basicamente, um "varname" é composto de caracteres alfanuméricos/sublinhados; e um "operador" é qualquer coisa que não contenha espaços (excluindo uma palavra e uma string entre aspas).

    • Embora a regex consuma qualquer sequência de escape de barra invertida presente em uma string entre aspas duplas, somente \"ela é interpretada; talvez seja necessário implementar a decodificação de outras sequências de escape também.

    • 6

relate perguntas