Convertir une chaîne de texte dans un bash à la matrice

Comment puis-je convertir une chaîne comme celle-ci en BASH pour un tableau dans le coup!

J'ai une chaîne str qui contient "title1 titre2 titre3 title4 title5"
(les séparant par des espaces titres)

Je veux le str de modification d'un tableau qui permet de stocker chaque titre de chaque indice.

Si vos titres n'ont pas d'espaces, vous pouvez utiliser: array=( $string ) (pas de guillemets pour $string). Si vos titres sont l'espace... eh bien... cela dépend de la façon dont ils sont formés.
Il a travaillé! Merci!

OriginalL'auteur Ayush Mishra | 2013-10-29

  1. 26

    Afin de convertir la chaîne en un tableau, dire:

    $ str="title1 title2 title3 title4 title5"
$ arr=( $str )

    Le shell de réaliser de couper un mot sur les espaces, sauf si vous citez la chaîne.

    Afin de boucle sur les éléments du ainsi créé tableau:

    $ for i in "${arr[@]}"; do echo $i; done
title1
title2
title3
title4
title5
    Pour info, cela ne fonctionnera pas pour Zsh; voir zsh.sourceforge.net/FAQ/zshfaq03.html

    OriginalL'auteur devnull

  2. 1

    Une autre méthode à l'aide de lire:

    read -a array <<< $str

    OriginalL'auteur perreal

  3. 0

    Je suis malheureusement dans une position où j'ai longtemps d'un script shell qui est de la mise à niveau de l'interne à l'aide de variables scalaires à l'aide de tableaux. Mais, les utilisateurs sont également autorisés à définir ces variables elles-mêmes, éventuellement, avec un fichier qui est connecté sur le démarrage.

    Donc, j'avais besoin de faire un moyen pour conditionnellement convertir un scalaire à un tableau, selon que l'utilisateur est provenant script est déclaré dans la nouvelle façon ou à l'ancienne.

    Ma solution est overkill pour le cas simple ci-dessus, mais je voulais document pour les autres à la recherche de cette solution, car il est non trivial de venir avec quelque chose qui s'occupait de mon cas d'utilisation.

    Le seul moyen que j'ai trouvé fiable pour gérer toutes les options en toute sécurité est donc:

    convert_array() {
        __array_name="$1"; shift
        __declaration="$(declare -p "$__array_name" 2>/dev/null)"
        if [ -z "${__declaration}" ]; then
                # variable is not set
                eval "${__array_name}=()"
        elif [ "$(echo "${__declaration}" | grep -c '^declare \-a')" -eq 0 ]; then
                # variable is not an array
                __existing_value="$(eval echo "${$__array_name}" | sed -e 's,^[[:space:]]*,,' -e 's,[[:space:]]*$,,')"
                unset "${__array_name?}"
                IFS=" " read -r -a "${__array_name?}" <<< "${__existing_value}"
        fi
}

    Proprement gère tous les cas: variable existante, tableau existant, et il n'est pas défini.

    Noter que, même si cela peut sembler un peu exagéré:

    __existing_value="$(eval echo "\${$__array_name}" | sed -e 's,^[[:space:]]*,,' -e 's,[[:space:]]*$,,')"

    ...il traite le cas que la plupart des gens sont la construction de leur source configurations quelque chose comme ceci:

    ADDITIONAL_OPTIONS="${ADDITIONAL_OPTIONS} -Xmx2g"
ADDITIONAL_OPTIONS="${ADDITIONAL_OPTIONS} -Dsome.property=foo"

    Dans ces cas, la $ADDITIONAL_OPTIONS variable va commencer par un espace. Si vous savez que votre intrants n'aurez pas besoin de rognage, tout cela est inutile.

    test_foo() {
        convert_array FOO
        for VAR in "${FOO[@]}"; do
                echo "var=$VAR"
        done
}

$ FOO="foo bar baz"
$ test_foo
var=foo
var=bar
var=baz
$ unset FOO
$ test_foo
$ FOO=(foo bar baz "something with spaces")
$ test_foo
var=foo
var=bar
var=baz
var=something with spaces

    OriginalL'auteur Benjamin Reed