echo 'un texte' | tr ' ' '_' > ./fichier.txt

#/bin/ksh
# Cette fonction permet de factoriser le code des fonctions 
# de calcul du min et du max
function recherche {
	res=$1
	for nombre in $*
	do
		(( $nombre $symbole $res )) && res=$nombre
	done
	echo $res
}

# Cette fonction affiche le minimum de la chaine en paramètre
function min {
	symbole='<'
	recherche $*
}

# Cette fonction affiche le maximum de la chaine en paramètre
function max {
	symbole='>'
	recherche $*
}

# Cette fonction affiche le minimum de la chaine en paramètre
function min {
	echo $* | tr ' ' '\n' | sort -n | head -1
}
 
# Cette fonction affiche le maximum de la chaine en paramètre
function max {
	echo $* | tr ' ' '\n' | sort -n | tail -1
}

#!/bin/ksh
# Emplacement de la corbeille
corbeille=/tmp/$USERNAME/corbeille

# Cette fonction permet d'archiver un fichier
# $1 chemin complet du fichier à archiver
function del {
	[[ ! -e $corbeille ]] && mkdir -p $corbeille
	[[ -e $1 ]] && tar -cvf $corbeille/$1.tar $1 && rm -r $1 
}

# Cette fonction restaure un fichier 
# $1 nom du fichier à restaurer
function undel {
	if [[ -e $corbeille/$1.tar ]]
	then
		tar -xvf $corbeille/$1.tar
		rm $corbeille/$1.tar
	fi
}

# Cette fonction liste les fichiers de la corbeille
function listdel {
	ls $corbeille
}

# Cette fonction vide la corbeille
function purgedel {
	for fichier in $(ls $corbeille)
	do
		rm $corbeille/$fichier
	done
}

(( alea = $RANDOM % 101 ))
i=1
echo "Essayez de deviner le nombre (entre 0 et 100)"
while [[ $i -le 10 ]]
do
	read proposition
	[[ $proposition -lt $alea ]] && echo trop petit
	[[ $proposition -gt $alea ]] && echo trop grand
	[[ $proposition -eq $alea ]] && echo Gagne && exit 0
	echo "Essayez encore"
	(( i++ ))
done
echo "Perdu ! le nombre etait $alea"

#/bin/ksh

