UNIX/LINUX

Le Korn Shell (ksh) : le langage de scripting Unix

5 juillet 2026 · par Romain RICHER

Parmi les shells Unix, le Korn Shell — abrégé ksh — occupe une place particulière : c’est à la fois un shell interactif et un véritable langage de programmation, longtemps la référence dans les environnements Unix professionnels. Créé dans les années 1980, il a inspiré une bonne partie de ce qu’on trouve aujourd’hui dans bash, et il reste très présent sur les systèmes d’entreprise.

Ce guide présente le scripting en Korn Shell : la structure d’un script, les variables, les tests, les boucles, les fonctions, avec des exemples commentés. Une section est consacrée aux différences avec bash, car c’est souvent la question que l’on se pose en découvrant ksh. Les exemples sont neutres et réutilisables. Si vous débutez en ligne de commande Unix, notre article sur les commandes Unix utiles pose des bases complémentaires.

Qu’est-ce que le Korn Shell ?

Le Korn Shell a été écrit par David Korn chez Bell Labs, avec une première version en 1983. Son ambition : conserver la compatibilité avec le Bourne Shell (sh, l’ancêtre) tout en ajoutant de vraies capacités de programmation. Deux versions ont marqué son histoire : ksh88 (1988), qui a servi de base aux standards POSIX, et ksh93, plus récente et plus riche. On rencontre aussi des variantes libres comme pdksh ou mksh.

Pendant longtemps, ksh a été le shell par défaut ou « recommandé » sur les grands Unix commerciaux (Solaris, AIX, HP-UX). Aujourd’hui, sur Linux, bash est devenu le shell le plus répandu — mais ksh garde une place solide dans les environnements d’entreprise historiques, et sa connaissance reste précieuse.

Un premier script

Un script ksh est un fichier texte débutant par une ligne spéciale, le shebang, qui indique quel interpréteur utiliser :

#!/bin/ksh
print "Bonjour depuis le Korn Shell"

Deux choses à noter. La ligne #!/bin/ksh indique au système d’exécuter le script avec ksh. Et surtout, on utilise ici print pour afficher du texte : c’est la commande d’affichage privilégiée du Korn Shell, là où bash emploie plutôt echo (qui fonctionne aussi en ksh).

Pour rendre le script exécutable puis le lancer :

chmod +x mon_script.ksh
./mon_script.ksh

Les variables

Les variables se définissent sans espace autour du signe égal, et se lisent en les préfixant d’un $ :

#!/bin/ksh
nom="Dupont"
age=42
print "Nom : $nom, age : $age"

Le Korn Shell offre une particularité appréciée : la commande typeset, qui permet de typer les variables. Par exemple, déclarer un entier ou forcer une casse :

typeset -i compteur=0      # entier
typeset -u code="abc"      # forcé en majuscules -> ABC
typeset -l nom="DUPONT"    # forcé en minuscules -> dupont

Ce typage, plus poussé que dans le Bourne Shell d’origine, donne au ksh un caractère « langage de programmation » assumé. typeset -i est notamment pratique pour les calculs, car la variable est traitée comme un vrai entier.

Les calculs arithmétiques

Le Korn Shell évalue les expressions arithmétiques avec la syntaxe $(( ... )) :

#!/bin/ksh
a=7
b=3
somme=$(( a + b ))
produit=$(( a * b ))
print "Somme : $somme, produit : $produit"

On peut aussi utiliser (( ... )) sans le $ pour des opérations ou des tests numériques directs :

(( compteur = compteur + 1 ))
(( compteur > 10 )) && print "Compteur depasse 10"

Le ksh a historiquement été réputé performant sur les traitements arithmétiques intensifs, ce qui explique son usage dans des scripts de calcul.

Les tests et conditions

La structure conditionnelle repose sur if / then / else / fi. Les tests s’écrivent entre doubles crochets [[ ... ]] :

#!/bin/ksh
note=12
if [[ $note -ge 10 ]]
then
    print "Admis"
else
    print "Recale"
fi

Quelques opérateurs de test courants :

-eq, -ne, -lt, -le, -gt, -ge : comparaisons numériques (égal, différent, inférieur, etc.) ;
== et != : comparaisons de chaînes ;
-z : chaîne vide ; -n : chaîne non vide ;
-f : le fichier existe ; -d : le répertoire existe.

Par exemple, vérifier qu’un fichier existe avant de le traiter :

if [[ -f "donnees.txt" ]]
then
    print "Le fichier existe"
fi

Les boucles

