Renvoyer un tableau depuis une commande

Bonjour,

j'utilise une fonction qui me renvoie une liste via la création d'une variable que je peux réutiliser après.

Je souhaiterai convertir cette fonction en une "vraie" commande.

Mon soucis est de renvoyer une liste lorsque j'appelle la commande.

Afin que je comprenne bien, simplifions la commande (qui n'a que peu d’intérêt mais bon :p ), on lui entre des valeurs, elle crée une liste avec et ne la renvoie que partiellement (genre les clés 1 et 3) :
Il faudrait donc que :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

variable=($(ma_super_commande oui non ouioui nononon))   # Crée une liste mais ne doit me renvoyer que : # liste[1] qui vaut non # liste[3] qui vaut nonnon   # Ainsi je devrais obtenir : echo "${variable[@]}" non nononon   echo "${!variable[@]}" 1 3

---

j'arrive à renvoyer les textes via des echo mais comment faire pour qu'au final j'ai une liste avec conservation des clés ?

Le but est bien évidemment qu'il n'y ait rien à faire pour l'utilisateur hormis appeler la fonction... (car oui on pourrait facilement boucler après coup dessus pour créer la liste).

Merci à vous :)

J'ai rien compris :ptdr: :lol:

que veux tu faire véritablement ?
qu'est ce que "vraie commande" signifie ?
exemple d'entrée et exemple de résultat attendu ?

Merci

le terme "vraie" commande n'est pas en effet pas bon, c'est juste appeler un script au final mais dont je veux récupérer des informations.

Citation:

---

que veux tu faire ?
exemple d'entrée et exemple de résultat attendu ?

---

C'est ce que je pensais avoir fait...


Comment récupérer un tableau en conservant ses clés et de ses valeurs depuis l'appel d'un autre fichier ?

j'appelle ma super commande qui doit me renvoyer un tableau dans une variable donc :

Code:

---

1 2 3 4 5 6 7

x=($(ma_super_commande))   echo ${x[@]} valeur1 valeur3   echo ${!x[@]} 1 3

---

Encore une fois, on se fiche de ce que fait la super commande car au final, je cherche à comprendre comment (et si c'est possible) récupérer un tableau et ce sans avoir rien à faire de particulier pour l'utilisateur.

Mon but est d'eviter que l'utilisateur ait besoin de faire genre :

Code:

---

1 2 3 4 5 6 7 8 9 10

x=($(ma_super_commande))   echo ${x[@]} 1:valeur1 3:valeur3   y=() for elem in "${x[@]}" do y[${elem%%:*}]="${elem#*:}" done

---

ou :

Code:

---

1 2 3 4 5 6

x=() while IFS+=":" read num elem do # La commande me renvoie des lignes de type : Numero:Valeur x[${num}]="${elem}" done < <(ma_super_commande)

---

Cela fonctionne mais demande du traitement post commande, ce que je voudrais vraiment éviter.

En espérant avoir été plus clair... ( et que ce soit possible)

Bonjour,

un script accepte des paramètres "individuels", pas des tableaux.

le seul "tableau" accessible par défaut dans un script est $@, qui contient la liste des tous les arguments du script.

aqjs, il faudra parser la sortie de ta super commande pour y récupérer les informations.

pour info, x=($(ma_super_commande)) est une mauvaise façon de faire, car le découpage de la sortie de la commande en éléments du tableau est fonction de l'IFS.

Code:

---

1 2 3 4 5 6 7 8 9 10

$ maFonc() { echo "bla bla 'tra la la' \"la lère\"";} $ monTableau=( $(maFonc) ) $ printf '%s\n' "${monTableau[@]}" bla bla 'tra la la' "la lère"

---

Code:

---

1 2 3 4 5 6

$ maFonc() { echo "bla bla:tra la la:la lère";} $ IFS=':' monTableau=( $(maFonc) ) $ printf '%s\n' "${monTableau[@]}" bla bla tra la la la lère

---

mais ça ne répond pas à ton interrogation.
et pour pouvoir faire un while read line efficace, il faudrait que ta super commande affiche les informations ligne par ligne.

Ca doit être un super bordel dans ma tête XD
du coup mes explications s'en ressentent.

mon but n'est pas d'utiliser un while read ou quoi que ce soi derriere.

Essayons autrement... mmmhhh :

imaginons qu'un script fait tout un travail et doit me renvoyer un tableau :

Code:

---

1 2 3 4 5 6 7

# Il contient 2 valeurs echo ${Tableau[@]} oui non   # il contient 2 clés mais pas 0 et 1 forcement... echo ${!Tableau[@]} 0 5

---

Je souhaiterait lorsque je fais appel à ce script via une commande type :

Code:

---

x=( $(ma_commande) )

---

obtenir le même résultat que ci dessus, c'est à dire :

Code:

---

1 2 3 4 5

echo ${x[@]} oui non   echo ${!x[@]} 0 5

---

Actuellement j'en suis à :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

variable=() while read line do # Me renvoie les lignes : # 0:oui # 5:non # Je traite les lignes afin de séparer la clé et la valeur variable[${line%%:*}]="${line#*:}" done < <(ma_commande)   echo ${variable[@]} oui non   echo ${!variable[@]} 0 5

---

J'ai donc bien le résultat escompté.

Mais mon but est de supprimer tout le traitement présent ici et de le délocaliser dans ma fameuse commande afin qu'un appel à ma commande suffise à me renvoyer le résultat.

Mais cela ne me semble pas possible...

il me semble avoir bien compris.

en deux mots : pas possible.

un script ne renvoie pas un tableau, il affiche des données "brutes".
et l'insertion dans un tableau de la sortie d'une commande n'en préserve pas l'apparent format tabulaire, puisqu'un script ne sort pas un tableau...

OK merci beaucoup à vous d'avoir pris le temps d'essayer de me comprendre !

Dommage que ce soit pas possible :)

