cut : extraire des colonnes

Quand on doit extraire rapidement une colonne d'un fichier CSV, récupérer un champ d'un fichier de configuration ou isoler une partie d'une ligne de log, cut est l'outil idéal. Simple et rapide, cut permet d'extraire des portions de texte par position (caractères) ou par champs (délimiteur), directement en ligne de commande.

Ce que vous allez apprendre

• Extraire des colonnes par position avec -c (caractères)
• Extraire des champs avec délimiteur avec -f et -d
• Utiliser des plages (1-5, 3-, -10)
• Combiner cut avec d'autres commandes (grep, sort, uniq)

La commande cut dans l'écosystème Linux

cut fait partie des commandes de traitement de texte sous Linux. Chaque outil a sa spécialité :

Commande	Spécialité	Quand l'utiliser
cut	Extraire des colonnes/champs	Fichiers délimités simples (CSV, TSV, passwd)
awk	Traitement avancé de colonnes	Calculs, conditions, formats complexes
sed	Éditer du texte en flux	Remplacer, supprimer, insérer
grep	Filtrer des lignes	Rechercher des patterns
tr	Translitérer des caractères	Remplacer caractère par caractère
paste	Fusionner des fichiers	Joindre des colonnes côte à côte

Glissez pour voir

Quand utiliser cut vs awk ?

Situation	cut	awk
Extraire une colonne simple	Oui, cut -d',' -f2	Oui, mais disproportionné
Délimiteur unique et fixe	Oui, cas idéal	Oui
Espaces multiples comme délimiteur	Non	Oui, awk '{print $2}'
CSV avec guillemets	Non	Oui (ou csvtool)
Réordonner les colonnes	Non	Oui, awk '{print $3,$1}'
Calculs sur les colonnes	Non	Oui, awk '{sum+=$2}'

Glissez pour voir

Combinaisons fréquentes :

# grep + cut : filtrer puis extraire
grep 'admin' users.csv | cut -d',' -f2

# cut + sort + uniq : compter les valeurs d'une colonne
cut -d',' -f4 users.csv | sort | uniq -c

# cut + xargs : exécuter une commande sur chaque valeur
cut -d':' -f1 /etc/passwd | xargs -I{} id {}

Comprendre la commande cut en 2 min

🧠 Modèle mental — Comment fonctionne cut

cut = Choisir le mode → Spécifier quoi extraire → Obtenir le résultat

Points clés

