Come può Bash rinominare una serie di pacchetti per rimuovere i loro numeri di versione? Ho giocato con entrambi expre %%, inutilmente.

Esempi:

Xft2-2.1.13.pkg diventa Xft2.pkg

jasper-1.900.1.pkg diventa jasper.pkg

xorg-libXrandr-1.2.3.pkg diventa xorg-libXrandr.pkg

Potresti usare la funzione di espansione dei parametri di bash

for i in ./*.pkg ; do mv "$i" "${i/-[0-9.]*.pkg/.pkg}" ; done

Le virgolette sono necessarie per i nomi di file con spazi.

Se tutti i file si trovano nella stessa directory, la sequenza

ls | 
sed -n 's/\(.*\)\(-[0-9.]*\.pkg\)/mv "\1\2" "\1.pkg"/p' | 
sh

farà il tuo lavoro. Il comando sed creerà una sequenza di comandi mv , che puoi quindi inserire nella shell. È meglio eseguire prima la pipeline senza il trailing in | shmodo da verificare che il comando faccia quello che vuoi.

Per ricorrere a più directory usa qualcosa di simile

find . -type f |
sed -n 's/\(.*\)\(-[0-9.]*\.pkg\)/mv "\1\2" "\1.pkg"/p' |
sh

Si noti che in sed la sequenza di raggruppamento delle espressioni regolari è costituita da parentesi quadre precedute da una barra rovesciata \(e \), anziché da singole parentesi (e ).

Farò qualcosa di simile:

for file in *.pkg ; do
    mv $file $(echo $file | rev | cut -f2- -d- | rev).pkg
done

suppone che tutti i tuoi file siano nella directory corrente. In caso contrario, prova a utilizzare Trova come consigliato sopra da Javier.

EDIT : Inoltre, questa versione non utilizza alcuna funzionalità specifica di bash, come altre sopra, il che ti porta a una maggiore portabilità.

Ecco un POSIX quasi equivalente della risposta attualmente accettata . Questo scambia l' ${variable/substring/replacement}espansione dei parametri solo Bash con una disponibile in qualsiasi shell compatibile con Bourne.

for i in ./*.pkg; do
    mv "$i" "${i%-[0-9.]*.pkg}.pkg"
done

L'espansione del parametro ${variable%pattern}produce il valore di variablecon qualsiasi suffisso che corrisponde a patternrimosso. (C'è anche ${variable#pattern}da rimuovere un prefisso.)

Ho mantenuto lo schema secondario -[0-9.]*dalla risposta accettata anche se forse è fuorviante. Non è un'espressione regolare, ma un modello glob; quindi non significa "un trattino seguito da zero o più numeri o punti". Invece, significa "un trattino, seguito da un numero o un punto, seguito da qualsiasi cosa". Il "qualsiasi cosa" sarà la partita più breve possibile, non la più lunga. (Bash offre ##e %%per ritagliare il prefisso o il suffisso più lungo possibile, piuttosto che il più breve.)

Possiamo presumere che sedsia disponibile su qualsiasi * nix, ma non possiamo essere sicuri che supporterà la sed -ngenerazione di comandi mv. ( NOTA: solo GNU lo sedfa.)

Anche così, bash builtins e sed, possiamo creare rapidamente una funzione di shell per farlo.

sedrename() {
  if [ $# -gt 1 ]; then
    sed_pattern=$1
    shift
    for file in $(ls $@); do
      mv -v "$file" "$(sed $sed_pattern <<< $file)"
    done
  else
    echo "usage: $0 sed_pattern files..."
  fi
}

uso

sedrename 's|\(.*\)\(-[0-9.]*\.pkg\)|\1\2|' *.pkg

before:

./Xft2-2.1.13.pkg
./jasper-1.900.1.pkg
./xorg-libXrandr-1.2.3.pkg

after:

./Xft2.pkg
./jasper.pkg
./xorg-libXrandr.pkg

Creazione di cartelle di destinazione:

Poiché mvnon crea automaticamente cartelle di destinazione, non possiamo utilizzare la nostra versione iniziale di sedrename.

È un cambiamento abbastanza piccolo, quindi sarebbe bello includere questa funzionalità:

Avremo bisogno di una funzione di utilità, abspath(o percorso assoluto) poiché bash non ha questa build.

abspath () { case "$1" in
               /*)printf "%s\n" "$1";;
               *)printf "%s\n" "$PWD/$1";;
             esac; }

Una volta ottenuto ciò, possiamo generare le cartelle di destinazione per un pattern sed / rename che include una nuova struttura di cartelle.

Ciò garantirà che conosciamo i nomi delle nostre cartelle di destinazione. Quando rinomineremo, dovremo usarlo sul nome del file di destinazione.

# generate the rename target
target="$(sed $sed_pattern <<< $file)"

# Use absolute path of the rename target to make target folder structure
mkdir -p "$(dirname $(abspath $target))"

# finally move the file to the target name/folders
mv -v "$file" "$target"

Ecco lo script completo di riconoscimento delle cartelle ...

sedrename() {
  if [ $# -gt 1 ]; then
    sed_pattern=$1
    shift
    for file in $(ls $@); do
      target="$(sed $sed_pattern <<< $file)"
      mkdir -p "$(dirname $(abspath $target))"
      mv -v "$file" "$target"
    done
  else
    echo "usage: $0 sed_pattern files..."
  fi
}

Ovviamente funziona anche quando non abbiamo cartelle di destinazione specifiche.

Se volessimo mettere tutte le canzoni in una cartella, ./Beethoven/possiamo farlo:

uso

sedrename 's|Beethoven - |Beethoven/|g' *.mp3

before:

./Beethoven - Fur Elise.mp3
./Beethoven - Moonlight Sonata.mp3
./Beethoven - Ode to Joy.mp3
./Beethoven - Rage Over the Lost Penny.mp3

after:

./Beethoven/Fur Elise.mp3
./Beethoven/Moonlight Sonata.mp3
./Beethoven/Ode to Joy.mp3
./Beethoven/Rage Over the Lost Penny.mp3

Round bonus ...

Utilizzando questo script per spostare i file dalle cartelle in una singola cartella:

Supponendo di voler raccogliere tutti i file corrispondenti e inserirli nella cartella corrente, possiamo farlo:

sedrename 's|.*/||' **/*.mp3

