Ho un file con -|come delimitatore dopo ogni sezione ... è necessario creare file separati per ogni sezione utilizzando unix.

esempio di file di input

wertretr
ewretrtret
1212132323
000232
-|
ereteertetet
232434234
erewesdfsfsfs
0234342343
-|
jdhg3875jdfsgfd
sjdhfdbfjds
347674657435
-|

Risultato previsto nel file 1

wertretr
ewretrtret
1212132323
000232
-|

Risultato previsto nel file 2

ereteertetet
232434234
erewesdfsfsfs
0234342343
-|

Risultato previsto nel file 3

jdhg3875jdfsgfd
sjdhfdbfjds
347674657435
-|

Una linea, nessuna programmazione. (tranne la regexp ecc.)

csplit --digits=2  --quiet --prefix=outfile infile "/-|/+1" "{*}"

testato su: csplit (GNU coreutils) 8.30

Note sull'utilizzo su Apple Mac

"Per gli utenti di OS X, nota che la versione csplitfornita con il sistema operativo non funziona. Ti consigliamo la versione in coreutils (installabile tramite Homebrew), che si chiama gcsplit." - @Danial

"Solo per aggiungere, puoi far funzionare la versione per OS X (almeno con High Sierra). Devi solo modificare un po 'gli argomenti csplit -k -f=outfile infile "/-\|/+1" "{3}". Le caratteristiche che non sembrano funzionare sono "{*}", dovevo essere specifico su il numero di separatori e necessario aggiungere -kper evitare che cancelli tutti i file in uscita se non riesce a trovare un separatore finale. Inoltre, se lo desideri --digits, devi -ninvece usarlo . " - @Pebbl

awk '{f="file" NR; print $0 " -|"> f}' RS='-\\|'  input-file

Spiegazione (modificata):

RSè il separatore di record e questa soluzione utilizza un'estensione gnu awk che gli consente di contenere più di un carattere. NRè il numero di record.

L'istruzione print stampa un record seguito da " -|"in un file che contiene il numero di record nel suo nome.

Debian lo ha csplit, ma non so se sia comune a tutte / la maggior parte / altre distribuzioni. In caso contrario, però, non dovrebbe essere troppo difficile rintracciare il sorgente e compilarlo ...

Ho risolto un problema leggermente diverso, in cui il file contiene una riga con il nome dove dovrebbe andare il testo che segue. Questo codice perl fa il trucco per me:

#!/path/to/perl -w

#comment the line below for UNIX systems
use Win32::Clipboard;

# Get command line flags

#print ($#ARGV, "\n");
if($#ARGV == 0) {
    print STDERR "usage: ncsplit.pl --mff -- filename.txt [...] \n\nNote that no space is allowed between the '--' and the related parameter.\n\nThe mff is found on a line followed by a filename.  All of the contents of filename.txt are written to that file until another mff is found.\n";
    exit;
}

# this package sets the ARGV count variable to -1;

use Getopt::Long;
my $mff = "";
GetOptions('mff' => \$mff);

# set a default $mff variable
if ($mff eq "") {$mff = "-#-"};
print ("using file switch=", $mff, "\n\n");

while($_ = shift @ARGV) {
    if(-f "$_") {
    push @filelist, $_;
    } 
}

# Could be more than one file name on the command line, 
# but this version throws away the subsequent ones.

$readfile = $filelist[0];

open SOURCEFILE, "<$readfile" or die "File not found...\n\n";
#print SOURCEFILE;

while (<SOURCEFILE>) {
  /^$mff (.*$)/o;
    $outname = $1;
#   print $outname;
#   print "right is: $1 \n";

if (/^$mff /) {

    open OUTFILE, ">$outname" ;
    print "opened $outname\n";
    }
    else {print OUTFILE "$_"};
  }

Il seguente comando funziona per me. Spero che sia d'aiuto.

awk 'BEGIN{file = 0; filename = "output_" file ".txt"}
    /-|/ {getline; file ++; filename = "output_" file ".txt"}
    {print $0 > filename}' input

