Comment imprimer la plus longue ligne dans un fichier?

Je cherche la méthode la plus simple pour imprimer la plus longue ligne d'un fichier. J'ai fait quelques recherches sur Google et, étonnamment, je n'ai pas semblé trouver de réponse. J'imprime fréquemment la longueur de la plus longue ligne d'un fichier, mais je ne sais pas comment imprimer la plus longue ligne. Quelqu'un peut-il fournir une solution pour imprimer la plus longue ligne d'un fichier? Merci d'avance.

cat ./text | awk ' { if ( length > x ) { x = length; y = $0 } }END{ print y }'

UPD : résumant tous les conseils dans les commentaires

awk 'length > max_length { max_length = length; longest_line = $0 } END { print longest_line }' ./text 

cat filename | awk '{ print length }' | sort -n | tail -1

sed -rn "/.{$(<file expand -t1 |wc -L)}/{p;q}" file

Ceci lit d'abord le fichier à l'intérieur de la substitution de commande et affiche la longueur de la plus longue ligne (auparavant, expandconvertit les tabulations en espaces pour surmonter la sémantique de wc -L- chaque tabulation de la ligne ajoutera 8 au lieu de 1 à la longueur de la ligne). Cette longueur est ensuite utilisée dans une sedexpression signifiant "trouver une ligne de ce nombre de caractères, l'imprimer, puis quitter". Cela peut donc être aussi optimal que la plus longue ligne se trouve en haut du fichier, heheh (merci pour les commentaires impressionnants et constructifs).

Un autre, j'avais pensé plus tôt que le sed (en bash):

#!/bin/bash
while read -r line; do
    (( ${#line} > max )) && max=${#line} && longest="$line"
done
echo "$longest"

Voici une solution Perl:

perl -e 'while(<>){
           $l=length;  
           $l>$m && do {$c=$_; $m=$l}  
         } print $c' file.txt 

Ou, si vous voulez imprimer toutes les lignes les plus longues

perl -e 'while(<>){
           $l=length;
           push @{$k{$l}},$_;
           $m=$l if $l>$m;
         } print @{$k{$m}}' file.txt 

Comme je n'avais rien de mieux à faire, j'ai effectué des tests sur un fichier texte 625M. Étonnamment, ma solution Perl était toujours plus rapide que les autres. Certes, la différence avec la awksolution acceptée est minime, mais elle est là. Évidemment, les solutions imprimant plusieurs lignes étant plus lentes, j'ai donc trié par type, du plus rapide au plus lent.

N'imprimez qu'une des plus longues lignes:

$ time perl -e 'while(<>){
           $l=length;  
           $l>$m && do {$c=$_; $m=$l}  
         } print $c' file.txt 
real    0m3.837s
user    0m3.724s
sys     0m0.096s



$ time awk 'length > max_length { max_length = length; longest_line = $0 }
 END { print longest_line }' file.txt
real    0m5.835s
user    0m5.604s
sys     0m0.204s



$ time sed -rn "/.{$(<file.txt expand -t1 |wc -L)}/{p;q}" file.txt 
real    2m37.348s
user    2m39.990s
sys     0m1.868s

Imprimer toutes les lignes les plus longues:

$ time perl -e 'while(<>){
           $l=length;
           push @{$k{$l}},$_;
           $m=$l if $l>$m;
         } print @{$k{$m}}' file.txt 
real    0m9.263s
user    0m8.417s
sys     0m0.760s


$ time awk 'length >x { delete y; x=length }
     length==x { y[NR]=$0 } END{ for (z in y) print y[z] }' file.txt
real    0m10.220s
user    0m9.925s
sys     0m0.252s


## This is Chris Down's bash solution
$ time ./a.sh < file.txt 
Max line length: 254
Lines matched with that length: 2
real    8m36.975s
user    8m17.495s
sys     0m17.153s

Grep la première ligne la plus longue

grep -Em1 "^.{$(wc -L <file.txt)}\$" file.txt 

La commande est inhabituellement difficile à lire sans pratique, car elle mélange la syntaxe shell et regexp.
Pour l'explication, je vais d'abord utiliser le pseudocode simplifié. Les lignes commençant par ##ne sont pas exécutées dans le shell.
Ce code simplifié utilise le nom de fichier F et laisse de côté les citations et des parties de regexps pour des raisons de lisibilité.

Comment ça marche

La commande a deux parties, une grep- et une wcinvocation:

## grep "^.{$( wc -L F )}$" F

