Kaip grąžinti eilutės reikšmę iš bash funkcijos

Noriu grąžinti eilutę iš bash funkcijos.

Parašysiu java pavyzdį ir parodysiu, ką norėčiau padaryti:

 public String getSomeString() { return "tadaa"; } String variable = getSomeString(); 

Toliau pateiktas pavyzdys veikia bash, bet ar yra geresnis būdas tai padaryti?

 function getSomeString { echo "tadaa" } VARIABLE=$(getSomeString) 
331
13 июля '10 в 14:55 2010-07-13 14:55 Tomas F yra nustatytas liepos 13 d., 10 val. 14:55 2010-07-13 14:55
@ 18 atsakymų

Nėra geresnio būdo išsiaiškinti. Bash žino tik būsenos kodus (sveikieji skaičiai) ir eilutes, parašytas pagal standartinę išvestį.

201
13 июля '10 в 15:03 2010-07-13 15:03 atsakymą pateikė Philippas liepos 13 d. 10 val. 15:03 2010-07-13 15:03

Galite turėti funkciją priimti kintamąjį kaip pirmąjį arg ir pakeisti kintamąjį su eilute, kurią norite grąžinti.

 #!/bin/bash set -x function pass_back_a_string() { eval "$1='foo bar rab oof'" } return_var='' pass_back_a_string return_var echo $return_var 

Spausdinti „foo bar rab oof“.

Redaguoti : pridėta citata tinkamoje vietoje, kad eilutėje būtų vietos, kurioje būtų galima pateikti komentarą @Luca Borrione.

Keisti . Žr. Šią demonstravimo programą. Tai universalus sprendimas: jis netgi leidžia jums gauti eilutę į vietinį kintamąjį.

 #!/bin/bash set -x function pass_back_a_string() { eval "$1='foo bar rab oof'" } return_var='' pass_back_a_string return_var echo $return_var function call_a_string_func() { local lvar='' pass_back_a_string lvar echo "lvar='$lvar' locally" } call_a_string_func echo "lvar='$lvar' globally" 

Spaudiniai:

 + return_var= + pass_back_a_string return_var + eval 'return_var='\''foo bar rab oof'\''' ++ return_var='foo bar rab oof' + echo foo bar rab oof foo bar rab oof + call_a_string_func + local lvar= + pass_back_a_string lvar + eval 'lvar='\''foo bar rab oof'\''' ++ lvar='foo bar rab oof' + echo 'lvar='\''foo bar rab oof'\'' locally' lvar='foo bar rab oof' locally + echo 'lvar='\'''\'' globally' lvar='' globally 

Redaguoti : rodo, kad pradinė kintamojo vertė yra prieinama funkcijoje, kaip @Xichen Li neteisingai kritikavo komentare.

 #!/bin/bash set -x function pass_back_a_string() { eval "echo in pass_back_a_string, original $1 is \$$1" eval "$1='foo bar rab oof'" } return_var='original return_var' pass_back_a_string return_var echo $return_var function call_a_string_func() { local lvar='original lvar' pass_back_a_string lvar echo "lvar='$lvar' locally" } call_a_string_func echo "lvar='$lvar' globally" 

Taip gaunamas rezultatas:

 + return_var='original return_var' + pass_back_a_string return_var + eval 'echo in pass_back_a_string, original return_var is $return_var' ++ echo in pass_back_a_string, original return_var is original return_var in pass_back_a_string, original return_var is original return_var + eval 'return_var='\''foo bar rab oof'\''' ++ return_var='foo bar rab oof' + echo foo bar rab oof foo bar rab oof + call_a_string_func + local 'lvar=original lvar' + pass_back_a_string lvar + eval 'echo in pass_back_a_string, original lvar is $lvar' ++ echo in pass_back_a_string, original lvar is original lvar in pass_back_a_string, original lvar is original lvar + eval 'lvar='\''foo bar rab oof'\''' ++ lvar='foo bar rab oof' + echo 'lvar='\''foo bar rab oof'\'' locally' lvar='foo bar rab oof' locally + echo 'lvar='\'''\'' globally' lvar='' globally 
153
14 июля '10 в 5:39 2010-07-14 05:39 Atsakymą duoda bstpierre liepos 10 d., 10 val. 5:39 2010-07-14 05:39

