Category: OS

netstat -anltp | grep 7001

arborescence de fichier

du -h --max-depth=0 /exploit

1.2M /exploit

du -h --max-depth=1 /exploit

1004K /exploit/logs
136K /exploit/scripts
1.2M /exploit

Exemple avec le service vsftpd

root@Vsch1:/#ps -ef |grep vsftpd
root 2100 1 0 Jul06 ? 00:00:00 /usr/sbin/vsftpd
root 8874 8753 0 10:44 pts/0 00:00:00 grep ftp

[root@pong sbin]# cd /etc/init.d/

[root@pong init.d]# ./vsftpd start
Starting vsftpd for vsftpd:                                [  OK  ]

root@Vsch1:/#stop vsftpd
vsftpd stop/waiting

root@Vsch1:/#start vsftpd
vsftpd start/running, process 8904

root@Vsch1:/#/etc/init.d/tis_commandline restart

root@Vsch1:/#ps -ef |grep ftp
root 8904 1 0 10:53 ? 00:00:00 /usr/sbin/vsftpd
root 8906 8753 0 10:53 pts/0 00:00:00 grep ftp

#!/bin/bash
d1=`date + »%S.%N »`
read -p ‘Entree pour continuer’ var
d2=`date + »%S.%N »`

echo debut : $d1
echo fin : $d2

echo « scale=2; $d2-$d1″ | bc

ecart=`echo  » scale=2; $d2-$d1″ | bc`

echo duree : $ecart

VSCH2 : /exploit/scripts/zab_cal.sh

Deux commandes simples qui permettent :

pour la première de trier (par ordre alphabétique par défaut)

et la seconde de dédoublonner (sur exact match par défaut).

Vous pouvez améliorer leur efficacité ou les spécialisées pour vos besoins avec des options. (sort –help et uniq –help pour les voir)

Sous le compte root :

apt-get install snmpd

vim /etc/snmp/snmpd.conf

activer la deuxieme ligne

# sec.name source community
#com2sec paranoid default public
com2sec readonly default public
#com2sec readwrite default private

vim /etc/snmp/snmpd.local.conf

syslocation vsch2
syscontact cco_exploit@faiveleytransport.com

vi /etc/default/snmpd

Mettre l’adresse IP de la carte réseau (du serveur) vsch2 = 10.20.112.40 :

# snmpd options (use syslog, close stdin/out/err).
#SNMPDOPTS=’-Lsd -Lf /dev/null -u snmp -g snmp -I -smux -p /var/run/snmpd.pid 127.0.0.1′
SNMPDOPTS=’-Lsd -Lf /dev/null -u snmp -g snmp -I -smux -p /var/run/snmpd.pid 10.20.112.40‘

Démarrer le service

sudo /etc/init.d/snmpd restart

Imaginons, par exemple, que vous souhaitiez remplacer une adresse email dans tous les fichiers .php d’un répertoire et de ses sous-répertoires. Si l’adresse à remplacer est « georges@6ma.fr », et que la nouvelle adresse est « michel@6ma.fr », voici la commande :

find . -name « *.php » -print | xargs sed -i ‘s/georges@6ma.fr/michel@6ma.fr/g’

set -o emacs

a mettre dans le .profile

ps aux |grep -v grep | grep java

ou pour plusieurs processus

ps aux |grep -v grep | grep « java\|core\|palo\|httpd »

Problème :

/soft/jedox/ps/start_ef_palo.sh: line 26: chroot: command not found

ça fonctionne avec Putty pas avec Vtom.

Explication :

La commande chroot n’est pas trouvée dans /usr/sbin car le PATH utilisé en batch n’est pas bon.

Solution :

Il faut ajouter /usr/sbin dans le PATH de la queue batch VTOM

PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/opt/vtom5/admin:/opt/vtom5/abm/bin

vi /opt/vtom5/admin/vtom_init.ksh

[ -z « `echo – $PATH | grep $ABM_BIN` » ] && PATH=${PATH}:/usr/sbin:${ABM_BIN} ; export PATH

Relancer le client Vtom.

PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/sbin:/opt/vtom5/admin:/opt/vtom5/abm/bin

La c’est OK

Relancer l’agent Vtom

Se connecter root

root@home:~# passwd pcr
Entrez le nouveau mot de passe UNIX :
Retapez le nouveau mot de passe UNIX :
passwd : le mot de passe a été mis à jour avec succès

Si le même mot de passe a déjà été utiliser un message d’avertissement nous prévient.

BAD PASSWORD: it is based on a dictionary word

retapez le mot de passe est tout est OK.

Lors de l’exécution d’un batch ‘jai le message :

bin/ksh bad interpreter no such file or directory

Il faut installer le ksh.

sudo apt-get install ksh

ou

yum install ksh

pour désinstaller

sudo apt-get remove ksh

Les infos sont dans /proc/cpuinfo

grep « processor\|cpu cores » /proc/cpuinfo

processor : 0
cpu cores : 4
processor : 1
cpu cores : 4
processor : 2
cpu cores : 4
processor : 3
cpu cores : 4

4 processeurs avec chacun 4 coeurs.

cat /proc/cpuinfo

processor : 15
vendor_id : GenuineIntel
cpu family : 6
model : 26
model name : Intel(R) Xeon(R) CPU X5560 @ 2.80GHz
stepping : 5
cpu MHz : 2800.246
cache size : 8192 KB
physical id : 1
siblings : 8
core id : 11
cpu cores : 4
fpu : yes
fpu_exception : yes
cpuid level : 11
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx rdtscp lm pni monitor ds_cpl est tm2 cx16 xtpr popcnt lahf_lm
bogomips : 5600.29
clflush size : 64
cache_alignment : 64
address sizes : 40 bits physical, 48 bits virtual
power management:

Les processeurs sont numérotés à partir de 0. Ici nous avons le détail du processeur N° 15 donc le 16ième.

How many physical processors are there?

$ grep ‘physical id’ /proc/cpuinfo | sort | uniq | wc -l
2

How many virtual processors are there?

$ grep ^processor /proc/cpuinfo | wc -l
4

Are the processors dual-core (or multi-core)?

$ grep ‘cpu cores’ /proc/cpuinfo
cpu cores : 2
cpu cores : 2
cpu cores : 2
cpu cores : 2

« 2 » indicates the two physical processors are dual-core, resulting in 4 virtual processors.

If « 1 » was returned, the two physical processors are single-core. If the processors are single-core, and the number of virtual processors is greater than the number of physical processors, the CPUs are using hyper-threading. Hyper-threading is supported if ht is present in the CPU flags and you are using an SMP kernel.

Sur Redhat

uname -p

x86_64

Sur Ubuntu

lscpu

Architecture: i686
CPU op-mode(s): 64-bit
CPU(s): 1
Thread(s) per core: 1
Core(s) per socket: 1
CPU socket(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 44
Stepping: 2
CPU MHz: 2532.613
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 12288K

source

Comme dit notre directeur technique “less can more”. Comprendre que la commande less fait tout ce que fait la commande more, en mieux et bien plus. Less vous permet d’afficher un contenu ligne par ligne, page par page et même de chercher dans cet affichage.

Exemples d’usage de less

less toto.txt less toto.txt

ATTENTION EN CAS DE CHANGEMENT DE VERSION.

Chaque modif doit faire l’objet d’une montée de version dans Talend pour tests et avant mise en Prod.

Ceci afin de preserver la version en Prod.

Les commandes suivantes s’appliquent à la version 0.7 de l’interface, mais sont identiques pour toutes montées de version.

1) Récupération du Zip sur /home/adminlinux copie et unzip

