쉘 스크립트의 연관 배열
-
22-08-2019 - |
문제
우리는 쉘 스크립팅을위한 연관 배열이나 맵을 시뮬레이션하는 스크립트가 필요합니까?
해결책
추가합니다 Irfan의 대답, 여기 더 짧고 빠른 버전이 있습니다 get()
지도 내용에 반복이 필요하지 않기 때문에 :
get() {
mapName=$1; key=$2
map=${!mapName}
value="$(echo $map |sed -e "s/.*--${key}=\([^ ]*\).*/\1/" -e 's/:SP:/ /g' )"
}
다른 팁
휴대 성이 주요 관심사가 아닌 경우 또 다른 옵션은 쉘에 내장 된 연관 배열을 사용하는 것입니다. 이것은 bash 4.0에서 작동해야합니다 (현재 대부분의 주요 배포판에서 사용할 수 있지만 직접 설치하지 않는 한 OS X는 아니지만), KSH 및 ZSH :
declare -A newmap
newmap[name]="Irfan Zulfiqar"
newmap[designation]=SSE
newmap[company]="My Own Company"
echo ${newmap[company]}
echo ${newmap[name]}
쉘에 따라 typeset -A newmap
대신에 declare -A newmap
, 또는 일부는 전혀 필요하지 않을 수 있습니다.
또 다른 비 배시 4 웨이.
#!/bin/bash
# A pretend Python dictionary with bash 3
ARRAY=( "cow:moo"
"dinosaur:roar"
"bird:chirp"
"bash:rock" )
for animal in "${ARRAY[@]}" ; do
KEY=${animal%%:*}
VALUE=${animal#*:}
printf "%s likes to %s.\n" "$KEY" "$VALUE"
done
echo -e "${ARRAY[1]%%:*} is an extinct animal which likes to ${ARRAY[1]#*:}\n"
당신은 거기에서 검색에 대한 if 문을 던질 수 있습니다. [[$ var = ~ / blah /]] 인 경우. 또는 무엇이든.
나는 당신이 물러서서지도 나 연관 배열이 무엇인지 생각해야한다고 생각합니다. 주어진 키에 대한 값을 저장하고 그 값을 빠르고 효율적으로 되돌리는 방법입니다. 키를 반복하여 모든 키 값 쌍을 검색하거나 키와 관련 값을 삭제할 수 있습니다.
이제 쉘 스크립팅에서 항상 사용하는 데이터 구조와 스크립트를 쓰지 않고 쉘에서도 이러한 특성을 가진 데이터 구조에 대해 생각해보십시오. 그루터기? 파일 시스템입니다.
실제로 쉘 프로그래밍에 연관 배열이 필요한 것은 온도 디렉토리입니다. mktemp -d
연관 배열 생성자입니다.
prefix=$(basename -- "$0")
map=$(mktemp -dt ${prefix})
echo >${map}/key somevalue
value=$(cat ${map}/key)
사용하고 싶지 않다면 echo
그리고 cat
, 항상 작은 포장지를 쓸 수 있습니다. 이 것들은 Irfan에서 모델링되지만, 임의 변수를 다음과 같이 설정하는 대신 값을 출력합니다. $value
:
#!/bin/sh
prefix=$(basename -- "$0")
mapdir=$(mktemp -dt ${prefix})
trap 'rm -r ${mapdir}' EXIT
put() {
[ "$#" != 3 ] && exit 1
mapname=$1; key=$2; value=$3
[ -d "${mapdir}/${mapname}" ] || mkdir "${mapdir}/${mapname}"
echo $value >"${mapdir}/${mapname}/${key}"
}
get() {
[ "$#" != 2 ] && exit 1
mapname=$1; key=$2
cat "${mapdir}/${mapname}/${key}"
}
put "newMap" "name" "Irfan Zulfiqar"
put "newMap" "designation" "SSE"
put "newMap" "company" "My Own Company"
value=$(get "newMap" "company")
echo $value
value=$(get "newMap" "name")
echo $value
편집하다:이 접근법은 실제로 질문자가 제안한 SED를 사용한 선형 검색보다 훨씬 빠르고 더 강력합니다 (키와 값은 -, =, space, qnd ": sp :")를 포함 할 수 있습니다. 파일 시스템을 사용한다는 사실은 느리게 만들지 않습니다. 이 파일은 실제로 전화하지 않는 한 디스크에 기록되지 않습니다. sync
; 짧은 수명이있는 이와 같은 임시 파일의 경우, 많은 파일이 디스크에 결코 쓰지 않을 것 같지 않습니다.
IRFAN 코드의 벤치 마크, Jerry의 Irfan 코드 수정 및 다음 드라이버 프로그램을 사용하여 내 코드를 수행했습니다.
#!/bin/sh
mapimpl=$1
numkeys=$2
numvals=$3
. ./${mapimpl}.sh #/ <- fix broken stack overflow syntax highlighting
for (( i = 0 ; $i < $numkeys ; i += 1 ))
do
for (( j = 0 ; $j < $numvals ; j += 1 ))
do
put "newMap" "key$i" "value$j"
get "newMap" "key$i"
done
done
결과 :
$ time ./driver.sh irfan 10 5 real 0m0.975s user 0m0.280s sys 0m0.691s $ time ./driver.sh brian 10 5 real 0m0.226s user 0m0.057s sys 0m0.123s $ time ./driver.sh jerry 10 5 real 0m0.706s user 0m0.228s sys 0m0.530s $ time ./driver.sh irfan 100 5 real 0m10.633s user 0m4.366s sys 0m7.127s $ time ./driver.sh brian 100 5 real 0m1.682s user 0m0.546s sys 0m1.082s $ time ./driver.sh jerry 100 5 real 0m9.315s user 0m4.565s sys 0m5.446s $ time ./driver.sh irfan 10 500 real 1m46.197s user 0m44.869s sys 1m12.282s $ time ./driver.sh brian 10 500 real 0m16.003s user 0m5.135s sys 0m10.396s $ time ./driver.sh jerry 10 500 real 1m24.414s user 0m39.696s sys 0m54.834s $ time ./driver.sh irfan 1000 5 real 4m25.145s user 3m17.286s sys 1m21.490s $ time ./driver.sh brian 1000 5 real 0m19.442s user 0m5.287s sys 0m10.751s $ time ./driver.sh jerry 1000 5 real 5m29.136s user 4m48.926s sys 0m59.336s
hput () {
eval hash"$1"='$2'
}
hget () {
eval echo '${hash'"$1"'#hash}'
}
hput France Paris
hput Netherlands Amsterdam
hput Spain Madrid
echo `hget France` and `hget Netherlands` and `hget Spain`
$ sh hash.sh
Paris and Amsterdam and Madrid
Bash4는 이것을 기본적으로 지원합니다. 사용하지 마세요 grep
또는 eval
, 그들은 가장 추악한 해킹입니다.
예제 코드에 대한 상세한 답변은 다음을 참조하십시오.https://stackoverflow.com/questions/3467959
####################################################################
# Bash v3 does not support associative arrays
# and we cannot use ksh since all generic scripts are on bash
# Usage: map_put map_name key value
#
function map_put
{
alias "${1}$2"="$3"
}
# map_get map_name key
# @return value
#
function map_get
{
alias "${1}$2" | awk -F"'" '{ print $2; }'
}
# map_keys map_name
# @return map keys
#
function map_keys
{
alias -p | grep $1 | cut -d'=' -f1 | awk -F"$1" '{print $2; }'
}
예시:
mapName=$(basename $0)_map_
map_put $mapName "name" "Irfan Zulfiqar"
map_put $mapName "designation" "SSE"
for key in $(map_keys $mapName)
do
echo "$key = $(map_get $mapName $key)
done
이제이 질문에 대답합니다.
다음 스크립트는 쉘 스크립트의 연관 배열을 시뮬레이션합니다. 간단하고 이해하기 쉽습니다.
맵은 keyvaluepair를 -name = irfan -designation = sse -company = my : sp : sp : company로 저장 한 끝없는 문자열 일뿐입니다.
공백은 ': sp :'값으로 대체됩니다.
put() {
if [ "$#" != 3 ]; then exit 1; fi
mapName=$1; key=$2; value=`echo $3 | sed -e "s/ /:SP:/g"`
eval map="\"\$$mapName\""
map="`echo "$map" | sed -e "s/--$key=[^ ]*//g"` --$key=$value"
eval $mapName="\"$map\""
}
get() {
mapName=$1; key=$2; valueFound="false"
eval map=\$$mapName
for keyValuePair in ${map};
do
case "$keyValuePair" in
--$key=*) value=`echo "$keyValuePair" | sed -e 's/^[^=]*=//'`
valueFound="true"
esac
if [ "$valueFound" == "true" ]; then break; fi
done
value=`echo $value | sed -e "s/:SP:/ /g"`
}
put "newMap" "name" "Irfan Zulfiqar"
put "newMap" "designation" "SSE"
put "newMap" "company" "My Own Company"
get "newMap" "company"
echo $value
get "newMap" "name"
echo $value
편집하다: 모든 키를 가져 오는 다른 방법을 추가했습니다.
getKeySet() {
if [ "$#" != 1 ];
then
exit 1;
fi
mapName=$1;
eval map="\"\$$mapName\""
keySet=`
echo $map |
sed -e "s/=[^ ]*//g" -e "s/\([ ]*\)--/\1/g"
`
}
Bash 3의 경우 멋지고 간단한 솔루션이있는 특정 사례가 있습니다.
많은 변수를 처리하고 싶지 않거나 키가 단순히 유효하지 않은 변수 식별자 인 경우 그리고 당신의 배열에는 보장됩니다 256 개 미만의 항목, 기능 반환 값을 남용 할 수 있습니다. 이 솔루션은 값이 변수로 쉽게 구할 수 있으므로 성능이 비명을 지르기 위해 반복을 쉽게 사용할 수 있으므로 서브 쉘이 필요하지 않습니다. 또한 Bash 4 버전과 거의 비슷하게 읽을 수 있습니다.
가장 기본적인 버전은 다음과 같습니다.
hash_index() {
case $1 in
'foo') return 0;;
'bar') return 1;;
'baz') return 2;;
esac
}
hash_vals=("foo_val"
"bar_val"
"baz_val");
hash_index "foo"
echo ${hash_vals[$?]}
단일 따옴표를 사용하십시오 case
, 그렇지 않으면 글로브의 대상이됩니다. 처음부터 정적/냉동 해시에 정말 유용하지만 A에서 인덱스 생성기를 쓸 수 있습니다. hash_keys=()
정렬.
조심하십시오. 첫 번째는 기본값으로 기본적으로 Zeroth 요소를 따로 설정할 수 있습니다.
hash_index() {
case $1 in
'foo') return 1;;
'bar') return 2;;
'baz') return 3;;
esac
}
hash_vals=("", # sort of like returning null/nil for a non existent key
"foo_val"
"bar_val"
"baz_val");
hash_index "foo" || echo ${hash_vals[$?]} # It can't get more readable than this
경고 : 이제 길이가 잘못되었습니다.
또는 제로 기반 인덱싱을 유지하려면 다른 인덱스 값을 예약하고 존재하지 않는 키를 보호 할 수 있지만 읽기 쉽지 않습니다.
hash_index() {
case $1 in
'foo') return 0;;
'bar') return 1;;
'baz') return 2;;
*) return 255;;
esac
}
hash_vals=("foo_val"
"bar_val"
"baz_val");
hash_index "foo"
[[ $? -ne 255 ]] && echo ${hash_vals[$?]}
또는 길이를 올바르게 유지하려면 인덱스 오프셋 인덱스 씩 다음과 같습니다.
hash_index() {
case $1 in
'foo') return 1;;
'bar') return 2;;
'baz') return 3;;
esac
}
hash_vals=("foo_val"
"bar_val"
"baz_val");
hash_index "foo" || echo ${hash_vals[$(($? - 1))]}
동적 변수 이름을 사용하고 변수 이름이 해시 맵의 키처럼 작동하도록 할 수 있습니다.
예를 들어, 예제와 같이 이름, 크레딧의 두 열이있는 입력 파일이있는 경우 각 사용자의 수입을 합산하려는 경우.
Mary 100
John 200
Mary 50
John 300
Paul 100
Paul 400
David 100
벨로우즈 명령은 동적 변수를 키로 사용하여 모든 것을 요약합니다. 지도 _ $ {person}:
while read -r person money; ((map_$person+=$money)); done < <(cat INCOME_REPORT.log)
결과를 읽으려면 :
set | grep map
출력은 다음과 같습니다.
map_David=100
map_John=500
map_Mary=150
map_Paul=500
이러한 기술에 대해 자세히 설명하면서, 나는 github에서 해시 맵 객체, shell_map.
"만들기 위해"해시 맵 인스턴스" shell_map 함수 다른 이름으로 자체 사본을 만들 수 있습니다. 각각의 새 함수 사본에는 다른 $ funcname 변수가 있습니다. $ funcName은 각 맵 인스턴스에 대한 네임 스페이스를 작성하는 데 사용됩니다.
맵 키는 $ funcname_data_ $ 키 양식의 글로벌 변수이며, 여기서 $ 키는 맵에 추가 된 키입니다. 이러한 변수는 다음과 같습니다 동적 변수.
벨로우 나는 당신이 예로 사용할 수 있도록 단순화 된 버전을 넣을 것이다.
#!/bin/bash
shell_map () {
local METHOD="$1"
case $METHOD in
new)
local NEW_MAP="$2"
# loads shell_map function declaration
test -n "$(declare -f shell_map)" || return
# declares in the Global Scope a copy of shell_map, under a new name.
eval "${_/shell_map/$2}"
;;
put)
local KEY="$2"
local VALUE="$3"
# declares a variable in the global scope
eval ${FUNCNAME}_DATA_${KEY}='$VALUE'
;;
get)
local KEY="$2"
local VALUE="${FUNCNAME}_DATA_${KEY}"
echo "${!VALUE}"
;;
keys)
declare | grep -Po "(?<=${FUNCNAME}_DATA_)\w+((?=\=))"
;;
name)
echo $FUNCNAME
;;
contains_key)
local KEY="$2"
compgen -v ${FUNCNAME}_DATA_${KEY} > /dev/null && return 0 || return 1
;;
clear_all)
while read var; do
unset $var
done < <(compgen -v ${FUNCNAME}_DATA_)
;;
remove)
local KEY="$2"
unset ${FUNCNAME}_DATA_${KEY}
;;
size)
compgen -v ${FUNCNAME}_DATA_${KEY} | wc -l
;;
*)
echo "unsupported operation '$1'."
return 1
;;
esac
}
용법:
shell_map new credit
credit put Mary 100
credit put John 200
for customer in `credit keys`; do
value=`credit get $customer`
echo "customer $customer has $value"
done
credit contains_key "Mary" && echo "Mary has credit!"
전에 질문을 보지 못한 것은 얼마나 동정심 이었는지 - 나는 도서관을 썼습니다. 쉘 프레임 워크 여기에는 맵 (연관 배열)이 포함되어 있습니다. 그것의 마지막 버전을 찾을 수 있습니다 여기.
예시:
#!/bin/bash
#include map library
shF_PATH_TO_LIB="/usr/lib/shell-framework"
source "${shF_PATH_TO_LIB}/map"
#simple example get/put
putMapValue "mapName" "mapKey1" "map Value 2"
echo "mapName[mapKey1]: $(getMapValue "mapName" "mapKey1")"
#redefine old value to new
putMapValue "mapName" "mapKey1" "map Value 1"
echo "after change mapName[mapKey1]: $(getMapValue "mapName" "mapKey1")"
#add two new pairs key/values and print all keys
putMapValue "mapName" "mapKey2" "map Value 2"
putMapValue "mapName" "mapKey3" "map Value 3"
echo -e "mapName keys are \n$(getMapKeys "mapName")"
#create new map
putMapValue "subMapName" "subMapKey1" "sub map Value 1"
putMapValue "subMapName" "subMapKey2" "sub map Value 2"
#and put it in mapName under key "mapKey4"
putMapValue "mapName" "mapKey4" "subMapName"
#check if under two key were placed maps
echo "is map mapName[mapKey3]? - $(if isMap "$(getMapValue "mapName" "mapKey3")" ; then echo Yes; else echo No; fi)"
echo "is map mapName[mapKey4]? - $(if isMap "$(getMapValue "mapName" "mapKey4")" ; then echo Yes; else echo No; fi)"
#print map with sub maps
printf "%s\n" "$(mapToString "mapName")"
이미 언급했듯이 최상의 성과 방법은 키/vals를 파일에 작성한 다음 grep/awk를 사용하여 검색하는 것이 사실임을 알게되었습니다. 모든 종류의 불필요한 IO처럼 들리지만 디스크 캐시가 시작되어 매우 효율적입니다. 위의 방법 중 하나를 사용하여 메모리에 저장하는 것보다 훨씬 빠릅니다 (벤치 마크가 표시).
다음은 내가 좋아하는 빠르고 깨끗한 방법입니다.
hinit() {
rm -f /tmp/hashmap.$1
}
hput() {
echo "$2 $3" >> /tmp/hashmap.$1
}
hget() {
grep "^$2 " /tmp/hashmap.$1 | awk '{ print $2 };'
}
hinit capitols
hput capitols France Paris
hput capitols Netherlands Amsterdam
hput capitols Spain Madrid
echo `hget capitols France` and `hget capitols Netherlands` and `hget capitols Spain`
키당 단일 값을 시행하려면 hput ()에서 약간의 grep/sed 동작을 수행 할 수도 있습니다.
몇 년 전 저는 다른 기능들 (로깅, 구성 파일, 명령 줄 인수에 대한 확장 된 지원, 도움말 생성, 단위 테스트 등)을 지원하는 Bash 용 스크립트 라이브러리를 작성했습니다. 라이브러리에는 연관 배열 용 래퍼가 포함되어 있으며 적절한 모델로 자동으로 전환합니다 (Bash4의 내부 및 이전 버전의 경우 에뮬레이션). 그것은 Shell-Framework라고 불리며 Origo.ethz.ch에서 호스팅되었지만 오늘날 리소스는 닫힙니다. 누군가가 여전히 필요하다면 나는 당신과 공유 할 수 있습니다.
쉘은 데이터 구조와 같은 내장 맵이 없으므로 원시 문자열을 사용하여 다음과 같은 항목을 설명합니다.
ARRAY=(
"item_A|attr1|attr2|attr3"
"item_B|attr1|attr2|attr3"
"..."
)
항목과 그 속성을 추출 할 때 :
for item in "${ARRAY[@]}"
do
item_name=$(echo "${item}"|awk -F "|" '{print $1}')
item_attr1=$(echo "${item}"|awk -F "|" '{print $2}')
item_attr2=$(echo "${item}"|awk -F "|" '{print $3}')
echo "${item_name}"
echo "${item_attr1}"
echo "${item_attr2}"
done
이것은 다른 사람들의 대답보다 영리하지는 않지만 새로운 사람들이 껍질을 껍질을 나누기 쉽습니다.
JQ를 사용할 수있는 경우 다른 옵션 추가 :
export NAMES="{
\"Mary\":\"100\",
\"John\":\"200\",
\"Mary\":\"50\",
\"John\":\"300\",
\"Paul\":\"100\",
\"Paul\":\"400\",
\"David\":\"100\"
}"
export NAME=David
echo $NAMES | jq --arg v "$NAME" '.[$v]' | tr -d '"'
다음과 함께 Vadim의 솔루션을 수정했습니다.
####################################################################
# Bash v3 does not support associative arrays
# and we cannot use ksh since all generic scripts are on bash
# Usage: map_put map_name key value
#
function map_put
{
alias "${1}$2"="$3"
}
# map_get map_name key
# @return value
#
function map_get {
if type -p "${1}$2"
then
alias "${1}$2" | awk -F "'" '{ print $2; }';
fi
}
# map_keys map_name
# @return map keys
#
function map_keys
{
alias -p | grep $1 | cut -d'=' -f1 | awk -F"$1" '{print $2; }'
}
존재하지 않는 키를 요청하는 경우 오류가 반환되지 않도록 MAP_GET으로 변경됩니다. 부작용은 누락 된 맵을 조용히 무시할 것이지만 저만 이후로 내 유스 케이스에 더 적합하다는 것입니다. 루프에서 품목을 건너 뛰기 위해 키를 확인하고 싶었습니다.
늦게 답장을 보내지 만 Bash 내장을 사용하여 이런 식으로 문제를 해결하는 것을 고려하십시오. 읽다 다음과 같은 UFW 방화벽 스크립트의 코드 스 니펫에 설명 된 바와 같이. 이 접근법은 원하는만큼 구분 된 필드 세트 (2가 아닌)를 사용한다는 장점이 있습니다. 우리는 사용했습니다 | 구분기는 포트 범위 지정자가 결장을 필요로 할 수 있기 때문에 6001:6010.
#!/usr/bin/env bash
readonly connections=(
'192.168.1.4/24|tcp|22'
'192.168.1.4/24|tcp|53'
'192.168.1.4/24|tcp|80'
'192.168.1.4/24|tcp|139'
'192.168.1.4/24|tcp|443'
'192.168.1.4/24|tcp|445'
'192.168.1.4/24|tcp|631'
'192.168.1.4/24|tcp|5901'
'192.168.1.4/24|tcp|6566'
)
function set_connections(){
local range proto port
for fields in ${connections[@]}
do
IFS=$'|' read -r range proto port <<< "$fields"
ufw allow from "$range" proto "$proto" to any port "$port"
done
}
set_connections