Visi aukščiau pateikti atsakymai ignoruoja tai, kas buvo nurodyta pagrindiniame puslapyje.

  • Visus funkcijoje deklaruotus kintamuosius dalins skambinančioji aplinka.
  • Visi vietiniai deklaruoti kintamieji nebus bendrinami.

Kodo pavyzdys

 #!/bin/bash f() { echo function starts local WillNotExists="It still does!" DoesNotExists="It still does!" echo function ends } echo $DoesNotExists #Should print empty line echo $WillNotExists #Should print empty line f #Call the function echo $DoesNotExists #Should print It still does! echo $WillNotExists #Should print empty line 

Ir išvada

 $ sh -x ./x.sh + echo + echo + f + echo function starts function starts + local 'WillNotExists=It still does!' + DoesNotExists='It still does!' + echo function ends function ends + echo It still 'does!' It still does! + echo 

Taip pat pagal pdksh ir ksh šis scenarijus daro tą patį!

80
24 янв. atsakymą pateikė Vicky Ronnen Jan 24 2012-01-24 18:20 '12, 18:20 pm 2012-01-24 18:20

Kaip aukščiau paminėtas, naudoju ir rekomenduoju naudoti aiškiai nurodytus išvesties kintamuosius:

 function another_func() # ARG { local result some_func result "$1" echo result is $result } 
24
27 янв. Markarian451 atsakė į sausio 27 d 2013-01-27 00:01 '13 prie 0:01 2013-01-27 00:01

Bash, nuo 4.3 versijos, 2014 m. Vasario mėn. (?), Turi aiškų palaikymą referenciniams kintamiesiems arba pavadinimams (namerefs), be „eval“, su tokiomis pačiomis naudingomis savybėmis ir netiesioginiu poveikiu, kuris gali būti aiškesnis jūsų scenarijuose, taip pat sunkiau „pamiršti„ eval “ir ištaisyti šią klaidą“:

 declare [-aAfFgilnrtux] [-p] [name[=value] ...] typeset [-aAfFgilnrtux] [-p] [name[=value] ...] Declare variables and/or give them attributes ... -n Give each name the nameref attribute, making it a name reference to another variable. That other variable is defined by the value of name. All references and assignments to name, except for⋅ changing the -n attribute itself, are performed on the variable referenced by name value. The -n attribute cannot be applied to array variables. ... When used in a function, declare and typeset make each name local, as with the local command, unless the -g option is supplied... 

ir taip pat:

PARAMETRAI

Kintamasis gali būti priskirtas nameref atributui, naudojant parametrą -n, kad deklaruotumėte arba vietines integruotas komandas (žr. Deklaracijų aprašymus ir vietinius žemiau), kad sukurtumėte nameref arba nuorodą į kitą kintamąjį. Tai leidžia manipuliuoti kintamaisiais netiesiogiai. Kai nameref kintamasis yra nurodomas arba priskirtas, operacija faktiškai atliekama su kintamuoju, nurodytu nameref kintamojo verte. Namec paprastai naudojamas korpuso funkcijos viduje, nurodant kintamąjį, kurio pavadinimas perduodamas kaip argumentas funkcijai. Pvz., Jei kintamojo pavadinimas perduodamas į apvalkalo funkciją kaip pirmasis argumentas, vykdant

  declare -n ref=$1 

funkcijos viduje sukuriamas kintamasis nameref ref, kurio vertė yra kintamojo pavadinimas yra perduodamas kaip pirmasis argumentas. Nuorodos ir priskyrimai priskiriami nuorodoms ir priskyrimams kintamajam, kurio pavadinimas buvo perduotas kaip $ 1. Jei kontroliniame kintamajame „for“ kilpoje yra atributas nameref, žodinis sąrašas gali būti lukšto kintamųjų sąrašas, o pavadinimo nuoroda bus lygi kiekvienam sąraše pateiktam žodžiui, savo ruožtu, kai veikia kilpa. Armatūros kintamieji negali būti priskirti atributui -n. Tačiau nameref kintamieji gali būti susiję su masyvo kintamaisiais ir indeksuotais masyvo kintamaisiais. Namerefs galima išjungti naudodami -n parinktį, kad išjungtumėte integruotą. Priešingu atveju, jei atliksite išjungimą su vardo vardo kintamojo pavadinimu kaip argumentą, kintamasis, kurį nurodo nameref kintamasis, bus išjungtas.

