You could build up a new array without the undesired element, then assign it back to the old array. This works in bash:

array=(pluto pippo)
new_array=()
for value in "$array[@]"
do
 [[ $value != pluto ]] && new_array+=($value)
done
array=("$new_array[@]")
unset new_array

This yields:

echo "$array[@]"
pippo

This is the most direct way to unset a value if you know it's position.

$ array=(one two three)
$ echo $#array[@]
3
$ unset 'array[1]'
$ echo $array[@]
one three
$ echo $#array[@]
2

Here's a one-line solution with mapfile:

$ mapfile -d $'' -t arr < <(printf '%s' "$arr[@]" | grep -Pzv "<regexp>")

Example:

$ arr=("Adam" "Bob" "Claire"$'n'"Smith" "David" "Eve" "Fred")

$ echo "Size: $#arr[*] Contents: $arr[*]"

Size: 6 Contents: Adam Bob Claire
Smith David Eve Fred

$ mapfile -d $'' -t arr < <(printf '%s' "$arr[@]" | grep -Pzv "^ClairenSmith$")

$ echo "Size: $#arr[*] Contents: $arr[*]"

Size: 5 Contents: Adam Bob David Eve Fred

This method allows for great flexibility by modifying/exchanging the grep command and doesn't leave any empty strings in the array.

To expand on the above answers, the following can be used to remove multiple elements from an array, without partial matching:

ARRAY=(one two onetwo three four threefour "one six")
TO_REMOVE=(one four)

TEMP_ARRAY=()
for pkg in "$ARRAY[@]"; do
 for remove in "$TO_REMOVE[@]"; do
 KEEP=true
 if [[ $pkg == $remove ]]; then
 KEEP=false
 break
 fi
 done
 if $KEEP; then
 TEMP_ARRAY+=($pkg)
 fi
done
ARRAY=("$TEMP_ARRAY[@]")
unset TEMP_ARRAY

This will result in an array containing:
(two onetwo three threefour "one six")

Here's a (probably very bash-specific) little function involving bash variable indirection and unset; it's a general solution that does not involve text substitution or discarding empty elements and has no problems with quoting/whitespace etc.

