I'm trying to write a function that reassigns an array to
another local array but the method used in reassigning
the array reformats the contents of the array which is
what I am trying to prevent.
The method used to load a file into an array works as
expected and the entire array is returned to the main
body of the script i.e. preserves all white spaces and
each line is stored in its respective array index.
Load the contents of a file into an array.
use: array_load _array_file_ $filename
local -a _ARRAY_
*
_ARRAY_[I++]=" \"$LINE\""
*
eval "$1=( ${_ARRAY_[@]} )"
However, when I try to reassign the array to another
local array within a function, the destination array is
reformatted. Each item within an array looses its
white spaces and gains it's own array index.
Assign array 2 to array 1
use: array_assign ARR1 ARR2
function array_assign
{
local -a _ARRAY_
_ARRAY_=( $(eval "echo \${$2[@]}") )
eval "$1=( ${_ARRAY_[@]} )"
}
Correct array structure:
item1 item2 item3 item4
Array structure after passing to function and executing
'eval echo' on array when assigning to local variable:
item1
item2
item3
item4
As recommended, I did search the web and tried the
majority of the methods found, but I still ended with an
array that is transposed.
The objective is to have reusable code so the function
can't rely on global variables and only rely on the
variables passed to the function.
Solutions or a suggestion would be greatly appreciated.
Unfortunately, the outcome seems to be the same
transposed array that I was trying to avoid.
I would have thought it would have worked as it's
the same method used to return an array from the
'load' function which works as expected. However,
the array being returned from the 'load' function isn't
a passed variable and is not reassigned.
The problem seems to specifically originate from the
assignment of an array to array regardless of
method used to assign them, as it would seem.
An article did describe the reassignment of arrays
and that it does automatically strips white space from
an array which I find is a bad policy enforcing limitations
on the coder.
The alternatives that I've also tried are:
function pointers,
referenced variables i.e. ${!ARRAY},
changing the IFS variable to '' ,
and the alternatives that I'm considering:
regex to reconstruct the lines of the array
by using an end of line character,
and global variables (last resort).
The passing of an array to a function is the foundation
of my library, any solution would ideally fit to as fewer
lines as possible as it's repeated throughout every function,
unless I can reuse the 'array_assign' function within another
function with it executing correctly.
Any further suggestions would again be appreciated.
The corrected code works flawlessly. Additionally,
I can use it within other functions to assign arrays.
Your help and solution has exceeding my expectations.
For the benefit of other users the whole code follows:
#!/bin/bash
function array_assign
{
eval "$1=( \"\${$2[@]}\" )"
}
function array_count
{
eval "$1=( \${#$2[@]} )"
}
function array_load
{
local _FILE_; _FILE_=( $(eval "echo \$2") )
local -a _THIS_
while read _LINE_; do
case $_LINE_ in
'#'*) continue;; # lines to exclude
'*'*) continue;;
'/'*) continue;;
"") continue;;
*) _THIS_[_I_++]=" \"$_LINE_\"";;
esac
done < $_FILE_
eval "$1=( ${_THIS_[@]} )"
}
#usage:
declare filename=/path/to/file/array.data
declare -a _array1_ _array2_
declare -i _count_
array_load _array1_ $filename
array_assign _array2_ _array1_
array_count _count_ _array2_