Se positionner dans /data/talend/jobs rapatrier le .zip

cp /home/adminlinux/LPZ_SAP_M3_INTEGRATION_0.7.zip .

et le dézipper

unzip LPZ_SAP_M3_INTEGRATION_0.7.zip

2) Le script lancé par Vtom est /exploit/scripts/lpz_sap_m3_run_07.sh

il faut le modifier (changement du chemin)

ainsi que :

/data/talend/repository/LPZ_SAP_M3_INTEGRATION_run_07.sh

(il contient les 2 paramètres : context et mode de lancement)

Se positionner dans la directorie où se trouve le .sh

cd /data/talend/jobs/LPZ_SAP_M3_INTEGRATION_0.7/LPZ_SAP_M3_INTEGRATION

Copier le .sh de /data/talend/repository

cp /data/talend/repository/LPZ_SAP_M3_INTEGRATION_run_07.sh .

3) Contenu du repository (exemple Test = SBX902 ou Prod = PFT300)

cd /data/talend/repository/SBX902

En cas d’initialisation mettre les 4 fichiers suivants, dans cette directorie.

MITMAS_REF.xls

TEMPLATEITEM.txt

Xunit.xls

XUNIT.xls

Vider le repository

rm *

Copier les 4 fichiers ci-dessus depuis le niveau inférieur.

