info

https://opensource.com/article/18/3/creating-bash-completion-script

COMPREPLY

an array variable used to store the completions. The completion mechanism uses this variable to display its contents as completions

COMPREPLY=( $(compgen -W "now tomorrow never" -- ${COMP_WORDS[COMP_CWORD]}) ) # propose given words at each let choose the first completion from given words and repeat it after (replace)
COMPREPLY=( $(compgen -W "now tomorrow never" "${COMP_WORDS[1]}") ) # let choose the first completion from given words and repeat it after (replace)

complete

complete command to register this list for completion

complete -A directory $cmd # provide completion for directory
complete -d $cmd # provide completion for directory
complete -D $cmd # provide completion for directory
complete -f $cmd # provide completion for file
complete -W "$words" $cmd # Wordlist, provide the list of words for completion to command $cmd
complete -F _foo $cmd # use function _foo_comp to register completions for command $cmd

compopt

https://helpmanual.io/man1/bash/

variables

COMP_WORDS # an array of all the words typed after the name of the program the compspec belongs to
COMP_CWORD # an index of the COMP_WORDS array pointing to the word the current cursor is at—in other words
COMP_LINE # the current command line

tricks

exec bash # reload completions

examples

qemu-img

#!/usr/bin/env bash

_qemuimg_comp()
{
    COMPREPLY=()
    local cur=${COMP_WORDS[COMP_CWORD]}
    local prev="${COMP_WORDS[COMP_CWORD-1]}"
    local opts='amend bench bitmap check commit compare convert create dd info map measure snapshot rebase resize'
    local formats='blkdebug blklogwrites blkverify bochs cloop compress copy-before-write copy-on-read dmg file ftp ftps gluster host_cdrom host_device http https iscsi iser luks nbd nfs null-aio null
-co nvme parallels preallocate qcow qcow2 qed quorum raw rbd replication snapshot-access ssh throttle vdi vhdx vmdk vpc vvfat'

    #echo "COMP_LINE=$COMP_LINE" >> /tmp/qemu
    #echo "COMP_WORDS=$COMP_WORDS[@] | COMP_CWORD=$COMP_CWORD" >> /tmp/qemu
    #echo "cur=$cur | prev=$prev" >> /tmp/qemu
    if [ ${COMP_CWORD} -eq 1 ]; then
        COMPREPLY=( $(compgen -W "${opts}" -- "${cur}" ) )
        return 0
    elif [[ $prev =~ -[oOf] ]]; then
        COMPREPLY=( $(compgen -W "${formats}" -- "${cur}" ) )
    else
        COMPREPLY=( $(compgen -f -- "${cur}") )
        if [ -d "${COMPREPLY}" ]; then
            compopt -o nospace
            COMPREPLY=${COMPREPLY}/
        fi
    fi
} && 
complete -F _qemuimg_comp qemu-img

haconf

#!/usr/bin/env bash
#
# Bash completion function for the 'haconf' command.

_haconf()
{
    local cur prev path_enabled path_available opts

    path_enabled="/etc/haproxy/conf-enabled"
    path_available="/etc/haproxy/conf-available"

    __disabled() {
        local confs conf notused
        confs="$(ls "${path_available}")"
        for conf in ${confs}; do
            ! [ -h "${path_enabled}/${conf}" ] && notused="${notused} ${conf}"
        done
        echo ${notused}
    }

    __enabled() {
        ls ${path_enabled}
    }

    COMPREPLY=()
    cur=${COMP_WORDS[COMP_CWORD]}
    prev=${COMP_WORDS[COMP_CWORD-1]}

    # primary commans
    opts='check clear enable disable list reload'

    # level 1 for commands
    if [ $COMP_CWORD -eq 1 ]; then
        COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
        return 0
    # level 2 for arguments
    else
        case $prev in
            enable)
                COMPREPLY=( $(compgen -W "$(__disabled)" -- "$cur" ) )
                return 0
                ;;
            disable)
                COMPREPLY=( $(compgen -W "$(__enabled)" -- "$cur" ) )
                return 0
                ;;
        esac
    fi

}
complete -F _haconf haconf

MAN

synopsis

sed [OPTION]... {script-only-if-no-other-script} [input-file]...

sed [-options] [commande] [] sed [-n [-e commande] [-f script] [-i[.extension]] [l [cesure]] rsu] [] []