delete_ary_elmt() 
 local word=$1 # the element to search for & delete
 local aryref="$2[@]" # a necessary step since '$!$2[@]' is a syntax error
 local arycopy=("$!aryref") # create a copy of the input array
 local status=1
 for (( i = $#arycopy[@] - 1; i >= 0; i-- )); do # iterate over indices backwards
 elmt=$arycopy[$i]
 [[ $elmt == $word ]] && unset "$2[$i]" && status=0 # unset matching elmts in orig. ary
 done
 return $status # return 0 if something was deleted; 1 if not


array=(a 0 0 b 0 0 0 c 0 d e 0 0 0)
delete_ary_elmt 0 array
for e in "$array[@]"; do
 echo "$e"
done

# prints "a" "b" "c" "d" in lines

Use it like delete_ary_elmt ELEMENT ARRAYNAME without any $ sigil. Switch the == $word for == $word* for prefix matches; use $elmt,, == $word,, for case-insensitive matches; etc., whatever bash [[ supports.

It works by determining the indices of the input array and iterating over them backwards (so deleting elements doesn't screw up iteration order). To get the indices you need to access the input array by name, which can be done via bash variable indirection x=1; varname=x; echo $!varname # prints "1".

You can't access arrays by name like aryname=a; echo "$$aryname[@], this gives you an error. You can't do aryname=a; echo "$!aryname[@]", this gives you the indices of the variable aryname (although it is not an array). What DOES work is aryref="a[@]"; echo "$!aryref", which will print the elements of the array a, preserving shell-word quoting and whitespace exactly like echo "$a[@]". But this only works for printing the elements of an array, not for printing its length or indices (aryref="!a[@]" or aryref="#a[@]" or "$!!aryref" or "$#!aryref", they all fail).

So I copy the original array by its name via bash indirection and get the indices from the copy. To iterate over the indices in reverse I use a C-style for loop. I could also do it by accessing the indices via $!arycopy[@] and reversing them with tac, which is a cat that turns around the input line order.

A function solution without variable indirection would probably have to involve eval, which may or may not be safe to use in that situation (I can't tell).

Using unset

To remove an element at particular index, we can use unset and then do copy to another array. Only just unset is not required in this case. Because unset does not remove the element it just sets null string to the particular index in array.

declare -a arr=('aa' 'bb' 'cc' 'dd' 'ee')
unset 'arr[1]'
declare -a arr2=()
i=0
for element in "$arr[@]"
do
 arr2[$i]=$element
 ((++i))
done
echo "$arr[@]"
echo "1st val is $arr[1], 2nd val is $arr[2]"
echo "$arr2[@]"
echo "1st val is $arr2[1], 2nd val is $arr2[2]"

Output is

aa cc dd ee
1st val is , 2nd val is cc
aa cc dd ee
1st val is cc, 2nd val is dd

Using :<idx>

We can remove some set of elements using :<idx> also. For example if we want to remove 1st element we can use :1 as mentioned below.

declare -a arr=('aa' 'bb' 'cc' 'dd' 'ee')
arr2=("$arr[@]:1")
echo "$arr2[@]"
echo "1st val is $arr2[1], 2nd val is $arr2[2]"

Output is

bb cc dd ee
1st val is cc, 2nd val is dd

POSIX shell script does not have arrays.

So most probably you are using a specific dialect such as bash, korn shells or zsh.

Therefore, your question as of now cannot be answered.

Maybe this works for you:

unset array[$delete]

Actually, I just noticed that the shell syntax somewhat has a behavior built-in that allows for easy reconstruction of the array when, as posed in the question, an item should be removed.

# let's set up an array of items to consume:
x=()
for (( i=0; i<10; i++ )); do
 x+=("$i")
done

# here, we consume that array:
while (( $#x[@] )); do
 i=$(( $RANDOM % $#x[@] ))
 echo "$x[i] / $x[@]"
 x=("$x[@]:0:i" "$x[@]:i+1")
done

Notice how we constructed the array using bash's x+=() syntax?

You could actually add more than one item with that, the content of a whole other array at once.

http://wiki.bash-hackers.org/syntax/pe#substring_removal

$PARAMETER#PATTERN # remove from beginning

$PARAMETER##PATTERN # remove from the beginning, greedy match

$PARAMETER%PATTERN # remove from the end

$PARAMETER%%PATTERN # remove from the end, greedy match

In order to do a full remove element, you have to do an unset command with an if statement. If you don't care about removing prefixes from other variables or about supporting whitespace in the array, then you can just drop the quotes and forget about for loops.

See example below for a few different ways to clean up an array.

options=("foo" "bar" "foo" "foobar" "foo bar" "bars" "bar")

# remove bar from the start of each element
options=("$options[@]/#"bar"")
# options=("foo" "" "foo" "foobar" "foo bar" "s" "")

# remove the complete string "foo" in a for loop
count=$#options[@]
for ((i = 0; i < count; i++)); do
 if [ "$options[i]" = "foo" ] ; then
 unset 'options[i]'
 fi
done
# options=( "" "foobar" "foo bar" "s" "")

# remove empty options
# note the count variable can't be recalculated easily on a sparse array
for ((i = 0; i < count; i++)); do
 # echo "Element $i: '$options[i]'"
 if [ -z "$options[i]" ] ; then
 unset 'options[i]'
 fi
done
# options=("foobar" "foo bar" "s")

# list them with select
echo "Choose an option:"
PS3='Option? '
select i in "$options[@]" Quit
 do
 case $i in 
 Quit) break ;;
 *) echo "You selected "$i"" ;;
 esac
 done

Output

Choose an option:
1) foobar
2) foo bar
3) s
4) Quit
Option? 

Hope that helps.

In ZSH this is dead easy (note this uses more bash compatible syntax than necessary where possible for ease of understanding):

# I always include an edge case to make sure each element
# is not being word split.
start=(one two three 'four 4' five)
work=($(@)start)

idx=2
val=$work[idx]

# How to remove a single element easily.
# Also works for associative arrays (at least in zsh)
work[$idx]=()

echo "Array size went down by one: "
[[ $#work -eq $(($#start - 1)) ]] && echo "OK"

echo "Array item "$val" is now gone: "
[[ -z $work[(r)$val] ]] && echo OK

echo "Array contents are as expected: "
wanted=("$start[@]:0:1" "$start[@]:2")
[[ "$(j.:.)wanted[@]" == "$(j.:.)work[@]" ]] && echo "OK"

echo "-- array contents: start --"
print -l -r -- "-- $#start elements" $(@)start
echo "-- array contents: work --"
print -l -r -- "-- $#work elements" "$work[@]"

Results:

Array size went down by one:
OK
Array item two is now gone:
OK
Array contents are as expected:
OK
-- array contents: start --
-- 5 elements
one
two
three
four 4
five
-- array contents: work --
-- 4 elements
one
three
four 4
five

There is also this syntax, e.g. if you want to delete the 2nd element :

array=("$array[@]:0:1" "$array[@]:2")

which is in fact the concatenation of 2 tabs. The first from the index 0 to the index 1 (exclusive) and the 2nd from the index 2 to the end.

Partial answer only

To delete the first item in the array

unset 'array[0]'

To delete the last item in the array

unset 'array[-1]'

To avoid conflicts with array index using unset - see https://stackoverflow.com/a/49626928/3223785 and https://stackoverflow.com/a/47798640/3223785 for more information - reassign the array to itself: ARRAY_VAR=($ARRAY_VAR[@]).

#!/bin/bash

ARRAY_VAR=(0 1 2 3 4 5 6 7 8 9)
unset ARRAY_VAR[5]
unset ARRAY_VAR[4]
ARRAY_VAR=($ARRAY_VAR[@])
echo $ARRAY_VAR[@]
A_LENGTH=$#ARRAY_VAR[*]
for (( i=0; i<=$(( $A_LENGTH -1 )); i++ )) ; do
 echo ""
 echo "INDEX - $i"
 echo "VALUE - $ARRAY_VAR[$i]"
done

exit 0

[Ref.: https://tecadmin.net/working-with-array-bash-script/ ]

What I do is:

array="$(echo $array | tr ' ' 'n' | sed "/itemtodelete/d")"

BAM, that item is removed.

This is a quick-and-dirty solution that will work in simple cases but will break if (a) there are regex special characters in $delete, or (b) there are any spaces at all in any items. Starting with:

array+=(pluto)
array+=(pippo)
delete=(pluto)

Delete all entries exactly matching $delete:

array=(`echo $array | fmt -1 | grep -v "^$delete$" | fmt -999999`)

resulting in
echo $array -> pippo, and making sure it's an array:
echo $array[1] -> pippo

fmt is a little obscure: fmt -1 wraps at the first column (to put each item on its own line. That's where the problem arises with items in spaces.) fmt -999999 unwraps it back to one line, putting back the spaces between items. There are other ways to do that, such as xargs.

Addendum: If you want to delete just the first match, use sed, as described here:

array=(`echo $array | fmt -1 | sed "0,/^$delete$///d;" | fmt -999999`)

How about something like:

array=(one two three)
array_t=" $array[@] "
delete=one
array=($array_t// $delete / )
unset array_t

#/bin/bash

echo "# define array with six elements"
arr=(zero one two three 'four 4' five)

echo "# unset by index: 0"
unset -v 'arr[0]'
for i in $!arr[*]; do echo "arr[$i]=$arr[$i]"; done

arr_delete_by_content() # value to delete
 for i in $!arr[*]; do
 [ "$arr[$i]" = "$1" ] && unset -v 'arr[$i]'
 done
 

echo "# unset in global variable where value: three"
arr_delete_by_content three
for i in $!arr[*]; do echo "arr[$i]=$arr[$i]"; done

echo "# rearrange indices"
arr=( "$arr[@]" )
for i in $!arr[*]; do echo "arr[$i]=$arr[$i]"; done

delete_value() sed 's,^[^=]*=,,'
 

echo "# new array without value: two"
declare -a arr="$(delete_value two "$arr[@]")"
for i in $!arr[*]; do echo "arr[$i]=$arr[$i]"; done

delete_values() # arraydecl values..., returns array decl. (keeps indices)
 declare -a arr="$1"; local i v; shift
 for v in "$@"; do 
 for i in $!arr[*]; do
 [ "$v" = "$arr[$i]" ] && unset -v 'arr[$i]'
 done
 done
 declare -p arr
echo "# new array without values: one five (keep indices)"
declare -a arr="$(delete_values "$(declare -p arr|sed 's,^[^=]*=,,')" one five)"
for i in $!arr[*]; do echo "arr[$i]=$arr[$i]"; done

# new array without multiple values and rearranged indices is left to the reader