![\"\"](\"https:\/\/linuxhint.com\/wp-content\/uploads\/2019\/01\/1-20.png\")
<\/p>\nBash doesn\u2019t have a strong type system. To allow type-like behavior, it uses attributes that can be set by a command.<\/p>\n
\u2018declare\u2019<\/p>\n
is a bash built-in command that allows you to update attributes applied to variables within the scope of your shell. In addition, it can be used to declare a variable in longhand. Lastly, it allows you to peek into variables.<\/p>\n
Here you will find out that you are blind or using the bash declare command.<\/p>\n
At this point you are thinking, what do I need to know to use the declare command in bash? At the time like these, the man command comes in handy. I\u2019m just going to paste the part about declare in bash builtins here.<\/p>\n
<\/p>\n
Here are some help commands to see what it looks like in your terminal. Note that the last one is a failsafe for our friends running Git Bash in Windows.<\/p>\n
Help commands for bash declare<\/p>\n
Now that you have read the primer, man page for declare in bash, it is time to get our hands dirty with some examples of bash declare in the wild. Note that as you scroll down deep into the jungle of bash declare examples, your pay grade and level of understanding of declare will improve.<\/p>\n
First let\u2019s start out by seeing if anyone declared a variable called bar. If no one has yet, dibs!<\/p>\n
If you see the error bash: declare: bar: not found, then no one has yet. Let\u2019s just echo $? to be sure.<\/p>\n
1, okay good. Otherwise, you should see something like declare — bar=””. If you haven\u2019t yet, go ahead and declare bar as something, bar= or declare bar= should do the trick. Note that the latter of the two is the longhand for variables in bash. If you are wondering what the — in declare output is, that is where variable attributes go, and there are none.<\/p>\n
Now that assigning variables using declare is out of the picture, let\u2019s start giving them attributes.<\/p>\n
If you are running bash v4.3-alpha or later, this section on the -n option. If you are not sure, check using the bash –version command. Otherwise, don\u2019t try this at home.<\/p>\n
Look at that. We just asigned a variable to another by name. Look what happens here.<\/p>\n
bar=x
\ndeclare -n foo=bar
\necho $ $ # x x
\nfoo=y
\necho $ $ # y y
\ntrue<\/p>\n
Now look what happens when when we don\u2019t use declare with the -n option.<\/p>\n
bar=x
\ndeclare foo=bar
\necho $ $ # x x
\nfoo=y
\necho $ $ # y x
\ntrue<\/p>\n
Now suppose that we tried to do something odd like this:<\/p>\n
echo{,} $ > echo-bar.sh
\nbash echo-bar.sh<\/p>\n
As you may suspect, nothing happened in standard output. Don\u2019t worry about the voodoo in the first line. Programmers are lazy. The declare command can make names export!<\/p>\n
declare -x bar # export bar<\/p>\n
Now give it a try.<\/p>\n
Note that using the \u2013x option for declare can also be done through the export command as follows. Be sure to open up a new shell or remove the attribute using the +x option before trying out the following example.<\/p>\n
bar=x
\necho{,} $ > echo-bar.sh
\nbash echo-bar.sh #
\nexport bar
\nbash echo-bar.sh # x<\/p>\n
In bash, variables may have the integer attribute and the only way to accomplish this is through declare command.<\/p>\n
Suppose that we are dealing with integers and want to make our variables behavior more responsible. We could give such variables the integer attribute using the \u2013i option for declare.<\/p>\n
declare \u2013i bar # don\u2019t know what\u2019s in bar anymore but now it\u2019s an integer
\necho $ # x (maybe)
\nbar=x
\necho $ # 0
\nbar=1
\necho $ # 1
\nbar=3.14 # ouch
\ntrue<\/p>\n
Note that now when we try to assign a new value to our variable 3 things happen: 1) The value is interpreted as 0; 2) The value is interpreted as an integer; 3) Error.<\/p>\n
In addition to modifying the value assignment behavior, variables now behavior differently in arithmetic expressions as follows.<\/p>\n
declare -i bar=1
\ndeclare car=1
\necho $ # 1
\necho $ # 1
\nbar=bar+1
\ncar=car+1
\necho $ # 2
\necho $ # car+1
\ntrue<\/p>\n
Note that you can still get away with using a variable to store an integer and carry out arithmetic without setting the integer attribute for a variable but it is there just in case.<\/p>\n
In bash, variables may have case attributes applied on assignment. Declare allows conversion to cases lower or upper if \u2013l or \u2013u options are set, respectfully.<\/p>\n
declare -u uppers=
\ndeclare -l lowers=
\nuppers=uppercase
\nlowers=LOWERCASE
\necho $ # UPPERCASE
\necho $ # lowercase
\necho $ # uppercase
\necho $ # LOWERCASE
\ntrue<\/p>\n
These attributes may come in handy if you require single case without having to do the conversion yourself.<\/p>\n
In bash, variable may be readonly. To accomplish this there is the -r option for declare.<\/p>\n
declare \u2013r lowers # try to make lowers final
\nlowers=”Yet another lowers”
\necho $ # yet another lowers
\ndeclare -rl final_lowers=”Yet another lowers”
\necho $ # yet another lowers
\nfinal_lowers=”Yet again another lowers” # assignment block
\ntrue<\/p>\n
This attribute could come in handy if you know that a variable has no business being changed after assignment. Note that the +r option does not work; that is stripping a variable of its readonly attribute is not allowed in bash.<\/p>\n
In bash, variables may be arrays. To make a variable an associative or indexed array, the \u2013A and \u2013a options for declare are used, respectfully.<\/p>\n
declare -a indexed_array
\ndeclare -A associative_array
\nindexed_array[0]=1
\nassociative_array[0]=1
\nindexed_array[one]=2 # ?
\nassociative_array[one]=2
\necho $ # 2
\necho $ # 1
\necho $ # 2
\necho $ # 2
\ndeclare -p indexed_array
\ndeclare -p associative_array
\necho $ # ouch
\ntrue<\/p>\n
In most programming languages having the ability to use arrays is a powerful construct. Bash is no exception. It allows this through array attributes which could come in handy if requiring hash lookup or in implementing object-like behavior. Note that the index of indexed arrays behaviors like a variable with the integer attribute, thus is expected to break in the same manner, hence the last line before true.<\/p>\n
In bash, variable may have the trace attribute applied via the -t option in declare. Trace variables unlike variables with other attributes applied depend heavily on the environment of the calling shell.<\/p>\n
I have found mixed results using the trace attribute which have led to a review on traps and applications of trapping the DEBUG and RETURN signal. For those that tinker, finding a use for declaring a variable with the -t option is extra credit.<\/p>\n
In bash, one of the most useful uses for the declare command is being able to display functions. The -f and -F options for declare display definition and just function names if available, respectfully.<\/p>\n
Suppose that you want to have a fallback in case a function is not defined in your shell. We can use declare to accomplish this task as follows. For simplicity sakes, let\u2019s use a function called foo.<\/p>\n
# if foo is not declared<\/p>\n
# declare it# else use available footest ! “$( declare -F foo )\u201d || {
\nfoo() { true ; }
\n}<\/p>\n
For those that tinker, there is an alias using called commands<\/a> that I cooked up a while back that uses declare to check if functions are available.<\/p>\n Although most programmers can get away with not having to use it at all, like most builtins, the declare command in bash is an essential command to really know your way around the bash shell.<\/p>\nConclusion<\/h4>\n