• cut extrait des parties de chaque ligne (colonnes, caractères ou champs)
• -c pour les caractères (position), -f pour les champs (avec délimiteur)
• Par défaut, le délimiteur est la tabulation (\t)
• Utilise -d pour spécifier un autre délimiteur (virgule, deux-points...)
• Les plages : 1-5 (de 1 à 5), 3- (à partir de 3), -10 (jusqu'à 10)
• cut ne modifie pas le fichier, il affiche sur stdout

Règles d'or

1

Toujours spécifier -d si le délimiteur n'est pas une tabulation Par défaut cut utilise TAB. Pour CSV, utiliser -d','

2

Préférer awk pour les cas complexes cut est limité : un seul délimiteur, pas de regex, pas de calculs

Vocabulaire essentiel

-c1-10

Caractères 1 à 10

-f2

Champ numéro 2

-d','

Délimiteur virgule

-f1,3,5

Champs 1, 3 et 5

-f2-

Du champ 2 jusqu'à la fin

--complement

Inverse la sélection

📚 Pour aller plus loin — 6 options avancées

-b

Extraction par octets (utile pour UTF-8)

-s

N'affiche que les lignes avec délimiteur

--output-delimiter

Change le délimiteur en sortie

-f-3

Du début jusqu'au champ 3

-f1,3-5,7

Combinaison de champs et plages

-c1,5,10

Caractères spécifiques (non contigus)

cut lit le fichier ligne par ligne, découpe selon le mode choisi (caractères ou champs), puis affiche les portions sélectionnées sur stdout.

Syntaxe minimale

La signature est volontairement pauvre : aucune option n'a de valeur par défaut utile. Sans -f, -c ou -b, cut refuse de travailler et renvoie you must specify a list of bytes, characters, or fields. Si vous omettez le fichier, cut lit stdin, ce qui en fait un maillon naturel de pipeline.

cut [OPTIONS] [FICHIER]

Les 2 modes d'extraction

cut propose deux modes principaux, et le choix se fait sur une seule question : les colonnes sont-elles séparées par un caractère constant, ou alignées à une position constante ? Un CSV, un /etc/passwd ou un TSV relèvent du premier cas, une sortie tabulée à largeur fixe du second.

Mode	Option	Usage	Exemple
Champs	-f	Fichiers délimités (CSV, TSV)	cut -d',' -f2 data.csv
Caractères	-c	Positions fixes	cut -c1-10 log.txt

Glissez pour voir

Extraction par champs (-f + -d)

C'est le mode le plus courant. On spécifie :

• -d'X' : le délimiteur (caractère séparateur)
• -f N : le(s) champ(s) à extraire

# Fichier CSV (virgule)
cut -d',' -f2 users.csv

# Fichier passwd (deux-points)
cut -d':' -f1,7 /etc/passwd

# Fichier TSV (TAB par défaut)
cut -f2 data.tsv

Important : sans -d, cut utilise la tabulation comme délimiteur par défaut.

Les plages de sélection

La même syntaxe de plage s'applique à -f (champs) et à -c (caractères) : ce qui change, c'est l'unité comptée, pas la grammaire. Retenez surtout les deux formes ouvertes, -f3- et -f-3 : ce sont elles qui évitent de connaître à l'avance le nombre de colonnes. Le tiret seul (-f-) est refusé, cut répond invalid range with no endpoint.

Syntaxe	Signification	Exemple
-f N	Champ N seul	-f2 → 2ème champ
-f N,M,P	Champs N, M et P	-f1,3,5 → champs 1, 3, 5
-f N-M	De N à M	-f2-4 → champs 2, 3, 4
-f N-	De N à la fin	-f3- → du 3ème à la fin
-f -N	Du début à N	-f-3 → champs 1, 2, 3

Glissez pour voir

Extraction par caractères (-c)

Utile pour les fichiers à largeur fixe (logs, exports mainframe). Ce mode ignore complètement les délimiteurs : -d n'a aucun effet avec -c. Comptez les positions sur une ligne réelle, jamais sur l'en-tête, dont l'alignement diffère souvent des données.

# Les 15 premiers caractères (adresse IP dans un log)
cut -c1-15 access.log

# Caractères 10 à 20
cut -c10-20 fichier.txt

# Caractères spécifiques (non contigus)
cut -c1,5,10 fichier.txt

Options utiles

Trois options font gagner du temps sans changer la logique d'extraction. --complement évite d'énumérer vingt colonnes pour en écarter une seule. -s protège les traitements automatisés : sans lui, une ligne de commentaire ou une ligne vide traverse cut intacte et pollue la sortie. --output-delimiter sépare le délimiteur d'entrée du délimiteur de sortie, utile pour convertir un CSV en TSV.

Option	Effet	Exemple
--complement	Inverse la sélection	-f3 --complement (tout sauf champ 3)
-s	Ignore les lignes sans délimiteur	-d':' -f1 -s
--output-delimiter	Change le délimiteur en sortie	--output-delimiter=';'

Glissez pour voir

Erreurs typiques (et solutions)

Le point commun de ces quatre situations : cut ne signale rien. Il ne renvoie pas de code d'erreur quand le champ demandé n'existe pas, ni quand le délimiteur est absent de la ligne. C'est donc la sortie qu'il faut inspecter, jamais $?. Lisez la colonne « Cause » avant la colonne « Solution » : dans trois cas sur quatre, la réponse est de passer à awk, pas de bricoler les options de cut.

Erreur	Cause	Solution
Toute la ligne est affichée	Mauvais délimiteur ou délimiteur absent	Vérifier avec cat -A, utiliser le bon -d
Résultat vide	Champ inexistant (numéro trop grand)	Compter les colonnes avec head -1 | tr ',' '\n' | wc -l
Colonnes mal découpées	Espaces multiples ou guillemets CSV	Utiliser awk à la place
L'ordre des colonnes n'est pas respecté	cut affiche dans l'ordre du fichier	Utiliser awk '{print $3,$1}'

Glissez pour voir

Les modèles d'extraction courants

Maintenant que vous comprenez la logique de cut, voici douze modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Extraire un champ

Récupérer une seule colonne d'un fichier délimité.

cut -d'DELIM' -f N <fichier>   # formule
cut -d',' -f2 users.csv        # exemple

• DELIM : caractère séparateur (virgule, deux-points…)
• N : numéro du champ à extraire (commence à 1)

Extraire plusieurs champs

Récupérer plusieurs colonnes précises.

cut -d'DELIM' -f N,M,P <fichier>   # formule
cut -d':' -f1,7 /etc/passwd        # exemple

• N,M,P : liste de champs séparés par des virgules

Extraire une plage de champs

Récupérer une série de colonnes consécutives.

cut -d'DELIM' -f N-M <fichier>   # formule
cut -d',' -f2-4 data.csv         # exemple

• N-M : du champ N au champ M inclus

Du champ N jusqu'à la fin

Extraire à partir d'un champ jusqu'au dernier.

cut -d'DELIM' -f N- <fichier>   # formule
cut -d':' -f3- /etc/passwd      # exemple

• N- : à partir du champ N jusqu'à la fin de la ligne

Du début jusqu'au champ N

Extraire du premier champ jusqu'à N.

cut -d'DELIM' -f -N <fichier>   # formule
cut -d',' -f-3 data.csv         # exemple

• -N : du début jusqu'au champ N inclus

Extraire par position (caractères)

Extraire des caractères à des positions fixes.

cut -c N-M <fichier>        # formule
cut -c1-15 access.log      # exemple

• -c : mode caractères (position fixe)
• N-M : positions des caractères

Fichiers TSV (tabulation)

Extraire des colonnes d'un fichier séparé par des tabulations.

cut -f N <fichier.tsv>   # formule
cut -f2 data.tsv         # exemple

• -f sans -d : utilise la tabulation par défaut

Inverser la sélection

Afficher tout sauf les champs spécifiés.

cut -d'DELIM' -f N --complement <fichier>      # formule
cut -d',' -f3 --complement users.csv           # exemple

• --complement : inverse la sélection

Changer le délimiteur en sortie

Utiliser un séparateur différent dans le résultat.

cut -d'DELIM1' -f N,M --output-delimiter='DELIM2' <fichier>   # formule
cut -d',' -f1,3 --output-delimiter=$'\t' data.csv             # exemple

• --output-delimiter : délimiteur appliqué à la sortie
• cut n'interprète aucune séquence d'échappement : --output-delimiter='\t' écrit les deux caractères \ et t. Pour une vraie tabulation, passez par la syntaxe $'\t' du shell (bash, zsh)

Pipeline avec grep

Filtrer les lignes, puis extraire des colonnes.

grep 'PATTERN' <fichier> | cut -d'DELIM' -f N    # formule
grep ',admin,' users.csv | cut -d',' -f2         # exemple

• grep filtre d'abord, cut extrait ensuite

Pipeline avec sort et uniq

Extraire une colonne et compter ses valeurs uniques.

cut -d'DELIM' -f N <fichier> | sort | uniq -c    # formule
cut -d',' -f4 users.csv | sort | uniq -c         # exemple

• sort | uniq -c : trie puis compte les occurrences

Ignorer les lignes sans délimiteur

N'afficher que les lignes contenant effectivement le délimiteur.

cut -d'DELIM' -f N -s <fichier>   # formule
cut -d':' -f1 -s mixed.txt        # exemple

• -s : supprime de la sortie les lignes sans délimiteur

Les pièges à éviter

Six erreurs reviennent constamment avec cut. Pour chacune : la commande piégée, le symptôme, la cause et la correction.

Oubli du délimiteur (tabulation par défaut)

cut -f2 fichier.csv   # INCORRECT : sur un CSV : toute la ligne ressort

Symptôme : toute la ligne s'affiche au lieu du 2ᵉ champ. Cause : sans -d, cut attend une tabulation, pas une virgule.

cut -d',' -f2 fichier.csv   # CORRECT : délimiteur explicite

Espaces multiples comme délimiteur

cut -d' ' -f2 fichier.txt   # INCORRECT : plusieurs espaces entre colonnes

Symptôme : résultats vides ou décalés. Cause : cut traite un seul espace comme délimiteur, jamais une suite d'espaces.

awk '{ print $2 }' fichier.txt   # CORRECT : awk gère les espaces multiples

CSV avec champs entre guillemets

cut -d',' -f2 fichier.csv   # INCORRECT : "Alice, Bob",email : découpage faux

Symptôme : les champs contenant une virgule interne sont mal découpés. Cause : cut ne connaît pas les guillemets CSV (RFC 4180).

awk -F'","' '{ print $2 }' fichier.csv   # CORRECT : ou un vrai parseur : csvtool col 2 fichier.csv

Les champs sortent dans l'ordre du fichier

cut -d',' -f3,1 fichier.csv   # INCORRECT : affiche dans l'ordre 1,3 : pas 3,1

Symptôme : l'ordre des champs n'est pas celui demandé. Cause : cut affiche toujours les champs dans leur ordre d'apparition.

awk -F',' '{ print $3","$1 }' fichier.csv   # CORRECT : awk réordonne

Champ inexistant

cut -d',' -f10 fichier.csv   # INCORRECT : fichier à 5 colonnes : rien ne sort

Symptôme : lignes vides, aucune sortie. Cause : cut renvoie du vide si le champ n'existe pas, sans message d'erreur.

head -1 fichier.csv | tr ',' '\n' | wc -l   # CORRECT : compter les colonnes d'abord

Caractères UTF-8 multi-octets

cut -c1-5 fichier.txt   # INCORRECT : sur du texte accentué : caractères tronqués

Symptôme : caractères coupés ou mal affichés. Cause : dans GNU coreutils, -c est aujourd'hui traité comme -b, donc il compte les octets. Un caractère accentué en occupe deux en UTF-8, un émoji jusqu'à quatre. Régler LANG sur une locale UTF-8 n'y change rien : la troncature persiste.

awk '{ print substr($0, 1, 5) }' fichier.txt   # CORRECT : gawk compte les caractères

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les huit étapes. À la fin, nettoyez avec rm -rf ~/cut-lab.

Préparer le terrain

Ce script crée quatre fichiers de test dans ~/cut-lab : un CSV, un TSV, un fichier de type passwd et un log à largeur fixe.

# Créer le lab
mkdir -p ~/cut-lab
cd ~/cut-lab

# Fichier CSV (virgule)
cat > users.csv << 'EOF'
id,nom,email,role,salaire
1,Alice,alice@example.com,admin,5000
2,Bob,bob@example.com,user,3500
3,Charlie,charlie@example.com,user,3200
4,Diana,diana@example.com,moderator,4000
5,Eve,eve@example.com,admin,5500
EOF

# Fichier TSV (tabulation)
cat > data.tsv << 'EOF'
Produit  Prix  Stock  Catégorie
Laptop  999  50  Informatique
Souris  29  200  Périphériques
Clavier  79  150  Périphériques
Écran  299  75  Informatique
EOF

# Fichier type passwd (deux-points)
cat > passwd.txt << 'EOF'
root:x:0:0:root:/root:/bin/bash
bob:x:1000:1000:Bob User:/home/bob:/bin/bash
alice:x:1001:1001:Alice Admin:/home/alice:/bin/zsh
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
EOF

# Fichier log à largeur fixe
cat > access.log << 'EOF'
192.168.1.10  2025-01-15  GET   /index.html    200
192.168.1.20  2025-01-15  POST  /api/users     201
192.168.1.30  2025-01-15  GET   /style.css     200
192.168.1.10  2025-01-15  GET   /favicon.ico   404
EOF

echo "Lab créé dans ~/cut-lab"
ls -la ~/cut-lab

Les huit étapes

1. Extraire une colonne CSV. Extrayez la colonne nom (2ᵉ champ) du fichier users.csv.

   cut -d',' -f2 ~/cut-lab/users.csv

   -d',' définit la virgule comme délimiteur, -f2 sélectionne le 2ᵉ champ. Pour sauter l'en-tête : tail -n +2 ~/cut-lab/users.csv | cut -d',' -f2.

2. Extraire plusieurs colonnes. Extrayez les colonnes nom et email (champs 2 et 3) de users.csv.

   cut -d',' -f2,3 ~/cut-lab/users.csv

   -f2,3 sélectionne les champs 2 et 3.

3. Extraire une plage de colonnes. Extrayez les colonnes 2 à 4 (nom, email, role) de users.csv.

   cut -d',' -f2-4 ~/cut-lab/users.csv

   -f2-4 sélectionne les champs de 2 à 4 inclus.

4. Fichier avec tabulation (TSV). Extrayez la colonne Prix (champ 2) du fichier data.tsv.

   cut -f2 ~/cut-lab/data.tsv

   Sans -d, cut utilise la tabulation par défaut, parfait pour un TSV.

5. Fichier passwd (deux-points). Extrayez le nom d'utilisateur (champ 1) et le shell (champ 7) de passwd.txt.

   cut -d':' -f1,7 ~/cut-lab/passwd.txt

   Le fichier passwd utilise : comme délimiteur ; le shell est le 7ᵉ champ.

6. Extraire par caractères. Extrayez les 12 premiers caractères de chaque ligne d'access.log (l'adresse IP).

   cut -c1-12 ~/cut-lab/access.log

   -c1-12 extrait les caractères 1 à 12, utile pour les formats à largeur fixe.