Le wcest utilisé dans une extension de processus $( ... ), il est donc exécuté avant grep. Il calcule la longueur de la plus longue ligne. La syntaxe d'expansion du shell est mélangée à la syntaxe du modèle d'expression régulière d'une manière qui prête à confusion, donc je décomposerai l'extension du processus:

## wc -L F
42
## grep "^.{42}$" F

Ici, l’extension du processus a été remplacée par la valeur qu’elle renverrait, créant la grepligne de commande utilisée. Nous pouvons maintenant lire l’expression régulière plus facilement: elle correspond exactement de start ( ^) à end ( $) de la ligne. L'expression entre eux correspond à n'importe quel caractère sauf newline, répété 42 fois. Combinées, il s’agit de lignes comportant exactement 42 caractères.

Revenons maintenant aux commandes réelles du shell: L' grepoption -E( --extended-regexp) permet de ne pas échapper à la {}lisibilité. Option -m 1( --max-count=1) le fait s'arrêter après la première ligne. Le <dans la wccommande écrit le fichier dans son stdin, pour empêcher l' wcimpression du nom du fichier avec la longueur.

Quelles lignes les plus longues?

Pour rendre les exemples plus lisibles avec le nom de fichier apparaissant deux fois, je vais utiliser une variable fpour le nom de fichier; Chacun $fdans l'exemple pourrait être remplacé par le nom du fichier.

f="file.txt"

Affiche la première ligne la plus longue - la première ligne aussi longue que la plus longue:

grep -E -m1 "^.{$(wc -L <"$f")}\$" "$f"

Afficher toutes les lignes les plus longues - toutes les lignes aussi longues que la ligne la plus longue:

grep -E "^.{$(wc -L <"$f")}\$" "$f" 

Affiche la dernière ligne la plus longue - la dernière ligne aussi longue que la ligne la plus longue:

tac "$f" | grep -E -m1 "^.{$(wc -L <"$f")}\$"

Afficher la ligne la plus longue unique - la ligne la plus longue plus longue que toutes les autres lignes, ou échouer:

[ $(grep -E "^.{$(wc -L <"$f")}\$" "$f" | wc -l) = 1 ] && grep -E "^.{$(wc -L <"$f")}\$" "$f" 

(La dernière commande est encore plus inefficace que les autres, car elle répète la commande grep complète. Elle doit évidemment être décomposée de manière à ce que la sortie wcet les lignes écrites par grepsoient enregistrées dans des variables.
Notez que toutes les lignes les plus longues peuvent en réalité être toutes les lignes. Pour enregistrer dans une variable, seules les deux premières lignes doivent être conservées.)

L'exemple suivant allait être, et aurait dû être, un commentaire sur la réponse de dmitry.malikov , mais à cause de l' utilisation inutile de l'espace de commentaire visible ici, j'ai choisi de le présenter ici, où il sera au moins visible. ..

Ceci est une simple variante de la méthode awk à passe unique de dmitry .
Il imprime toutes les lignes "égales les plus longues". (Remarque. delete arrayEst une extension gawk).

awk 'length >x { delete y; x=length }
     length==x { y[NR]=$0 } END{ for (z in y) print y[z] }' file

En pure bash:

#!/bin/bash

_max_length=0
while IFS= read -r _line; do
    _length="${#_line}"
    if (( _length > _max_length )); then
        _max_length=${_length}
        _max_line=( "${_line}" )
    elif (( _length == _max_length )); then
        _max_line+=( "${_line}" )
    fi
done

printf 'Max line length: %d\n' "${_max_length}"
printf 'Lines matched with that length: %d\n' "${#_max_line[@]}"
(( ${#_max_line[@]} )) && printf '%s\n' '----------------' "${_max_line[@]}"

J'ai développé un petit script shell pour cela. Il affiche la longueur, le numéro de ligne et le trait lui-même par longueur dépassant une taille donnée, telle que 80 caractères:

#!/bin/sh

# Author: Surinder

if test $# -lt 2
then
   echo "usage: $0 length file1 file2 ..."
   echo "usage: $0 80 hello.c"
   exit 1
fi

length=$1

shift

LONGLINE=/tmp/longest-line-$$.awk

cat << EOF > $LONGLINE
  BEGIN {
  }

  /.*/ {
    current_length=length(\$0);
    if (current_length >= expected_length) {
       printf("%d at line # %d %s\n", current_length, NR, \$0);
    }
  }

  END {
  }
EOF

for file in $*
do
  echo "$file"
  cat $file | awk -v expected_length=$length -f $LONGLINE |sort -nr
done

rm $LONGLINE

https://github.com/lordofrain/tools/blob/master/longest-line/longest-line.sh

Vous pouvez utiliser wc:

wc -L fileName