Löschen bestimmter Werte aus einem array in der ksh

Habe ich eine angepasste .Profil, dass ich verwenden in der ksh und unten ist eine Funktion, die ich erstellt zu überspringen hin und her von Verzeichnissen mit allzu komplizierte oder lange Namen.

Wie Sie sehen können, die Pfade sind gespeichert in einem array (BOOKMARKS[]) zu verfolgen und verweisen Sie zu einem späteren Zeitpunkt. Ich möchte, löschen zu können, bestimmte Werte aus dem array, mit einer case-Anweisung (oder OPTARG wenn notwendig) so, dass kann ich nur bmk -d # entfernen Sie den Pfad zu dem entsprechenden index.

Habe ich fummelte, um mit array +A and -A, aber es aufgewickelt Schrauben ist mein array (was ist Links in der auskommentierten code vielleicht nicht schön...ich habe nicht Korrektur gelesen, es).

Irgendwelche Vorschläge/Tipps, wie Sie erstellen, die diese Funktionalität? Danke!

# To bookmark the current directory you are in for easy navigation back and forth from multiple non-aliased directories
# Use like 'bmk' (sets the current directory to a bookmark number) to go back to this directory, i.e. type 'bmk 3' (for the 3rd)
# To find out what directories are linked to which numbers, type 'bmk -l' (lowercase L)
# For every new directory bookmarked, the number will increase so the first time you run 'bmk' it will be 1 then 2,3,4...etc. for every consecutive run therea
fter
# TODO: finish -d (delete bookmark entry) function
make_bookmark()
{
        if [[ $# -eq 0 ]]; then
                BOOKMARKS[${COUNTER}]=${PWD}
                (( COUNTER=COUNTER+1 ))
        else
                case $1 in
                        -l)     NUM_OF_ELEMENTS=${#BOOKMARKS[*]}

                                while [[ ${COUNTER} -lt ${NUM_OF_ELEMENTS} ]]
                                do
                                        (( ACTUAL_NUM=i+1 ))
                                        echo ${ACTUAL_NUM}":"${BOOKMARKS[${i}]}
                                        (( COUNTER=COUNTER+1 ))
                                done
                                break ;;


                       #-d)    ACTUAL_NUM=$2
                                #(( REMOVE=${ACTUAL_NUM}-1 ))
                                #echo "Removing path ${BOOKMARKS[${REMOVE}]} from 'bmk'..."
                                #NUM_OF_ELEMENTS=${#BOOKMARKS[*]}

                                #while [[ ${NUM_OF_ELEMENTS} -gt 0 ]]
                                #do
                                        #if [[ ${NUM_OF_ELEMENTS} -ne ${ACTUAL_NUM} ]]; then
                                        #       TEMP_ARR=$(echo "${BOOKMARKS[*]}")
                                        #       (( NUM_OF_ELEMENTS=${NUM_OF_ELEMENTS}-1 ))
                                        #fi
                                        #echo $TEMP_ARR
                                #done
                                #break
                                #for VALUE in ${TEMP_ARR}
                                #do
                                #       set +A BOOKMARK ${TEMP_ARR}
                                #done
                                #echo ${BOOKMARK[*]}

                                #break ;;

                        *)      (( INDEX=$1-1 ))
                                cd ${BOOKMARKS[${INDEX}]}
                                break ;;
                esac
        fi
}

InformationsquelleAutor Sean | 2010-01-21

Arrays in der Korn-shell (oder Bash und andere) sind spärlich, so dass, wenn Sie verwenden unset löschen von Mitgliedern des Feldes, werden Sie nicht in der Lage zu verwenden, die Größe des Arrays als index für das Letzte Element und anderen Einschränkungen.

Hier sind einige nützliche snippets (die zweite for Schleife ist etwas, was Sie vielleicht in der Lage sein, um sofort):

array=(1 2 3)
unset array[2]
echo ${array[2]}          # null
indices=(${!array[@]})    # create an array of the indices of "array"
size=${#indices[@]}       # the size of "array" is the number of indices into it
size=${#array[@]}         # same
echo ${array[@]: -1}      # you can use slices to get array elements, -1 is the last one, etc.
for element in ${array[@]}; do    # iterate over the array without an index

for index in ${indices[@]}        # iterate over the array WITH an index
do
    echo "Index: ${index}, Element: ${array[index]}"
done

for index in ${!array[@]}         # iterate over the array WITH an index, directly

Dass Letzte kann man beseitigen die Notwendigkeit für einen Schalter.

Hier sind ein paar mehr praktische Techniken:

array+=("new element")    # append a new element without referring to an index
((counter++))             # shorter than ((counter=counter+1)) or ((counter+=1))
if [[ $var == 3 ]]        # you can use the more "natural" comparison operators inside double square brackets
while [[ $var < 11 ]]     # another example
echo ${array[${index}-1]  # math inside an array subscript

Diese alle davon ausgegangen, ksh93, manche Dinge können nicht in früheren Versionen.

Genial...vielen Dank Dennis! Diese sind wirklich praktisch zu wissen, und ich werde Ihnen so schnell wie möglich 🙂

InformationsquelleAutor Paused until further notice.

2

können Sie nicht gesetzt. zB löschen array-element 1
```
unset array[0]
```
löschen gesamte array
```
unset array
```
InformationsquelleAutor ghostdog74
1

Einige Vorbehalte in Bezug auf die Vorherige Antwort:

Ersten: ich sehe diese Fehler die ganze Zeit. Wenn Sie ein array-element auf "unset", Sie haben zu zitieren, es. Bedenken Sie:
```
$ echo foo > ./a2
$ ls a[2]
a2
$ a2="Do not delete this"
$ a=(this is not an array)
$ unset -v a[2]
$ echo "a2=${a2-UNSET}, a[]=${a[@]}"
a2=UNSET a[]=this is not an array
```
Was ist passiert? Platzhalter. Sie wollte offensichtlich zu element löschen 2 a[], aber die shell-syntax sein, was es ist, die shell als erstes im aktuellen Verzeichnis nach einer Datei, die aufeinander abgestimmt die glob pattern "[2]". Wenn es eine übereinstimmung findet, ersetzt es das glob pattern mit, dass mit dem Namen, und Sie wind-up eine Entscheidung darüber, welche variable zu löschen, basierend auf, was für Dateien gibt es in Ihrem aktuellen Verzeichnis.

Dies ist zutiefst dumm. Aber es ist nicht etwas, was jemand hat sich die Mühe gemacht, zu beheben, offenbar, und der Fehler taucht in allen Arten von Dokumentation und Beispiel-code aus den letzten 3 Jahrzehnten.

Weiter geht es mit einem verwandten problem: es ist einfach zum einfügen von Elementen in das assoziative array mit jedem Schlüssel, den Sie mögen. Aber es ist schwieriger zu entfernen diese Elemente:
```
typeset -A assoc
key="foo] bar"
assoc[$key]=3    #No problem!
unset -v "assoc[$key]"    #Problem!
```
In der bash können Sie dies tun:
```
unset -v "assoc[\$key]"
```
In der Korn-Shell, die Sie haben, dies zu tun:
```
unset -v "assoc[foo\]\ bar]"
```
So wird es ein bisschen komplizierter in dem Fall, wo Sie Ihre Schlüssel enthalten syntax-Zeichen.

InformationsquelleAutor tetsujin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.