A que finalidade serve o cólon?

Eu hackeei muitos scripts shell e, às vezes, as coisas mais simples me confundem. Hoje, deparei-me com um script que fazia uso extensivo do :bash (dois pontos) incorporado.

A documenação parece bastante simples:

: (a colon)  
     : [arguments]  

Não faça nada além de expandir argumentos e executar redirecionamentos. O status de retorno é zero.

No entanto, eu já vi isso apenas em demonstrações de expansão de shell. O caso de uso no script que eu deparei fez uso extensivo dessa estrutura:

if [ -f ${file} ]; then
    grep some_string ${file} >> otherfile || :
    grep other_string ${file} >> otherfile || :
fi

Na verdade, havia centenas de greps, mas são apenas mais do mesmo. Nenhum redirecionamento de entrada / saída está presente além da estrutura simples acima. Nenhum valor de retorno é verificado posteriormente no script.

Estou lendo isso como uma construção inútil que diz "ou não faça nada". Qual o propósito de terminar com esses "cumprimentos" ou "não fazer nada"? Em que caso essa construção causaria um resultado diferente do que simplesmente deixar de fora || :todas as instâncias?

Parece que os :s no seu script estão sendo usados ​​no lugar true. Se grepnão encontrar uma correspondência no arquivo, ele retornará um código de saída diferente de zero; como jw013 menciona em um comentário, se errexitestiver definido, provavelmente -ena linha shebang, o script sairá se algum dos greps falhar em encontrar uma correspondência. Claramente, não era isso que o autor queria, então ele adicionou || :para tornar o status de saída desse comando composto sempre zero, como o mais comum (na minha experiência) || true/ || /bin/true.

O :built-in também é útil com a expansão do shell "atribuir valores padrão" do Bash, onde a expansão é frequentemente usada apenas para o efeito colateral e o valor expandido é descartado:

# assign FOO=bar iff FOO is unset
: ${FOO:=bar}

Posso pensar em dois lugares que usei :no passado.

while :
do
     shell commands
     some exit condition
done

Esse é um ciclo para sempre.

function doSomethingStub {
    :
}

Coloque uma função de esboço, apenas para corrigir o fluxo de controle de nível superior.

Um uso que eu já vi nos velhos tempos: em vez de uma #!/bin/sh(ou qualquer outra) linha, você veria uma :linha. Alguns dos kernels do Real Unix mais antigos ou shells do Real Unix usariam isso para significar "eu sou um script de shell, eles devem me executar". Pelo que me lembro, foi exatamente quando o csh estava fazendo incursões como um shell interativo comum.

O :built-in já estava no shell Thompson - foi documentado para o Unix V6 em 1975. No shell Thompson, :indicou um rótulo para o gotocomando. Se você nunca tentou chamar gotouma linha iniciada por : , essa linha era efetivamente um comentário.

O shell Bourne , o ancestral dos shells Bourne / POSIX como os conhecemos, nunca teve um gotoque eu saiba, mas foi mantido :como um comando não operacional (já estava presente no Unix V7 ).

Eu descobri uma referência antiga: "O ambiente de programação UNIX" (c) 1984 por Kernighan e Pike.

A página 147 (Programação de shell) diz o seguinte:

":" é um comando interno do shell que não faz nada além de avaliar seus argumentos e retornar "true". Em vez disso [referindo-se a um exemplo de script], poderíamos ter usado true , que simplesmente retorna um status de saída verdadeiro. (Também existe um comando falso .) Mas ':' é mais eficiente que verdadeiro porque não executa um comando do sistema de arquivos . [Itálico / ênfase é minha.]

Parece que me lembro que as versões anteriores do shell não tinham uma sintaxe de comentário. Uma linha iniciada com :(que provavelmente teria sido um executável real, semelhante a /bin/true) teria sido a melhor alternativa.

Aqui está uma página de manual para o antigo shell Thompson (sem relação); não há menção a nenhuma sintaxe de comentário.

":" é útil para depuração.

DEBUGLOG=": debugfunction"

statement
statement
$DEBUGLOG arg1 arg2 ...
statement
statement

Executando normalmente, a função de depuração nunca é executada, portanto, basta passar por cima do noop (variáveis ​​e curingas são expandidos). Se for necessária uma depuração mais aprofundada, remova o noop da variável e a função de depuração será chamada com os argumentos necessários.

Outro uso útil é como um comentário em bloco, que é um recurso ausente da sintaxe do shell.

: << COMMENT
all --statements --in --here
are now -a here document which are
passed to --the noop
COMMENT