Systeminformationen

OS: OS X

bash: GNU bash, Version 3.2.57 (1) -release (x86_64-apple-darwin16)

Hintergrund

Ich möchte, dass Time Machine eine Reihe von Verzeichnissen und Dateien aus meinem git / nodejs-Projekt ausschließt. Meine Projektverzeichnisse befinden sich in ~/code/private/und ~/code/public/deshalb versuche ich, die Bash-Schleife zu verwenden tmutil.

Problem

Kurze Version

Wenn ich eine berechnete Zeichenfolgenvariable habe k, wie mache ich sie in oder direkt vor einer for-Schleife:

i='~/code/public/*'
j='*.launch'
k=$i/$j # $k='~/code/public/*/*.launch'

for i in $k # I need $k to glob here
do
    echo $i
done

In der langen Version unten sehen Sie k=$i/$j. Daher kann ich die Zeichenfolge in der for-Schleife nicht fest codieren.

Lange Version

#!/bin/bash
exclude='
*.launch
.classpath
.sass-cache
Thumbs.db
bower_components
build
connect.lock
coverage
dist
e2e/*.js
e2e/*.map
libpeerconnection.log
node_modules
npm-debug.log
testem.log
tmp
typings
'

dirs='
~/code/private/*
~/code/public/*
'

for i in $dirs
do
    for j in $exclude
    do
        k=$i/$j # It is correct up to this line

        for l in $k # I need it glob here
        do
            echo $l
        #   Command I want to execute
        #   tmutil addexclusion $l
        done
    done
done

Ausgabe

Sie sind nicht kugelförmig. Nicht was ich will.

~/code/private/*/*.launch                                                                                   
~/code/private/*/.DS_Store                                                                                  
~/code/private/*/.classpath                                                                                 
~/code/private/*/.sass-cache                                                                                
~/code/private/*/.settings                                                                                  
~/code/private/*/Thumbs.db                                                                                  
~/code/private/*/bower_components                                                                           
~/code/private/*/build                                                                                      
~/code/private/*/connect.lock                                                                               
~/code/private/*/coverage                                                                                   
~/code/private/*/dist                                                                                       
~/code/private/*/e2e/*.js                                                                                   
~/code/private/*/e2e/*.map                                                                                  
~/code/private/*/libpeerconnection.log                                                                      
~/code/private/*/node_modules                                                                               
~/code/private/*/npm-debug.log                                                                              
~/code/private/*/testem.log                                                                                 
~/code/private/*/tmp                                                                                        
~/code/private/*/typings                                                                                    
~/code/public/*/*.launch                                                                                    
~/code/public/*/.DS_Store                                                                                   
~/code/public/*/.classpath                                                                                  
~/code/public/*/.sass-cache                                                                                 
~/code/public/*/.settings                                                                                   
~/code/public/*/Thumbs.db                                                                                   
~/code/public/*/bower_components                                                                            
~/code/public/*/build                                                                                       
~/code/public/*/connect.lock                                                                                
~/code/public/*/coverage                                                                                    
~/code/public/*/dist                                                                                        
~/code/public/*/e2e/*.js                                                                                    
~/code/public/*/e2e/*.map                                                                                   
~/code/public/*/libpeerconnection.log                                                                       
~/code/public/*/node_modules                                                                                
~/code/public/*/npm-debug.log                                                                               
~/code/public/*/testem.log                                                                                  
~/code/public/*/tmp                                                                                         
~/code/public/*/typings

Sie können eine weitere Evaluierungsrunde mit erzwingen eval, dies ist jedoch nicht unbedingt erforderlich. (Und es evaltreten ernsthafte Probleme auf, sobald Ihre Dateinamen Sonderzeichen wie enthalten $.) Das Problem liegt nicht beim Globbing, sondern bei der Tilde-Erweiterung.

Globbing erfolgt nach Variablenerweiterung, wenn die Variable nicht in Anführungszeichen gesetzt ist, wie hier ^(*) :

$ x="/tm*" ; echo $x
/tmp

Auf die gleiche Weise ähnelt dies dem, was Sie getan haben und funktioniert:

$ mkdir -p ~/public/foo/ ; touch ~/public/foo/x.launch
$ i="$HOME/public/*"; j="*.launch"; k="$i/$j"
$ echo $k
/home/foo/public/foo/x.launch

Aber mit der Tilde tut es nicht:

$ i="~/public/*"; j="*.launch"; k="$i/$j"
$ echo $k
~/public/*/*.launch