Le Korn Shell propose les boucles classiques. La boucle for parcourt une liste de valeurs :

#!/bin/ksh
for jour in Lundi Mardi Mercredi
do
    print "Jour : $jour"
done

La boucle while répète tant qu’une condition est vraie :

#!/bin/ksh
typeset -i i=1
while (( i <= 5 ))
do
    print "Compteur : $i"
    (( i = i + 1 ))
done

On peut aussi parcourir les lignes d'un fichier, un grand classique du scripting shell :

#!/bin/ksh
while read ligne
do
    print "Ligne lue : $ligne"
done < fichier.txt

Ici, chaque ligne du fichier est lue tour à tour dans la variable ligne. C'est la base de nombreux scripts de traitement de données.

Les fonctions

Le Korn Shell permet de définir des fonctions, pour organiser et réutiliser le code. Deux syntaxes coexistent, la forme avec le mot-clé function étant caractéristique du ksh :

#!/bin/ksh
function saluer
{
    print "Bonjour $1"
}

saluer "Marie"
saluer "Paul"

Les paramètres passés à la fonction se récupèrent via $1, $2, etc. (et $@ pour tous). Dans ksh93, les fonctions déclarées avec function disposent en plus d'une portée locale des variables (via typeset), un vrai plus pour écrire du code propre et modulaire.

Un exemple complet

Rassemblons ces éléments dans un petit script utile : il parcourt les fichiers .log d'un répertoire et compte les lignes contenant le mot « ERROR ».

#!/bin/ksh

function compter_erreurs
{
    typeset fichier="$1"
    typeset -i nb
    nb=$(grep -c "ERROR" "$fichier")
    print "$fichier : $nb erreur(s)"
}

for f in *.log
do
    if [[ -f "$f" ]]
    then
        compter_erreurs "$f"
    fi
done

Ce script combine une fonction typée, une boucle for, un test d'existence de fichier, et l'appel à une commande externe (grep). C'est représentatif de la façon dont le shell « pilote » d'autres outils — sa vraie force. À ce sujet, grep, sed ou awk sont les compagnons naturels des scripts ksh ; notre guide sur la commande awk détaille l'un des plus puissants d'entre eux.

Korn Shell et bash : quelles différences ?

Comme bash s'est largement inspiré du Korn Shell, les deux se ressemblent beaucoup : mêmes pipelines, mêmes redirections, mêmes structures case, for, while, mêmes tests [[ ... ]] et même arithmétique $(( ... )). Un script simple écrit pour l'un fonctionne souvent presque tel quel sur l'autre. Les différences se nichent dans les détails :

Affichage : ksh privilégie print, bash utilise echo (disponible dans les deux) ;
Typage : ksh a une approche « typée » assez élégante via typeset (dont integer) ; bash propose declare, à la syntaxe différente ;
Tableaux associatifs : présents dans ksh93 comme dans bash, mais avec des syntaxes qui diffèrent — un point de vigilance pour la portabilité ;
Écosystème : bash bénéficie aujourd'hui d'une communauté et d'une documentation bien plus vastes, ce qui en fait le choix par défaut pour les scripts Linux multi-distributions.

Un piège à connaître : il existe plusieurs implémentations de ksh (ksh88, ksh93, mksh…), et certaines fonctionnalités varient de l'une à l'autre. Si un script doit tourner sur des systèmes variés, mieux vaut s'en tenir aux constructions POSIX de base, communes à tous.

En résumé

Le Korn Shell est un shell de programmation complet, à la fois historique et toujours pertinent :

un script débute par #!/bin/ksh et utilise print pour afficher ;
typeset permet de typer les variables (entiers, casse) — une signature du ksh ;
tests avec [[ ... ]], arithmétique avec (( ... )), boucles for / while ;
les fonctions (mot-clé function) structurent le code, avec portée locale en ksh93 ;
proche de bash, dont il a inspiré une grande partie, à quelques différences près (print, typeset, tableaux).

Apprendre le Korn Shell, c'est comprendre les fondations du scripting Unix moderne — et rester à l'aise dans les nombreux environnements d'entreprise où il reste en service. Comme toujours en shell, le meilleur apprentissage passe par la pratique : écrire de petits scripts, les exécuter, les corriger. Et pour des scripts portables, garder en tête la base POSIX commune à ksh et bash évite bien des surprises.

Vous automatisez des tâches sous Unix ? Le Korn Shell, avec sa rigueur et son typage, reste un excellent outil pour écrire des scripts robustes — surtout dans les environnements où il est déjà le shell de référence.