Shell Programming and Scripting

According to the standards, if an equivalent of the command:

Code:

set -u

has been run, and an equivalent of the command

Code:

set +u

has not been run to counteract it, then:
Otherwise, ${unknown_variable} expands to an empty string.

Maybe typeset is beyond set/unset, like a tattoo?

No need to typeset, just unset or set x and test x for being set.

Somewhere in the man page as copies way below, ksh promises you can test just set and unset, no typeset, but I cannot see it, so maybe just go for blank or not. Your test cost is mostly variable lookup:

Code:

$ dtksh -xc '
 set x ; echo ColonEqualSet  ${x:=Right};echo x=$x
 unset x ; echo ColonEqualUnset  ${x:=Right};echo x=$x
 set x ; echo ColonMinusSet  ${x:-Right};echo x=$x
 unset x ; echo ColonMinusUnset  ${x:-Right};echo x=$x
 set x ; echo ColonPlusSet  ${x:+Right};echo x=$x
 unset x ; echo ColonPlusUnset  ${x:+Right};echo x=$x
 set x ; echo EqualSet  ${x=Right};echo x=$x
 unset x ; echo EqualUnset  ${x=Right};echo x=$x
 set x ; echo MinusSet  ${x-Right};echo x=$x
 unset x ; echo MinusUnset  ${x-Right};echo x=$x
 set x ; echo PlusSet  ${x+Right};echo x=$x
 unset x ; echo PlusUnset  ${x+Right};echo x=$x
 set x ; echo ColonQuerySet  ${x:?Right};echo x=$x
 unset x ; echo ColonQueryUnset  ${x:?Right};echo x=$x
 set x ; echo QuerySet  ${x?Right};echo x=$x
 unset x ; echo QueryUnset  ${x?Right};echo x=$x
'
+ set x
+ echo ColonEqualSet Right
ColonEqualSet Right
+ echo x=Right
x=Right
+ unset x
+ echo ColonEqualUnset Right
ColonEqualUnset Right
+ echo x=Right
x=Right
+ set x
+ echo ColonMinusSet Right
ColonMinusSet Right
+ echo x=Right
x=Right
+ unset x
+ echo ColonMinusUnset Right
ColonMinusUnset Right
+ echo x=
x=
+ set x
+ echo ColonPlusSet
ColonPlusSet
+ echo x=
x=
+ unset x
+ echo ColonPlusUnset
ColonPlusUnset
+ echo x=
x=
+ set x
+ echo EqualSet Right
EqualSet Right
+ echo x=Right
x=Right
+ unset x
+ echo EqualUnset Right
EqualUnset Right
+ echo x=Right
x=Right
+ set x
+ echo MinusSet Right
MinusSet Right
+ echo x=Right
x=Right
+ unset x
+ echo MinusUnset Right
MinusUnset Right
+ echo x=
x=
+ set x
+ echo PlusSet
PlusSet
+ echo x=
x=
+ unset x
+ echo PlusUnset
PlusUnset
+ echo x=
x=
+ set x
dtksh: line 15: x: Right

${parameter:-word}

If parameter is set and is non-null then substitute its value. Oth-
erwise substitute word.

word is not evaluated unless it is to be used as the substituted
string.

In the following example, pwd is executed only if d is not set or
is NULL:

print ${d:-$(pwd)}

If the colon ( : ) is omitted from the expression, the shell only
checks whether parameter is set or not.

${parameter:=word}

If parameter is not set or is null, set it to word. The value of
the parameter is then substituted. Positional parameters cannot be
assigned to in this way.

word is not evaluated unless it is to be used as the substituted
string.

In the following example, pwd is executed only if d is not set or
is NULL:

print ${d:-$(pwd)}

If the colon ( : ) is omitted from the expression, the shell only
checks whether parameter is set or not.

${parameter:?word}

If parameter is set and is non-null, substitute its value. Other-
wise, print word and exit from the shell , if the shell is not
interactive. If word is omitted then a standard message is printed.

word is not evaluated unless it is to be used as the substituted
string.

In the following example, pwd is executed only if d is not set or
is NULL:

print ${d:-$(pwd)}

If the colon ( : ) is omitted from the expression, the shell only
checks whether parameter is set or not.

${parameter:+word}

If parameter is set and is non-null, substitute word. Otherwise
substitute nothing.

word is not evaluated unless it is to be used as the substituted
string.

In the following example, pwd is executed only if d is not set or
is NULL:

print ${d:-$(pwd)}

If the colon ( : ) is omitted from the expression, the shell only
checks whether parameter is set or not.

Well, I'm in a function here, and I don't want to name clash, so I use typeset. The function is a widely-used utility function. I suppose I could follow some naming convention to help prevent clashes, but using typeset to create a local parameter seems cleaner. Preventing the name clash is my main reason for using typeset. Adding "-i" was kind of an afterthought to help performance, but the unexpected result on Version M 93t+ 2009-05-01 was that "-i" causes empty to show up as 0.

Name clashes will be. Does typeset do anything just assigning a value to the variable does not? All variables are local unless exported, and cannot escape their subshell in in any case. I assume shells keep unexported variables in a higher priority local container, to search before going to the exported flat ascii environment container.

So, forget about -i and just use:

Code:

typeset x=""

From this discussion, it should be clear that declaring a variable to have an integer value AND expecting it to be able to hold an empty string does not produce portable behavior.

Right, and variables explicitly declared with "typeset" can't escape their function. For example:

Code:

x="outside f"
function f
{
    typeset x="inside f"
}
f
print $x
outside f

---------- Post updated at 06:49 PM ---------- Previous update was at 06:46 PM ----------

Yeah, that's what I ended up doing.

Yeah, I'll just consider the behavior of empty integers to be unspecified.

If a function gets put on a pipe, all bets are off, anyway. If outside X is getting stomped by inside x, there is (), but I guess typeset is cheaper. It forces a local variable generation without interrogation of the two existing variable stores for variables to use.

Is it really maintainable long term even for you to have inside x and outside x floating around the same script?

For boolean, the -i is worth it only if you get c boolean with it like in 'x &&', '(( x || y ))' and such. I guess have 1 and 0 is familiar. I rarely use a boolean, maybe using flow instead.