Salta i primi 3 byte di un file

Sto usando la shell AIX 6.1 ksh.

Voglio usare una fodera per fare qualcosa del genere:

cat A_FILE | skip-first-3-bytes-of-the-file

Voglio saltare i primi 3 byte della prima riga; C'è un modo per fare questo?

Vecchia scuola - potresti usare dd:

dd if=A_FILE bs=1 skip=3

Il file di input è A_FILE, la dimensione del blocco è di 1 carattere (byte), salta i primi 3 'blocchi' (byte). (Con alcune varianti ddcome GNU dd, potresti usare bs=1cqui - e le alternative come bs=1kleggere in blocchi di 1 kilobyte in altre circostanze. ddSembra che su AIX non lo supporti; la variante BSD (macOS Sierra) non supporta cma supporta k, m, g, etc.)

Esistono anche altri modi per ottenere lo stesso risultato:

sed '1s/^...//' A_FILE

Funziona se ci sono 3 o più caratteri sulla prima riga.

tail -c +4 A_FILE

E potresti usare anche Perl, Python e così via.

Invece di usare catpuoi usare tailcome tale:

tail -c +4 FILE

Questo stamperà l'intero file ad eccezione dei primi 3 byte. Consultare man tailper ulteriori informazioni.

Di recente dovevo fare qualcosa di simile. Stavo aiutando con un problema di supporto sul campo e dovevo consentire a un tecnico di vedere i grafici in tempo reale mentre stavano apportando modifiche. I dati si trovano in un registro binario che cresce durante il giorno. Ho un software in grado di analizzare e tracciare i dati dai registri, ma al momento non è in tempo reale. Quello che ho fatto è stato acquisire la dimensione del registro prima di iniziare l'elaborazione dei dati, quindi andare in un ciclo che avrebbe elaborato i dati e ogni passaggio creava un nuovo file con i byte del file che non erano stati ancora elaborati.

#!/usr/bin/env bash

# I named this little script hackjob.sh
# The purpose of this is to process an input file and load the results into
# a database. The file is constantly being update, so this runs in a loop
# and every pass it creates a new temp file with bytes that have not yet been
# processed.  It runs about 15 seconds behind real time so it's
# pseudo real time.  This will eventually be replaced by a real time
# queue based version, but this does work and surprisingly well actually.

set -x

# Current data in YYYYMMDD fomat
DATE=`date +%Y%m%d`

INPUT_PATH=/path/to/my/data
IFILE1=${INPUT_PATH}/${DATE}_my_input_file.dat

OUTPUT_PATH=/tmp
OFILE1=${OUTPUT_PATH}/${DATE}_my_input_file.dat

# Capture the size of the original file
SIZE1=`ls -l ${IFILE1} | awk '{print $5}'`

# Copy the original file to /tmp
cp ${IFILE1} ${OFILE1}

while :
do
    sleep 5

    # process_my_data.py ${OFILE1}
    rm ${OFILE1}
    # Copy IFILE1 to OFILE1 minus skipping the amount of data already processed
    dd skip=${SIZE1} bs=1 if=${IFILE1} of=${OFILE1}
    # Update the size of the input file
    SIZE1=`ls -l ${IFILE1} | awk '{print $5}'`

    echo

    DATE=`date +%Y%m%d`

done

Se uno ha Python sul proprio sistema, si può usare un piccolo script Python per sfruttare la seek()funzione per iniziare a leggere all'ennesimo byte in questo modo:

#!/usr/bin/env python3
import sys
with open(sys.argv[1],'rb') as fd:
    fd.seek(int(sys.argv[2]))
    for line in fd:
        print(line.decode().strip())

E l'utilizzo sarebbe così:

$ ./skip_bytes.py input.txt 3

Si noti che il conteggio dei byte inizia da 0 (quindi il primo byte è in realtà indice 0), quindi specificando 3 stiamo effettivamente posizionando la lettura per iniziare a 3 + 1 = 4 ° byte