arrayutils.bash

#!/usr/bin/env bash
# 
# File:
# arrayutils.bash
# 
# Description:
# Bash array utilities
# 

# ============================================
# Validation
# ============================================

# Usage:
# arrayContainsValue <value> <array reference>
arrayContainsValue() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for arrVal in "${arr[@]}"; do [ "${1}" = "${arrVal}" ] && \
 return 0; done
 return 1
}

# Usage:
# arrayContainsKey <key> <array reference>
arrayContainsKey() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for arrKey in "${!arr[@]}"; do [ "${1}" = "${arrKey}" ] && \
 return 0; done
 return 1
}

# Check if a value matches an array regex value.
# Usage:
# arrayContainsValueByRegex <regex> <array reference>
arrayContainsValueByRegex() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for arrVal in "${arr[@]}"; do [[ "${arrVal}" =~ ${1} ]] && \
 return 0; done
 return 1
}

# Check if array contains a value that is a prefix for the given value.
# Usage:
# arrayContainsPrefixForValue <value> <array reference>
arrayContainsPrefixForValue() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for arrVal in "${arr[@]}"; do [[ "${1}" = "${arrVal}"* ]] && \
 return 0; done
 return 1
}

# ============================================
# Getters
# ============================================

# Get a value from an array
# Usage:
# getArrayValue <value> <array reference>
getArrayValue() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for arrVal in "${arr[@]}"; do [ "${arrVal}" = "${1}" ] && \
 echo "${arrVal}" && break; done
}

# Get the position of an array element matching a value.
# Usage:
# getPositionOfArrayElement <value> <array reference>
getPositionOfArrayElement() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for indx in ${!arr[@]}; do [ "${arr[${indx}]}" = "${1}" ] && \
 echo "${indx}" && break; done
}

# Get the first value in the array that contains the given string.
# Usage:
# getFirstArrayValueContainingString <string> <array reference>
getFirstArrayValueContainingString() {
 local arr="${2}[@]"
 arr=("${!arr}")
 for arrVal in "${arr[@]}"; do [[ "${1}" = *"${arrVal}"* ]] && \
 echo "${arrVal}" && break; done
}

# ============================================
# Manipulation
# ============================================

# Usage:
# removeElementFromArray <value> <array reference>
removeElementFromArray() {
 local arr="${2}[@]"
 arr=("${!arr}")
 local indx=0
 for arrVal in "${arr[@]}"; do
 [ "${arrVal}" = "${1}" ] && \
 arr=("${arr[@]:0:${indx}} ${arr[@]:$((${indx} + 1))}") && \
 break
 ((indx++))
 done
 echo "${arr[@]}"
}

# Usage:
# removeDuplicatesFromArray <array reference>
removeDuplicatesFromArray() {
 local arr="${1}[@]"
 arr=("${!arr}")
 local retArr
 for arrVal in "${arr[@]}"; do
 local has=0
 for retArrVal in "${retArr[@]}"; do
 [ "${retArrVal}" = "${arrVal}" ] && has=1 && break; done
 [ ${has} -eq 0 ] && retArr+=("${arrVal}")
 done
 echo "${retArr[@]}"
}

# ============================================
# Sets
# ============================================

# Get the intersection of two arrays.
# Example:
# A=(1 3 9 2 7); B=(2 5 3 7 5)
# getIntersection A B # returns "3 2 7"
getIntersection() {
 local arr1="${1}[@]"
 local arr2="${2}[@]"
 arr1=(${!arr1})
 arr2=(${!arr2})
 local retArr
 for arr1Val in "${arr1[@]}"; do
 for arr2Val in "${arr2[@]}"; do
 if [ "${arr2Val}" = "${arr1Val}" ]; then
 local has=0
 for retArrVal in "${retArr[@]}"; do
 [ "${retArrVal}" = "${arr1Val}" ] && has=1 && break; done
 [ ${has} -eq 0 ] && retArr+=("${arr1Val}")
 fi
 done
 done
 echo "${retArr[@]}"
}