Dies ist für Bash eindeutig dokumentiert :

Die Reihenfolge der Erweiterungen ist: Klammererweiterung; Tildeerweiterung, Parameter- und Variablenerweiterung, ...

Die Tildeerweiterung erfolgt vor der Variablenerweiterung, sodass Tilde in Variablen nicht erweitert werden. Die einfache Problemumgehung besteht darin, $HOMEstattdessen den vollständigen Pfad zu verwenden.

_{(* Das Erweitern von Globs aus Variablen ist normalerweise nicht das, was Sie wollen.)}

Etwas anderes:

Wenn Sie die Muster durchlaufen, wie hier:

exclude="foo *bar"
for j in $exclude ; do
    ...

Beachten Sie, dass es, wie $excludenicht zitiert, sowohl aufgeteilt als auch globalisiert ist. Wenn das aktuelle Verzeichnis also etwas enthält, das mit dem Muster übereinstimmt, wird es folgendermaßen erweitert:

$ i="$HOME/public/foo"
$ exclude="*.launch"
$ touch $i/real.launch
$ for j in $exclude ; do           # split and glob, no match
    echo "$i"/$j ; done
/home/foo/public/foo/real.launch

$ touch ./hello.launch
$ for j in $exclude ; do           # split and glob, matches in current dir!
    echo "$i"/$j ; done
/home/foo/public/foo/hello.launch  # not the expected result

Verwenden Sie eine Array-Variable anstelle einer geteilten Zeichenfolge, um dies zu umgehen:

$ exclude=("*.launch")
$ exclude+=("something else")
$ for j in "${exclude[@]}" ; do echo "$i"/$j ; done
/home/foo/public/foo/real.launch
/home/foo/public/foo/something else

Als zusätzlichen Bonus können Array-Einträge auch Leerzeichen ohne Probleme mit der Aufteilung enthalten.

Ähnliches könnte getan werden find -path, wenn es Ihnen egal ist, auf welcher Verzeichnisebene sich die Zieldateien befinden sollten. Zum Beispiel, um einen Pfad zu finden, der endet in /e2e/*.js:

$ dirs="$HOME/public $HOME/private"
$ pattern="*/e2e/*.js"
$ find $dirs -path "$pattern"
/home/foo/public/one/two/three/e2e/asdf.js

Wir müssen $HOMEstatt aus ~dem gleichen Grund wie zuvor verwenden und $dirsmüssen in der findBefehlszeile $patternnicht in Anführungszeichen gesetzt werden, damit es aufgeteilt wird, sollten aber in Anführungszeichen gesetzt werden, damit es nicht versehentlich durch die Shell erweitert wird.

(Ich denke, Sie könnten mit -maxdepthGNU find spielen, um zu begrenzen, wie tief die Suche geht, wenn es Sie interessiert, aber das ist ein etwas anderes Problem.)

Sie können es als Array anstelle einer Zeichenfolge speichern, um es später in vielen Fällen zu verwenden, und das Globbing beim Definieren zulassen. In Ihrem Fall zum Beispiel:

k=(~/code/public/*/*.launch)
for i in "${k[@]}"; do

oder im späteren Beispiel werden Sie evaleinige der Zeichenfolgen benötigen

