Perhaps someone can assist?
How do you pass a variable from one function into another function?
and/or make it a "global" variable from within a function.
Not sure how "c" got assigned a value of "0"
I want it to say 200.
My actual script has to calculate the variable within a function then send that to various other functions that may have to send variables to yet other functions.

MyUbuntu$ cat myscript
#!/usr/bin/bash
this(){
( a="hi"
b=3
c=200
) }
that(){
( echo "c in that called from this: $((this ${c}))"
) }
that

#OUTPUT:
MyUbuntu$ myscript
c in that called from this: 0

On 2021-06-17, Chris Roberts <thecjguy1@gmail.com> wrote:
> Perhaps someone can assist?
> How do you pass a variable from one function into another function?

Bash implements dynamic scoping. When you declare a file "local" inside
a function, this is a dynamic binding which is visible to functions
which are then called from that function. The dynamic binding goes away
when the binding function terminates. This reveals any earlier binding
which that variable had.

foo=42

print_foo()
{
echo "foo is $foo"
}

override_foo()
{
local foo=73
print_foo
}

print_foo
override_foo
print_foo

Output:

foo is 42
foo is 73
foo is 42

After override_foo terminates, the 42 value is restored.

> #!/usr/bin/bash
> this(){
> (
> a="hi"
> b=3
> c=200
> )
> }
> that(){
> (
> echo "c in that called from this: $((this ${c}))"
> )
> }
> that

But "that" is not being called from "this"; your message is misleading.

Anyway, let us continue. Dynamic binding means that the most recent
local binding of a variable is also visible to the eval function.

In a function if we do this:

local foo=42
local foo_name="foo"

eval echo '$'$foo_name

it will print 42. You see where this is headed? We can have a computed
variable name, represented as a string. We can stick a dollar sign on
that string and pass it to eval, to get the dynamic value of that
variable.

So if you put all this together, you have a way to literally "pass a
variable" to another function.

You can bind a variable like foo, and then pass the name "foo"
to another function. That other function can do the eval trick
and obtain the value of foo. De facto, you have passed a variable
using a "call by name" parameter passing strategy.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

In article <51e84159-f764-4eba-b807-6154dc88a6b6n@googlegroups.com>,
Chris Roberts <thecjguy1@gmail.com> wrote:
>Perhaps someone can assist?
>How do you pass a variable from one function into another function?
>and/or make it a "global" variable from within a function.
>Not sure how "c" got assigned a value of "0"
>I want it to say 200.
>My actual script has to calculate the variable within a function then send
>that to various other functions that may have to send variables to yet
>other functions.

Lose the parens (That is, the ( and ))

() makes things run in a subshell, which means changes do not propagate
back.

Observe:

$ unset foo
$ (foo=42)
$ echo $foo

$

Obviously, if we left out the () on the assignment, the final echo would
show the value 42.

--
1) The only professionals who refer to their customers as "users" are
computer guys and drug dealers.
2) The only professionals who refer to their customers as "clients" are
lawyers and prostitutes.

On Thu, 17 Jun 2021 12:07:49 -0700, Chris Roberts wrote:

> Perhaps someone can assist?
> How do you pass a variable from one function into another function?
> and/or make it a "global" variable from within a function.
> Not sure how "c" got assigned a value of "0"
> I want it to say 200.
> My actual script has to calculate the variable within a function then send that to various other functions that may have to send variables to yet other functions.
>
> MyUbuntu$ cat myscript
> #!/usr/bin/bash
> this(){
> (
> a="hi"
> b=3
> c=200
> )
> }
> that(){
> (
> echo "c in that called from this: $((this ${c}))"
> )
> }
> that
>
> #OUTPUT:
> MyUbuntu$ myscript
> c in that called from this: 0

Some hints to remember:

1) ordinary variables (not "local" variables) are shared
between the function and it's caller
Thus
function A(){
b=7;
}
b=5;
A
echo $b
will show that the the A function updated the mainline variable b

2) local variables exist only within the function that they are declared in
Thus
function Q() {
local r;
r=5;
echo "r is set to $r"
}
r=10;
Q
echo $r
will show that, while the Q function used the variable r, it did not update
the /mainline/ variable r

3) functions can accept arguments, and the values for those arguments
can come from the caller
Thus
function B(){
b=$1;
echo "Setting b to $1"
}
b=5;
B 100
echo $b
will show that the B function updated the mainline variable b with
a value provided by the call to B

4) functions can return values in their stdout
Thus
function C(){
echo 1000;
}
b=$(C)
echo $b
will show that the C function provided the value stored in the
mainline variable b

5) lists of commands executed between left and right parenthesis
do NOT share an environment with commands outside of the parenthesis
Thus
b=8;
(b=100;echo "Set b=$b";)
echo "b = $b"
will show that the value of the variable b /outside/ of the parenthesis
did not change even though the value of the variable b /inside/ of the
parenthesis did

6) lists of commands executed between left and right brace brackets share
an environment with commands outside of the brace brackets
Thus
b=8;
{ b=100;echo "Set b=$b"; }
echo "b = $b"
will show that the value of the variable b /outside/ of the brace brackets
changed to the value of the variable b /inside/ of the brace brackets

7) there are two forms of "command substitution":
$(command)
and
`command`
In either case, the shell replaces the command substitution with the stdout
of the executed command
Thus,
a=$(date)
assigns to the variable a the value that is the stdout of the date command.

8) In arithmetic expansion, the shell evaluates an arithmetic expression and substitutes
it's value for the expression
Thus
a=$((1 + 4))
assigns to the variable a the value that is the arithmetic result of 1 + 4

Now, on to your script

> this(){
> (
> a="hi"
> b=3
> c=200
> )
> }

Because you contain the assignments within parenthesis, hint #5 comes in to
play, and the assignments are, effectively, local to the parenthetical block.
This means that, as is, the assignments in your function this() will not
leak out of the function.

Had you coded the function as
this() {
a="hi"
b=3
c=200
}
then hint #1 would come into effect and the values set in a, b, and c by the
function this() would be shared with the caller's versions of a, b, and c.

> that(){
> (
> echo "c in that called from this: $((this ${c}))"
> )
> }

Since your this() function wrapped it's assignments in parenthesis, it cannot
change the value of variable c in the that() function.
Note that your echo uses an arithmetic expansion (hint #8), which expects
arguments consisting of names of variables, numeric constants, or arithmetic
operators. You give it arguments: the variable "this", and the value of an
unset variable ${c}. The ${c} evaluates to a null string, and is ignored.
The "this" is evaluated as an unset variable, and taken to have a value of 0.
Your that() function never invokes your this() function. You probably meant
to use a command substitution. If you had, your that() function would look
like

> that(){
> (
> echo "c in that called from this: $(this ${c})"
> )
> }

Note also that, in this form, the command substitution is provided the
value of variable c set (or, in this case, not) by the that() function.
Nowhere in your this() function do you look at the arguments provided
to the this() function, so even if c were set here, this() wouldn't
have actually seen it.

HTH
--
Lew Pitcher
"In Skills, We Trust"