7. Combiner avec d'autres commandes. Listez les noms des utilisateurs ayant le rôle admin dans users.csv.

   grep ',admin,' ~/cut-lab/users.csv | cut -d',' -f2

   grep filtre les lignes contenant admin, puis cut en extrait le nom.

8. Inverser la sélection. Affichez toutes les colonnes de users.csv sauf le salaire (champ 5).

   cut -d',' -f5 --complement ~/cut-lab/users.csv

   --complement inverse la sélection : tout sauf le champ 5.

Exercices progressifs

Huit exercices pour valider votre maîtrise. Tous se traitent sur les fichiers du lab ~/cut-lab (ou sur /etc/passwd). Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Exercice 1, Extraire une colonne CSV. Extrayez uniquement les emails (3ᵉ colonne) de users.csv. Indice : le CSV utilise la virgule comme délimiteur.

Voir la solution

cut -d',' -f3 ~/cut-lab/users.csv

-d',' définit le délimiteur virgule, -f3 sélectionne le 3ᵉ champ.

Exercice 2, Lister les utilisateurs du système. Listez les noms d'utilisateurs depuis /etc/passwd. Indice : le fichier passwd utilise : comme délimiteur, le nom est le 1ᵉʳ champ.

Voir la solution

cut -d':' -f1 /etc/passwd