cp ../*.xls .
cp ../*.txt .

—————————————————————–

Pour tester

—————————————————————–

Sur Athena LpzXM3/Input

Lancer l’integration « Firstswicht » en mettant en parametre l’avant dernier fichier.

Puis lancer une integration « normale » en mettant en parametre « integration »

Ubuntu 18.04 :

sudo apt install ntp

Serveur WCT :
vim /etc/ntp.conf

server timeserver.wabtec.com
restrict timeserver.wabtec.com mask 255.255.255.255 nomodify
notrap noquery
server 10.129.20.20

service ntpd stop
service ntpd start
service ntpd restart

cat /var/log/messages

Sur EL7 (octal_V15)

root@wctsrv0057:~# timedatectl
 Local time: Tue 2019-10-01 15:30:45 CEST
Universal time: Tue 2019-10-01 13:30:45 UTC
RTC time: Tue 2019-10-01 12:24:05
Time zone: Europe/Paris (CEST, +0200)
NTP enabled: yes
NTP synchronized: yes
RTC in local TZ: no
DST active: yes
Last DST change: DST began at
Sun 2019-03-31 01:59:59 CET
Sun 2019-03-31 03:00:00 CEST
Next DST change: DST ends (the clock jumps one hour backwards) at
Sun 2019-10-27 02:59:59 CEST
Sun 2019-10-27 02:00:00 CET

root@wctsrv0057:~# timedatectl set-ntp false

root@wctsrv0057:~# timedatectl
Local time: Tue 2019-10-01 15:35:05 CEST
Universal time: Tue 2019-10-01 13:35:05 UTC
RTC time: Tue 2019-10-01 12:28:25
Time zone: Europe/Paris (CEST, +0200)
NTP enabled: no
NTP synchronized: yes
RTC in local TZ: no
DST active: yes
Last DST change: DST began at
Sun 2019-03-31 01:59:59 CET
Sun 2019-03-31 03:00:00 CEST
Next DST change: DST ends (the clock jumps one hour backwards) at
Sun 2019-10-27 02:59:59 CEST
Sun 2019-10-27 02:00:00 CET

root@wctsrv0057:~# systemctl enable ntpd.service

Pour voir la date et l’heure actuelle

date

Pour changer l’heure

date -s « 09:56:00 »

Pour changer le jour

date -s « 2011-03-22 »

Mise à jour automatique de l’heure

Ajouter le service ntp

sous Ubuntu ou Debian
sudo apt-get install ntp

sous Redhat ou centos
yum install ntp

Lancer le service

sudo service ntpd start
ou
sudo service ntpd restart

sudo service ntp start
ou
sudo service ntp restart

ps -ef | grep ntp

vi /etc/ntp.conf

# /etc/ntp.conf, configuration for ntpd; see ntp.conf(5) for help

driftfile /var/lib/ntp/ntp.drift
# Enable this if you want statistics to be logged.
#statsdir /var/log/ntpstats/

statistics loopstats peerstats clockstats
filegen loopstats file loopstats type day enable
filegen peerstats file peerstats type day enable
filegen clockstats file clockstats type day enable
# You do need to talk to an NTP server or two (or three).
#server ntp.ubuntu.com
#server 10.20.112.64
server pft.ft.grp

# Access control configuration; see /usr/share/doc/ntp-doc/html/accopt.html for
# details. The web page <http://support.ntp.org/bin/view/Support/AccessRestrictions>
# might also be helpful.
#
# Note that « restrict » applies to both servers and clients, so a configuration
# that might be intended to block requests from certain clients could also end
# up blocking replies from your own upstream servers.

# By default, exchange time with everybody, but don’t allow configuration.
restrict -4 default kod notrap nomodify nopeer noquery
restrict -6 default kod notrap nomodify nopeer noquery

# Local users may interrogate the ntp server more closely.
restrict 127.0.0.1
restrict ::1

# Clients from this (example!) subnet have unlimited access, but only if
# cryptographically authenticated.
#restrict 192.168.123.0 mask 255.255.255.0 notrust
# If you want to provide time to your local subnet, change the next line.
# (Again, the address is an example only.)
#broadcast 192.168.123.255

# If you want to listen to time broadcasts on your local subnet, de-comment the
# next lines. Please do this only if you trust everybody on the network!
#disable auth
#broadcastclient

Par défault on a :

/etc/init.d/ntp
/etc/rc1.d/K77ntp
/etc/rc2.d/S23ntp
/etc/rc3.d/S23ntp
/etc/rc4.d/S23ntp
/etc/rc5.d/S23ntp

ln -s ../init.d/ntp /etc/rc1.d/K77ntp
ln -s ../init.d/ntp /etc/rc2.d/S23ntp
ln -s ../init.d/ntp /etc/rc3.d/S23ntp
ln -s ../init.d/ntp /etc/rc4.d/S23ntp
ln -s ../init.d/ntp /etc/rc5.d/S23ntp

SOMMAIRE

1- Numeroter – compter – additionner – cumuler
2- operations sur les champs : NF
3- operations sur les lignes : NR – occurrences
4- pattern
5- Remplacer des lignes des chiffres ou des lettres
6- Supprimer ou inserer des lignes blanches ,espaces ,tabulations
7- Inserer
8- divers

L’execution du script peut dépendre de la version de Linux installée. Parfois le script s’execute dans un « sous shell » (en tapant ‘sh’) (taper ‘exit’ pour sortir)

@1-Numeroter – compter – additionner – cumuler

• Affiche le nombre de lignes (avec les lignes vides)
  
  sed -n -e ‘$=’ in.txt
  awk ‘END{print NR}’ in.txt
  awk ‘{n++} END{print n}’ in.txt
• Affiche le nombre de lignes (sans les lignes vides)
  
  awk ‘/./ {print}’ in.txt | wc -l
  grep « . » in.txt | wc -l
• Somme avec cumul de la colonne 1
  
  awk ‘{print (total +=$1)}’ in.txt
• Print le nombre de mots
  
  awk ‘{x=x+NF}END{print x}’ in.txt
• Compte nombre de lignes contenant le pattern ‘titi’
  
  awk ‘/titi/{x+=1}END{print x}’ in.txt
• Print le numero de chaque ligne
  
  awk ‘{print NR,$0}’ in.txt
  c=0; while read line; do ((c+=1)); echo $c $line; done < in.txt
• compteur vertical
  
  for i in `seq 1 15`;do echo « $i »;done
• Compte le nombre de lignes vides d’un fichier
  
  awk ‘/^$/ {x += 1};END {print x }’ in.txt
• Compter le nombre de mots d’un fichier
  
  cat in.txt | wc -w
• compter le nombre de lignes et de mots
  
  awk ‘BEGIN{nl=0;nw=0} {nl++;nw+=NF} END {print « lines: »,nl, « words: »,nw}’ in.txt
• compter un caractere (ici: i)
  
  var=`cat in.txt` ; var= »${var//[^i]/} » ; echo ${#var}
• affiche le numero de ligne du pattern
  
  grep -n « pattern » in.txt
• Compter le nombre d’occurrences de ‘pattern’
  
  grep -c « pattern » in.txt
  awk ‘/pattern/ {n++} END {print n}’ in.txt
• Numeroter toutes les lignes contenant ‘pattern’ (affiche 1 numero par ligne)
  
  sed -n ‘/pattern/=’ in.txt
• Numeroter toutes les lignes entre 2 patterns (affiche 1 numero par ligne)
  
  sed -n ‘/pattern1/,/pattern2/{=;d;}’ in.txt
• Numeroter les lignes sans les lignes blanches
  
  nl in.txt
• Numeroter les lignes avec les lignes blanches
  
  cat -n in.txt
  sed = in.txt | sed ‘N; s/\n/\t/’
• Numeroter les lignes
  
  awk ‘{print NR,$0}’ in.txt
  while read line; do N=$((N+1)); echo « Line $N = $line »; done < in.txt
• Ecrire le nom du fichier devant chaque ligne
  
  grep -H « pattern » in.txt
• Somme et cumul d’une colonne ($2) , en utilisant 1 colonne clef ($1)
  
  awk ‘{arr[$1]+=$2} END {for(i in arr) {print i, arr[i]}}’ in.txt | sort

   

  @2-Operations sur les champs : NF

• Compter le nombre de champs de chaque ligne (separateur = « , »)
  
  awk ‘{cnt=0 ; for(i=1; i<=NF; i++) {if($i != «  ») {cnt++}} {print NR  » : « cnt » fields »}}’ FS= », » in.txt
• Printer les 5 premiers caractères de toutes les lignes d’un fichier
  
  while read line;do echo ${line::5};done < in.txt
  while read line ; do echo $line | cut -c1-5 ; done < in.txt
• Deleter les 5 premiers caracteres de toutes les lignes d’un fichier
  
  colrm 1 5 < in.txt
  awk ‘sub(« ^….. », «  »)’ in.txt
  while read line ; do echo $line | cut -c6- ; done < in.txt
• Printer les 5 derniers caracteres de toutes les lignes
  
  sed ‘s/^.*\(…..\)$/\1/’ in.txt
  sed ‘s/\(.*\)\(.\{5\}\)/\2/’ in.txt
  while read line;do echo ${line: -5};done < in.txt
  awk ‘{print substr($0, length($0) – 4, length($0) ) }’ in.txt
• Deleter les 5 derniers caracteres de toutes les lignes
  
  awk ‘sub(« …..$ », «  »)’ in.txt
• Supprimer un champ
  
  echo « data1 line1 » | sed ‘s/.* //’
  echo « data1 line1 » | sed -n ‘s/.* //;p’
  resultat: line1
• Supprimer le dernier champ
  
  awk ‘{$NF= » »; print $0}’ in.txt
• Champ tampon ‘elapse’ pour operations intermediaires
  
  awk ‘{elapse = $1/3600; if(elapse<8) print int($1/3600)}’ in.txt
• Dans champ 1, a la position 2, printer 3 caracteres
  
  awk ‘{print substr($1,2,3)}’ in.txt
• Print l’avant dernier champ ($NF-1) de chaque ligne
  
  awk ‘{print $(NF-1)}’ in.txt
• Print le nombre de champs uniquement
  
  awk ‘{print NF}’ in.txt
• Print le nombre maximum de champs
  
  awk ‘{print NF}’ in.txt | sort -n | sed -n ‘$p’
• Print le nombre minimum de champs
  
  awk ‘{print NF}’ in.txt | sort -n | sed -n ‘1p’
• Printer 2 colonnes en precisant le separateur
  
  awk -F'[ ]’ ‘{print $2,$3}’ in.txt
  cut -d ‘ ‘ -f2,3 in.txt
• Printer du 5eme caractere au dernier (inclus) sur toutes les lignes d’un fichier
  
  cat in.txt | cut -c ‘5-‘
• Printer du 1er au 5eme caractere (inclus) sur toutes les lignes d’un fichier
  
  cat in.txt | cut -c ‘-5’
• Printer du 3eme au 5eme caractere (inclus) et du 7eme au 9eme (inclus) sur toutes les lignes d’un fichier
  
  cat in.txt | cut -c ‘3-5,7-9’
• Printer les lignes dont le nombre de champs est inferieur a 3
  
  awk ‘NF<3’ in.txt
• Printer les lignes n’ayant qu’un seul champ
  
  awk ‘{if(NF == 1) {print}}’ in.txt
• tri de la 1ère colonne au 22eme caractere
  
  sort -k1.22
• Print si longueur de ‘colonne 1’ >3 « ET » ou « OU » longueur de ‘colonne 2’ <5
  
  awk ‘length($1)>3 && length($2)awk ‘length($1)>3 || length($2)
• Condition de print sur la longueur de colonne
  
  awk ‘{if(length($1)

   

  @3-operations sur les lignes : occurrences – digits – suppression – doubles – printer

• Occurrences
  Capturer la premiere occurrence d’une serie de lignes ayant meme pattern
  
  cat in.txt | sort -k1 | awk ‘x !~ $1 ; {x = $1}’
  cat in.txt | sort -k1 | awk ‘!d[$1] {print} {d[$1]=1}’
  cat in.txt | sort -k1 | awk ‘x[$1]++ {next} {print}’
  cat in.txt | sort -k1 | awk ‘!_[$1]++ {print $0 ; next} {next}’
• Occurrences
  Compter et marquer a la fin de la ligne les occurrences d’un unique pattern
  
  awk ‘/pattern/ {i=i+1} {print $0,i}’ in.txt | awk ‘!a[NF]++ {print $0 ; next} {sub($NF, » ») ; print}’
• Occurrences
  Compter les occurrences d’un pattern (total cumule)
  
  awk ‘/pattern/ {n++} END {print « pattern ecrit » n « fois »}’ in.txt
• Occurrences
  Compter les occurrences d’un pattern (pour chaque ligne)
  
  awk -F « pattern » ‘{print NF-1}’ in.txt
• Occurrences
  Remplace sur chaque ligne la 1ère occurrence de ‘t’ par ‘b’
  
  sed -e ‘1,$ s/t/b/1’ in.txt
  while read line; do echo ${line/t/b}; done < in.txt
• Occurrences
  Remplacer la 2ème occurrence d’un pattern de la premiere ligne
  
  sed ‘0,/old/ s//new/2’ in.txt
• Occurrences
  Remplacer la 2ème occurrence d’un pattern pour chaque ligne
  
  sed ‘s/old/new/2’ in.txt
  sed ‘/old/ s//new/2’ in.txt
  awk ‘{print gensub(/old/, « new », 2)}’ in.txt
• Occurrences
  Print la 1ère occurrence d’un « pattern »
  
  grep -m1 « pattern » in.txt
  sed -n ‘/pattern/{p;q;}’ in.txt
• Occurrences
  Printer les lignes dont les elements de la colonne 2 ont plus d’une occurrence
  
  awk ‘FNR==NR && a[$2]++ {b[$2] ; next} $2 in b’ in.txt in.txt
• Digits
  Printer les 4 premiers digits de chaque ligne
  
  cat in.txt | cut -c1-4
  for line in $(cat in.txt); do echo `expr « $line » : ‘\(….\)’`; done
  while read line; do echo `expr « $line » : ‘\(….\)’`; done < in.txt
• Digits
  Printer les 4 derniers digits de chaque ligne
  
  awk ‘{print substr($0, length($0)-3, length($0))}’ in.txt
• Digits
  Deleter les 3 derniers digits de chaque ligne
  
  sed -n ‘1,$ s/…$//p’ in.txt
• Digits
  Printer du 5ème digit au dernier de la ligne pour toutes les lignes
  
  while read line; do echo « substr($line,4) » | m4; done < in.txt
• Digits
  Printer 6 digits à partir du 2ème digit
  
  while read line; do echo `expr substr « $line » 2 6`; done < in.txt
• Suppression de lignes
  Supprime de la ligne 4 a 7 (inclus) du fichier
  
  sed ‘4,7d’ in.txt
• Suppression de lignes
  Supprime les lignes contenant ‘toto’
  
  sed ‘/toto/d’ in.txt
  grep -v « toto » in.txt
• Suppression de lignes
  Supprime ‘toto’ de la ligne 2 a 6
  
  sed -e ‘2,6 s/toto//g’ in.txt
• Suppression de lignes
  Supprime les lignes debutant par un chiffre (1 a 9)
  
  awk ‘$1 ~ /^[1-9]/ {next} {print}’ in.txt
• Suppression de lignes
  Supprime la ligne debutant par ‘@’ et les 2 suivantes
  
  sed ‘/^@/ {N;N;d;}’ in.txt
• Suppression de lignes
  Supprimer la 1ere ligne , la derniere ligne …
  
  sed ‘1d’ in.txt ……….. #supprime la premiere ligne
  sed ‘3d’ in.txt ……….. #supprime la ligne 3
  sed ‘$d’ in.txt ……….. #supprime la derniere ligne
• Suppression de lignes
  Supprimer les lignes 1, 4, 7, 10…..
  
  sed -e ‘1~3d’ in.txt
• Suppression de lignes
  Supprimer 1 ligne toutes les 3 lignes
  
  sed ‘0~3d’ in.txt
  sed ‘n;n;d;’ in.txt
• Suppression de lignes
  Deleter les 2 dernieres lignes
  
  sed ‘N;$!P;$!D;$d’ in.txt
• Suppression de lignes
  Deleter les 10 dernieres lignes
  
  sed -e :a -e ‘$d;N;2,10ba’ -e ‘P;D’
  sed -n -e :a -e ‘1,10!{P;N;D;};N;ba’
• Lignes doubles
  Printer les lignes uniques sans les doubles
  
  sort -u in.txt
  sort in.txt | uniq
  awk ‘!x[$0]++’ in.txt
  awk ‘{ a[$1]++ } END {for (i in a) print i}’ in.txt | sort
  sed ‘$!N; /^\(.*\)\n\1$/!P; D’ in.txt ………consecutive lines
• Lignes doubles
  Printer les lignes doubles , deleter le reste
  
  cat in.txt | uniq -d
  sed ‘$!N; s/^\(.*\)\n\1$/\1/; t; D’ in.txt
• Lignes doubles
  Printer les lignes doubles (ou triples …)
  
  awk ‘FNR==NR && a[$0]++ {b[$0] ; next} $0 in b’ in.txt in.txt
• Printer des lignes
  Printer uniquement la ligne 10
  
  sed ’10q;d’ in.txt
  sed ’10!d’ in.txt
  sed -n ’10p’ in.txt
  awk ‘{f[NR]=$0} END {print f[10]}’ in.txt
  awk ‘NR == 10 {print}’ in.txt
• Printer des lignes
  Printer de la ligne 1 a 10
  
  sed 10q in.txt
  awk ‘NR <=10{print}’ in.txt
• Printer des lignes
  Printer de la ligne 3 a 5
  
  sed ‘3,5!d’ in.txt
  sed -n ‘3,5p’ in.txt
  awk ‘NR >= 3 && NR <= 5’ in.txt
  head -5 in.txt | tail -3
  sed -n ‘3{:a;N;5!ba;p}’ in.txt
• Printer des lignes
  Printer la ligne 5 et 10 d’une serie de fichiers
  
  for i in fichiers*;do awk ‘NR == 5;NR == 10 {print $0}’ $i;done
• Printer des lignes
  Printer de la ligne 5 a 10 en numerotant
  
  awk ‘NR == 5,NR == 10 {print NR »  » $0}’ in.txt
• Printer des lignes
  Printer la 1ere ligne à la place de la 3eme ligne
  
  sed -n -e ‘1h; 1!p; 3{g;p}’ in.txt
• Printer des lignes
  Printer la 1ere ligne
  
  sed q in.txt
• Printer des lignes
  Printer la dernière ligne
  
  sed -n ‘$p’ in.txt
  sed ‘$!d’ in.txt
• Printer des lignes
  Printer les 2 dernieres lignes
  
  sed ‘$!N;$!D’ in.txt
• Printer des lignes
  Printer les 10 dernieres lignes
  
  sed -e :a -e ‘$q;N;11,$D;ba’ in.txt
• Printer des lignes
  Printer la 1ere et derniere ligne
  
  head -1 in.txt ; tail -1 in.txt
  sed -n ‘1p ; $p’ in.txt
  awk ‘NR==1 ; END {print}’ in.txt
  sed q in.txt;sed ‘$!d’ in.txt
  sed q in.txt;sed ‘$\!d’ in.txt ……….#selon version de Linux
  IFS=$’\n’;array=($(cat in.txt)); echo ${array[0]};sed ‘$!d’ in.txt ……..#en sous shell
• Printer des lignes
  Printer les lignes ayant moins de 6 caracteres
  
  sed ‘/^.\{6,\}/d’ in.txt
• Printer des lignes
  Printer les lignes de 6 caracteres ou plus
  
  sed -n ‘/^.\{6\}/p’ in.txt
• Indexage du premier ‘t’ lu pour chaque ligne
  
  while read line; do echo `expr index « $line » t`; done < in.txt
• Longueur de chaque ligne (en nombre de digits) – voir si la version de Linux supporte : ‘ m4 ‘
  
  while read line; do echo « len($line) » | m4; done < in.txt
  while read line; do echo `expr length « $line »`; done < in.txt
• Formater sur une meme ligne : une ligne paire a droite d’une ligne impaire
  
  cat in.txt | sed « N;s/\(.*\)\n\(.*\)/\1 \2/ »
  cat in.txt | sed « N;s/\n/ / »
  cat in.txt | sed ‘$ !N; s/\n/ /’
• Formater sur une meme ligne : une ligne impaire a droite d’une ligne paire
  
  cat in.txt | sed « N;s/\(.*\)\n\(.*\)/\2 \1/ »
• Affiche 1 ligne sur 2 (lignes 1, 3, 5…)
  
  sed ‘n;d’ in.txt
  sed -n ‘p;n’ in.txt
  sed -n ‘1,${p;n;}’ in.txt
  sed ‘2~2d’ in.txt
  awk ‘FNR % 2’ in.txt
  awk ‘NR%2 {print}’ in.txt
  awk ‘NR%2 == 1’ in.txt
• Affiche 1 ligne sur 2 (lignes 2, 4, 6…)
  
  sed -n ‘n;p’ in.txt
  sed -n ‘1,${n;p;}’ in.txt
  sed ‘1~2d’ in.txt
  awk ‘!(FNR % 2)’ in.txt
  awk ‘(NR+1)%2 {print}’ in.txt
  awk ‘NR%2 == 0’ in.txt
• Affiche 1 ligne sur 5 a partir de la ligne 3
  
  sed -n ‘3,${p;n;n;n;n;}’ in.txt
• Recherche de la ligne la plus longue
  
  awk ‘{ if ( length > L ) { L=length ; s=$0 } } END { print L, »\ » »s »\ » »}’ in.txt

   

  @4-pattern

• Capture d’un pattern dans 1 fichier
  
  grep ‘pattern’ in.txt
  grep -w ‘pattern’ in.txt
  awk ‘/pattern/’ in.txt
  awk ‘$0 ~ /\ypattern\y/ {print}’ in.txt
  sed -n ‘/pattern/p’ in.txt
  sed ‘/pattern/ !d’ in.txt
  grep ‘\’ in.txt
• Printer les lignes ne contenant que des chiffres
  
  sed -n ‘/^[[:digit:]]*$/p’ in.txt
• Printer les lignes ne contenant que des lettres
  
  sed -n ‘/^[[:alpha:]]*$/p’ in.txt
• Capture d’un pattern dans plusieurs fichiers
  
  grep « pattern » in*.txt
  for i in in*.txt;do seq=`ls $i`;awk ‘/pattern/ {print seq,$0}’ seq=${seq} $i;done
• Printer un paragraphe separe par des lignes blanches , contenant un pattern
  
  sed -e ‘/./{H;$!d;}’ -e ‘x;/pattern/!d;’ in.txt
• Printer un paragraphe separe par des lignes blanches , contenant pattern1 ‘et’ pattern2
  
  sed -e ‘/./{H;$!d;}’ -e ‘x;/pattern1/!d;/pattern2/!d’ in.txt
• Printer un paragraphe separe par des lignes blanches , contenant pattern1 ‘ou’ pattern2
  
  sed -e ‘/./{H;$!d;}’ -e ‘x;/pattern1/b’ -e ‘/pattern2/b’ -e d in.txt
• Capturer dans la colonne 1 le pattern ‘2’ et printer la colonne 3
  
  awk ‘$1 ~ /2/ {print $3}’ in.txt
  awk ‘$1 == « 2 » {print $3}’ in.txt
  awk ‘{if($1 ~ /t/){gsub(/t/, « z »,$1);print $0}}’ in.txt
  awk ‘$1 !~ /2/ {print $3}’ in.txt ……….. #syntaxe inverse
  awk ‘$1 \!~ /2/ {print $3}’ in.txt ………..#syntaxe inverse (selon version Linux)
• Supprimer les lignes contenant des patterns
  
  awk ‘$1 !~ /pattern1/ && $2 !~ /pattern2/ ‘ in.txt
  awk ‘$1 ~ /pattern1/ || $2 ~ /pattern2/ {next} {print}’ in.txt
• Capturer le caractère # à la 4ème position
  
  egrep ‘^.{3}#’ in.txt
• Capturer les lignes ayant 4 chiffres ou plus
  
  grep « [0-9]\{4\} » in.txt
• Lire plusieurs patterns – (possibilite de lignes doubles)
  
  awk ‘/pattern1/ {print $0} /pattern2/ {print $0}’ in.txt
  awk ‘FNR==NR && a[$0]=/^t/ || a[$0]=/^d/ {b[$0] ; next} $0 in b’ in.txt in.txt
• utiliser ‘egrep’ si le pattern a plusieurs lignes
  
  egrep -a « MIN WORD 2|MIN WORD32 » in.txt
• ajouter antislash (\) pour le caractère special: |
  
  egrep « 3 \|DISK|4 \| DISK » in.txt
• Lire plusieurs patterns – (sans lignes doubles) (ici lignes contenant a ‘ou’ b)
  
  sed ‘/[ab]/!d’ in.txt
  sed ‘/[ab]/\!d’ in.txt
• Lire plusieurs patterns – (ici lignes contenant a ‘et’ b)
  
  sed ‘/a/!d; /b/!d’ in.txt
  sed ‘/a/\!d; /b/\!d’ in.txt
• Printer les 2 premieres occurrences du pattern
  
  grep -m2 « tata » in.txt
• Substitution uniquement pour la 1ere occurrence
  
  sed ‘0,/tata/ s//zaza/’ in.txt
• Remplace ‘old’ par ‘new’ uniquement sur les lignes commencant par %%
  
  sed ‘/^%%/ s/old/new/g’ in.txt
• Remplace sur chaque ligne du début de la ligne au signe ‘=’ par ‘new’
  
  sed -e ‘1,$ s/^.*=/new/’ in.txt
• Supprimer la ligne contenant ‘toto’ entre ‘titi’ et ‘tutu’
  
  sed -e ‘/titi/,/tutu/ {/toto/d}’ in.txt
• Capture entre ‘toto’ et ‘tata’ (attention si plusieurs occurrences du pattern)
  
  sed -n ‘/toto/,/tata/p’ in.txt
  sed -e ‘/toto/,/tata/ !{/./d}’ in.txt
  sed -e ‘/toto/,/tata/ \!{/./d}’ in.txt
  perl -e « while() {print if/toto/…/tata/} » in.txt
  awk « /toto/,/tata/ » in.txt
• Supprimer entre ‘pattern1’ et ‘pattern2’ (les patterns inclus)
  
  sed -e ‘/pattern1/,/pattern2/d’ in.txt
• Substitution entre 2 patterns
  
  sed ‘/titi/,/tata/ s/toto/zz/g’ in.txt
• Definir un pattern sur lequel la substitution ne se fera pas
  
  sed ‘/toto/!s/t/z/g’ in.txt
• Printer entre ‘titi’ et ‘tutu’
  
  sed -n ‘/titi/{:a;N;/tutu/!ba;p;}’ in.txt
• Capture de ‘titi’ a ‘tutu’ de la ligne 3 a 10
  
  sed -n ‘3,10{/titi/,/tutu/p}’ in.txt
• Supprimer une ligne contenant un pattern + les 2 lignes suivantes
  
  sed ‘/pattern/,+2d’ in.txt
• Supprimer de la ligne 3 a la ligne contenant ‘pattern’
  
  sed -e ‘3,/pattern/d’ in.txt
• Printer d’une ligne contenant 1 pattern jusqu’a la fin
  
  sed -n ‘/pattern/,$p’ in.txt
  sed -n ‘/pattern/,EOF’ in.txt
• Si le pattern est une variable
  
  sed -n ‘/’$var’/p’ in.txt
• Ne pas selectionner les lignes contenant un pattern
  
  grep -v « pattern » in.txt
  awk ‘!/pattern/’ in.txt
  sed ‘/pattern/d’ in.txt
  sed -n ‘/pattern/!p’ in.txt
  awk ‘$0 ~ /pattern/ {next} {print}’ in.txt
• A un pattern inserer une ligne
  
  sed -e ‘/pattern/ i\ligne ecrite avant le pattern’ in.txt ………… (option ‘i’ : avant le pattern)
  sed -e ‘/pattern/ a\ligne ecrite apres le pattern’ in.txt ………… (option ‘a’ : apres le pattern)
• A un pattern inserer une ligne blanche
  
  sed -e ‘/pattern/ i\ ‘ in.txt ………… (option ‘i’ : avant le pattern)
  sed -e ‘/pattern/ a\ ‘ in.txt ………… (option ‘a’ : apres le pattern)
• print le pattern sans distinguer majuscules ou minuscules
  
  grep -i « pattern » in.txt
• print 2 lignes après un pattern ( dans la colonne 1 )
  
  awk ‘/^pattern/ {c=2; next} c–>0’ in.txt
  awk ‘BEGIN {counter=0}; $1== »pattern » {counter=2; next}; counter>0 {counter–; print}’ in.txt
• print le pattern + 2 lignes après (After)
  
  grep -A2 « pattern » in.txt
  sed -n ‘/pattern/ {N;N;p;}’ in.txt
• delete le pattern + 2 lignes après
  
  sed ‘/pattern/ {N;N;d;}’ in.txt
• print le pattern + 2 lignes avant (Before)
  
  grep -B2 « pattern » in.txt
• selectionner tous les caracteres (sans afficher les lignes blanches)
  
  grep « . » in.txt
  awk « /./ » in.txt
  sed -n ‘/./ {p;d}’ in.txt
• combiner motif et ligne
  
  sed ‘8,/fin/ s/toto/titi/g’ in.txt
  sed ‘/debut/,$ s/toto/titi/g’ in.txt
• substituer tout un texte entre 2 motifs excluant les motifs
  
  sed ‘/titi/,/tutu/{/titi/b;/tutu/b;s/.*/SED/;}’ in.txt
