PENSE-BETE KORN SHELL

INITIALISATION/ TERMINAISON DE KSH
------------------------------------------------------------------------
Initialisation 
    - Lit /etc/environment
        Initialisation $PATH , $MANPATH , etc. . . .     
    
    - Lit /etc/profile 
        Prompt, alias, etc.     
    
    - Lit $HOME/.profile 
        Equivalent à /etc/profile , mais spéecifique à un utilisateur.

Terminaison 
    Lit $HOME/.logout (permet de faire du ménage automatiquement, par
exemple)

CONFIGURATION
------------------------------------------------------------------------
Variables
    PATH=/usr/local/bin:/usr/bin
    export PATH=/usr/local/bin:/usr/bin
    PATH=$PATH:/usr/bin/X11
Mode d’édition:
    set -o emacs 
Alias :
    alias -x rm="/usr/bin/rm -i"   ; alias ls="ls -a" 

LES PRINCIPALES VARIABLES
------------------------------------------------------------------------
$EDITOR     : equivalent ` a la commande "set -o editeur"
$HISTFILE   : fichier d’historique
$HISTSIZE   : taille du fichier d’historique
$HOME       :repertoire par defaut
$PATH       : liste des repertoires d’executables
$PS1        : prompt principal
$PS2, $PS3, $PS4 : prompts secondaires
$?          : code de retour du dernier processus termine
$$          :numero du processus courant
$PWD        :repertoire courant

TRAVAILLER AVEC L'ENVIRONMENT
------------------------------------------------------------------------
logname login name
id      login name and active group id
groups  display group membership
env     display values of environment variables

MANIPULATION DES VARIABLES
------------------------------------------------------------------------
Modification d’une variable :
    PATH=/usr/bin
    PATH=$PATH:$HOME/bin:.

Liste des variables :
    env 

Exportation de variables :
    export PATH
    export PATH=/usr/bin    

EXPANSION DES NOMS DE FICHIER
------------------------------------------------------------------------
~˜ , ~˜user : repertoire personnel
toto[1-9] : [1-9] remplace un caractere entre ’1’ et ’9’
Auto-completion (en mode emacs) :
    meta- ESC : complete le mot 
    meta-= : affiche la liste des completions possibles

COMMAND LINE EDITING
------------------------------------------------------------------------
<ESC>k puis [k] ou [j] pour avancer/reculer dans l'historique
set -o vi ou set -o emacs

CHAINES DE CARACTERES
------------------------------------------------------------------------
- Simple quote : chaine brute, aucune substitution
  echo ’'mon repertoire est $HOME’'
- Double quote : interprete les caracteres $, \, et ‘
  echo "mon repertoire est $HOME"
- Back quote : 
  remplace la chaine par le resultat de son execution
  echo "le repertoire courant est `‘pwd`‘"

ENCHAINEMENT DE COMMANDES
------------------------------------------------------------------------
- commande 
- commande1 ; commande2 
- (cd /etc ; ls)   --> dans un autre shell
- commande &
- commande1 && commande2 
( 2 si 1 est ok )
- commande1 || commande2
 ( 2 si 1 non ok )

REDIRECTIONS
------------------------------------------------------------------------
- le shell dispose de 3 flots de communication 
    - l'entrée standard : stdin (0)
    - la sortie standard : stdout (1)
    - la sortie des erreurs : stderr (2)

- commande > fic1 
- commande < fic2 
- commande >> fic1 
- commande << LA FIN 
  xyz
  abc 
  LA FIN 
- commande 2> fic1 ( redirige la sortie 2 )
- commande >&2

- d=$(date)  redigire la sortie de la commande date dans la variable d


QUELQUES COMMANDES 
------------------------------------------------------------------------
who / whoami 
su

head : debut du fichier 
    Les 10 premieres lignes : head toto.txt 
    Les 20 premieres lignes : head -20 toto.txt 
tail : fin du fichier 

cut : extrait un/plusieurs champ(s) des lignes d’entree 
    Les mots 3 et 4 de chaque ligne :
    cut -f 3,4 -d ' '’ toto.txt 
wc : compte les lignes/mots/caracteres

find : find repertoire critere action 
       Example : find $HOME -name ’'*.c'’
                 find /users -name a.out -mtime +7 -exec rm {} \; 


sort : tri 
    Tri alphabetique : sort toto. txt 
    Tri numerique : sort -n toto. txt 

grep : 
    grep bonjour toto.txt 
    grep "bonjour a tous" toto.txt 
    grep "^bonjour a tous" toto.txt 
 (debut de ligne)
    grep "bonjour a tous$" toto.txt	(fin de ligne)

xargs
	ls *.txt | xargs cat

SCRIPTS SHELL
------------------------------------------------------------------------
>> EXECUTION
    Par le shell courant : . fichier  
(symbole point)
    Par un nouveau shell : 
        - ksh fichier 
        - fichier (si fichier est executable)
    
    Pour etre sur que le script soit execute par un shell ksh 
        au debut du script : #!/usr/bin/ksh 
        ? Rendre le fichier executable )

>> RECUPERATION DES PARAMETRES
    $0 : nom de la commande 
    $# : nombre de parametres 
    $* : l’ensemble des parametres 
    $1 , $2 , ..., $9 : les 9 premiers parametres

    Pour recuperer plus de 9 parametres, utiliser shift 
        shift n : decalage de n positions des numeros de parametre (par
        defaut, decalage de 1). Attention : on ne peut pas revenir en arriere

    Pour positionner les parametres : set p1 p2 p3
    
>> OPERATIONS SUR LES VARIABLES
    Affectation : 
        v=aa
                v=$HOME/toto 
        Attention : pas d’espace autour du signe =.
    
    Operations arithmetiques : 
        a=35 
        l e<=>          le t<=>          a=  <=>          a=$(($a+1))

>> ENTREES/SORTIES
    Saisie    : read x?" message :"
    Affichage : echo $x

>> EXPRESSIONS CONDITIONNELLES
    Expression conditionnelle :
        test expression 
        [ expression ] ( Attention : les espaces sont obligatoires)
        
        Code de retour: l'inverse de C

    Expressions sur les fichiers : 
        -a : existence 
        -d : repertoire 
        -s : fichier de taille non nulle 
    
    Expressions sur les chaines de caracteres :
        Comparaisons alphabetiques : =, !=
        Comparaisons numeriques : -eq , -ne , -lt , -le , -gt , -ge 
        Connecteurs logiques : ! , && , ||
        Exemple : [ "$1" != "$HOME" ] && [ $2 -eq 34 ]

>> IF... THEN... ELSE... FI

    if[ -s $1 ]
        then echo "$1 existe"
    else 
        echo "$1 n’existe pas ou est vide"
    fi 
    
    if [ $x -gt 10 ]
    then 
        let x=$x-10
    fi
    
>> WHILE... DO... DONE

    while [ a -gt 0 ]      ( ou while true )
    do 
        echo "a=$a"
        let a=$a-1
    done 
    
    while [ $# -gt 0 ]
    do 
        echo $1
        shift 
    done

>> FOR... DO... DONE

    for x in 1 2 3 
    do 
        echo $x
    done
    
    for x in *.c 
    do 
    echo "Compilation de $x"
    cc -o ‘basename $x.c‘ $x
    done 
    
    for a est equivalent a for a in$*

>> CASE... ESAC
    case $1 in
    *.c)    echo "$1 est un fichier C";;
    *.txt)  echo "$1 est un fichier texte";;
    *)
        echo "$1 n’est pas d’un format connu"
        echo "Completez le programme!";;
    esac
    
>> FONCTIONS 
    A considerer comme des scripts independants, lances depuis le script principal
    --> a l’interieur d’une fonction, $1 , $2 , shift , etc... manipulent les
        parametres de la fonction, pas ceux du script principal.
    
    Definition :
        function toto {
        ..
        }
    
    Appel de la fonction (avec des parametres) :
        toto a b
    
    Exemple :
        function add {
            tmp=0
            while [ $# -ne 0 ]
            do 
                let tmp=$ tmp+$ 1
                shift 
            done 
            echo $tmp
            return 0 
        }
        x=‘add 1 2 3‘
        echo "x=$x"
    
------------------------------------------------------------------------
DIVERS
------------------------------------------------------------------------

sous shell: 
	TERM=VT200
	resize