repertoire=$1
nbRep=0
nbFic=0
for element in $repertoire/*
do
	[[ -d $repertoire/$element ]] && (( nbRep++ ))
	[[ -f $repertoire/$element ]] && (( nbFic++ ))
done
echo $nbRep repertoires et $nbFic fichiers

repertoire=$1
ls -l $repertoire | grep '^d.*' | wc -l

i=0
while [[ $i -lt 20 ]]
do
	alea=$RANDOM
	(( $alea % 2 == 0 )) && echo $alea && (( i++ ))
done

#!/bin/ksh

# Cette fonction permet de numéroter les lignes lues 
# dans l'entrée standard
function numeroter {
	i=0
	while read a
	do
		(( i++ ))
		echo $i" "$a
	done
}
if [[ $# -ne 0 ]]
then
	numeroter < $1
else
	numeroter
fi

function numeroter {
	awk '{print NR" "$1}';
}

[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}

[0-9][0-9] [a-z][a-z]* [0-9][0-9][0-9][0-9]

#/bin/ksh

dossier_echange=/net/S50F-KSH-GGA/Users/k0b6qu/Desktop/echange
ident=k0b6qu

while read commande 
do 
	echo $commande > $dossier_echange/actions_$ident.ksh
	while [[ ! -e $dossier_echange/reponse_$ident.txt ]]
	do
		sleep 1
	done
	cat $dossier_echange/reponse_$ident.txt
	rm -f $dossier_echange/reponse_$ident.txt
done

Partie 2 : le serveur

• Le serveur attent qu'un fichier actions_<idep>.ksh soit créé dans le répertoire d'échange
• Une fois que ce fichier est créé, il exécute la commande contenue dans ce fichier, et enregistre le résultat de la commande dans le répertoire échange sous la forme : reponse_<idep>.txt
• Il supprime le fichier actions_<idep>.ksh et se remet en attente de ce fichier

#/bin/ksh
# Emplacement du dossier partagé
dossier_echange=/net/S50F-KSH-GGA/Users/k0b6qu/Desktop/echange

# Identifiant des fichiers à traiter
ident=k0b6qu

# Fonction permettant de traiter une commande dans le fichier
# texte $dossier_echange/actions_$ident.ksh
function traiter_commande {
	reponse=$dossier_echange/reponse_$ident.txt
	$dossier_echange/actions_$ident.ksh > $reponse 2>&1
	rm -f $dossier_echange/actions_$ident.ksh
}

commande=$dossier_echange/actions_$ident.ksh
while true
do
	[[ -e  $commande ]] && traiter_commande
	sleep 1
done

BEGIN{
	i=0;
	n=0;
}
{
	n=n+$9;
	i=i+1;
}
END{
	printf "%d fichiers\nTaille moyenne : %.2f\n", i, n/i;
}

#
# Ce script permet de lancer un jeu "Motus"
# Parametre 1
#	Le mot à trouver
#

# La chaine de caractères à trouver
atrouver=$1

#
# Fonction permettant de comparer une proposition à atrouver
# La chaine de caractères en_cours est actualisée par la fonction
# Parametre 1
# 	Proposition à comparer à atrouver
# Retour
#	0 si les chaines de caractères sont identiques
#	1 sinon
#
function verifier {
	res=0
	encours=$(echo $atrouver | cut -c 1)
	i=2
	while [[ $i -le ${#atrouver} ]]
	do
		l1=$(echo $atrouver | cut -c $i)
		l2=$(echo $1 | cut -c $i)
		if [[ "$l1" == "$l2" ]]
		then
			encours=$encours" $l1"
		else
			encours=$encours" _"
			res=1
		fi
		(( i++ ))
	done
	return $res
}

verifier

clear
while true
do
	echo $encours
	echo "Entrez votre proposition"
	read prop
	clear
	verifier $prop
	[[ $? -eq 0 ]] && echo Gagne && break
done

lastmodif=0
fichier_conversation=/dev/fs/D/messagerie/conversation.txt
while true
do
	modif=$(ls $fichier_conversation -l | cut -d " " -f 9)
	if (( $modif == $lastmodif ))
	then
		sleep 1
	else
		clear
		cat $fichier_conversation
		lastmodif=$modif
	fi
done

fichier_conversation=/dev/fs/D/messagerie/conversation.txt
while true
do
	read a
	while [[ -e /dev/fs/D/samuelestlemeilleur/.LOCK ]]
	do
		sleep 1
	done
	touch /dev/fs/D/messagerie/.LOCK
	echo "Julien dit: $a" >> $fichier_conversation
	rm -f /dev/fs/D/messagerie/.LOCK
done

BEGIN{
	pas=0.15;
	borneinf=0;
	borneSup=500;
	multiplicateur=40;
	for(i=borneinf;i*pas+borneinf<borneSup;i++) {
		system("sleep 1");
		x=borneinf+pas*i;
		chaine="";
		if(multiplicateur*cos(x)>0) {
			for(j=0; j<multiplicateur;j++) {
				chaine=sprintf("%s ", chaine);
			}
			chaine=sprintf("%s|", chaine);
			for(j=0;j<multiplicateur*cos(x);j++){
				chaine=sprintf("%s ", chaine);
			}
			chaine=sprintf("%s*", chaine);
		}
		else{
			for(j=-multiplicateur;j<multiplicateur*cos(x);j++){
				chaine=sprintf("%s ", chaine);
			}
			chaine=sprintf("%s*", chaine);
			for(j=multiplicateur*cos(x); j<-2;j++){
				chaine=sprintf("%s ", chaine);
			}
			chaine=sprintf("%s|", chaine);
		} 
		print chaine;
	}
}

#!/bin/ksh
# Ce script permet d'afficher un fichier texte
# Options
# -n
#	Numérote les lignes du fichier
# -h nb
# 	Affiche les nb premières lignes du fichier
# Paramètres
# paramètre 1
#	Le fichier texte à afficher

echo $* | grep -q '\-n' && numerotation=ok
debut=$(echo $* | grep '\-h' | sed 's/.*-h *\([0-9]*\).*/\1/')

fichier=$(echo $* | sed 's/-n//;s/-h *[0-9]*//;s/ +/ /g;s/^ *//')
[[ ! -e $fichier ]] && echo Le fichier n\'existe pas >&2 && exit 1

# Cette fonction permet de numéroter les lignes
# de l'entrée standard
function numeroter_lignes {
	i=1
	while read l
	do
		echo "$i : $l"
		(( i++ ))
	done
}

commande="cat"
[[ ! -z $lignes_deb ]] && commande="head -$debut" 
commande="$commande $fichier"
[[ "$numerotation" = "ok" ]] && $commande | numeroter_lignes && exit 0
$commande && exit 0
exit 1

#Le pipe ne sert à rien, la redirection de l'entrée se fait sur un fichier et non sur un processus.
grep '7:' < fichier.txt