• ne pas printer les lignes contenant ‘tata’
  
  sed ‘/tata/d’ in.txt
  sed -n ‘/tata/!p’ in.txt
• Printer les lignes precedant un pattern
  
  sed -n ‘/tata/{g;1!p;};h’ in.txt
• Printer les lignes suivant un pattern
  
  sed -n ‘/tata/{n;p;}’ in.txt
• Remembering a pattern (‘_’ is delimiter)
  
  echo « a line1 » | sed ‘s_\([a-z]\)\([ ]\)\([a-z]*\)\([0-9]\)_\1\2\3 \4_’
  (result: a line 1)

   

  @5-Remplacer des lignes des chiffres ou des lettres

• Exemple d’une suite d’actions entre 2 patterns
  
  sed -n ‘4,10 {/pattern1/,/pattern2/ {s/^0./y&/;/^$/d;s/m/w/g;p}}’ in.txt
• Supprimer tous les chiffres en gardant un tiret ‘-‘ a la place
  
  tr -d 0-9 < in.txt
• supprimer toutes les lettres en gardant un tiret ‘-‘ a la place
  
  tr -d [a-zA-Z] < in.txt
• Conserver les lignes contenant des chiffres
  
  sed -e ‘/[0-9]/!d’ in.txt
  sed -e ‘/[0-9]/\!d’ in.txt ……….. (selon version Unix)
