La plus fantastique moyen de supprimer les retours à la ligne (en Perl

Après avoir creusé un peu à travers la perlre docs un peu, je vais vous présenter mes meilleurs suggestion de la mesure qui semble fonctionner assez bien. Perl 5.10 ajout de la \R caractère de classe généralisée saut de ligne:

$line =~ s/\R//g;

C'est la même chose que:

(?>\x0D\x0A?|[\x0A-\x0C\x85\x{2028}\x{2029}])

Je vais garder cette question ouverte un certain temps encore, juste pour voir si il y a de plus chouette des moyens en attente d'être suggéré.

Lecture perlport je proposerais quelque chose comme

$line =~ s/
$line =~ s/\015?\012?$//;15?
$line =~ s/\015?\012?$//;12?$//;

pour être sûr de la plateforme qui vous êtes et ce que le saut de ligne style, vous pouvez être le traitement, car ce qui est dans \r et \n peuvent différer par le biais de différents Perl saveurs.

Note à partir de 2017: File::Slurp n'est pas recommandée en raison des erreurs de conception et laissés à l'abandon des erreurs. Utilisation Fichier::Slurper ou Chemin D'Accès::Minuscule à la place.

l'extension de votre réponse à la question

use File::Slurp ();
my $value = File::Slurp::slurp($filename);
$value =~ s/\R*//g;

Fichier::Slurp résumés loin le Fichier IO trucs et retourne une chaîne de caractères pour vous.

NOTE

1. Important de noter l'ajout de /g , sans elle, donné un multi-ligne de chaîne, il ne fera que remplacer le première délinquance de caractère.

2. Aussi, la suppression de $, qui est redondante dans ce but, que nous voulons à la bande tous les sauts de ligne, et pas seulement des sauts de lignes avant ce que l'on entend par $ sur cet OS.

3. Dans un multi-ligne de chaîne, $ correspond à la fin de la chaîne et qui serait problématique ).

4. Point 3 signifie que le point 2 est fait avec l'hypothèse que vous voulez également utiliser /m sinon, ' $ ' serait essentiellement de sens pour quelque chose de pratique dans une chaîne de caractères avec >1 lignes, ou, faire la seule ligne de traitement, un système d'exploitation qui, en fait, comprend $ et parvient à trouver les \R* que procéder la $

Exemples

while( my $line = <$foo> ){
      $line =~ $regex;
}

Donné les notations ci-dessus, un système d'exploitation qui ne permet pas de comprendre quels que soient vos fichiers '\n' ou '\r' délimiteurs, dans le scénario par défaut avec le système d'exploitation par défaut de délimiteur défini pour $/ entraînera dans la lecture de votre fichier entier comme une seule chaîne de caractères ( à moins que votre chaîne a le $OS de délimiteurs, où elle permettra de délimiter par qui )

Dans ce cas, l'ensemble de ces regex sont inutiles:

• /\R*$// : Efface uniquement la dernière séquence de \R dans le fichier
• /\R*// : Efface uniquement la première séquence de \R dans le fichier

• /\012?\015?// : Quand seulement effacer la première 012\015 , \012 , ou \015 séquence, \015\012 entraînera soit \012 ou \015 émis.

• /\R*$// : Si il arrive à être pas les séquences d'octets de "\015$OSDELIMITER' dans le fichier, puis ensuite PAS mais les sauts de ligne seront supprimés, sauf pour les OS propres.

Il semblerait que personne ne comprend de quoi je parle, voici donc un exemple de code, c'est-à testé à PAS supprimer les sauts de ligne. L'exécutez, vous verrez qu'il laisse les sauts de ligne dans.

#!/usr/bin/perl 
use strict;
use warnings;
my $fn = 'TestFile.txt';
my $LF = "\012";
my $CR = "\015";
my $UnixNL = $LF;
my $DOSNL  = $CR . $LF;
my $MacNL  = $CR;
sub generate { 
my $filename = shift;
my $lineDelimiter = shift;
open my $fh, '>', $filename;
for ( 0 .. 10 )
{
print $fh "{0}";
print $fh join "", map { chr( int( rand(26) + 60 ) ) } 0 .. 20;
print $fh "{1}";
print $fh $lineDelimiter->();
print $fh "{2}";
}
close $fh;
}
sub parse { 
my $filename = shift;
my $osDelimiter = shift;
my $message = shift;
print "Parsing $message File $filename : \n";
local $/ = $osDelimiter;
open my $fh, '<', $filename;
while ( my $line = <$fh> )
{
$line =~ s/\R*$//;
print ">|" . $line . "|<";
}
print "Done.\n\n";
}
my @all = ( $DOSNL,$MacNL,$UnixNL);
generate 'Windows.txt' , sub { $DOSNL }; 
generate 'Mac.txt' , sub { $MacNL };
generate 'Unix.txt', sub { $UnixNL };
generate 'Mixed.txt', sub {
return @all[ int(rand(2)) ];
};
for my $os ( ["$MacNL", "On Mac"], ["$DOSNL", "On Windows"], ["$UnixNL", "On Unix"]){
for ( qw( Windows Mac Unix Mixed ) ){
parse $_ . ".txt", @{ $os };
}
}

Pour la CLAIREMENT non Transformés de sortie, voir ici: http://pastebin.com/f2c063d74

Note il y a certaines combinaisons de travaux de cours, mais ils sont probablement ceux que vous avez vous-même naívely testé.

Noter que, dans cette sortie, tous les résultats doivent être de la forme >|$string|<>|$string|< avec PAS de LIGNE de FLUX pour être considérée comme valide de sortie.

et $string est de la forme générale {0}$data{1}$delimiter{2} où, dans toutes les sources de sortie, il devrait y avoir :

1. Rien entre {1} et {2}
2. seulement |<>| entre {1} et {2}

D'étendre Ted Cambron la réponse ci-dessus, et quelque chose qui n'a pas été abordé ici: Si vous supprimez tous les sauts de ligne sans discernement à partir d'un morceau de texte saisi, vous allez vous retrouver avec les paragraphes les uns des autres, sans espaces, lors de la sortie de ce texte plus tard. C'est ce que j'utilise:

sub cleanLines{
my $text = shift;
$text =~ s/\r//; #replace \r with space
$text =~ s/\n//; #replace \n with space
$text =~ s/  / /g; #replace double-spaces with single space
return $text;
}

La dernière substitution utilise le g "avides" modificateur de sorte qu'il continue à trouver les doubles espaces jusqu'à ce qu'il remplace tous. (En fait, la substitution de quelque chose de plus que le seul espace)