/etc/passwd est délimité par deux-points ; le nom d'utilisateur est le champ 1.

Exercice 3, Plusieurs colonnes. Extrayez le nom et le salaire (colonnes 2 et 5) de users.csv. Indice : séparez les numéros de champs par des virgules.

Voir la solution

cut -d',' -f2,5 ~/cut-lab/users.csv

-f2,5 sélectionne les champs 2 et 5, affichés dans l'ordre du fichier.

Niveau composition

Exercice 4, Plage de colonnes. Extrayez les colonnes 2 à 4 du fichier TSV data.tsv. Indice : pas besoin de -d pour un fichier séparé par des tabulations.

Voir la solution

cut -f2-4 ~/cut-lab/data.tsv

Sans -d, cut utilise la tabulation ; -f2-4 est une plage de champs.

Exercice 5, Extraire par caractères. Extrayez les 10 premiers caractères de chaque ligne d'access.log. Indice : utilisez -c, pas -f.

Voir la solution

cut -c1-10 ~/cut-lab/access.log

-c1-10 extrait les caractères 1 à 10 (positions fixes).

Exercice 6, Inverser la sélection. Affichez toutes les colonnes de users.csv sauf la 3ᵉ (email). Indice : --complement inverse la sélection.

Voir la solution

cut -d',' -f3 --complement ~/cut-lab/users.csv