• Supprimer les lettres minuscules en fin de ligne
  
  awk ‘{ sub(« [a-z]*$ », «  »); print }’ in.txt
• Remplacer les lettres par une operande (ici: +)
  
  cat in.txt | tr ‘[:alpha:]’ +
• Remplacer les chiffres par une operande (ici: +)
  
  cat in.txt | tr ‘[:digit:]’ +
• Remplacer 1 caractere par un autre
  
  tr « t » « z » < in.txt
• Suppression des sauts de lignes
  
  tr ‘\n’ ‘ ‘ < in.txt
• Supprimer la répétition de caractères
  
  echo « boonnjoouuur » | tr -s « onu »
• Remplace le bloc (‘t’ suivi de 2 caracteres) par zorro en ligne 4
  
  sed -e ‘4s/t../zorro/g’ in.txt
• Inserer 1 caractere (1 point=1 caractere)
  ( ici l’insertion de ‘Q’ se fera apres les 2 premiers caractères )
  
  echo ‘abcdef’ | sed ‘s/^../&Q/’ ……….. #resultat : abQcdef
• Remplacer en debut de chaine un nombre de points par une lettre
  
  echo ‘abcdef’ | sed ‘s/^../Q/’ ……….. #resultat : Qcdef
• Uniquement le 2eme caractere ‘t’ est remplace par ‘z’ en ligne 4
  
  sed -e ‘4s/t/z/2’ in.txt
  awk ‘NR==4 {print gensub(/t/, »z »,2)}; NR!=4 {print}’ in.txt
