A tubulação, deslocamento ou expansão de parâmetros é mais eficiente?

• Primeira regra de otimização de software: não .

  Até que você saiba que a velocidade do programa é um problema, não há necessidade de pensar em quão rápido ele é. Se sua lista tiver esse tamanho ou apenas cerca de 100 a 1.000 itens, você provavelmente nem perceberá quanto tempo leva. Há uma chance de você estar gastando mais tempo pensando na otimização do que na diferença.
  
  

• Segunda regra: Medir .

  Essa é a maneira certa de descobrir, e aquela que dá respostas para o seu sistema. Especialmente com conchas, existem muitas e nem todas são idênticas. Uma resposta para um shell pode não se aplicar ao seu.

  Em programas maiores, a criação de perfil também ocorre aqui. A parte mais lenta pode não ser a que você pensa que é.
  
  

• Terceiro, a primeira regra de otimização de script de shell: não use o shell .

  Sim, realmente. Muitos shells não são feitos para serem rápidos (já que o lançamento de programas externos não precisa ser), e eles podem até analisar as linhas do código-fonte novamente a cada vez.

  Use algo como awk ou Perl. Em um micro-benchmark trivial que fiz, awkfoi dezenas de vezes mais rápido do que qualquer shell comum na execução de um loop simples (sem E/S).

  No entanto, se você usar o shell, use as funções internas do shell em vez de comandos externos. Aqui, você está usando o exprque não está embutido em nenhum shell que encontrei no meu sistema, mas que pode ser substituído pela expansão aritmética padrão. Por exemplo i=$((i+1)), em vez de i=$(expr $i + 1)incrementar i. Seu uso de cutno último exemplo também pode ser substituído por expansões de parâmetros padrão.

  Veja também: Por que usar um loop de shell para processar texto é considerado uma prática ruim?

Os passos 1 e 2 devem se aplicar à sua pergunta.

Bem simples com awk. Isso fornecerá o valor de cada quarto campo para entrada de qualquer comprimento:

$ awk -F' ' '{for( i=1;i<=NF;i+=3) { printf( "%s%s", $i, OFS ) }; printf( "\n" ) }' <<< $list
1 5 6 9 15

Isso funciona aproveitando awkvariáveis ​​internas como NF(o número de campos no registro) e fazendo alguns loops simples forpara iterar ao longo dos campos para fornecer os que você deseja sem precisar saber com antecedência quantos serão.

Ou, se você realmente deseja apenas esses campos específicos, conforme especificado em seu exemplo:

$ awk -F' ' '{ print $1, $4, $7, $10, $13 }' <<< $list
1 5 6 9 15

Quanto à questão sobre eficiência, o caminho mais simples seria testar este ou cada um de seus outros métodos e usar timepara mostrar quanto tempo leva; você também pode usar ferramentas como stracever como as chamadas do sistema fluem. Uso de timese parece com:

$ time ./script.sh

real    0m0.025s
user    0m0.004s
sys     0m0.008s

Você pode comparar essa saída entre vários métodos para ver qual é o mais eficiente em termos de tempo; outras ferramentas podem ser usadas para outras métricas de eficiência.

Vou apenas dar alguns conselhos gerais nesta resposta, e não referências. Os benchmarks são a única maneira de responder de forma confiável a perguntas sobre desempenho. Mas como você não diz quantos dados você está manipulando e com que frequência você executa essa operação, não há como fazer um benchmark útil. O que é mais eficiente para 10 itens e o que é mais eficiente para 1000.000 itens geralmente não é o mesmo.

Como regra geral, invocar comandos externos é mais caro do que fazer algo com construções de shell puro, desde que o código de shell puro não envolva um loop. Por outro lado, um loop de shell que itera em uma string grande ou em uma grande quantidade de string provavelmente será mais lento do que uma invocação de uma ferramenta de propósito especial. Por exemplo, sua invocação de loop cutpode ser notavelmente lenta na prática, mas se você encontrar uma maneira de fazer tudo com uma única cutinvocação, provavelmente será mais rápido do que fazer a mesma coisa com a manipulação de strings no shell.

Observe que o ponto de corte pode variar muito entre os sistemas. Pode depender do kernel, de como o escalonador do kernel está configurado, do sistema de arquivos que contém os executáveis ​​externos, de quanta pressão de CPU vs memória existe no momento e muitos outros fatores.

Não ligue exprpara fazer aritmética se estiver preocupado com o desempenho. Na verdade, não ligue exprpara fazer cálculos aritméticos. Os shells têm aritmética integrada, que é mais clara e rápida do que invocar expr.

Você parece estar usando bash, já que está usando construções bash que não existem em sh. Então, por que diabos você não usaria uma matriz? Uma matriz é a solução mais natural e provavelmente a mais rápida também. Observe que os índices de matriz começam em 0.

