Alimente arquivos específicos da função do diretório

#!/bin/sh

set -- *_file.txt

until [ "$#" -lt 2 ]; do
    process "$1" "$2" >"output_${1%_file.txt}${2%_file.txt}"
    shift 2
done

Isso define os parâmetros posicionais para a lista de nomes de arquivo nos quais você está interessado, com base em um padrão de globbing de nome de arquivo correspondente aos nomes na pergunta. Em seguida, ele usa um loop para iterar sobre essa lista até que restem menos de dois nomes na lista ( $#é o comprimento da lista de parâmetros posicionais).

Em cada iteração, os dois primeiros elementos da lista, $1e $2, são processados ​​e então deslocados para fora da lista usando shift 2.

A saída do processamento é redirecionada para um arquivo nomeado output_seguido pela concatenação das partes variáveis ​​dos dois nomes de arquivo (o que estiver antes da _file.txtstring estática em cada um).

Isso pressupõe que os arquivos sejam nomeados de forma que a classificação dos nomes em ordem lexicográfica (o que a expansão do padrão globbing fará) resulte em uma lista de nomes que podem ser emparelhados da maneira mostrada na pergunta.

Você poderia fazer isso com o xargscomando. Se eu tiver esses arquivos:

$ ls
A_file.txt  B_file.txt  C_file.txt  D_file.txt  E_file.txt  F_file.txt  G_file.txt  H_file.txt

Então eu posso processar esses dois ao mesmo tempo assim:

$ find . -type f | xargs -n2 echo some_program
some_program ./A_file.txt ./B_file.txt
some_program ./C_file.txt ./D_file.txt
some_program ./E_file.txt ./F_file.txt
some_program ./G_file.txt ./H_file.txt

Aqui estou simplesmente chamando echo, mas é claro que você pode descartar o echoe realmente executar some_program. Isso processará dois arquivos por vez... mas não lida com a geração de um nome de arquivo de saída para cada chamada.

Se tornarmos um pouco mais elaborado, podemos gerar um arquivo com o nome do primeiro nome de arquivo de entrada:

find . -type f | xargs -n2 sh -c 'echo some_program $1 $2 > $1.output' --

Isso produzirá o arquivo A_file.txt.outputpara A_file.txte B_file.txt, C_File.txt.outputpara o próximo par e assim por diante. Você pode ficar mais sofisticado com o nome do arquivo de saída aplicando várias transformações; por exemplo, para obter o nome do arquivo que você pediu em sua pergunta, você pode escrever:

find . -type f | xargs -n2 sh -c 'echo some_program $1 $2 > output_${1:2:1}${2:2:1}' --

Isso gerará nomes de arquivos de saída output_AB, output_CD, etc.

Se mudar de bash para zsh for uma opção, então é só:

for i j ( *.txt(N) ) some_program -- $i $j > output_$i[1]$j[1]

(N)permite nullglob dessa expansão glob para não relatar um erro se não houver correspondência.

Se houver um número ímpar de arquivos, a última execução será executada com o $jconjunto para a string vazia. Como o deixamos sem aspas no argumento para some_program, isso resultará em nenhum argumento correspondente a ser passado para ele. Substitua por "$j"se preferir que um argumento vazio seja passado para ele nesse caso.

A *.txtexpansão estará em ordem alfabética; você pode alterar a ordem para o que quiser usando os qualificadores o, Oe/ou n glob .

Para um número arbitrário de arquivos em cada iteração, em vez de apenas 2:

files=( *.txt(N) ) n=5
while (( $#files )) {
  some_program -- $files[1,n] > output_${(Mj[])files[1,n]#?}
  files[1,5]=()
}

Ou usando zargs:

autoload -Uz zargs
process() some_program -- $@ > output_${(Mj[])@#?}
zargs -rl5 -- *.txt(N) -- process

Em ${(Mj[])array#?}, ${array#?}retiraria o caractere inicial de cada elemento do array, mas com M, o que é Manexado é retornado. O resultado é junificado com nada ( []), então você obtém uma string feita com o primeiro caractere de cada elemento.

Despeje a lista de arquivos em uma matriz e leia a partir dela.

#!/bin/bash
arr=( *.txt )
i=0
while [ $i -lt ${#arr[@]} ];
do
  echo ${arr[$i]} ${arr[ $[$i+1] ]}
  i=$[$i+2]
done

Se você tiver um número ímpar de arquivos, a solicitação ${arr[ $[$i+1] ]}fornecerá silenciosamente uma string vazia. Cabe a você decidir o que fazer neste caso.