• Remplace ‘t’ par ‘k’ , et ‘o’ par ‘l’
  
  sed ‘y/to/kl/’ in.txt
• Effectue le remplacement des lignes 4 a 10 et n’ecrit dans ‘out.txt’ que celles modifiees
  
  sed -e ‘4,10 s/t/&zorro/gw out.txt’ in.txt
• Remplacer un pattern (‘titi’ remplace par: ‘titi et tata’)
  
  sed ‘/titi/ s//& et tata/g’ in.txt
  sed ‘s/titi/titi et tata/g’ in.txt
• tr : remplacement dans un sous shell (taper: sh)
  
  a=abcdef; echo $a | tr f g ……….. #resultat : abcdeg
  a=abcdef; echo ${a//f/g} ……….. #resultat : abcdeg
  a=abcdef; echo $a | tr [ac] [xz] ……….. #resultat : xbzdef
• tr + option -d: effacement (utiliser un sous shell) (taper: sh)
  
  a=abcdef; echo $a | tr -d f ……….. #resultat : abcde
  a=abcdef; echo ${a//f/} ……….. #resultat : abcde
  a=abcdef; echo $a | tr -d [a-c] ……….. #resultat : def
  a=abcdef; echo ${a//[a-c]/} ……….. #resultat : def
  a=abcdef; echo $a | tr -d [ac] ……….. #resultat : bdef
  a=abcdef; echo ${a//[ac]/} ……….. #resultat : bdef
• tr + option -c: inverse l’ensemble des caractères a detecter
  
  echo « acfdeb123 » | tr -c b-d + ……. resultat: +c+d+b++++
• Remplacer toutes les occurrences d’un caractère ou d’un pattern pour chaque ligne
  
  var= »newpattern » ; awk ‘{gsub( /oldpattern/, « ‘ »$var »‘ » )};1’ in.txt
  var= »newpattern » ; awk -v v= »$var » ‘{gsub( /oldpattern/, v )}1’ in.txt
• Remplacer la 2eme occurrence d’un caractère ou d’un pattern pour chaque ligne
  
  awk ‘{print gensub(/old/, « new », 2) }’ in.txt
• Remplacer ‘o’ par ‘zorro’ sauf pour le pattern ‘toto’ ,
  
  sed -e ‘/toto/!s/o/zorro/’ in.txt
• Supprimer les 3 derniers caractères de la dernière ligne uniquement
  
  expr « $(cat in.txt) » : « \(.*\)…$ »
• Supprimer les 3 derniers caractères de chaque ligne
  
  awk ‘sub( « …$ », «  » )’ in.txt
• Printer les 5 premiers caractères de la premiere ligne
  
  echo `cat in.txt`| cut -c1-5
  echo `expr « $(cat in.txt) » : ‘\(…..\)’`
• Printer les 5 premiers caractères de toutes les lignes d’un fichier
  
  cat in.txt | cut -c1-5
  while read line;do echo ${line::5};done < in.txt
  while read line ; do echo $line | cut -c1-5 ; done < in.txt
• Printer les 5 derniers caracteres de toutes les lignes d’un fichier
  
  while read line;do echo ${line: -5};done < in.txt
  sed ‘s/^.*\(…..\)$/\1/’ in.txt
  sed ‘s/\(.*\)\(.\{5\}\)/\2/’ in.txt
• Substituer toto ou titi par tata
  
  sed ‘s/toto\|titi/tata/g’ in.txt

   

  @6-Supprimer des lignes blanches ,espaces ,tabulations

• Supprimer les lignes blanches (l’option ‘-i’ reecrit directement dans le fichier)
  
  sed ‘/./!d’ in.txt
  sed -i ‘/^$/d’ in.txt ……….. (l’option ‘-i’ est a manier avec precaution)
• Supprimer les lignes blanches repetees sauf la 1ere
  
  cat -s in.txt
• Supprimer uniquement les lignes blanches du debut du fichier
  
  sed ‘/./,$!d’ in.txt
• Supprimer tout ce qui suit la 1ere ligne blanche
  
  sed ‘/^$/q’ in.txt
• Supprimer tout ce qui precede la 1ere ligne blanche
  
  sed ‘1,/^$/d’ in.txt
• Supprimer les lignes blanches entre ‘tata’ et ‘route’
  
  sed -e ‘/tata/,/route/ {/^$/d}’ in.txt
• Remplacer 2 blancs (ou +) par 1 seul blanc
  
  sed ‘s/\ \ */\ /g’ in.txt
• Suppression des espaces et tabulations en debut et fin de ligne
  
  sed ‘s/^[ \t]*//;s/[ \t]*$//’ in.txt
• Suppression des lignes vides
  
  grep -v ‘^$’ in.txt
  grep ‘.’ in.txt
  sed -n ‘/^$/!p’ in.txt
  awk NF in.txt
  awk ‘/./’ in.txt
  sed ‘/^$/d’ in.txt
  sed ‘/./!d’ in.txt
  awk ‘/^$/ {next} {print}’ in.txt
• tr + option squeeze-repeats: efface tout sauf la première
  occurence d’une chaîne de caractères
  (utile pour supprimer plusieurs espaces blancs)
  
  echo « XXXXX » | tr –squeeze-repeats ‘X’ ……. resultat: X
• Supprime tous les espaces au début de toutes les lignes
  
  sed ‘s/^ *//g’ in.txt
• Supprime tous les espaces à la fin de toutes les lignes
  
  sed ‘s/ *$//g’ in.txt
• Supprimer seulement la première ligne de chaque ensemble de lignes vides consecutives
  
  sed ‘/[0-9A-Za-z]/,/^$/{/^$/d}’ in.txt
• to join lines ( en deletant les lignes blanches )
  
  sed -e ‘/./!d’ -e ‘$!N;s/\n/ /’ in.txt
  sed -e ‘/./\!d’ -e ‘$\!N;s/\n/ /’ in.txt
  grep « . » in.txt | sed ‘$\!N;s/\n/ /’
• to join lines ( en gardant les lignes blanches )
  
  sed -e ‘/./!b’ -e ‘$!N;s/\n/ /’ in.txt
  sed -e ‘/./\!b’ -e ‘$\!N;s/\n/ /’ in.txt
  grep « . » in.txt | sed ‘$\!N;s/\n/ /’ | sed G

   

  @7-Inserer

• Inserer une ligne blanche apres chaque ligne
  
  sed G in.txt
  sed ‘a\ ‘ in.txt
• Inserer une ligne de tirets toutes les 2 lignes
  
  sed ‘n;a\———-‘ in.txt
• Inserer une ligne blanche toutes les 3 lignes
  
  sed ‘n;n;G;’ in.txt
• Inserer une ligne blanche apres chaque ligne sauf apres la ligne 3
  
  sed ‘3!G’ in.txt
• Inserer une ligne au debut, à la 3eme ligne et à la fin du fichier
  
  sed -e ‘1i \debut\ du\ traitement’ in.txt
  sed -e ‘3i \ajout\ a\ la\ 3eme\ ligne’ in.txt
  awk ‘NR == 3 {print « line3 »}1’ in.txt
  sed -e ‘$a \fin\ du\ traitement’ in.txt
• Inserer une ligne à un pattern
  
  sed -e ‘/pattern/ i\ligne ecrite avant le pattern’ in.txt ………… (option ‘i’ : avant le pattern)
  sed -e ‘/pattern/ a\ligne ecrite apres le pattern’ in.txt ………… (option ‘a’ : apres le pattern)
• Inserer une ligne blanche à un pattern
  
  sed -e ‘/pattern/ i\ ‘ in.txt ………… (option ‘i’ : avant le pattern)
  sed -e ‘/pattern/ a\ ‘ in.txt ………… (option ‘a’ : apres le pattern)
• Changer la ligne si elle contient un pattern
  
  sed -e ‘/pattern/ c\new line’ in.txt
• Inserer **DELETED** et supprimer les lignes entre 2 patterns
  
  sed ‘/pattern1/,/pattern2/ c\**DELETED**’ in.txt
• Inserer la ligne ‘line before’ avant chaque ligne du fichier
  
  sed -e ‘i\line before’ in.txt
• Inserer du texte avant une ligne matchée par un pattern
  
  sed -e ‘/pattern/ i\line before pattern’ in.txt
• Inserer une ligne blanche avant une ligne matchée par un pattern
  
  sed ‘/tata/{x;p;x}’ in.txt
  sed -e ‘/pattern/ i\ ‘ in.txt
• Inserer une ligne blanche après une ligne matchée par un pattern
  
  sed ‘/tata/G’ in.txt
  sed -e ‘/pattern/ a\ ‘ in.txt
• Inserer une ligne blanche avant et apres une ligne matchee par un pattern
  
  sed ‘/tata/{x;p;x;G}’ in.txt
• Inserer un fichier ‘temp.txt’
  
  sed ‘1r temp.txt’ < in.txt ……….après la 1ère ligne de ‘in.txt’
  sed ‘/pattern/ r temp.txt’ < in.txt ………apres le pattern
• Inserer un ‘blanc’ devant toutes les lignes
  
  sed -e ‘s/^./ &/g’ in.txt
  sed ‘{s_^_ _}’ in.txt
• Inserer un ‘blanc’ à toutes les fins de lignes
  
  sed -e ‘s/.$/& /g’ in.txt
• Inserer un ‘blanc’ apres tous les ‘t’ (a droite) en ligne 4
  
  sed -e ‘4s/t/& /g’ in.txt
  sed -e ‘4\!s/t/& /g’ in.txt ……….. #syntaxe inverse
• Inserer au 5ème caractère après 3 caractères le signe # sur la ligne 2
  
  sed -r « 2 ~ s/^(.{4})(.{3})/\2#/ » in.txt

   

  @8-divers

• Printer un fichier
  
  cat in.txt
  sed  » in.txt
  sed ‘:’ in.txt
• Dupliquer toutes les lignes
  
  sed ‘p’ in.txt
• printer 3 fois chaque ligne
  
  sed ‘{h;p;p}’ in.txt
  while read line;do for i in `seq 1 3`;do echo $line;done;done < in.txt
• Inverser l’ordre d’un fichier
  
  tac in.txt
  sed -n ‘1!G;h;$p’ in.txt
  awk ‘{ a[i++]=$0 } END { for (j=i-1; j>=0; ) print a[j–] }’ in.txt
• Ecrire 1 mot par ligne (pour 5 mots: -n5)
  
  cat in.txt | xargs -n1
  awk ‘{i=1; while (i<=NF){print $i,  » « ;i++}}’ in.txt
• Ecrire un caractère par ligne
  
  while read line; do echo -n « $line » | dd cbs=1 conv=unblock 2>/dev/null; done < in.txt
• Ecrire un fichier sur une ligne
  
  sed ‘{:a;$!N;s_\n_ _;ta}’ in.txt
• Joindre les lignes paires a la suite des lignes impaires
  
  sed ‘$!N; s/\n/ /g’ in.txt
• Transforme les lignes en colonnes
  
  awk ‘{printf « ligne%d: %s « ,NR,$0> »z-cible »}’ z-source
• Ajouter en prefixe le nombre d’occurences des mots et trier
  
  cat in.txt | xargs -n1 | sort | uniq -c | sort -nr
• Print les 10 premiers (ou derniers) caracteres d’un fichier
  
  head -10c in.txt ……….. #les 10 premiers
  tail -10c in.txt ……….. #les 10 derniers
• Decoupe en n caracteres le fichier ‘in.txt’ (ici n=10)
  creation de fichiers: prefixe_outaa (outab..outac…)
  
  split -b 10 in.txt prefixe_out
• Decoupe en n lignes le fichier ‘in.txt’ (ici n=5)
  
  creation de fichiers: prefixe_outaa (outab..outac…)
  split -l 5 in.txt prefix_out
  awk ‘{print >(« prefix_out » int((NR+4)/5))}’ in.txt
• Trier un fichier
  
  dans un ordre numerique (-n); avec separateur (-t); colonne (-k); et place du caractere (.)
  cat in.txt | sort -n -t »  » -k2.4
  dans un ordre decroissant (-r) et en retirant les doubles (-u) :
  cat in.txt | sort -r -u
• Copier un fichier
  
  cp old_file new_file
  sed ‘w new_file’ old_file
• Definir un marqueur en fin de ligne (ici ,) qui joindra la ligne suivante
  
  sed ‘/\,$/ {N; s_\,\n_ _}’ in.txt
  sed -e :a -e ‘/\,$/N; s_\,\n_ _; ta’ in.txt
• Si 1 ligne se termine par ‘,’ joindre la suivante a elle
  
  sed -e :a -e ‘/,$/N ; s#\n## ; ta’ in.txt
• Si 1 ligne commence par un signe egale ‘=’ , l’ajouter a la ligne precedente et remplacer le signe egale ‘=’ par un espace
  
  sed -e :a -e ‘$!N;s/\n=/ /;ta’ -e ‘P;D’ in.txt
• « Dispach » (inverse du « regroupe »)
  split en couples: [‘colonne 1’-‘parties[k]’]
  en ‘k’ fois nombre de lignes
  
  awk ‘{key=$1;$1= » »;n=split($0, parties, « [,] »);for(k=1; k0) print $0}’ | awk ‘{if($1 != key){key = $1} else {$2 += cum} cum=$2; print}’ > out.txt
• « Regroupe » (inverse du « dispach »)
  (tous les elements semblables de la colonne 1
  sont regroupes sur 1 seule ligne)
  
  awk ‘{key=$1; $1=$2= » »;f[key]=f[key] s[key] $0;s[key]= », »} END {for(key in f){gsub(/[[:space:]]/, » »,f[key]);printf « %s %s\n »,key,f[key]}}’ in.txt| sort > out.txt
• Encadre le premier nombre de la ligne avec des ** , ne printer que ces lignes
  
  sed -n « s/\([0-9][0-9]*\)/**\1**/p » in.txt
• Printer les lignes avec 3 digits consecutifs
  
  sed -n ‘/[0-9]\{3\}/p’ in.txt
• Inserer un espace entre chaque lettre
  
  echo -e « bonjour »|sed ‘s/./& /g’ …………….resultat: b o n j o u r
  echo -e « bonjour »|sed -r ‘s/([^ ])/\1 /g’
  echo -e « bonjour »|sed ‘s/\([^ ]\)/\1 /g’
• Mettre en majuscule la 1ère lettre d’une phrase
  
  echo -e « texte ligne1\ntexte ligne2 » | sed ‘s/^./\u&/’
• dirname …………(en sous shell)
  
  var= »/home/Bureau/1/in.txt » ……. (en sous shell)
• dirname $var ……….. —-> /home/Bureau/1
  
  echo ${var%/*} ……….. —-> /home/Bureau/1
• basename ……. (en sous shell)
  
  basename $var ……….. —-> in.txt
  echo ${var##*/} ……….. —-> in.txt
• while dans un sous shell (taper: sh)
  
  while read line; do echo -en « $line\n »; done < in.txt
  while read line; do echo -e $line; done < in.txt
• ‘set’ decoupe 1 variable en parametres positionnels dans un sous shell (taper: sh)
  
  string= »a b:c def:g »; IFS=’:’; set $string; echo « $1 »
• read …$REPLY : equivalent de : head -1
  
  read -r
• Contenu des dossiers sans les sous dossiers
  
  for fichier in *;do ls -al ;done
• Contenu des dossiers avec les sous dossiers
  
  for fichier in *;do ls -al « $fichier »;done
• nombre de fichiers dans le repertoire courant (equivaut a: ls|wc -l)
  
  a=0;for i in *;do a=$(($a+1));done;echo nb=$a
• apostrophe et guillemet
  
  echo -n « your name is: « ; read name ……….. #taper: toto
  echo ‘hi $name’ ……….. #resultat : hi name
  echo « hi $name » ……….. #resultat : hi toto
• par defaut, le separateur est ‘blanc’
  [Utiliser les parentheses () pour le sous shell]
  
  echo « moi et moi, lui, les autres » | (read x y ;echo $y) ……….. (->lui les autres)
• nouveau separateur
  
  IFS= », »;echo « moi et moi, lui, les autres » | (read x y;echo $x) ……….. (->moi et moi)
• liste des variables d’environnement
  
  export
• detruire la valeur d’une variable
  (utiliser un sous shell en tapant: sh + return)
  
  var=7 echo $var ……….. -> 7
  unset var ……….. -> nothing
• Concatenation
  (utiliser un sous shell en tapant: sh + return)
  
  var=debut;echo ${var}ant ……….. —->debutant
• Commande ‘set’ et ‘shift’
  (utiliser un sous shell en tapant: sh + return)
  
  c= »prof eleve classe note »;set $c;echo $1 $2
  ……….. —>prof eleve
  c= »prof eleve classe note »;shift;echo $1 $2
  ……….. —>eleve classe

• Commande ‘eval’
  (utiliser un sous shell en tapant: sh + return)
  
  message= »date d’aujourd’hui? »;set $message;echo $# …….#resultat: 2
  message= »date d’aujourd’hui? »;set $message;echo $1 …….#resultat: date
  message= »date d’aujourd’hui? »;set $message;eval $1 …….#resultat: dim 20 jan..
   

c’est un outil sympa qui permet de filtrer. Soit on lui demande ce que l’on veut voir, soit on lui demande d’enlever ce que l’on ne veut pas voir.

Exemple d’usages de grep

Si je tape : grep titi toto.txt, il va m’afficher les occurrences du mot titi dans le contenu du fichier toto.txt

si je fais grep -r titi toto.txt, il m’affichera tout ce qui ne contient pas titi dans le fichier toto.txt.

Grep travail ligne à ligne ce qui permet de faire disparaitre toutes les lignes qui comporterait titi et d’afficher toutes les autres. Bien sûr on peut chainer les grep :

cat toto.txt | grep titi | grep -v tata | grep -v tutu

Cette commande affichera toutes les lignes de toto.txt qui contienne titi mais pas tata ou tutu. Si on ajoute le switch -r ca devient une commande récursive (qui ira dans les sous directory), par exemple : grep -r tutu *.txt cherchera dans tous les fichiers .txt de tous les sous répertoires l’expression tutu. On peut aussi utiliser -i pour qu’il ne soit pas sensible à la casse (majuscule/minuscule) et qu’il considère que TUTU et Tutu sont les mêmes choses.