pfnuesel's questions

Eu tenho um script, que não faz nada útil além de executar os argumentos posicionais. (Estou ciente dos riscos de segurança e o script não faz nada útil porque é um exemplo de trabalho mínimo.)

$ cat script
> #!/usr/bin/env bash
>
> eval "${*}"


$ cat "docu ment"
> Lorem ipsum dolor sit amet

O que eu gostaria de fazer é chamar o script com ./script cat "docu ment", ou ./script cat docu\ ment, mas as aspas ou o caractere de escape desaparecem e o script tentará cat docu ment, o que não funciona. Como eu corrigiria a cotação em tal caso?

EDIT: O que eu realmente quero fazer é invocar um comando quantas vezes até retornar um código de saída bem-sucedido ou tentar n vezes. Meu script está assim:

#!/usr/bin/env bash

# Try command several times, until it reports success (exit code 0)
# or I give up (tried n times)

tryMax=10
try=1

# Do until loop in bash
while
    eval "${@}"
    exitcode="${?}"
    [[ "${exitcode}" -ne 0 && "${try}" -lt "${tryMax}" ]]
do (( try++ ))
done

if [[ "${exitcode}" -ne 0 ]]; then
    echo -n "I tried hard, but did not manage to make this work. The exit code "
    echo "of the last iteration of this command was: ${exitcode}."
    exit "${exitcode}"
fi

eu tenho uma função

f(){
    echo 777
}

e uma variável à qual atribuo o "valor de retorno" da função.

x=$(f)

Muito conciso! No entanto, no meu código real, os nomes de variáveis ​​e funções são um pouco mais longos e a função também consome argumentos posicionais, de modo que a linha concisa acima fica muito longa. Como gosto de manter as coisas organizadas, gostaria de dividir o código acima em duas linhas.

x=\
$(f)

Ainda funciona! Mas: manter as coisas arrumadas também significa respeitar o recuo, então isso dá algo como

if foo
    x=\
    $(f)
fi

que não funciona mais devido a espaços em branco! Existe uma boa solução para isso?

Digamos que eu tenha uma variável e queira imprimir 5 dígitos significativos depois de multiplicá-la por 1000 zsh.

zsh$ x=2.8026407e+00
zsh$ printf "%.5g\n" "$(( 1000*${x} ))"
zsh> 2802.6

Pode bashfazê-lo também?

bash$ x=2.8026407e+00
bash$ printf "%.5g\n" "$(( 1000*${x} ))"
bash> bash: 1000*2.8026407e+00 : syntax error: invalid arithmetic operator (error token is ".8026407e+00 ")

Eu acho que não há como fazer o bash nativo entender as operações de ponto flutuante, não é? Eu sei que posso usar, por exemplo awk, mas eu queria saber se bashpoderia fazer isso ou não.

(Não estou surpreso que bashnão possa lidar com carros alegóricos, mas isso zshpode!)

Eu quero fazer um tarball de um diretório, mas excluindo todos os arquivos que terminam com .foo, exceto um arquivo específico. Isso exclui todos os arquivos com .fooo final:

tar czf "${nameTarball}" dir/ --exclude '*.foo'

O que estou perdendo é algum tipo de --includeopção. Isto existe? Estou usando o GNU tar 1.23.

Como ele substitui meu histórico quando usado em vários terminais, desejo desativar a funcionalidade fc -W. Infelizmente, tenho o hábito de digitá-lo com frequência.

Acho que não é possível fazer um alias, pois há um espaço em branco no arquivo fc -W.

Então eu tentei fazer uma função, algo assim:

# Make sure to never invoke fc -W
fc(){
    for x; do
        if [[ "${x}" == -W ]]; then
            echo "I'm sorry Dave. I'm afraid I can't do that."
            return
        fi
    done
    fc "${@}"
}

No entanto, agora a chamada fc "${@}"chama a si mesma e obtenho recursão infinita. Normalmente, eu evitaria isso usando, por exemplo /usr/bin/fc, em vez de fc, no entanto:

$ type fc
> fc is a shell builtin

Como posso evitar a recursão infinita neste caso? Ou existe uma maneira melhor de desabilitar um sinalizador de um comando?

Acabei de perceber que um fluxo de trabalho que venho usando há anos não faz o que deveria fazer. Como não percebi isso por tanto tempo, você pode pensar que não vale a pena colocar muito esforço nisso, mas acontece que agora isso se tornou um tanto importante.

Do que estou falando? Ok, estou tmuxrodando com várias sessões e cada sessão tem janelas diferentes e assim por diante. Trabalhar assim é maravilhoso. Há uma desvantagem nisso, no entanto. Quando o servidor é reiniciado, por qualquer motivo, ele fecha todas as minhas sessões. Justo, não pode ser evitado e não acontece com frequência. No entanto, a parte chata é que todo o meu zshor bash historytambém se foi. Isto é um problema. Eu confio na minha história, talvez demais.

Eu estava contornando esse problema pressionando fc -W(in zsh) de vez em quando. Achei que isso acrescentaria o histórico que está na memória e só perderia a parte entre minha última invocação fc -We a reinicialização do servidor. Mas não é isso que ele faz. Se eu usar fc -Wem uma janela, então fc -Wem outra, o histórico da primeira janela será substituído pelo histórico da segunda janela. Eu precisaria usar fc -Rprimeiro, mas isso duplicaria todo o histórico... basicamente eu estava usando mal o fccomando o tempo todo.

Aqui está a pergunta: Como posso ter certeza de não perder nada do meu histórico quando estou dentro tmuxe há um corte repentino de energia? Observação:

• Eu uso história infinita, caso isso importe.
• Perder parte do histórico não tem problema, ou seja, se eu tiver que invocar um comando manualmente (ou em um cronjob) e perder a parte do histórico desde a última execução do comando, tudo bem.
• Sair do terminal e abrir um novo não é a solução.
• Não quero armazenar meus comandos diretamente no histórico, pois isso mistura diferentes históricos.
• Soluções para ambos bashe zshsão bem-vindas. zshé preferível.

Editar: destaque a parte que todos parecem não entender.