Uniligne

Un uniligne est généralement un programme informatique jetable, mais peu banal, écrit pour une tâche ponctuelle en un langage de script tel que Perl ou Ruby, et tanant sur une seule ligne. Des langages qui imposent plusieurs phases avant l'exécution, la déclaration explicite de variables, de fonctions ou, pire, de classes, ne se prêtent pas aux unilignes. Les unilignes exploitent typiquement les qualités DWIM d'un langage.

Parce qu'un uniligne est rarement destiné à être réutilisé, les considérations de lisibilité par un tiers sont secondaires. Certains unilignes sont des assombrissements délibérés.

Historique

Le mot est apparu pour la première fois dans le livre de Aho, Kernighan et Weinberger, The AWK Programming Language. Ce livre a pour sujet le langage AWK, utilisé dans le système d'exploitation Unix. Les auteurs expliquent comment leur travail quotidien sur Unix fut à l'origine de ce paradigme : « La version de 1977 [d'Unix] possédait très peu de variables internes et de fonctions prédéfinies. Elle est conçue pour écrire des programmes courts [...] Notre modèle était qu'un appel de fonction serait long d'une ou deux lignes, exécutées sitôt tapées. [...] Nous, en tant qu'auteurs, "savions" comment le langage était sensé être utilisé, et c'est pour cela que n'écrivions que des unilignes. »

Exemples

Le livre "The AWK Programming Language" contient plus de 20 exemples à la fin du premier chapitre.

Voici les premiers :

1. Afficher le nombre total de lignes lues en entrée :

END { print NR }

2. Afficher la dixième ligne d'un fichier :

NR == 10

3. Afficher le dernier champ de chaque ligne :

{ print $NF }

Inverser tous les octets d'un fichier (en Perl :

perl -0777e 'print scalar reverse <>' nomFichier

Les unilignes sont également utilisés pour démontrer l'expressivité de certains langages de programmation. Ils servent souvent à démontrer le talent du programmeur, et de nombreux concours sont organisés pour savoir qui fera le plus exceptionnel.

Voici un exemple en C, lauréat du concours IOCCC.

main(int c,char**v){return!m(v[1],v[2]);}m(char*s,char*t){return*t-42?*s?63==*t|*s==*t&&m(s+1,t+1):!*t:m(s,t+1)||*s&&m(s+1,t);}

Ce programme permet de vérifier si un chaîne de caractères correspond à un pattern, avec les conventions Unix : * pour une suite de caratères quelconques de longueur quelconque, ? pour un seul caractère... Le code de retour est 0 pour vrai et 1 sinon. A noter que le pattern matching se fait sur toute la chaîne, et non sur un sous-ensemble de celle-ci. Exemples d'exécution :

$ prog foo 'f??'; echo $?
$ prog 'chaine quelconque' '??ai*e**n?*'; echo $?  -> renvoie 1
$ prog 'chaine quelconque' 'ch*o?'; echo $?        -> renvoie 0

Un autre exemple en |Haskell]]. Il y a deux déclarations import ce qui porte en réalité le nombre de lignes du programme à trois. Cet uniligne trie les lignes qu'il prend en entrée selon l'ordre lexicographique du code ASCII.

import IO
import List
main = (sequence . map putStrLn . sort . lines) =<< getContents

Hello World en Java :

public class OneLine { public static void main(String[] args) { System.out.println("One-liner."); } }

Voir aussi

• Code_impénétrable
• Perl

Liens externes

• (fr) Unilignes Perl
• (en) Perl One Liners
• (en) Perl Oneliners
• (en) Hot Perl OnLiners
• (en) Perl One Liners