[adresse[,adresse]][!]commande[arguments]

[adresse[,adresse]]{
 commande1
 commande2;commande3
}

options

-n, --quiet, --silent # suppress automatic printing of pattern space
-e script, --expression=script # add the script to the commands to be executed
-f script-file, --file=script-file # add the contents of script-file to the commands to be executed
--follow-symlinks # follow symlinks when processing in place
-i[SUFFIX], --in-place[=SUFFIX] # edit files in place (makes backup if SUFFIX supplied)
-l N, --line-length=N # specify the desired line-wrap length for the `l' command
--posix # disable all GNU extensions
-E, -r, --regexp-extended # use extended regular expressions in the script (for portability use POSIX -E)
-s, --separate # consider files as separate rather than as a single, continuous long stream
--sandbox # operate in sandbox mode
-u, --unbuffered # load minimal amounts of data from the input files and flush the output buffers more often
-z, --null-data # separate lines by NUL characters
--help # display this help and exit
--version # output version information and exit

Zero-address ``commands''

: label # Label for b and t commands
'#'comment # The comment extends until the next newline (or the end of a -e script fragment)
} # The closing bracket of a { } block

Zero- or One- address commands

= # Print the current line number
a \text # Append text, which has each embedded newline preceded by a backslash
i \text # Insert text, which has each embedded newline preceded by a backslash
c \text # Replace text, which has each embedded newline preceded by a backslash
q [exit-code] # Immediately quit the sed script without processing any more input, except that if auto-print is not disabled the current pattern space will be printed
Q [exit-code] # Immediately quit the sed script without processing any more input
r filename # Append text read from filename
R filename # Append a line read from filename. Each invocation of the command reads a line from the file. This is a GNU extension

Commands which accept address ranges