je confirme maintenant que je vois le besoin.
C'est juste impossible.

il faut penser ça autrement, par exemple passer via un fichier de sortie crée par un script (à toi de choisir le format, cvs, xml, yml,html,etc...) peut importe de là un autre script, utilisateur, etc... peut aller chercher ces informations et travailler dessus.

mais ce n'est pas

Merci,
ce qui me rassure c'est que j'étais bien partie comme il le fallait :)

salut,

c'est ça que tu cherches ?

Code:

---

1 2 3 4 5

$ x=(["0"]="oui" ["5"]="non") $ echo ${x[@]} oui non $ echo ${!x[@]} 0 5

---

En fait c'était ça :

Code:

---

1 2 3 4 5 6 7 8 9

function test { echo "[0]='oui' [5]='non'" }   x=( $(test) )   $ echo ${x[@]} oui non   $ echo ${!x[@]} 0 5

---

Mais ce n'est pas possible.

et test (mauvais choix de nom) doit obligatoirement être une fonction, ça n'est pas envisageable de sourcer un fichier pour récupérer le tableau, quitte à le recopier ensuite par exemple ?

Code:

---

1 2 3 4

source script2 x=(${tab[@]}) echo ${x[@]} echo ${!x[@]}

---

Code:

---

tab=(["0"]="oui" ["5"]="non")

---

en réalité ce n'est pas une fonction mais un script (un autre fichier) qui est lancé et non une fonction (ça permet d'utiliser getops entre autre).
Du coup le source ne fait pas exactement pareil...

Bonjour,
Peut-être une piste (mais dangereux) :

Code:

---

1 2 3 4 5 6 7

$ unset x $ titi() { echo "[0]='oui' [5]='non'" ;} $ eval x=($(titi)) $ echo ${x[@]} oui non $ echo ${!x[@]} 0 5

---

Je connais quelqu'un qui dit toujours : "eval c'est mal" :p

« une piste (mais dangereux) »

C'est vrai, mais on peut quand on maîtrise l'évaluation et que l'on ne peut pas faire autrement.
Le problème de eval, c'est que l'on peut détourner ce qu'il doit évaluer pour y introduire un peu n'importe quelle commande à des fins de corrompre le système.
Pour faire simple, il peut introduire de gros problème de sécurité, sauf si ce qu'il doit évalué est bien circonscrit et donc ici, tu dois te poser la question si l'utilisateur pourra lui faire évaluer des commandes ou si le script qui fournit le résultat qui passe dans l'évaluation ne permettra jamais d'évaluer des commandes...

Oui oui j'ai bien lu ce qui était écrit :)

Je connais un peu eval, je sais qu'il est très puissant mais relativement dangereux aussi comme tu le précise dans tes explications.

Je pense rester dans mon système actuel, un peu moins pratique mais sans risque.

encore merci pour vos propositions.

C'est amusant parce que, pour un besoin personnel, ça fait 2 jours que je suis sur cette même question: comment une fonction shell pourrait "retourner" à son appelant un tableau... (j'utilise "retourner" au sens habituel des fonctions du lambda-calcul)

C'est quelque chose qui est tellement courant dans la plupart des langages de programmation qu'on aimerait bien avoir quelque chose d'identique en shell...
mais, apparemment, c'est pas simple, voire impossible...

Pour le fun, j'ai trouvé ceci (mais attention: eval is evil...):

Code:

---

1 2 3 4 5

maFonc() { local result declare -a result=([1]=hello [3]=world [5]='and "goodbye"!') declare -p result }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

$ temp=$(maFonc) # Je récupère la valeur "retournée" par la fonction dans une variable temporaire   $ echo "temp: '$temp'" Temp: 'declare -a result='([1]="hello" [3]="world" [5]="and \"goodbye\"!")''   $ eval "${temp/result=/x=}" # D'un coup de baguette magique, je transfère le résultat dans une variable "x"...   $ echo "Valeurs: ${x[@]}" Valeurs: hello world and "goodbye"!   $ echo "Indices: ${!x[@]}" Indices: 1 3 5   $ declare -p x # Pour vérifier l'ensemble des valeurs declare -a x='([1]="hello" [3]="world" [5]="and \"goodbye\"!")'

---

Au final je vais le passer en résolu mais je vais éviter de l'utiliser eval (le mal est toujours tentant :p )

On vient de me proposer cela également :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

mycommand () { declare -n _p="${1}" _p[8]="valeur 8" _p[12]="valeur 12" _p[2]="valeur 2" }   declare -Ag table_obj="matable"   mycommand matable echo ${matable[@]} echo ${!matable[@]} echo ${#matable[@]}

---

qui marche bien mais qu'il faut sourcer si mycommand est un fichier.