Puoi anche usare awk. Non ho molta familiarità con awk, ma quanto segue sembra funzionare per me. Ha generato part1.txt, part2.txt, part3.txt e part4.txt. Nota che l'ultimo file partn.txt che questo genera è vuoto. Non sono sicuro di come risolverlo, ma sono sicuro che potrebbe essere fatto con un piccolo ritocco. Qualcuno ha suggerimenti?

file awk_pattern:

BEGIN{ fn = "part1.txt"; n = 1 }
{
   print > fn
   if (substr($0,1,2) == "-|") {
       close (fn)
       n++
       fn = "part" n ".txt"
   }
}

comando bash:

awk -f awk_pattern input.file

Ecco uno script Python 3 che divide un file in più file in base a un nome file fornito dai delimitatori. File di input di esempio:

# Ignored

######## FILTER BEGIN foo.conf
This goes in foo.conf.
######## FILTER END

# Ignored

######## FILTER BEGIN bar.conf
This goes in bar.conf.
######## FILTER END

Ecco lo script:

#!/usr/bin/env python3

import os
import argparse

# global settings
start_delimiter = '######## FILTER BEGIN'
end_delimiter = '######## FILTER END'

# parse command line arguments
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--input-file", required=True, help="input filename")
parser.add_argument("-o", "--output-dir", required=True, help="output directory")

args = parser.parse_args()

# read the input file
with open(args.input_file, 'r') as input_file:
    input_data = input_file.read()

# iterate through the input data by line
input_lines = input_data.splitlines()
while input_lines:
    # discard lines until the next start delimiter
    while input_lines and not input_lines[0].startswith(start_delimiter):
        input_lines.pop(0)

    # corner case: no delimiter found and no more lines left
    if not input_lines:
        break

    # extract the output filename from the start delimiter
    output_filename = input_lines.pop(0).replace(start_delimiter, "").strip()
    output_path = os.path.join(args.output_dir, output_filename)

    # open the output file
    print("extracting file: {0}".format(output_path))
    with open(output_path, 'w') as output_file:
        # while we have lines left and they don't match the end delimiter
        while input_lines and not input_lines[0].startswith(end_delimiter):
            output_file.write("{0}\n".format(input_lines.pop(0)))

        # remove end delimiter if present
        if not input_lines:
            input_lines.pop(0)

Finalmente ecco come lo esegui:

$ python3 script.py -i input-file.txt -o ./output-folder/

Usalo csplitse ce l'hai.

Se non lo fai, ma hai Python ... non usare Perl.

Lettura pigra del file

Il tuo file potrebbe essere troppo grande per essere conservato in memoria tutto in una volta - la lettura riga per riga potrebbe essere preferibile. Supponiamo che il file di input si chiami "samplein":

$ python3 -c "from itertools import count
with open('samplein') as file:
    for i in count():
        firstline = next(file, None)
        if firstline is None:
            break
        with open(f'out{i}', 'w') as out:
            out.write(firstline)
            for line in file:
                out.write(line)
                if line == '-|\n':
                    break"

cat file| ( I=0; echo -n "">file0; while read line; do echo $line >> file$I; if [ "$line" == '-|' ]; then I=$[I+1]; echo -n "" > file$I; fi; done )

e la versione formattata:

#!/bin/bash
cat FILE | (
  I=0;
  echo -n"">file0;
  while read line; 
  do
    echo $line >> file$I;
    if [ "$line" == '-|' ];
    then I=$[I+1];
      echo -n "" > file$I;
    fi;
  done;
)

Questo è il tipo di problema per cui ho scritto la suddivisione del contesto: http://stromberg.dnsalias.org/~strombrg/context-split.html

$ ./context-split -h
usage:
./context-split [-s separator] [-n name] [-z length]
        -s specifies what regex should separate output files
        -n specifies how output files are named (default: numeric
        -z specifies how long numbered filenames (if any) should be
        -i include line containing separator in output files
        operations are always performed on stdin

Ecco un codice Perl che farà la cosa

#!/usr/bin/perl
open(FI,"file.txt") or die "Input file not found";
$cur=0;
open(FO,">res.$cur.txt") or die "Cannot open output file $cur";
while(<FI>)
{
    print FO $_;
    if(/^-\|/)
    {
        close(FO);
        $cur++;
        open(FO,">res.$cur.txt") or die "Cannot open output file $cur"
    }
}
close(FO);