Comment extraire une plage prédéterminée de lignes d'un fichier texte sous Unix?

J'ai un vidage SQL de ~ 23000 lignes contenant plusieurs bases de données pour des données. J'ai besoin d'extraire une certaine section de ce fichier (c'est-à-dire les données d'une seule base de données) et de la placer dans un nouveau fichier. Je connais les numéros de ligne de début et de fin des données que je veux.

Quelqu'un connaît-il une commande Unix (ou une série de commandes) pour extraire toutes les lignes d'un fichier entre disons les lignes 16224 et 16482, puis les rediriger dans un nouveau fichier?

sed -n '16224,16482p;16483q' filename > newfile

Du manuel sed :

p - Imprimez l'espace du motif (sur la sortie standard). Cette commande n'est généralement utilisée qu'en conjonction avec l'option de ligne de commande -n.

n - Si l'impression automatique n'est pas désactivée, imprimez l'espace du motif, puis, malgré tout, remplacez l'espace du motif par la ligne d'entrée suivante. S'il n'y a plus d'entrée, sed quitte sans traiter d'autres commandes.

q - Quittez sedsans traiter d'autres commandes ou entrées. Notez que l'espace de motif actuel est imprimé si l'impression automatique n'est pas désactivée avec l'option -n.

et

Les adresses d'un script sed peuvent prendre l'une des formes suivantes:

nombre La spécification d'un numéro de ligne correspondra uniquement à cette ligne dans l'entrée.

Une plage d'adresses peut être spécifiée en spécifiant deux adresses séparées par une virgule (,). Une plage d'adresses correspond à des lignes à partir de l'endroit où la première adresse correspond et continue jusqu'à ce que la deuxième adresse corresponde (inclusivement).

sed -n '16224,16482 p' orig-data-file > new-file

Où 16224,16482 sont le numéro de ligne de départ et le numéro de ligne de fin, inclus. Ceci est indexé 1. -nsupprime l'écho de l'entrée comme sortie, ce que vous ne voulez clairement pas; les nombres indiquent la plage de lignes sur laquelle exécuter la commande suivante; la commande pimprime les lignes pertinentes.

Assez simple avec tête / queue:

head -16482 in.sql | tail -258 > out.sql

en utilisant sed:

sed -n '16482,16482p' in.sql > out.sql

en utilisant awk:

awk 'NR>=10&&NR<=20' in.sql > out.sql

Vous pouvez utiliser 'vi' puis la commande suivante:

:16224,16482w!/tmp/some-file

Alternativement:

cat file | head -n 16482 | tail -n 258

EDIT: - Juste pour ajouter une explication, vous utilisez head -n 16482 pour afficher les premières 16482 lignes puis utilisez tail -n 258 pour extraire les 258 dernières lignes de la première sortie.

Il existe une autre approche avec awk:

awk 'NR==16224, NR==16482' file

Si le fichier est volumineux, il peut être utile de exitlire la dernière ligne souhaitée. De cette façon, il ne lira pas inutilement les lignes suivantes:

awk 'NR==16224, NR==16482-1; NR==16482 {print; exit}' file

awk 'NR==16224, NR==16482; NR==16482 {exit}' file

perl -ne 'print if 16224..16482' file.txt > new_file.txt

 # print section of file based on line numbers
 sed -n '16224 ,16482p'               # method 1
 sed '16224,16482!d'                 # method 2

cat dump.txt | head -16224 | tail -258

devrait faire l'affaire. L'inconvénient de cette approche est que vous devez effectuer l'arithmétique pour déterminer l'argument de queue et pour savoir si vous voulez que «entre» inclue la ligne de fin ou non.

Debout sur les épaules de boxxar, j'aime ça:

sed -n '<first line>,$p;<last line>q' input

par exemple

sed -n '16224,$p;16482q' input

Cela $signifie "dernière ligne", donc la première commande fait sedimprimer toutes les lignes commençant par la ligne 16224et la deuxième commande fait sedquitter après l' impression de la ligne 16428. (Ajout 1pour leq plage -r dans la solution de boxxar ne semble pas nécessaire.)

J'aime cette variante car je n'ai pas besoin de spécifier deux fois le numéro de ligne de fin. Et j'ai mesuré que l'utilisation $n'a pas d'effets néfastes sur les performances.

sed -n '16224,16482p' < dump.sql

Rapide et sale:

head -16428 < file.in | tail -259 > file.out

Ce n'est probablement pas la meilleure façon de le faire, mais cela devrait fonctionner.

BTW: 259 = 16482-16224 + 1.

J'ai écrit un programme Haskell appelé splitter qui fait exactement cela: lire mon article de blog .

Vous pouvez utiliser le programme comme suit:

$ cat somefile | splitter 16224-16482

Et c'est tout ce qu'il y a à faire. Vous aurez besoin de Haskell pour l'installer. Juste:

$ cabal install splitter

Et vous avez terminé. J'espère que vous trouverez ce programme utile.

Même nous pouvons le faire pour vérifier en ligne de commande:

cat filename|sed 'n1,n2!d' > abc.txt

Par exemple:

cat foo.pl|sed '100,200!d' > abc.txt

Utilisation de rubis:

ruby -ne 'puts "#{$.}: #{$_}" if $. >= 32613500 && $. <= 32614500' < GND.rdf > GND.extract.rdf

J'étais sur le point de publier le truc tête / queue, mais en fait, je déclencherais probablement des emacs. ;-)

1. esc- xgoto-line ret16224
2. marque ( ctrl- space)
3. esc- xgoto-line ret16482
4. esc-w

ouvrir le nouveau fichier de sortie, ctl-y enregistrer

Voyons ce qui se passe.

J'utiliserais:

awk 'FNR >= 16224 && FNR <= 16482' my_file > extracted.txt

FNR contient le numéro d'enregistrement (ligne) de la ligne lue dans le fichier.

Je voulais faire la même chose à partir d'un script en utilisant une variable et je l'ai réalisé en mettant des guillemets autour de la variable $ pour séparer le nom de la variable du p:

sed -n "$first","$count"p imagelist.txt >"$imageblock"

Je voulais diviser une liste en dossiers séparés et trouvé la question initiale et répondre à une étape utile. (La commande split n'est pas une option sur l'ancien système d'exploitation sur lequel je dois porter le code).

J'ai écrit un petit script bash que vous pouvez exécuter à partir de votre ligne de commande, tant que vous mettez à jour votre PATH pour inclure son répertoire (ou vous pouvez le placer dans un répertoire qui est déjà contenu dans le PATH).

Utilisation: $ pinch filename start-line end-line

#!/bin/bash
# Display line number ranges of a file to the terminal.
# Usage: $ pinch filename start-line end-line
# By Evan J. Coon

FILENAME=$1
START=$2
END=$3

ERROR="[PINCH ERROR]"

# Check that the number of arguments is 3
if [ $# -lt 3 ]; then
    echo "$ERROR Need three arguments: Filename Start-line End-line"
    exit 1
fi

# Check that the file exists.
if [ ! -f "$FILENAME" ]; then
    echo -e "$ERROR File does not exist. \n\t$FILENAME"
    exit 1
fi

# Check that start-line is not greater than end-line
if [ "$START" -gt "$END" ]; then
    echo -e "$ERROR Start line is greater than End line."
    exit 1
fi

# Check that start-line is positive.
if [ "$START" -lt 0 ]; then
    echo -e "$ERROR Start line is less than 0."
    exit 1
fi

# Check that end-line is positive.
if [ "$END" -lt 0 ]; then
    echo -e "$ERROR End line is less than 0."
    exit 1
fi

NUMOFLINES=$(wc -l < "$FILENAME")

# Check that end-line is not greater than the number of lines in the file.
if [ "$END" -gt "$NUMOFLINES" ]; then
    echo -e "$ERROR End line is greater than number of lines in file."
    exit 1
fi

# The distance from the end of the file to end-line
ENDDIFF=$(( NUMOFLINES - END ))

# For larger files, this will run more quickly. If the distance from the
# end of the file to the end-line is less than the distance from the
# start of the file to the start-line, then start pinching from the
# bottom as opposed to the top.
if [ "$START" -lt "$ENDDIFF" ]; then
    < "$FILENAME" head -n $END | tail -n +$START
else
    < "$FILENAME" tail -n +$START | head -n $(( END-START+1 ))
fi

# Success
exit 0

Cela pourrait fonctionner pour vous (GNU sed):

sed -ne '16224,16482w newfile' -e '16482q' file

ou profiter de bash:

sed -n $'16224,16482w newfile\n16482q' file

Utilisation de ed:

ed -s infile <<<'16224,16482p'

-ssupprime la sortie de diagnostic; les commandes réelles sont dans une chaîne ici. Plus précisément, 16224,16482pexécute la pcommande (impression) sur la plage d'adresses de ligne souhaitée.

Le -n dans les réponses acceptées fonctionne. Voici une autre façon au cas où vous seriez enclin.

cat $filename | sed "${linenum}p;d";

Cela fait ce qui suit:

1. canalisez le contenu d'un fichier (ou introduisez le texte comme vous le souhaitez).
2. sed sélectionne la ligne donnée, l'imprime
3. d est requis pour supprimer les lignes, sinon sed supposera que toutes les lignes seront éventuellement imprimées. c'est-à-dire, sans le d, vous obtiendrez toutes les lignes imprimées par la ligne sélectionnée imprimées deux fois parce que vous avez la partie $ {linen} p demandant qu'elle soit imprimée. Je suis sûr que le -n fait essentiellement la même chose que le d ici.

Puisque nous parlons d'extraire des lignes de texte d'un fichier texte, je donnerai un cas spécial où vous voulez extraire toutes les lignes qui correspondent à un certain modèle.

myfile content:
=====================
line1 not needed
line2 also discarded
[Data]
first data line
second data line
=====================
sed -n '/Data/,$p' myfile

Imprime la ligne [Données] et le reste. Si vous voulez que le texte de la ligne 1 au motif, vous tapez: sed -n '1, / Data / p' monfichier. De plus, si vous connaissez deux modèles (mieux vaut être unique dans votre texte), les lignes de début et de fin de la plage peuvent être spécifiées avec des correspondances.

sed -n '/BEGIN_MARK/,/END_MARK/p' myfile