list=(1 2 3 5 9 8 6 90 84 9 3 2 15 75 55)
for ((count = 0; count += 3; count < ${#list[@]})); do
  echo "${list[$count]}"
done

Seu script pode ser mais rápido se você usar sh, se seu sistema tiver dash ou ksh as em shvez de bash. Se você usar sh, não obterá arrays nomeados, mas ainda obterá um array de parâmetros posicionais, que pode ser definido com set. Para acessar um elemento em uma posição que não é conhecida até o tempo de execução, você precisa usar eval(cuide de citar as coisas corretamente!).

# List elements must not contain whitespace or ?*\[
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
set $list
count=1
while [ $count -le $# ]; do
  eval "value=\${$count}"
  echo "$value"
  count=$((count+1))
done

Se você quiser acessar o array apenas uma vez e estiver indo da esquerda para a direita (pulando alguns valores), você pode usar shiftem vez de índices de variáveis.

# List elements must not contain whitespace or ?*\[
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
set $list
while [ $# -ge 1 ]; do
  echo "$1"
  shift && shift && shift
done

Qual abordagem é mais rápida depende do shell e do número de elementos.

Outra possibilidade é usar o processamento de strings. Tem a vantagem de não usar os parâmetros posicionais, então você pode usá-los para outra coisa. Será mais lento para grandes quantidades de dados, mas é improvável que faça uma diferença notável para pequenas quantidades de dados.

# List elements must be separated by a single space (not arbitrary whitespace)
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
while [ -n "$list" ]; do
  echo "${list% *}"
  case "$list" in *\ *\ *\ *) :;; *) break;; esac
  list="${list#* * * }"
done

awké uma ótima escolha, se você puder fazer todo o seu processamento dentro do script Awk. Caso contrário, você acaba canalizando a saída do Awk para outros utilitários, destruindo o ganho de desempenho do awk.

basha iteração sobre uma matriz também é ótima, se você puder encaixar sua lista inteira dentro da matriz (o que para shells modernos provavelmente é uma garantia) e não se importar com a ginástica de sintaxe de matriz.

No entanto, uma abordagem de pipeline:

xargs -n3 <<< "$list" | while read -ra a; do echo $a; done | grep 9

Onde:

• xargsagrupa a lista separada por espaços em branco em lotes de três, cada nova linha separada
• while readconsome essa lista e gera a primeira coluna de cada grupo
• grepfiltra a primeira coluna (correspondente a cada terceira posição na lista original)

Melhora a compreensão, na minha opinião. As pessoas já sabem o que essas ferramentas fazem, então é fácil ler da esquerda para a direita e raciocinar sobre o que vai acontecer. Essa abordagem também documenta claramente o comprimento da passada ( -n3) e o padrão de filtro ( 9), por isso é fácil variar:

count=3
find=9
xargs -n "$count" <<< "$list" | while read -ra a; do echo $a; done | grep "$find"

Quando fazemos perguntas de "eficiência", não se esqueça de pensar em "eficiência total ao longo da vida". Esse cálculo inclui o esforço dos mantenedores para manter o código funcionando, e nós, sacos de carne, somos as máquinas menos eficientes em toda a operação.

Talvez isso?

cut -d' ' -f1,4,7,10,13 <<<$list
1 5 6 9 15

Não use comandos shell se quiser ser eficiente. Limite-se a pipes, redirecionamentos, substituições, etc., e programas. É por isso que xargsexistem parallelutilitários - porque bash while loops são ineficientes e muito lentos. Use loops bash apenas como a última resolução.

list="1 ant bat 5 cat dingo 6 emu fish 9 gecko hare 15 i j"
if 
    <<<"$list" tr -d -s '[0-9 ]' | 
    tr -s ' ' | tr ' ' '\n' | 
    grep -q -x '9'
then
    found=true
else 
    found=false
fi
echo ${found} 

Mas você provavelmente deve ficar um pouco mais rápido com bom awk.

Na minha opinião, a solução mais clara (e provavelmente a de melhor desempenho também) é usar as variáveis ​​RS e ORS awk:

awk -v RS=' ' -v ORS=' ' 'NR % 3 == 1' <<< "$list"

1. Usando o shell script GNU sed e POSIX :

   echo $(printf '%s\n' $list | sed -n '1~3p')
   

2. Ou com basha substituição de parâmetro de :

   echo $(sed -n '1~3p' <<< ${list// /$'\n'})
   

3. Não - GNU ( ou seja , POSIX ) sed, e bash:

   sed 's/\([^ ]* \)[^ ]* *[^ ]* */\1/g' <<< "$list"
   

   Ou mais portátil, usando ambos POSIX sed e script de shell:

   echo "$list" | sed 's/\([^ ]* \)[^ ]* *[^ ]* */\1/g'
   

Saída de qualquer um destes:

1 5 6 9 15