--complement affiche tout sauf le champ 3.

Niveau industrialisation

Exercice 7, Pipeline grep + cut. Listez les shells des utilisateurs dont le répertoire personnel est dans /home/. Indice : filtrez avec grep avant d'extraire avec cut.

Voir la solution

grep ':/home/' /etc/passwd | cut -d':' -f7

grep filtre les lignes contenant /home/, cut en extrait le shell (champ 7).

Exercice 8, Compter les valeurs uniques. Comptez combien d'utilisateurs ont chaque rôle dans users.csv. Indice : combinez cut, sort et uniq -c.

Voir la solution

cut -d',' -f4 ~/cut-lab/users.csv | tail -n +2 | sort | uniq -c

cut extrait le rôle, tail -n +2 saute l'en-tête, sort | uniq -c compte les occurrences.

Dépannage

Quand cut ne renvoie pas ce qu'on attend, le problème vient presque toujours du délimiteur. Voici comment diagnostiquer.

Méthodes de diagnostic

Ces quatre commandes se déroulent dans l'ordre : d'abord identifier le vrai séparateur, ensuite compter les colonnes, puis tester sur une seule ligne avant de lancer le traitement complet. cat -A est la plus utile des quatre : elle rend visible ce que l'œil ne voit pas, une tabulation (^I) déguisée en suite d'espaces, ou un retour chariot Windows (^M$) collé au dernier champ.