# Get the union of two arrays.
# Example:
# A=(5 7 1 1 4); B=(3 1 4 1 9)
# getUnion A B # returns "5 7 1 4 3 9"
getUnion() {
 local arr1="${1}[@]"
 local arr2="${2}[@]"
 arr1=(${!arr1})
 arr2=(${!arr2})
 local retArr
 for arr1Val in "${arr1[@]}"; do
 local has=0
 for retArrVal in "${retArr[@]}"; do
 [ "${retArrVal}" = "${arr1Val}" ] && has=1 && break; done
 [ ${has} -eq 0 ] && retArr+=("${arr1Val}")
 done
 for arr2Val in "${arr2[@]}"; do
 local has=0
 for retArrVal in "${retArr[@]}"; do
 [ "${retArrVal}" = "${arr2Val}" ] && has=1 && break; done
 [ ${has} -eq 0 ] && retArr+=("${arr2Val}")
 done
 echo "${retArr[@]}"
}

# Get the union of two arrays (2).
# Example:
# A=(5 7 1 1 4); B=(3 1 4 1 9)
# getUnion2 A B # returns "5 7 3 1 4 9"
getUnion2() {
 local arr1="${1}[@]"
 local arr2="${2}[@]"
 arr1=(${!arr1})
 arr2=(${!arr2})
 local unionArr
 local i=0 j=0
 while [[ ${i} -lt ${#arr1[@]} && ${j} -lt ${#arr2[@]} ]]; do
 if [[ "${arr1[${i}]}" > "${arr2[${j}]}" ]]; then
 unionArr+=("${arr1[$((i++))]}")
 elif [[ "${arr1[${i}]}" < "${arr2[${j}]}" ]]; then
 unionArr+=("${arr2[$((j++))]}")
 else
 unionArr+=("${arr1[$((i++))]}")
 ((j++))
 fi
 done
 while [ ${i} -lt ${#arr1[@]} ]; do unionArr+=("${arr1[$((i++))]}"); done
 while [ ${j} -lt ${#arr2[@]} ]; do unionArr+=("${arr2[$((j++))]}"); done
 local unionNoDuplctsArr
 for unionArrVal in "${unionArr[@]}"; do
 local has=0
 for unionNoDuplctsArrVal in "${unionNoDuplctsArr[@]}"; do
 [ "${unionNoDuplctsArrVal}" = "${unionArrVal}" ] && has=1 && break
 done
 [ ${has} -eq 0 ] && unionNoDuplctsArr+=("${unionArrVal}")
 done
 echo "${unionNoDuplctsArr[@]}"
}

# Get the difference between array 1 and array 2 (i.e. elements in array 1
# that are not in array 2).
# Example:
# A=(3 6 2 1 5 1 1); B=(2 4 6)
# getDifference A B # returns "3 1 5"
getDifference() {
 local arr1="${1}[@]"
 local arr2="${2}[@]"
 arr1=(${!arr1})
 arr2=(${!arr2})
 local retArr
 for arr1Val in "${arr1[@]}"; do
 local has=0
 for retArrVal in "${retArr[@]}"; do
 [ "${retArrVal}" = "${arr1Val}" ] && has=1 && break; done
 [ ${has} -eq 0 ] && for arr2Val in "${arr2[@]}"; do
 [ "${arr2Val}" = "${arr1Val}" ] && has=1 && break; done
 [ ${has} -eq 0 ] && retArr+=("${arr1Val}")
 done
 echo "${retArr[@]}"
}

# ============================================
# Parsing
# ============================================

# Join the elements of an array by a delimiter.
# Usage:
# joinArrayBy <delimiter> <array reference>
joinArrayBy() {
 local delim="${1}"
 local arr="${2}[@]"
 arr=("${!arr}")
 joined="$(printf "%s" "${arr[@]/#/$delim}")"
 echo "${joined#${delim}}"
}

# ============================================
# Other
# ============================================

# Create pairs between array 1 and array 2.
# Example:
# A=(0 12); B=(4 5)
# createPairs A B # returns "0:4 0:5 12:4 12:5"
createPairs() {
 local arr1="${1}[@]"
 local arr2="${2}[@]"
 arr1=(${!arr1})
 arr2=(${!arr2})
 local retArr
 for arr1Val in ${arr1[@]}; do
 for arr2Val in ${arr2[@]}; do
 local retArr+=("${arr1Val}:${arr2Val}")
 done
 done
 echo "${retArr[@]}"
}