Elvis Operator : définition, syntaxe et gestion des valeurs null

Qu’est-ce que l’Elvis Operator

Elvis Operator est un opérateur binaire nommé d’après la coiffure d’Elvis Presley. Le symbole ?: ressemble visuellement au visage du chanteur de profil : le point d’interrogation est l’œil et la patte, les deux points sont la bouche. L’opérateur prend deux opérandes : si le premier n’est pas null — il est renvoyé, sinon le second est renvoyé. Cela permet de remplacer une construction if-else complète par une seule expression courte.

Origine du nom

Le nom « Elvis Operator » s’est imposé dans les communautés Kotlin et Groovy, puis s’est répandu dans Xtend et d’autres langages JVM. En Swift et Dart, la construction analogue est appelée nil-coalescing operator, mais elle est fonctionnellement identique. L’association visuelle avec Elvis Presley a aidé l’opérateur à devenir l’un des symboles les plus reconnaissables dans la syntaxe des langages de programmation modernes.

Rôle dans la gestion des null

L’Elvis Operator fait partie du système null safety qui prévient les NullPointerException (NPE). Selon une étude JetBrains de 2023, les NPE représentent 28 % de toutes les exceptions dans le code JVM en production. L’utilisation de l’Elvis Operator élimine complètement les NPE au point d’affectation, garantissant une valeur par défaut. En combinaison avec l’opérateur d’appel sécurisé ?., une chaîne fiable est créée sans un seul bloc if.

Syntaxe de l’Elvis Operator en Kotlin

En Kotlin, l’Elvis Operator s’écrit ?: entre deux expressions. Si l’expression gauche n’est pas null — le résultat est égal à l’expression gauche, sinon l’expression droite est évaluée. L’expression droite est évaluée paresseusement — uniquement lorsque l’opérande gauche est null, ce qui est important pour les performances lors de l’utilisation de calculs coûteux ou d’appels API.

val name: String? = getUserName()
val displayName = name ?: "Guest"

fun getLength(str: String?): Int {
    return str?.length ?: 0
}

val config: Config? = loadConfig()
val timeout = config?.timeout ?: 30
println("Timeout: $timeout")

// Elvis with throw pour paramètres obligatoires
val requiredId = nullableId ?: throw IllegalArgumentException("ID is required")

// Elvis with return pour sortie anticipée
fun process(data: String?): Result {
    val safe = data ?: return Result.failure("No data")
    return processInternal(safe)
}

Combinaison avec let est un modèle courant en Kotlin, où l’Elvis Operator fournit une valeur par défaut, et let exécute une action sur le résultat non null. Cette approche remplace des blocs if-else entiers par une seule chaîne d’appels sans perte de lisibilité. L’Elvis Operator peut également être utilisé avec throw pour interrompre forcément en cas d’absence d’un paramètre obligatoire — c’est une manière idiomatique de valider les données d’entrée.

Elvis avec retour anticipé d’une fonction

Un modèle courant en Kotlin est Elvis + return. Si la valeur est null, la fonction retourne immédiatement un résultat ou lève une exception. L’idiome Elvis avec return est souvent utilisé dans les fonctions de transformation de données : val processed = rawData ?: return defaultValue. C’est plus compact que guard let de Swift et n’augmente pas l’imbrication du code.

Elvis Operator vs if-else : comparaison

Elvis Operator est plus court que if-else et ne nécessite pas de répéter la variable. Comparez : val x = a ?: b versus val x = if (a != null) a else b. Avec des expressions complexes, la réduction de code atteint 60 %, tandis que la sémantique est complètement identique — le compilateur peut générer le même bytecode pour les deux variantes.

Quand utiliser l’Elvis Operator

L’Elvis Operator est optimal pour attribuer des valeurs par défaut, enchaîner des appels de fonctions avec accès sécurisé et journaliser les valeurs manquantes. Les modèles idiomatiques Kotlin le recommandent comme remplacement de if-else pour les vérifications null simples dans les expressions. Combiné avec ?., il produit des chaînes compactes sans variables temporaires.

Quand if-else est préférable

if-else reste préférable pour des conditions multiples, lorsque des effets secondaires doivent être exécutés, ou lorsque les deux opérandes sont des blocs de code complexes avec plusieurs opérations. L’Elvis Operator ne prend pas en charge les blocs imbriqués — seulement des expressions uniques pour chaque opérande. Si la partie droite appelle une fonction avec des effets secondaires, la lisibilité de if-else est supérieure.

Elvis Operator dans d’autres langages de programmation

Groovy utilise exactement la même syntaxe ?: que Kotlin, car les deux langages fonctionnent sur la JVM et partagent la philosophie null-safety. L’opérateur est apparu plus tôt dans Groovy — il est présent dans le langage depuis la version 1.8, sortie en 2011. Groovy prend également en charge l’affectation Elvis : x ?= value (affecter seulement si x est null).

def name = getUserName()
def display = name ?: "Guest"

def map = ["key": "value"]
def result = map?.get("missing") ?: "default"
println(result)

// Affectation Elvis en Groovy
def config = null
config ?= "defaultConfig"
assert config == "defaultConfig"

En Swift, l’équivalent est appelé nil-coalescing operator et s’écrit ??. En Dart, la même syntaxe ?? est utilisée. La différence est que Swift et Dart exigent la correspondance des types des opérandes, tandis que Kotlin autorise des types différents avec conversion automatique vers un supertype commun. En TypeScript, l’opérateur ?? (nullish coalescing) est apparu dans la version 3.7 et fonctionne uniquement avec null et undefined, contrairement à || qui filtre toutes les valeurs falsy. En PHP, l’opérateur ?? est apparu dans la version 7.0, en C# — ?? depuis la version 6.0.

Erreurs courantes avec l’Elvis Operator

L’erreur la plus fréquente est de confondre l’Elvis Operator ?: avec l’opérateur d’appel sécurisé ?. En Kotlin, ?. appelle une méthode ou une propriété uniquement si l’objet n’est pas null, tandis que ?: retourne une valeur par défaut quand il est null. Ils sont combinés séquentiellement, mais chacun remplit sa propre fonction. La confusion survient chez les débutants qui tentent d’utiliser ?: sans ?. devant.

Effets secondaires dans l’opérande droit

La partie droite d’Elvis est évaluée paresseusement, mais si elle contient un appel de fonction avec des effets secondaires, cela peut entraîner un comportement inattendu. Les développeurs placent parfois des calculs coûteux ou de la journalisation dans la partie droite, qui n’est pas exécutée lorsque la valeur n’est pas nulle. Il est important de se rappeler que la partie droite est une expression qui n’est évaluée qu’en cas de besoin.

Elvis enchaînés sans regroupement

Plusieurs Elvis à la suite peuvent compliquer la lecture du code. Par exemple, a ?: b ?: c ?: d est évalué de gauche à droite, renvoyant le premier non null. Le regroupement avec des parenthèses ou l’extraction de la logique dans une fonction séparée améliore la lisibilité et facilite le débogage. Si la chaîne a plus de 3 éléments, il faut utiliser une expression when ou une fonction d’assistance.

Elvis au lieu de if-else avec des conditions booléennes

Les développeurs débutants essaient parfois d’utiliser l’Elvis Operator pour vérifier des valeurs booléennes : val x = flag ?: false. Cela ne fonctionne que si flag peut être null. Pour des conditions booléennes sans null, un if-else normal ou un opérateur ternaire est nécessaire — Kotlin n’a pas d’opérateur ternaire, mais il est remplacé par l’expression if-else : val x = if (flag) a else b.