Pavyzdžiui ( EDIT 2 : (ačiū Ronui) vardų pavardė (prefiksas) funkcijos pavadinimas yra vidinis kintamasis, sumažinantis išorinių kintamųjų susidūrimus, kurie galiausiai turi teisingai atsakyti į Carsten komentaruose iškeltą problemą):

 # $1 : string; your variable to contain the return value function return_a_string () { declare -n ret=$1 local MYLIB_return_a_string_message="The date is " MYLIB_return_a_string_message+=$(date) ret=$MYLIB_return_a_string_message } 

ir išbandykite šį pavyzdį:

 $ return_a_string result; echo $result The date is 20160817 

Atkreipkite dėmesį, kad bash "deklaruoti" įmontuotą, kai naudojama funkcija, deklaruojamą kintamąjį "vietinis" yra numatytasis, o "-n" taip pat galima naudoti su "vietiniu".

Norėčiau atskirti „svarbius deklaruotinus“ kintamuosius ir „nuobodu vietinius“ kintamuosius, taigi „deklaruoti“ ir „vietiniai“ rodikliai yra dokumentai.

1 - (Reaguodamas į komentarą žemiau Karsten) - nebegaliu toliau pridėti komentarų, tačiau Karsteno komentaras privertė mane galvoti, todėl atlikau šį testą, kuris skaito, AFAICT - Karsten, jei perskaitysite, pateikite tikslų testavimo etapų rinkinį komandų eilutė, rodanti, kad siūloma problema yra, nes šie tolesni veiksmai veikia labai gerai:

 $ return_a_string ret; echo $ret The date is 20170104 

(Buvau tik dabar, įterpdamas nurodytą funkciją į terminą bash - kaip matote, rezultatas veikia tik gerai.)

22
17 авг. atsakymas pateikiamas zenaan 17 rug . 2016-08-17 16:13 '16 at 16:13 2016-08-17 16:13

Taip pat galite parašyti funkcijos išvestį:

 #!/bin/bash function getSomeString() { echo "tadaa!" } return_var=$(getSomeString) echo $return_var # Alternative syntax: return_var=`getSomeString` echo $return_var 

Atrodo keista, bet geriau nei pasauliniai kintamieji IMHO. Parametrų perdavimas veikia kaip įprasta, tiesiog įkiškite į skliaustelius ar atgalines žymes.

17
17 авг. atsakymas pateikiamas chiborg 17 rug . 2010-08-17 12:02 '10, 12:02, 2010-08-17 12:02

Kaip minėta anksčiau, „teisingas“ būdas grąžinti eilutę iš funkcijos yra pakeisti komandą. Tuo atveju, kai funkcija taip pat turėtų būti perduodama į konsolę (kaip minėta pirmiau @Mani), funkcijos pradžioje sukurkite laikiną fd ir nukreipkite į konsolę. Prieš grąžindami eilutę, uždarykite laikinąjį fd failą.

 #!/bin/bash # file: func_return_test.sh returnString() { exec 3> >/dev/tty local s=$1 s=${s:="some default string"} echo "writing directly to console" exec 3> echo "$s" } my_string=$(returnString "$*") echo "my_string: [$my_string]" 

Skripto vykdymas be jokių parametrų sukuria ...

 # ./func_return_test.sh writing directly to console my_string: [some default string] 

tikiuosi, kad tai padės žmonėms

-Andy

8
09 окт. atsakymas duotas Andy 09 okt. 2013-10-09 00:22 '13 - 0:22 2013-10-09 00:22

Paprasčiausias ir patikimiausias sprendimas yra naudoti komandų pakeitimą, kaip rašė kiti žmonės:

 assign() { local x x="Test" echo "$x" } x=$(assign) # This assigns string "Test" to x 

Trūkumas yra našumas, nes tam reikia atskiro proceso.

Kitas šiame skyriuje siūlomas metodas, ty kintamojo pavadinimo perdavimas į paskirties vietą kaip argumentas, turi šalutinį poveikį, ir aš nerekomenduočiau jos pagrindinėje formoje. Problema ta, kad tikriausiai reikia tam tikrų kintamųjų funkcijoje, kad būtų galima apskaičiuoti grąžos vertę, ir gali atsitikti, kad kintamojo, kuris naudojamas išsaugoti grąžos vertę, pavadinimas trukdo vienam iš jų:

 assign() { local x x="Test" eval "$1=\$x" } assign y # This assigns string "Test" to y, as expected assign x # This will NOT assign anything to x in this scope # because the name "x" is declared as local inside the function 