# Afficher les caractères spéciaux pour identifier le vrai délimiteur
cat -A fichier.csv | head -1   # ^I = tabulation, $ = fin de ligne

# Compter le nombre de colonnes
head -1 fichier.csv | tr ',' '\n' | wc -l

# Tester le découpage sur une seule ligne
head -1 fichier.csv | cut -d',' -f2

# Afficher chaque champ numéroté
head -1 fichier.csv | awk -F',' '{ for (i=1; i<=NF; i++) print i": "$i }'

Erreurs fréquentes

cut ne produit que trois messages d'erreur, tous émis avant de lire la moindre ligne. Ils portent donc sur la ligne de commande, jamais sur les données. Si cut s'exécute sans rien dire mais renvoie un résultat faux, le problème est ailleurs : mauvais délimiteur, ou champ inexistant.

Message d'erreur	Cause probable	Solution
cut: invalid range with no endpoint	Syntaxe de plage incorrecte (-f- seul)	Corriger : -f1-5, -f3- ou -f-3
cut: you must specify a list of bytes, characters, or fields	Aucune option -c, -b ou -f	Ajouter -f pour les champs ou -c pour les caractères
cut: the delimiter must be a single character	Délimiteur de plusieurs caractères	Utiliser un seul caractère, ou passer à awk

Glissez pour voir

Aide-mémoire cut

Les six tableaux ci-dessous condensent tout ce qui a été démontré plus haut. Ils sont faits pour être relus en diagonale avant d'écrire une commande, pas pour être appris par cœur.

Syntaxe

Trois formes couvrent la quasi-totalité des usages : extraction par champ, extraction par position, et lecture depuis un pipe. Notez que le fichier est toujours le dernier argument, et qu'il peut simplement être omis quand cut reçoit ses données par l'entrée standard.

Forme	Rôle	Exemple
cut -d'X' -f N fichier	Extrait le champ N avec le délimiteur X	cut -d',' -f2 data.csv
cut -c N-M fichier	Extrait les caractères N à M	cut -c1-10 log.txt
cmd | cut …	Extrait depuis un pipe	cat f.csv | cut -d',' -f1