before:

./Beethoven/Fur Elise.mp3
./Beethoven/Moonlight Sonata.mp3
./Beethoven/Ode to Joy.mp3
./Beethoven/Rage Over the Lost Penny.mp3

after:

./Beethoven/ # (now empty)
./Fur Elise.mp3
./Moonlight Sonata.mp3
./Ode to Joy.mp3
./Rage Over the Lost Penny.mp3

Nota sui pattern di espressioni regolari sed

In questo script si applicano le regole dei pattern sed regolari, questi pattern non sono PCRE (Perl Compatible Regular Expressions). Potresti avere sed esteso la sintassi delle espressioni regolari, usando o sed -ro a sed -E seconda della tua piattaforma.

Vedere la conformità POSIX man re_formatper una descrizione completa dei pattern regexp di base ed estesi di sed.

Trovo che rinominare sia uno strumento molto più semplice da usare per questo genere di cose. L'ho trovato su Homebrew per OSX

Per il tuo esempio farei:

rename 's/\d*?\.\d*?\.\d*?//' *.pkg

La 's' significa sostituto. Il modulo è s / searchPattern / replacement / files_to_apply. È necessario utilizzare regex per questo che richiede un po 'di studio ma ne vale la pena.

uso migliore sedper questo, qualcosa come:

find . -type f -name "*.pkg" |
 sed -e 's/((.*)-[0-9.]*\.pkg)/\1 \2.pkg/g' |
 while read nameA nameB; do
    mv $nameA $nameB;
 done

capire l'espressione regolare è lasciato come esercizio (come si tratta di nomi di file che includono spazi)

Questo sembra funzionare supponendo che

• tutto finisce con $ pkg
• la tua versione # inizia sempre con un "-"

togliere il .pkg, quindi rimuovere - ..

for x in $(ls); do echo $x $(echo $x | sed 's/\.pkg//g' | sed 's/-.*//g').pkg; done

Avevo più *.txtfile da rinominare come .sqlnella stessa cartella. sotto ha funzionato per me:

for i in \`ls *.txt | awk -F "." '{print $1}'\` ;do mv $i.txt $i.sql; done

Grazie per queste risposte. Ho anche avuto qualche problema. Spostamento di file .nzb. Accodati in file .nzb. Aveva spazi e altri cruft nei nomi dei file e questo ha risolto il mio problema:

find . -type f -name "*.nzb.queued" |
sed -ne "s/^\(\(.*\).nzb.queued\)$/mv -v \"\1\" \"\2.nzb\"/p" |
sh

Si basa sulla risposta di Diomidis Spinellis.

L'espressione regolare crea un gruppo per l'intero nome del file e un gruppo per la parte prima di .nzb.queued e quindi crea un comando di spostamento della shell. Con le stringhe citate. Questo evita anche di creare un ciclo nello script di shell perché questo è già fatto da sed.