{ # Begin a block of commands (end with a })
b label # Branch to label; if label is omitted, branch to end of script
c \text # Replace the selected lines with text, which has each embedded newline preceded by a backslash
d # Delete pattern space. Start next cycle
D # If pattern space contains no newline, start a normal new cycle as if the d command was issued. Otherwise, delete text in the pattern space up to the first newline, and restart cycle with the resultant pattern space, without reading a new line of input
h H # Copy/append pattern space to hold space
g G # Copy/append hold space to pattern space
l # List out the current line in a ``visually unambiguous'' form
l width # List out the current line in a ``visually unambiguous'' form, breaking it at width characters. This is a GNU extension
n N # Read/append the next line of input into the pattern space
p # Print the current pattern space
P # Print up to the first embedded newline of the current pattern space
s/regexp/replacement/ # Attempt to match regexp against the pattern space. If successful, replace that portion matched with replacement. The replacement may contain the special character & to refer to that portion of the pattern space which matched, and the special escapes \1 through \9 to refer to the corresponding matching sub-expressions in the regexp
t label # If a s/// has done a successful substitution since the last input line was read and since the last t or T command, then branch to label; if label is omitted, branch to end of script
T label # If no s/// has done a successful substitution since the last input line was read and since the last t or T command, then branch to label; if label is omitted, branch to end of script. This is a GNU extension
w filename # Write the current pattern space to filename
W filename # Write the first line of the current pattern space to filename. This is a GNU extension
x # Exchange the contents of the hold and pattern spaces
y/source/dest/ # Transliterate the characters in the pattern space which appear in source to the corresponding character in dest

Addresses

Sed commands can be given with no addresses, in which case the command will be executed for all input lines; with one address, in which case the command will only be executed for input lines which match that address; or with two addresses, in which case the command will be executed for all input lines which match the inclusive range of lines starting from the first address and continuing to the second address. Three things to note about address ranges: the syntax is addr1,addr2 (i.e., the addresses are separated by a comma); the line which addr1 matched will always be accepted, even if addr2 selects an earlier line; and if addr2 is a regexp, it will not be tested against the line that addr1 matched

After the address (or address-range), and before the command, a ! may be inserted, which specifies that the command shall only be executed if the address (or address-range) does not match

The following address types are supported:

number # Match only the specified line number (which increments cumulatively across files, unless the -s option is specified on the command line)
first~step # Match every step'th line starting with line first. For example, ``sed -n 1~2p'' will print all the odd-numbered lines in the input stream, and the address 2~5 will match every fifth line, starting with the second. first can be zero; in this case, sed operates as if it were equal to step. (This is an extension.)
$ # Match the last line
/regexp/ # Match lines matching the regular expression regexp
\cregexpc # Match lines matching the regular expression regexp. The c may be any character

GNU sed also supports some special 2-address forms:

0,addr2 # Start out in "matched first address" state, until addr2 is found. This is similar to 1,addr2, except that if addr2 matches the very first line of input the 0,addr2 form will be at the end of its range, whereas the 1,addr2 form will still be at the beginning of its range. This works only when addr2 is a regular expression
addr1,+N # Will match addr1 and the N lines following addr1
addr1,~N # Will match addr1 and the lines following addr1 until the next line whose input line number is a multiple of N

COMMAND EDITING

ctrl+ a # go to the start of the command line
ctrl+ e # go to the end of the command line
ctrl+ k # delete from cursor to the end of the command line
ctrl+ u # delete from cursor to the start of the command line
ctrl+ w # delete from cursor to start of word (i.e. delete backwards one word)
ctrl+ y # paste word or text that was cut using one of the deletion shortcuts (such as the one above) after the cursor
ctrl+ xx # move between start of command line and current cursor position (and back again)
alt+ b # move backward one word (or go to start of word the cursor is currently on)
alt+ f # move forward one word (or go to end of word the cursor is currently on)
alt+ d # delete to end of word starting at cursor (whole word if cursor is at the beginning of word)
alt+ c # capitalize to end of word starting at cursor (whole word if cursor is at the beginning of word)
alt+ u # make uppercase from cursor to end of word
alt+ l # make lowercase from cursor to end of word
alt+ t # swap current word with previous
ctrl+ f # move forward one character
ctrl+ b # move backward one character
ctrl+ d # delete character under the cursor
ctrl+ h # delete character before the cursor
ctrl+ t # swap character under cursor with the previous one

COMMAND RECALL

ctrl+ r # search the history backwards
ctrl+ g # escape from history searching mode
ctrl+ p # previous command in history (i.e. walk back through the command history)
ctrl+ n # next command in history (i.e. walk forward through the command history)
alt+ . # use the last word of the previous command

COMMAND CONTROL

ctrl+ l # clear the screen
ctrl+ s # stops the output to the screen (for long running verbose command)
ctrl+ q # allow output to the screen (if previously stopped using command above)
ctrl+ c # terminate the command
ctrl+ z # suspend/stop the command

BASH BANG COMMAND !

!! # run last command
!blah # run the most recent command that starts with ‘blah’ (e.g. !ls)
!blah:p # print out the command that !blah would run (also adds it as the latest command in the command history)
!$ # the last word of the previous command (same as alt+ .)
!$:p # print out the word that !$ would substitute
!* # the previous command except for the last word (e.g. if you type ‘_find somefile.txt /’, then !* would give you ‘_find somefile.txt’)
!*:p # print out what !* would substitute

SYNTAX

comment

the line number is independent of sub selection, all the set of line is parsed and the counter of lines is for the global set

'/^while .*= "quit"/,/^done/ {/^\s*#/! {1, 70 s/^\(\s*\)/#\1/}}' /devs/install/alpine.install
<==>
'1,70 {/^while .*= "quit"/,/^done/ {/^\s*#/! s/^\(\s*\)/#\1/}}' /devs/install/alpine.install

use ';' or -e / different syntax for the same result

'1,70 {/^\s*#/! s/^\(\s*\)/#\1/}; s/^\(\s*\)/#\1/' /devs/install/alpine.install
<=>
-e '1,70 {/^\s*#/! s/^\(\s*\)/#\1/}' -e 's/^\(\s*\)/#\1/' /devs/install/alpine.install

BASIC EXAMPLES

# insert/add

"1i $line" # insert text at the beginning of file
"8i $line" # insert mytext in 8th line of file

"/$reg/ a \$line" # append line after the indicator
"/$reg/ i \$line" # insert line before the indicator
"/$reg/ c \$line" # replace line of the indicator

"s|^|$text|" # append text at the end of line
"s|$|$text|" # prepend text at the beginning of line

# sustitute

"/$begin/,/$end/ {s/\($str\).*/\1$str/}" # modify between two indicators
"/$begin/,$ {s/\($str\).*/\1$str/}" # modify between indicator to the end
"/$begin/,10 {s/\($str\).*/\1$str/}" # modify between indicator and the 10th line
"/$begin/,+2 {s/\($str\).*/\1$str/}" # modify between indicator and two lines after indicator

"s/$sch/$str/3" # replace only the 3rd 'sch' found string by str for each line

"s/$sch/\l$str/" # replace found string 'sch' by 'str' with the first character in lower case
"s/$sch/\L$str/" # replace found string 'sch' by 'str' with all characters in lower case

# modify

-e 's/\(.*\)/\L\1/' # to lowercase

# print/extract

-n "s/$select/ s|^export \(.*\)$|\1|p" # extract text from line

-n '2p;5p' # print 2rd & 5th lines
-n '3,$p' # print line from 3th to end
-n '/while/,+10p' # print lines from line matched while to 10 lines after. **REPEATED FOR EACH MATCHED LINE**

-s -n '4,10 p' /*/$file # print range of lines for each files

# delete

'7,9d' # delete lines between interval
'/pattern_start/,/pattern_start/d' # delete lines between two patterns

# backup

-i.bak '4i $line' $file # insert line at 4th lines & backup old file to $file.bak'

COMPLEX EXAMPLES

percent-code

decode percent-code

echo $text_encoded | sed 's@+@ @g;s@%@\\x@g' | xargs -0 printf "%b"

print TODO lines

print lines are in between patterns '<<TODO' & 'TODO' in /home/shared/dev

while read line; do
    echo -e "\n$line"
    sed -n '/^<<TODO/,/^TODO/ {p}' "$line"
done < <(grep '<<TODO' /home/shared/dev -rl)

select then modify

prepend '#' where not begin with # (with possible start with \s)

'/^\s*#/! s/^\(\s*\)/\1#/'

subtreatment with lines counter

prepend '#' where line not begin with # (possibly beginning with \s) for the lines are between line matched patterns '^while .*= "quit"' and '^done'

'/^while .*= "quit"/,/^done/ {/^\s*#/! {1, 70 s/^\(\s*\)/#\1/}}' /devs/install/alpine.install

selected lines between matched line and x next lines

prepend '#' for lines between matching $str and 10 lines after, and for wich are not begin with '#'

'/$str/,+10 {/^#/! s/\(.*\)/#\1/}'

inverse selected lines

prepend '#' for lines between matching $str and last line, and for wich are not begin with '#'

'/$str/,$ {/^#/! s/\(.*\)/#\1/}'

treats each file separately

treats each file separately, in difference of |xargs sed

ls $path | xargs -L 1 sed "\$a $str"
ls $path | xargs sed -s "\$a $str"
sed -s "$action" /*/*.conf

grep selected

replace string in file only in selected line by grep

while read line; do
    file="${line%%:*}"
    line="$(echo "$line"|awk -F : '{ print $2 }')"
    echo sed -i "$line s|\(\[ .*\) == \(.* \]\)|\1 = \2|g" "$file"
done <<< "$(grep -rn "\[ .* == .* \]" /home/shared/dev/install/)"

ENV

env # list environment variables
env [options] name=value [cmd [arg]] # Set name to value in the temporary environment & run COMMAND

printenv # list environment variables
printenv $var # return value of environment variables  $var if exists

( set -o posix ; set ) # list declared + environment variables
compgen -v # list available variable for completion
compgen -v $pat # list available variable for completion matched for a simple pattern $pat

DECLARE

declare [options]

If no NAMEs are given, Display the attributes and values of all variables

declare [-aAfFgilnrtux] [-p]
  -f # restrict action or display to function names and definitions
  -F # restrict display to function names only (plus line number and source file when debugging)
  -g # create global variables when used in a shell function; otherwise ignored
  -p # display the attributes and value of each NAME

declare [options] [name]

Declare variables and give them attributes

declare [-aAfFgilnrtux] [-p] [name[=value] ...]
  -a # to make NAMEs indexed arrays (if supported)
  -A # to make NAMEs associative arrays (if supported)
  -i # to make NAMEs have the `integer' attribute
  -l # to convert NAMEs to lower case on assignment
  -n # make NAME a reference to the variable named by its value
  -r # to make NAMEs readonly
  -t # to make NAMEs have the `trace' attribute
  -u # to convert NAMEs to upper case on assignment
  -x # to make NAMEs export

SCOPE

scope is general

terminal <-> function
terminal <-> sourced file
terminal <-> script / for exported variables : 'export'

script <-> function
script <-> sourced file
script <-> script / for exported variables : 'export'

scope is local

terminal <-> script
terminal <-> function / for localized variables : 'local'
terminal <-> sourced file / for localized variables : 'local'

script <-> script
script <-> function / for localized variables : 'local'
script <-> sourced file / for localized variables : 'local'

EXPANSION

value

${parameter:-[word]} # use default values if parameter is unset or null
${parameter:=[word]} # assign default values if parameter is unset or null
${parameter:?[word]} # indicate error if null or unset if parameter is unset or null
${parameter:+[word]} # use alternative value if parameter is not null

case

${var^} # First char in Uppercase
${var^^} # All chars in  UPPERCASE
${var,} # First char in lOWERCASE
${var,,} # All chars in  lowercase

remove

${parameter%[word]} # remove smallest suffix pattern. the word shall be expanded to produce a pattern
${parameter%%[word]} # remove largest suffix pattern. the word shall be expanded to produce a pattern
${parameter#[word]} # remove smallest prefix pattern. the word shall be expanded to produce a pattern
${parameter##[word]} # remove largest prefix pattern. the word shall be expanded to produce a pattern

position

${#string} # the length in characters of the value of parameter shall be substituted. the result is unspecified for parameter '*' or '@'
${string:position} # extract string from position
${string:position:length} # extract string from position to lenght
${string#substring} # strip shortest match of $substring from front of $string
${string##substring} # strip longest match of $substring from front of $string
${string%substring} # strip shortest match of $substring from back of $string
${string%%substring} # strip longest match of $substring from back of $string

replace

${string/substring/replacement} # replace first match of $substring with $replacement
${string//substring/replacement} # replace all matches of $substring with $replacement
${string/#substring/replacement} # if $substring matches front end of $string, substitute $replacement for $substring
${string/%substring/replacement} # if $substring matches back end of $string, substitute $replacement for $substring

reference

${!var} # display the value referenced by var (name of variable)
${!varprefix*} / ${!varprefix@} # matches all previously declared variables beginning with varprefix

${string:${#string}<3?0:-3} # take the last 3 characters if string length > 3

str=$(</dev/stdin)
# keep EOF
echo "$str"
# replace EOF
echo $str

SEQUENCE

{0..10..2} / seq 0 2 10 # 0 2 4 6 8 10
{2..-3..1} # 2 1 0 -1 -2 -3
{U..b} # U V W X Y Z [  ] ^ _ ` a b
{b..U} # b a ` _ ^ ]  [ Z Y X W V U

SYSTEM VARIABLES

$PWD # Actual working directory
$PATH # Path to binaries /usr/bin ...
$USER # User name
$EUID # "effective" user ID number
$UID # User ID number
$GROUPS # Groups current user belongs to
$HOME # Home directory of the user
$HOSTNAME # The hostname assigned at bootup in an init script
$HOSTTYPE # host type
$IFS # internal field separator

$BASH # The path to the Bash binary itself
$BASH_ENV # An environmental variable pointing to a Bash startup file
$BASH_SUBSHELL # A variable indicating the subshell level
$BASHPID # Process ID of the current instance of Bash, not same as $$
$BASH_VERSION # The version of Bash installed on the system
$BASH_VERSINFO[n] # A 6-element array containing version information
  [0] # Major version no
  [1] # Minor version no
  [2] # Patch level
  [3] # Build version
  [4] # Release status
  [5] # Architecture

$'' # permit embedded \n in variables
$CDPATH # A colon-separated list of search paths available to the cd command
$DIRSTACK # The top value in the directory stack
$EDITOR # The default editor invoked by a script, usually vi or emacs.
$GLOBIGNORE # A list of filename patterns to be excluded from matching in globbing
$IGNOREEOF # number of EOF(control-D) the shell will ignore before logging out
$LC_COLLATE # collation order in filename expansion and pattern matching
$LC_CTYPE # controls character interpretation in globbing and pattern matching
$MACHTYPE # machine type
$OLDPWD # Old working directory ("OLD-Print-Working-Directory")
$OSTYPE # operating system type
$REPLY # The default value when a variable is not supplied to read
$SHELLOPTS # The list of enabled shell options
$SHLVL # Shell level, how deeply Bash is nested
$TMOUT # the shell prompt will time out after $time seconds

$PIPESTATUS # Array variable holding exit status(es) of last executed foreground pipe
  [0] # holds the exit status of the first command in the pipe
  [1] # the exit status of the second command, and so on.

$PROMPT_COMMAND # holding a command to be executed just before the primary prompt
$PS1 # This is the main prompt, seen at the command-line
$PS2 # The 2nd prompt, when additional input is expected. It displays as ">"
$PS3 # The 3rd prompt, displayed in a select loop
$PS4 # as "+", The 4ry prompt, shown at the beginning of each line of output when invoking a script with the -x [verbose trace] option. It displays 

FUNCTION VARIABLES

$PPID # $PPID of a process is the process ID (pid) of its parent process
$FUNCNAME # Name of the current function
$BASH_SOURCE[0] # BASH_SOURCE array with hirerachical calls : level => filename
$LINENO # Line number of the shell script in which this variable appears
$SECONDS # The number of seconds the script has been running

$0 # name of script itself (called)
$1, $2, ... # Positional parameters
${*:2}  / ${@:2} # return second & following positional parameters
${*:2:3} # return three positional parameters, starting at second
$# # Number of command-line arguments or positional parameters
$* # All of the positional parameters, must be quoted "$*"
$@ # Same as $*, but each parameter is a quoted string
$- # Flags passed to script (using set)
$! # PID (process ID) of last job run in background
$_ # Special variable set to final argument of previous command executed
$? # Exit status of a command, function, or the script itself
$$ # Process ID (PID) of the script itself. The $$ variable often finds use in scripts to construct "unique" temp file names

declaration

# declares and initializes an empty indexed array
myarray=()
# sets the first element of an indexed array. If no array created it
myarray[0]=
# declares an indexed array. if existing not initialized it
declare -a myarray
# declares an associative array
declare -A myarray

value setting

# sets the element N of the indexed array
myarray[N]=VALUE
# sets the element indexed by strING of the associative array
myarray[strING]=VALUE
# set the zeroth element of indexed array, for associative array index with string "0"
myarray=VALUE
# sets array with given ek*lements, starting at zero. existing array is unset before
myarray=(E1 E2 …)
# sets index-value pairs for indexed or associative array
myarray=([X]=E1 [Y]=E2 …)

# append to array
myarray+=(E1 E2 …)
# concat two arrays
myarray3=( ${myarray1[@]} ${myarray2[@]} )
# concat & add elementstwo arrays
myarray3=( ${myarray1[@]:0:2} "str" "str2" )

value getting

# return value of array at index. if N<0 is an offset from the greatest index
${myarray[N]}
# return list of indexes in array
${!myarray[@]}
# return list of values in array, preserves breaks between elements
${myarray[@]}
# when you want join all array elements to a string
${myarray[*]}
# return M elements starting from N, preserves breaks between elements
${myarray[@]:N:M}
${myarray[*]:N:M}
# return M elements from position N from last (-N+M)
${myarray[*]: -N:M}
# return stringlength of value at index N (or key)
${#myarray[N]}
# return count of indexes in array, preserves breaks between elements
${#myarray[@]}
${#myarray[*]}
# return list of indexes in array, preserves breaks between elements
${!myarray[@]}
${!myarray[*]}
# test in key N exists in associative array, return _ if key exists or nothing
${myarray[N]+_}

substring removing

# removes shortest match from front of string(s)
${myarray[@]#*sch}
# longest match from front of string(s)
${myarray[@]##*sch}
# shortest match from back of string(s)
${myarray[@]%sch*}
# Longest match from back of string(s)
${myarray[@]%%sch*}

subtring replacement

# replace first occurrence of substring with replacement.
${myarray[@]/sch/str}
# replace all occurrences of substring.
${myarray[@]//sch/str}
# delete all occurrences of substring.
${myarray[@]//str/}
# replace front-end occurrences of substring.
${myarray[@]/#sch/str}
# replace back-end occurrences of substring.
${myarray[@]/%sch/str}

unset

unset -v myarray
# destroys entirely array
unset -v myarray[@]
unset -v myarray[*]
# destroys array element at index N (or key)
unset -v myarray[N]

create

# create array from file or readarray
mapfile -t myarray  FILE
# print table with 2 colums
printf "%s\n" "${!myarray[@]}" "${myarray[@]}" | pr -2t
# copy an array
myarray2=("${myarray1[@]}")