Suppresseur de lignes en double

Qu'est-ce que la suppression de lignes en double ?

La suppression de lignes en double est le processus qui consiste à parcourir un bloc de texte ligne par ligne et à ne conserver que la première occurrence de chaque ligne unique. Lorsque tu supprimes des lignes en double en ligne, l'outil découpe le texte sur les caractères de saut de ligne, suit les lignes déjà apparues grâce à une structure de données de type table de hachage (comme un Set), et ne renvoie que les lignes non encore vues. L'ordre original des lignes est préservé.

Deux lignes sont considérées comme des doublons lorsqu'elles correspondent exactement, caractère par caractère. En pratique, les données réelles coopèrent rarement avec une correspondance exacte. Les espaces en début ou fin de ligne, les majuscules incohérentes et les caractères invisibles comme les tabulations ou les retours chariot peuvent tous faire traiter comme uniques des lignes qui semblent identiques. C'est pourquoi la plupart des outils de déduplication proposent des options de comparaison insensible à la casse et de suppression des espaces avant comparaison.

La déduplication est une opération distincte du tri. La commande Unix sort -u trie et déduplique à la fois, ce qui modifie l'ordre des lignes. Si tu dois préserver l'ordre original, il faut une approche par ensemble de vus : parcourir les lignes en séquence, ajouter la forme normalisée de chaque ligne à un ensemble et ignorer toute ligne dont la clé existe déjà. Cet outil utilise cette méthode, donc les premières occurrences restent à leurs positions initiales.

Pourquoi utiliser ce suppresseur de doublons ?

Colle ton texte, choisis tes options de comparaison et obtiens le résultat dédupliqué immédiatement. Pas de configuration en ligne de commande, pas de regex, pas d'envoi de fichiers.

Cas d'usage du suppresseur de lignes en double

Méthodes de déduplication comparées

Il existe plusieurs approches pour supprimer les lignes en double, chacune avec des compromis différents en termes de préservation de l'ordre, d'utilisation de la mémoire et de précision.

Sensibilité à la casse et gestion des espaces

Deux options contrôlent la façon dont cet outil détermine si deux lignes sont des doublons. Comprendre quand utiliser chaque option évite les faux positifs (traiter des lignes différentes comme des doublons) et les faux négatifs (rater des lignes qui devraient correspondre).

Exemples de code

Supprime les lignes en double par programmation en JavaScript, Python, Go et en ligne de commande. Chaque exemple montre une déduplication préservant l'ordre et gère la sensibilité à la casse.

const text = `apple
banana
apple
Cherry
banana
cherry`

// Remove exact duplicates, preserve order
const unique = [...new Map(
  text.split('\n').map(line => [line, line])
).values()].join('\n')
// → "apple\nbanana\nCherry\ncherry"

// Case-insensitive deduplication
const seen = new Set()
const ciUnique = text.split('\n').filter(line => {
  const key = line.toLowerCase()
  if (seen.has(key)) return false
  seen.add(key)
  return true
}).join('\n')
// → "apple\nbanana\nCherry"

// Trim whitespace before comparing
const trimDedup = text.split('\n').filter(line => {
  const key = line.trim().toLowerCase()
  if (seen.has(key)) return false
  seen.add(key)
  return true
}).join('\n')

text = """apple
banana
apple
Cherry
banana
cherry"""

lines = text.splitlines()

# Remove duplicates, preserve order (Python 3.7+)
unique = list(dict.fromkeys(lines))
# → ['apple', 'banana', 'Cherry', 'cherry']

# Case-insensitive deduplication
seen = set()
ci_unique = []
for line in lines:
    key = line.lower()
    if key not in seen:
        seen.add(key)
        ci_unique.append(line)
# → ['apple', 'banana', 'Cherry']

# With whitespace trimming
seen = set()
trimmed = []
for line in lines:
    key = line.strip().lower()
    if key not in seen:
        seen.add(key)
        trimmed.append(line)

package main

import (
	"fmt"
	"strings"
)

func removeDuplicates(text string) string {
	lines := strings.Split(text, "\n")
	seen := make(map[string]bool)
	result := make([]string, 0, len(lines))

	for _, line := range lines {
		if !seen[line] {
			seen[line] = true
			result = append(result, line)
		}
	}
	return strings.Join(result, "\n")
}

func main() {
	text := "apple\nbanana\napple\ncherry\nbanana"
	fmt.Println(removeDuplicates(text))
	// → apple\nbanana\ncherry
}

# Remove duplicates (sorts output — does not preserve order)
sort -u file.txt

# Remove duplicates while preserving original order
awk '!seen[$0]++' file.txt

# Case-insensitive dedup, preserve order
awk 'BEGIN{IGNORECASE=1} !seen[tolower($0)]++' file.txt

# Trim whitespace then dedup
sed 's/^[[:space:]]*//;s/[[:space:]]*$//' file.txt | awk '!seen[$0]++'

# Count duplicates before removing
sort file.txt | uniq -c | sort -rn

Questions fréquentes