dirs=(~/code/private/* ~/code/public/*)
for i in "${dirs[@]}"; do
    for j in $exclude; do
        eval "for k in $i/$j; do tmutil addexclusion \"\$k\"; done"
    done
done

@ilkkachu Antwort löste das Hauptproblem Globbing. Volle Ehre für ihn.

V1

Da excludeEinträge mit und ohne Platzhalter (*) enthalten sind und möglicherweise auch nicht in allen vorhanden sind, ist nach dem Verschieben von eine zusätzliche Überprüfung erforderlich $i/$j. Ich teile meine Erkenntnisse hier.

#!/bin/bash
exclude="
*.launch
.DS_Store
.classpath
.sass-cache
.settings
Thumbs.db
bower_components
build
connect.lock
coverage
dist
e2e/*.js
e2e/*.map
libpeerconnection.log
node_modules
npm-debug.log
testem.log
tmp
typings
"

dirs="
$HOME/code/private/*
$HOME/code/public/*
"

# loop $dirs
for i in $dirs; do
    for j in $exclude ; do
        for k in $i/$j; do
            echo -e "$k"
            if [ -f $k ] || [ -d $k ] ; then
                # Only execute command if dir/file exist
                echo -e "\t^^^ Above file/dir exist! ^^^"
            fi
        done
    done
done

Output Erklärung

Das Folgende ist die Teilausgabe, um die Situation zu erklären.

/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/a.launch
    ^^^ Above file/dir exist! ^^^
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/b.launch
    ^^^ Above file/dir exist! ^^^
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/.DS_Store
    ^^^ Above file/dir exist! ^^^

Die obigen Angaben sind selbsterklärend.

/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/.classpath
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/.sass-cache
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/.settings
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/Thumbs.db
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/bower_components
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/build
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/connect.lock
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/coverage
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/dist

Das obige wird angezeigt, da der Exclude-Eintrag ( $j) kein Platzhalterzeichen enthält und $i/$jeine einfache Zeichenfolgenverkettung ist. Die Datei / dir existiert jedoch nicht.

/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/e2e/*.js
/Volumes/HD2/JS/code/public/simple-api-example-ng2-express/e2e/*.map

Das oben $jgezeigte Ergebnis enthält als Eintrag ausschließen ( ) einen Platzhalter, hat aber keine Datei- / Verzeichnisübereinstimmung. Beim Verschieben von wird $i/$jnur die ursprüngliche Zeichenfolge zurückgegeben.

V2

V2 verwenden Sie einfache Anführungszeichen evalund shopt -s nullgloberhalten Sie ein sauberes Ergebnis. Keine Datei / Verzeichnis-Endkontrolle erforderlich.

#!/bin/bash
exclude='
*.launch
.sass-cache
Thumbs.db
bower_components
build
connect.lock
coverage
dist
e2e/*.js
e2e/*.map
libpeerconnection.log
node_modules
npm-debug.log
testem.log
tmp
typings
'

dirs='
$HOME/code/private/*
$HOME/code/public/*
'

for i in $dirs; do
    for j in $exclude ; do
        shopt -s nullglob
        eval "k=$i/$j"
        for l in $k; do
            echo $l
        done
        shopt -u nullglob
    done
done

Mit zsh:

exclude='
*.launch
.classpath
.sass-cache
Thumbs.db
...
'

dirs=(
~/code/private/*
~/code/public/*
)

for f ($^dirs/${^${=~exclude}}(N)) {
  echo $f
}

${^array}stringist zu erweitern als $array[1]string $array[2]string.... $=varist das Aufteilen von Wörtern auf die Variable (etwas, was andere Shells standardmäßig tun!), $~vardas Globbing auf die Variable (etwas, was andere Shells ebenfalls standardmäßig tun) (wenn Sie dies normalerweise nicht möchten, hätten Sie $foben in Anführungszeichen setzen müssen andere Muscheln)).

(N)ist ein Glob-Qualifizierer, der nullglob für jeden dieser aus dieser $^array1/$^array2Erweiterung resultierenden Globs aktiviert . Dadurch werden die Globs zu nichts, wenn sie nicht übereinstimmen. Das passiert auch, dass ein Nicht-Glob wie ~/code/private/foo/Thumbs.dbeiner wird, was bedeutet, dass, wenn dieser bestimmte nicht existiert, er nicht enthalten ist.