Glissez pour voir

Options

-f, -c et -b sont mutuellement exclusives : cut refuse d'en combiner deux. -d n'a de sens qu'avec -f, il est ignoré en mode caractères. Le délimiteur doit tenir sur un seul caractère et, s'il a une signification pour le shell (|, ;, espace), il faut le protéger par des apostrophes.

Option	Rôle	Exemple
-d'DELIM'	Définit le délimiteur (défaut : tabulation)	-d',' -d':' -d'|'
-f	Sélection par champs (avec délimiteur)	-f1 -f2,4 -f1-3
-c	Sélection par caractères (position)	-c1-10 -c5,10,15
-b	Sélection par octets	-b1-10
-s	N'affiche que les lignes avec délimiteur	cut -d':' -f1 -s
--complement	Inverse la sélection	-f3 --complement
--output-delimiter	Change le délimiteur en sortie	--output-delimiter=';'

Glissez pour voir

Sélection de champs (-f)

La numérotation commence à 1, pas à 0 : le premier champ est -f1. Quelle que soit la forme employée, cut restitue toujours les champs dans l'ordre du fichier ; écrire -f3,1 ne réordonne rien.

Forme	Rôle	Exemple
-f N	Champ N uniquement	-f2
-f N,M,P	Champs N, M et P	-f1,3,5
-f N-M	Champs N à M	-f2-5
-f N-	Du champ N jusqu'à la fin	-f3-
-f -N	Du début jusqu'au champ N	-f-4

Glissez pour voir

Sélection de caractères (-c)

Ce mode ne convient qu'aux formats à largeur fixe : sorties de mainframe, journaux alignés à la colonne près, dumps à gabarit constant. Dès qu'une colonne peut varier d'un caractère, la découpe part de travers sur toutes les lignes suivantes. Rappel : ces positions sont comptées en octets, donc à éviter sur du texte accentué.

Forme	Rôle	Exemple
-c N	Caractère N uniquement	-c5
-c N-M	Caractères N à M	-c1-20
-c N,M,P	Caractères précis, non contigus	-c1,5,10

Glissez pour voir

Pipelines courants

cut prend tout son intérêt au milieu d'un pipe, jamais seul. La position compte : filtrer avec grep avant cut réduit le volume traité ; sort doit précéder uniq -c, sinon le comptage ne regroupe que les doublons consécutifs. Avec xargs -I{}, pensez à un jeu de données propre : un champ vide déclencherait une commande sans argument.

Enchaînement	Rôle	Exemple
grep | cut	Filtrer puis extraire	grep admin f.csv | cut -d',' -f2
cut | sort | uniq	Extraire puis compter	cut -d',' -f3 f.csv | sort | uniq -c
cut | xargs	Extraire puis exécuter	cut -d':' -f1 /etc/passwd | xargs -I{} id {}

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez cut lorsque vous pouvez cocher chacun de ces points :

• Je sais extraire un champ avec -d et -f
• Je sais extraire plusieurs champs (-f1,3,5)
• Je sais utiliser des plages (-f2-5, -f3-, -f-4)
• Je sais extraire par position avec -c
• Je sais que la tabulation est le délimiteur par défaut
• Je sais utiliser --complement pour inverser la sélection
• Je sais combiner cut avec grep et sort
• Je sais quand utiliser awk plutôt que cut

Conclusion

La commande cut est un outil simple mais efficace pour extraire des colonnes de fichiers délimités. Sa syntaxe concise en fait l'outil idéal pour les extractions rapides sur des CSV, TSV, fichiers passwd ou logs à format fixe. Pour des besoins plus complexes (espaces multiples, guillemets, calculs), préférez awk qui offre plus de flexibilité.

Articles qui pourraient vous intéresser

• Maîtriser awk pour le traitement de données
• Maîtriser sed pour l'édition de texte
• Maîtriser grep pour la recherche de patterns
• Maîtriser find pour la recherche de fichiers

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

×

📖 Voir la documentation →