Žinoma, jūs negalite deklaruoti funkcijų vidinių kintamųjų kaip vietiniai, bet jūs iš tikrųjų turėtumėte tai padaryti, nes kitaip, atsitiktinai galite netyčia perrašyti nesusijusį kintamąjį iš tėvų regiono, jei jis turi tą patį pavadinimą.

Vienas iš galimų problemų yra aiškiai paskelbti perduotą kintamąjį kaip pasaulinį:

 assign() { local x eval declare -g $1 x="Test" eval "$1=\$x" } 

Jei pavadinimas „x“ perduodamas kaip argumentas, antroji funkcijų kūno eilutė pakeis ankstesnę vietinę deklaraciją. Tačiau pačios pavadinimai vis tiek gali trukdyti, todėl, jei ketinate prieš perduodant grąžinimo vertę naudoti anksčiau perduotą kintamąjį, turėkite omenyje, kad turite jį nukopijuoti į kitą vietinį kintamąjį pradžioje; kitaip rezultatas bus nenuspėjamas! Be to, ji veiks tik naujausioje BASH versijoje, būtent 4.2 punkte. Daugiau nešiojamų kodų galima naudoti aiškias sąlygines konstrukcijas, turinčias tokį patį poveikį:

 assign() { if [[ $1 != x ]]; then local x fi x="Test" eval "$1=\$x" } 

Galbūt labiausiai elegantiškas sprendimas yra rezervuoti vieną visuotinį pavadinimą grąžintoms funkcijų reikšmėms ir nuosekliai naudoti kiekvieną jūsų parašytą funkciją.

7
13 авг. atsakymas Tomaszui augukui 13 rug. 2013-08-13 02:34 '13, 02:34 am 2013-08-13 02:34

Galite naudoti bendrą kintamąjį:

 declare globalvar='some string' string () { eval "$1='some other string'" } # ---------- end of function string ---------- string globalvar echo "'${globalvar}'" 

Tai suteikia

 'some other string' 
6
13 июля '10 в 15:58 2010-07-13 15:58 Atsakymą pateikė Fritz G. Mehner , liepos 13 d., 10 val. 15:58 2010-07-13 15:58

Jei norite iliustruoti mano komentarą apie Andy, atsakykite su papildomu failų tvarkymo apdorojimu, kad nesinaudotumėte /dev/tty :

 #!/bin/bash exec 3> returnString() { exec 4> > local s=$1 s=${s:="some default string"} echo "writing to stdout" echo "writing to stderr" > exec > echo "$s" } my_string=$(returnString "$*") echo "my_string: [$my_string]" 

Vis dar bjaurus.

5
13 марта '14 в 15:02 2014-03-13 15:02 atsakymas duotas jmb kovo 13 d. 14 val. 15:02 2014-03-13 15:02

Spręsdamas Vicky Ronnen , apsvarstęs šį kodą:

 function use_global { eval "$1='changed using a global var'" } function capture_output { echo "always changed" } function test_inside_a_func { local _myvar='local starting value' echo "3. $_myvar" use_global '_myvar' echo "4. $_myvar" _myvar=$( capture_output ) echo "5. $_myvar" } function only_difference { local _myvar='local starting value' echo "7. $_myvar" local use_global '_myvar' echo "8. $_myvar" local _myvar=$( capture_output ) echo "9. $_myvar" } declare myvar='global starting value' echo "0. $myvar" use_global 'myvar' echo "1. $myvar" myvar=$( capture_output ) echo "2. $myvar" test_inside_a_func echo "6. $_myvar" # this was local inside the above function only_difference 



duos

 0. global starting value 1. changed using a global var 2. always changed 3. local starting value 4. changed using a global var 5. always changed 6. 7. local starting value 8. local starting value 9. always changed 

Galbūt įprastas scenarijus yra naudoti sintaksę, naudojamą funkcijoje „ test_inside_a_func , todėl daugeliu atvejų galite naudoti abu metodus, nors išvesties surinkimas yra saugesnis metodas, visada dirbantis bet kokioje situacijoje, imituojant grąžos reikšmę iš funkcijos, kurią galite rasti kitos kalbos, kaip nurodė Vicky Ronnen .

3
09 мая '12 в 1:19 2012-05-09 01:19 atsakymą pateikė Luca Borrione gegužės 09 d., 12 d. 1:19 2012-05-09 01:19