#La commande cat permet de concaténer les fichiers, pas de les lire. Pour lire un fichier, on le place dans l'entrée standard
while read f
do
	commande "$f"
done < file

#Le nombre de test à réaliser est trop important, le programme sera long à cause des boucles imbriquées, et on ne comprend pas facilement ce qui se passe. Il y a plusieurs facons de corriger les erreurs.
partage_ihm=Production
[[ $S_ESPEXE == I ]] && partage_ihm=Recette
[[ $S_ESPEXE == A ]] && partage_ihm=Developpement
[[ $S_ESPEXE == S ]] && partage_ihm=Integration

case $S_ESPEXE in
	I ) partage_ihm=Recette ;;
	A ) partage_ihm=Developpement ;;
	S ) partage_ihm=Integration ;;
	X ) partage_ihm=Production ;;
esac

#Awk permet de réaliser des filtres sur les lignes d'un fichier, il n'y a donc pas de raison d'utiliser un grep.
ps -l | awk '!/ *STATE.*/{print $2}'

#Trop d'instructions s'enchainent, et bien qu'il n'y ait pas d'erreur grossière, le temps de traitement est très fortement impacté.
admsnap activate -s $sess | grep hdiskpower | cut -d ' ' -f '6' | sed 's/\/dev\/r//' | tr -d '.'
# ou
admsnap activate -s $sess | awk '/.*hdiskpower.*/{gsub("/dev/r/", "", $6);print $6;}'
# ou
admsnap activate -s $sess | sed 's/.*\(hdiskpower[0-9]*\)\.\([0-9]*\)/\1\2/g'

# Le cd est inutile, et les paramètre doivent être entourés par des guillemets au cas où l'utilisateur entre un nom de fichier avec des espaces.
while true
do
echo entrer le nom du fichier à afficher
read fichier
	cat "$repertoire/$fichier"
done

# *.txt est expansé directement, pas besoin d'utiliser de ls ou de echo.
for f in *.txt
do
	cat "$f"
done

# On ne réalise pas de cd dans une fonction pour ne pas modifier les informations du processus courant. Si on fait un cd, on restaure à l'état initial.
# Mais le mieux est sans doute de n'utiliser dans les fonction (et de manière générale) que des chemins absolus.
# Le cd est une simplification pour l'utilisateur, mais n'est pas indispensable dans les scripts.
function f {
	...
	rep_courant=$(pwd)
	cd /dev/fs/D/dossier
	cd $rep_courant
}

# Le pipe vers la commande read ne fonctionne pas en kornshell sous SUA, certains shell acceptent cette syntaxe.
var=$(ls $dossier | head –1)

# Il ne faut pas oublier les guillemets autour de $fichier dans ce cas. Même s'ils protègent l'affectation, ils ne se retrouvent pas dans la ligne suivante
fichier="/dev/fs/C/fichier 1.txt"
ls "$fichier"

# L'option -c permet de compter le nombre de motifs intercéptés par grep.
commmande | grep -c '..*'

alias est affiché. En effet, le traitement des alias est antérieur à celui des fonctions, f est donc d'abord remplacé par « echo alias ».

ps -l est exécuté. Les alias sont traités entièrement, tant qu'il existe un alias dans la ligne de commande, celui-ci est résolu.

fonction est affiché. Lors de l'appel de f, l'alias est traité en premier, f est remplacé par fonction. Lors de la localisation de la commande a effectuer, fonction est trouvée dans la liste des fonctions en mémoire et est exécutée.

Une erreur est générée, a n'est pas reconnu en tant que commande interne. Lors de la détermination du type de commande, le traitement des alias a déjà été effectué. Voir les étapes d'intérprétation de la ligne de commande.

Une erreur est générée, l'intéprétation des variables se fait après le traitement des alias.

ls est exécuté.

script1 est affiché dans la console

. ./script1.ksh

script1 est affiché dans la console et on sort de l'interpréteur.

Les variables ne sont intérprétées qu'une seule fois, $var1 est affiché. Pour afficher le contenu de var1, on utiliserait

eval echo $var2

Dans ce cas, l'évaluation des variables est faite deux fois.

pwd affiche /etc, le cd effectué dans Script1.ksh est fait dans un autre processus que le processus courant.

texte > fichier.txt est affiché dans la console, La mise en place des redirections ne signifie pas que la redirection est lue sur la commande, la redirection est récupérée sur au moment du découpage de la ligne en mots, le symbole > est considéré comme un séparateur.si un > se retourve encore sur la ligne de commande au moment de la mise en palce des redirections, il n'est pas pris en compte comme le symbole de redirection mais comme un caractère quelconque. S'il n'est pas présent au départ sur la ligne, la redirection ne peut être mise en place.

