Existe uma maneira de fazer "mv" falhar silenciosamente?

Um comando como mv foo* ~/bar/produz essa mensagem no stderr se não houver arquivos correspondentes foo*.

mv: cannot stat `foo*': No such file or directory

No entanto, no script em que estou trabalhando nesse caso, ficaria bem e gostaria de omitir essa mensagem de nossos logs.

Existe alguma maneira agradável de dizer mvpara ficar quieto, mesmo que nada tenha sido movido?

Você está procurando por isso?

$ mv  file dir/
mv: cannot stat ‘file’: No such file or directory
$ mv  file dir/ 2>/dev/null
# <---- Silent ----->

Na verdade, não acho que o silêncio mvé uma boa abordagem (lembre-se de que você também pode denunciar outras coisas que podem ser interessantes ... por exemplo, em falta ~/bar). Você deseja silenciá-lo apenas no caso de sua expressão glob não retornar resultados. De fato, prefiro não executá-lo.

[ -n "$(shopt -s nullglob; echo foo*)" ] && mv foo* ~/bar/

Não parece muito atraente e funciona apenas em bash.

OU

[ 'foo*' = "$(echo foo*)" ] || mv foo* ~/bar/

somente exceto se você estiver bashcom o nullglobconjunto. Você paga um preço de 3x a repetição do padrão glob.

find . -maxdepth 1 -name 'foo*' -type f -print0 | xargs -0r mv -t ~/bar/

- O GNU mvpossui uma boa opção "destination first" ( -t) e xargspode pular a execução de seu comando se não houver entrada ( -r). Usar -print0e -0correspondentemente garante que não haja confusão quando os nomes de arquivos contiverem espaços e outras coisas "engraçadas".

É importante perceber que, na verdade, é o shell que o expande foo*para a lista de nomes de arquivos correspondentes, para que haja pouco o mvque fazer.

O problema aqui é que, quando um glob não corresponde, algumas conchas como bash(e a maioria das conchas semelhantes a Bourne, esse comportamento de buggy foi realmente introduzido pelo shell Bourne no final dos anos 70) passam o padrão literalmente para o comando.

Portanto, aqui, quando foo*não corresponde a nenhum arquivo, em vez de interromper o comando (como os shells pré-Bourne e vários shells modernos), o shell passa um foo*arquivo literal para mv, basicamente pedindo mvpara mover o arquivo chamado foo*.

Esse arquivo não existe. Se isso acontecesse, ele realmente corresponderia ao padrão, então mvrelata um erro. Se o padrão tivesse sido foo[xy]substituído, mvpoderia mover acidentalmente um arquivo chamado em foo[xy]vez dos arquivos fooxe fooy.

Agora, mesmo nos shells que não têm esse problema (pré-Bourne, csh, tcsh, fish, zsh, bash -O failglob), você ainda receberia um erro mv foo* ~/bar, mas desta vez pelo shell.

Se você quiser considerar que não é um erro, se não houver nenhum arquivo correspondente foo*e, nesse caso, não mover nada, você deve criar a lista de arquivos primeiro (de uma maneira que não cause erro, usando a nullglobopção de algumas conchas) e, em seguida, apenas chamar mvé a lista não está vazia.

Isso seria melhor do que ocultar todos os erros mv(como adicionar 2> /dev/null) como se mvfalhasse por qualquer outro motivo, você provavelmente ainda desejaria saber o motivo.

em zsh

files=(foo*(N)) # where the N glob qualifier activates nullglob for that glob
(($#files == 0)) || mv -- $files ~/bar/

Ou use uma função anônima para evitar o uso de uma variável temporária:

() { (($# == 0)) || mv -- "$@" ~/bar/; } foo*(N)

zshé um daqueles shells que não possuem o bug Bourne e relatam um erro sem executar o comando quando um glob não corresponde (e a nullglobopção não foi ativada), então aqui, você pode ocultar zsho erro e restaurar stderr para mvque você ainda veja os mverros, se houver, mas não o erro sobre os globs não correspondentes:

(mv 2>&3 foo* ~/bar/) 3>&2 2>&-

Ou você pode usar o zargsque também evitaria problemas se a foo*glob se expandisse para arquivos demais.

autoload zargs # best in ~/.zshrc
zargs -r -- foo* -- mv -t ~/bar # here assuming GNU mv for its -t option

No ksh93:

files=(~(N)foo*)
((${#files[#]} == 0)) || mv -- "${files[@]}" ~/bar/

Na festança:

bashnão possui sintaxe para ativar nullglobapenas um glob, e a failglobopção é cancelada nullglob, sendo necessário itens como:

saved=$(shopt -p nullglob failglob) || true
shopt -s nullglob
shopt -u failglob
files=(foo*)
((${#files[@]} == 0)) || mv -- "${files[@]}" ~/bar/
eval "$saved"

ou defina as opções em um subshell para salvar, salve-as antes e restaure-as depois.

(
  shopt -s nullglob
  shopt -u failglob
  files=(foo*)
  ((${#files[@]} == 0)) || mv -- "${files[@]}" ~/bar/
)

No yash

(
  set -o nullglob
  files=(foo*)
  [ "${#files[@]}" -eq 0 ] || mv -- "${files[@]}" ~/bar/
)

No fish

No shell do peixe, o comportamento nullglob é o padrão para o setcomando, portanto, é apenas:

set files foo*
count $files > /dev/null; and mv -- $files ~/bar/

POSIXly

Não há nullglobopção no POSIX she nenhuma matriz além dos parâmetros posicionais. Existe um truque que você pode usar para detectar se um glob corresponde ou não:

set -- foo[*] foo*
if [ "$1$2" != 'foo[*]foo*' ]; then
  shift
  mv -- "$@" ~/bar/
fi

Usando a foo[*]e foo*glob, podemos diferenciar entre o caso em que não há arquivo correspondente e aquele em que há um arquivo que é chamado foo*(o que set -- foo*não poderia ser feito).

Mais leitura:

• Por que nullglob não é o padrão?
• essa discussão relacionada na lista de discussão do Austin Group (o Austin Group é o corpo que mantém a especificação POSIX)

Provavelmente não é o melhor, mas você pode usar o findcomando para verificar se a pasta está vazia ou não:

find "foo*" -type f -exec mv {} ~/bar/ \;

Estou assumindo que você está usando o bash, porque esse erro depende do comportamento do bash para expandir globs incomparáveis ​​para si mesmos. (Em comparação, o zsh gera um erro ao tentar expandir um globo incomparável.)

Então, e a seguinte solução alternativa?

ls -d foo* >/dev/null 2>&1 && mv foo* ~/bar/

Isso ignorará silenciosamente o mvif ls -d foo*falhar, enquanto ainda registrará erros se ls foo*for bem-sucedido, mas mvfalhar. (Cuidado, ls foo*pode falhar por outros motivos que foo*não existem, por exemplo, direitos insuficientes, problemas com o FS, etc., para que essas condições sejam silenciosamente ignoradas por esta solução.)

Você pode fazer por exemplo

mv 1>/dev/null 2>&1 foo* ~/bar/ ou mv foo* ~/bar/ 1&>2

Para mais detalhes, consulte: http://mywiki.wooledge.org/BashFAQ/055

Você pode trapacear (portably) com perl:

perl -e 'system "mv foo* ~/bar/" if glob "foo*"'

Se você vai usar o Perl, é melhor ir até o fim:

#!/usr/bin/perl
use strict;
use warnings;
use File::Copy;

my $target = "$ENV{HOME}/bar/";

foreach my $file (<foo*>) {
    move $file, $target  or warn "Error moving $file to $target: $!\n";
}

ou como uma linha:

perl -MFile::Copy -E 'move $_, "$ENV{HOME}/bar/" or warn "$_: $!\n" for <foo*>'

(Para detalhes do movecomando, consulte a documentação para File :: Copy .)

Em vez de

mv foo* ~/bar/

você pode fazer

cp foo* ~/bar/
rm foo* 

Simples, legível :)

mv foo* ~/bar/ 2>/dev/null

Se o comando Above é bem-sucedido ou não, podemos encontrar pelo status de saída do comando anterior

command: echo $?

se a saída de eco $? é diferente de 0 significa comando sem êxito se a saída for 0 significa comando com êxito