Início / unix / Perguntas / 776361
Accepted
Yuki San
Asked: 2024-05-13 14:43:48 +0800 CST

como desduplicar o bloco (timestamp + comando) do histórico do bash?

  • 772

Estou trabalhando com um arquivo bash_history contendo blocos com o seguinte formato:#unixtimestamp\ncommand\n

aqui está um exemplo do arquivo bash_history:

#1713308636
cat > ./initramfs/init << "EOF"
#!/bin/sh
/bin/sh
EOF
#1713308642
file initramfs/init
#1713308686
cpio -v -t -F init.cpio
#1713308689
cpio -v -t -F init.cpio
#1713308690
ls
#1713308691
ls

Meu objetivo é desduplicar totalmente os blocos, ou seja, tanto o carimbo de data/hora quanto os comandos associados. Tentei usar awk, mas essa abordagem processa as linhas individualmente, não as considerando como parte de um bloco.

Ouvi dizer que o uso ignoredupsevita a desduplicação, mas não funcionará neste caso ( a menos que você digite novamente o comando exato ) porque o comando duplicado já está lá.

Eu apreciaria sugestões sobre uma maneira mais eficaz de conseguir essa desduplicação.

EDIT: conforme sugerido por Ed Morton no comentário, aqui está o resultado esperado:

#1713308636
cat > ./initramfs/init << "EOF"
#!/bin/sh
/bin/sh
EOF
#1713308642
file initramfs/init
#1713308686
cpio -v -t -F init.cpio
#1713308690
ls

como solução alternativa, adiciono a funcionalidade de exclusão a este programa . mas ainda estou aberto a outras abordagens que usam comandos existentes.

bash

2 respostas

  1. Você não mostrou sua tentativa no awk, mas o seguinte programa awk imprime entradas no sentido de

    #[number]
[command consisting of one or more lines]

    onde o comando é único. O programa é:

    # dedup.awk
/^#[[:digit:]]+$/ {
    if (length(body) > 0)
    {
        if (!bodies[body])
        {
            bodies[body] = 1
            print header body
        }
        body = ""
    }
    in_header = 1
}

{
    if (in_header)
    {
        header = $0
        in_header = 0
        next
    }
    body = body "\n" $0
}

    A saída:

    $ cat test.file
#1713308636
cat > ./initramfs/init << "EOF"
#!/bin/sh
/bin/sh
EOF
#1713308642
file initramfs/init
#1713308686
cpio -v -t -F init.cpio
#1713308689
cpio -v -t -F init.cpio
#1713308690
ls
#1713308691
ls
$ awk -f dedup.awk test.file
#1713308636
cat > ./initramfs/init << "EOF"
#!/bin/sh
/bin/sh
EOF
#1713308642
file initramfs/init
#1713308686
cpio -v -t -F init.cpio
#1713308690
ls

    Observe que caso os "comandos" como

    $ #12345678

    são salvos no arquivo, o programa awk acima irá simplesmente ignorá-los, por exemplo:

    $ cat test.file.2
#1234512312
#1231231233
#1231231231
cd
#1237192388
ls
#1231231231
cd
$ awk -f dedup.awk test.file.2
#1231231231
cd
#1237192388
ls

    O programa pode ser ajustado para acomodar casos como este, mas requer especificação mais precisa do problema. Por exemplo, como lidar com:

    #1234512312
#1231231233
#1231231231
#1231231233
#1231231231
#1231231233
#1231231231
cd
#1237192388
ls
#1231231231
cd
    • 3
  2. Best Answer

    Usando Perl, você pode fazer:

    perl -ge '
    @u = map {
        $c = $_;
        $c =~ s/^#[0-9]{10}\n//;

        exists($d{$c}) ?
            () :
            ($d{$c} = 1 && $_)
        ;
    } <> =~ /^#[0-9]{10}\n.*?(?=^#[0-9]{10}\n|\z)/smg;

    print join("", @u);
' in

    A grande suposição é que isso ^#[0-9]{10}\nsempre identificará positivamente o início de uma entrada no arquivo.

    O comando é um pouco denso, mas a lógica por trás dele é:

    • Leia "em";
    • Dividir em registros, utilizando ^#[0-9]{10}\ncomo separador de registros, sem consumir o separador ( <> =~ /^#[0-9]{10}\n.*?(?=^#[0-9]{10}\n|\z)/smg);
    • Processar todos os registros;
    • Para cada registro, remova o separador (a linha lincluindo o carimbo de data/hora); se o restante (o comando) estiver em uma lista de comandos já processados, ignore-o, caso contrário armazene o comando exclusivo do separador na lista de comandos já processados ​​e armazene o comando inclusive o separador em uma matriz;
    • Junte os elementos do array em uma string vazia, imprimindo a string resultante.

    Detalhamento do regex:

    • ^#[0-9]{10}\n.*?(?=^#[0-9]{10}\n|\z): corresponderá a uma linha começando com um #caractere, seguido por 10 dígitos e uma nova linha; ele irá então corresponder preguiçosamente a qualquer coisa (incluindo novas linhas) até que uma nova ocorrência ^#[0-9]{10}\nou o final da string ( \z) seja encontrada (evitando capturar a ocorrência recém-encontrada de ^#[0-9]{10}\nna correspondência atual usando uma asserção antecipada de comprimento zero ( ?=) e permitindo que a próxima partida o capture); spermitirá .combinar novas linhas, mpermitirá ^e $combinará antes e depois de uma nova linha e gpermitirá capturar múltiplas ocorrências do padrão na string.

    Funciona bem na sua entrada de amostra; Também testei com comandos vazios (um carimbo de data/hora após outro carimbo de data/hora).

    Se forem encontradas entradas duplicadas, a primeira entrada será mantida e as posteriores serão descartadas.

    % cat in
#1713308636
cat > ./initramfs/init << "EOF"
#!/bin/sh
/bin/sh
EOF
#1713308642
file initramfs/init
#1713308686
cpio -v -t -F init.cpio
#1713308689
cpio -v -t -F init.cpio
#1713308690
ls
#1713308691
ls
% perl -ge '
        my @u = map {
                $c = $_;                                                                                                              
                $c =~ s/^#[0-9]{10}\n//;

                exists($d{$c}) ? () : ($d{$c} = 1 && $_);
        } <> =~ /^#[0-9]{10}\n.*?(?=^#[0-9]{10}\n|\z)/smg;

        print join("", @u);
' in
#1713308636
cat > ./initramfs/init << "EOF"
#!/bin/sh
/bin/sh
EOF
#1713308642
file initramfs/init
#1713308686
cpio -v -t -F init.cpio
#1713308690
ls
    • 1

relate perguntas