Tai, kaip jūs turite, yra vienintelis būdas tai padaryti nepažeidžiant rėmo. „Bash“ neturi sugrįžimo tipų, tiesiog išėjimo kodų ir failų deskriptorių (stdin / out / err ir tt)

3
14 июля '10 в 5:49 2010-07-14 05:49 atsakymas pateikiamas Daenyth'ui liepos 10 d., 10 val. 5:49 2010-07-14 05:49

Galite echo eilutę, bet sugauti jį dujotiekiu ( | ) kažkam kitam.

Tai galite padaryti su expr , nors „ ShellCheck“ praneša, kad šis naudojimas yra pasenęs.

2
20 нояб. Atsakymą pateikia „ apennebaker“ lapkričio 20 d 2013-11-20 22:16 '13, 10:16 pm 2013-11-20 22:16

Manau, visi parametrai yra išvardyti. Galite pasirinkti tinkamą konkrečios programos stilių, ir šiuo atveju noriu pasiūlyti vieną konkretų stilių, kurį radau naudinga. Be bash, kintamieji ir funkcijos nėra toje pačioje vardų erdvėje. Taigi kintamojo, turinčio tą patį pavadinimą, kaip ir funkcijos vertė, apdorojimas yra konvencija, kuri, mano nuomone, sumažina vardų susidūrimus ir pagerina skaitomumą, jei jį griežtai taiko. Realaus gyvenimo pavyzdys:

 UnGetChar= function GetChar() { # assume failure GetChar= # if someone previously "ungot" a char if ! [ -z "$UnGetChar" ]; then GetChar="$UnGetChar" UnGetChar= return 0 # success # else, if not at EOF elif IFS= read -N1 GetChar ; then return 0 # success else return 1 # EOF fi } function UnGetChar(){ UnGetChar="$1" } 

Ir tokių funkcijų naudojimo pavyzdys:

 function GetToken() { # assume failure GetToken= # if at end of file if ! GetChar; then return 1 # EOF # if start of comment elif [[ "$GetChar" == "#" ]]; then while [[ "$GetChar" != $'\n' ]]; do GetToken+="$GetChar" GetChar done UnGetChar "$GetChar" # if start of quoted string elif [ "$GetChar" == '"' ]; then # ... et cetera 

Kaip matote, jūsų grąžinimo būsena bus naudojama, kai to reikia, arba ignoruojama, jei to nepadarysite. „Grąžintas“ kintamasis taip pat gali būti naudojamas arba ignoruojamas, bet, žinoma, tik iškviečiant funkciją.

Žinoma, tai tik konvencija. Galite grąžinti nustatytą vertę prieš sugrįždami (todėl mano sutikimas visuomet panaikina funkciją pradžioje) arba suklupia jo vertę dar kartą paskambindamas (galbūt netiesiogiai). Tačiau tai yra susitarimas, kurį aš manau labai naudinga, jei naudoju bash funkcijas.

Skirtingai nuo jausmo, kad tai yra ženklas, jums reikia, pavyzdžiui, „Eikime į perl“, mano filosofija yra ta, kad konvencijos visada yra svarbios bet kokios kalbos sudėtingumui valdyti.

2
05 мая '15 в 3:19 2015-05-05 03:19 atsakė Ronui Burkui 05.05.15 val. 3:19 2015-05-05 03:19

Savo programose, pagal susitarimą, tai yra tai, ką yra $REPLY ankstesnis $REPLY kintamasis, kuris read tiksliai naudojamas šiam tikslui.

 function getSomeString { REPLY="tadaa" } getSomeString echo $REPLY 

Tai yra echo

 tadaa 

Tačiau, kad išvengtumėte konfliktų, bet koks kitas pasaulinis kintamasis.

 declare result function getSomeString { result="tadaa" } getSomeString echo $result 

Jei to nepakanka, rekomenduoju „ Markarian451“ sprendimą.

2
05 янв. atsakymas pateikiamas Evi1M4chine 05 jan. 2016-01-05 19:33 '16 at 19:33 2016-01-05 19:33

Jie yra pagrindinė bet kurios „pavadintos išvesties kintamojo“ schemos problema, kurioje skambinantysis gali perduoti kintamojo pavadinimą (naudojant eval arba declare -n ), yra nenumatytas slapyvardis, ty vardų konfliktai: iš kapsulių taško, tai yra baisu, kad neįmanoma pridėti arba pervardyti vietinį kintamąjį funkcijai, prieš tai neperžiūrėdami visų funkcijų skambintojų, kad įsitikintų, jog jie nenori perduoti to paties pavadinimo, kaip ir išvesties parametras. (Arba kitoje kryptyje nenoriu perskaityti funkcijos, kurią raginu, šaltinio, kad įsitikintumėte, jog išėjimo parametras, kurį ketinu naudoti, nėra vietinė šiai funkcijai.)

Vienintelis būdas yra naudoti vieną išskirtinį REPLY tipo produkcijos kintamąjį (kaip siūlo Evi1M4chine ) arba konvenciją, panašią į Ron Burko pasiūlymą.

Tačiau yra įmanoma, kad funkcijos naudoja fiksuotą išvesties kintamąjį viduje ir po to priduria šiek tiek cukraus virš viršaus, kad paslėptų šį faktą iš skambintojo , nes aš padariau naudojant call funkciją toliau pateiktame pavyzdyje. Apsvarstykite šį koncepcijos įrodymą, bet pagrindinius dalykus

  • Funkcija visada priskiria grąžinimo vertę REPLY ir taip pat gali grąžinti išėjimo kodą, kaip įprasta.
  • Skambintojo požiūriu grįžimo vertė gali būti priskirta bet kuriam kintamajam (vietiniam ar pasauliniam), įskaitant REPLY (žr. wrapper pavyzdį). Funkcijos išėjimo kodas praleidžiamas, todėl jų naudojimas, pavyzdžiui, if arba while ar panašios konstrukcijos veikia taip, kaip tikėtasi.
  • Sintaktinis funkcijos iškvietimas vis dar yra vienas paprastas teiginys.

Taip yra todėl, kad pati call funkcija neturi lokalių ir nenaudoja jokių kitų kintamųjų, išskyrus REPLY , išvengiant galimo vardų susidūrimo. Tuo metu, kai priskiriamas skambintojo nurodytas išvesties kintamojo pavadinimas, mes iš tikrųjų esame skambučio zonoje (techniškai identiškame call funkcijos kiekyje), o ne vadinamosios funkcijos srityje.

 #!/bin/bash function call() { # var=func [args ...] REPLY=; "${1#*=}" "${@:2}"; eval "${1%%=*}=\$REPLY; return $?" } function greet() { case "$1" in us) REPLY="hello";; nz) REPLY="kia ora";; *) return 123;; esac } function wrapper() { call REPLY=greet "$@" } function main() { local abcd call a=greet us echo "a='$a' ($?)" call b=greet nz echo "b='$b' ($?)" call c=greet de echo "c='$c' ($?)" call d=wrapper us echo "d='$d' ($?)" } main 

Išvada:

 a='hello' (0) b='kia ora' (0) c='' (123) d='hello' (0) 
1
03 янв. Atsakymas duotas Karsten 03 jan. 2017-01-03 15:33 '17 at 15:33 2017-01-03 15:33

grįžti į skaliarinius ir masyvinius objektus:

apibrėžimas

 url_parse() { # parse 'url' into: 'url_host', 'url_port', ... local "$@" # inject caller 'url' argument in local scope local url_host="..." url_path="..." # calculate 'url_*' components declare -p ${!url_*} # return only 'url_*' object fields to the caller } 

iššūkis

 main() { # invoke url parser and inject 'url_*' results in local scope eval "$(url_parse url=http://host/path)" # parse 'url' echo "host=$url_host path=$url_path" # use 'url_*' components } 
0
22 окт. Andrei Pozolotin atsakymas spalio 22 d 2017-10-22 05:15 '17, 15:15 am 2017-10-22 05:15
 agt@agtsoft:~/temp$ cat ./fc #!/bin/sh fcall='function fcall { local res p=$1; shift; fname $*; eval "$p=$res"; }; fcall' function f1 { res=$[($1+$2)*2]; } function f2 { local a; eval ${fcall//fname/f1} a 2 3; echo f2:$a; } a=3; f2; echo after:a=$a, res=$res agt@agtsoft:~/temp$ ./fc f2:10 after:a=3, res= 
-2
17 нояб. Atsakymą pateikė agtsoft 17 nov. 2012-11-17 01:40 '12 at 1:40 2012-11-17 01:40

Žr. Kitus klausimus apie žymių arba Užduoti klausimą