var est affiché, l'alias n'est remplacé que lorsqu'il s'agit d'une commande.

awk '
BEGIN{
	print "<html><body><h1>Annuaire</h1>";
}
/[A-Z][a-z]+ [A-Z]+ [0-9]+ [0-9]+ [0-9]+ M|F [0-9]+/{
	printf "<p>\n<b>";
	if($6 == "M"){
	printf "Mr ";
	}
	else {
		printf "Mme ";
	}
	printf "%s %s</b>\n<br />", $1, $2;
	printf "ne le : %d/%d/%d\n<br />", $3, $4, $5;
	printf "tel : %s\n<br />", $7;
	printf "mail:%s.%s@insee.fr</p>\n", tolower($1), tolower($2);
 
}
END{
	print "</body></html>";
}'

# Appel de sed sed -n -f commandes_sed.txt annuaire.txt

# Le script sed correspondant :
1, /[A-Z][a-z]* [A-Z]* [0-9]* [0-9]* [0-9]* [MF] [0-9]*/s!^!<html><body><h1>Annuaire</h1>!g

/[A-Z][a-z]* [A-Z]* [0-9]* [0-9]* [0-9]* [MF] [0-9]*/!d

s/\([A-Z][a-z]* [A-Z]* [0-9]* [0-9]* [0-9]* \)M\( [0-9]*\)/\1Mr\2/g

s/\([A-Z][a-z]* [A-Z]* [0-9]* [0-9]* [0-9]* \)F\( [0-9]*\)/\1Mme\2/g

s!\([A-Z][a-z]*\) \([A-Z]*\) \([0-9]*\) \([0-9]*\) \([0-9]*\) \(M[mr][e]*\) \([0-9]*\)!<p><b>\6 \1 \2</b><br />ne le : \3/\4/\5<br />tel : \7<br />mail : \1.\2@insee.fr</p>!g

p

#
# Fonction qui affiche autant de batons que d'alumettes restantes
# Parametre 1 : le nombre de batons à afficher
#
function afficher_reste {
	i=0
	a_afficher=""
	while (( $i < $1 ))
	do
		a_afficher="| "$a_afficher
		(( i++ ))
	done
	echo $1 alumettes restantes :
	echo $a_afficher
}

#
# Fonction qui permet de prendre des alumettes
# Parametre 1 : nombre d'alumettes à prendre
#
function prendre {
	if (( $1 < 4 ))
	then
		(( alumettes_resantes-=$1 ))
	else
		echo vous ne pouvez pas prendre plus de 3 alumettes
	fi
}

#
# Fonction qui permet de faire jouer l'ordinateur
#
function jeu_systeme {
	a_prendre=3
	(( \( $alumettes_resantes - 1 \) % 4 == 1 )) && a_prendre=1
	(( \( $alumettes_resantes - 2 \) % 4 == 1 )) && a_prendre=2
	echo le systeme prend $a_prendre alumettes
	prendre $a_prendre
}

#
# Fonction de lancement d'une nouvelle partie
#
function nouvelle_partie {
	alumettes_resantes=15
	while (( $alumettes_resantes > 1 ))
	do
		afficher_reste $alumettes_resantes
		echo combien vous vous en prendre ?
		read choix
		prendre $choix
		if [[ $alumettes_resantes -ne 1 ]]
		then
			sleep 1
			jeu_systeme
			(( $alumettes_resantes==1 )) && echo Vous avez perdu 
		else 
			echo vous avez gagne
		fi
	done
}

trap 'rm -f $sortie' INT
trap 'i=0' HUP
sortie=sortie.txt
i=0
while true
do
	sleep 5
	echo $i > $sortie
	(( i++ )) 
done

Partie 2. Lancement du processus
Lancez le processus en arrière plan et tester la réinitialisation et l'arrêt avec Ctrl+C (sans utiliser de kill).

./compeur.ksh &
kill -HUP %1 &
jobs
	[1] + Running	 ./compteur.ksh
fg %1
Ctrl+C

set -x
trap 'kill -9 $ancienPid; kill -9 $pidChampTexte; exit 0' INT KILL

fic=/home/messagerie/conversation.txt
> $fic_conv

java -DnomUtilisateur=Julien -jar ChampTexte.jar >> $fic_conv &
pidChampTexte=$!

nbLignes=0
while true
do
	nb=$(wc -l < $fic_conv)
	if [[ $nb -ne $nbLignes ]]
	then
		nbLignes=$nb
		[[ -n $ancienPid ]] && kill -9 $ancienPid
		java -jar AffichageFichier.jar $fic_conv &
		ancienPid=$!
	fi
	sleep 1
done