Opérateur de navigation sécuritaire

En programmation orientée objet , l' opérateur de navigation sécurisé (également connu sous le nom d' opérateur de chaînage facultatif , opérateur d'appel sécurisé , opérateur conditionnel nul , opérateur de propagation nul ) est un opérateur binaire qui renvoie null si son premier argument est nul ; sinon, il effectue une opération de déréférencement comme spécifié par le deuxième argument (généralement un accès membre d'objet, un index de tableau ou une invocation lambda).

Il est utilisé pour éviter les vérifications et les affectations de valeurs nulles explicites séquentielles et les remplacer par un chaînage de méthodes/propriétés. Dans les langages de programmation où l'opérateur de navigation (par exemple ".") conduit à une erreur s'il est appliqué à un objet nul, l'opérateur de navigation sécurisé arrête l'évaluation d'une chaîne de méthodes/champs et renvoie null comme valeur de l'expression de chaîne. Il a été utilisé pour la première fois par Groovy 1.0 en 2007 et est actuellement pris en charge dans des langages tels que C# , Swift , TypeScript , Ruby , Kotlin , Rust , JavaScript , et d'autres. Il n'existe actuellement aucune convention de dénomination commune pour cet opérateur, mais l'opérateur de navigation sécurisé est le terme le plus utilisé.

Le principal avantage de l'utilisation de cet opérateur est qu'il évite la pyramide de la mort . Au lieu d'écrire plusieurs ifs imbriqués, les programmeurs peuvent simplement utiliser le chaînage habituel, mais ajouter des points d'interrogation avant les points (ou d'autres caractères utilisés pour le chaînage).

Bien que l' opérateur de navigation sécurisée et l'opérateur de fusion nul soient tous deux des opérateurs prenant en charge les valeurs nulles , ils sont différents sur le plan opérationnel.

Exemples d’opérateurs de navigation sécurisée :

a [ x ]? . aMethod (). aField // Évalue à null si a[x] == null a [ x ] . aMethod () ? . aField // Renvoie null si a[x].aMethod() évalue à null String profileUrl = user . getProfileUrl () ? . toExternalForm (); return [ SELECT Name FROM Account WHERE Id = : accId ]? . Name ;

C# 6.0 et les versions ultérieures ont ?., l' opérateur d'accès aux membres conditionnels nuls (qui est également appelé opérateur Elvis par Microsoft et ne doit pas être confondu avec l'utilisation générale du terme opérateur Elvis , dont l'équivalent en C# est ??, l' opérateur de coalescence nul ) et ?[], l' opérateur d'accès aux éléments conditionnels nuls , qui effectue un appel null-safe d'un accesseur get d'indexeur . Si le type du résultat de l'accès au membre est un type de valeur , le type du résultat d'un accès conditionnel nul de ce membre est une version nullable de ce type de valeur .

L'exemple suivant récupère le nom de l'auteur du premier article dans un tableau d'articles (à condition que chaque article ait un Authormembre et que chaque auteur ait un Namemembre), et renvoie nullsi le tableau est null, si son premier élément est null, si le Authormembre de cet article est null, ou si le Namemembre de cet auteur est null. Notez qu'une erreur IndexOutOfRangeExceptionest toujours générée si le tableau est non nul mais vide (c'est-à-dire de longueur nulle).

var nom = articles ? [ 0 ] ?. Auteur ?. Nom ;

L'appel d'un lambda nécessite callback?.Invoke(), car il n'y a pas d'invocation conditionnelle nulle ( callback?()n'est pas autorisé).

var résultat = callback ?. Invoke ( args );

Clojure n'a pas de véritables opérateurs au sens où d'autres langages l'utilisent, mais comme il est interopérable avec Java et doit effectuer une navigation dans les objets lorsqu'il le fait, la macro some-> peut être utilisée pour effectuer une navigation sécurisée.

( quelque-> article .auteur .nom )

Opérateur existentiel :

zip = loterie . tirage au sort Gagnant ? (). adresse ? . code postal

Crystal prend en charge la tryméthode de navigation sécurisée

nom = article . essayer &. auteur . essayer &. nom

Opérateur d'accès conditionnel aux membres :

var nom = article ? . auteur ? . nom

Opérateur d'invocation Null Safe :

var nom = article ?. auteur ?. nom

L'opérateur d'invocation null-safe n'est pas nécessaire pour les attributs de classe déclarés comme propriétés Gosu :

classe Foo { var _bar : String comme Bar }
var foo : Foo = null
// ce qui suit sera évalué à null et ne renverra pas d'exception NullPointerException 
var bar = foo . Bar

Opérateur de navigation sécurisée et opérateur d'index sécurisé :

def nom = article ?. auteurs ?[ 0 ]. nom

Ajouté dans ECMAScript 2020, l'opérateur de chaînage facultatif fournit un moyen de simplifier l'accès aux valeurs via des objets connectés lorsqu'il est possible qu'une référence ou une fonction soit indéfinie ou null . Les principaux navigateurs de bureau prennent en charge cette fonction depuis 2020, et la plupart des navigateurs mobiles ont ajouté cette prise en charge d'ici 2024.

const nom = article ? . auteurs ? . [ 0 ] ? . nom const résultat = rappel ? .()

Il court-circuite toute la chaîne d'appels sur son côté droit : dans l'exemple suivant, bar n'est pas « accédé ».

nul ? . foo . bar

Opérateur d'appel sécurisé :

val nom = article ?. auteur ?. nom

La syntaxe de navigation normale peut être utilisée dans la plupart des cas sans tenir compte des valeurs NULL, car les messages sous-jacents, lorsqu'ils sont envoyés à NULL, sont rejetés sans aucun effet néfaste.

NSString * nom = article . auteur [ 0 ]. nom ;

Perl 5 ne dispose pas de ce type d'opérateur, mais une proposition d'inclusion a été acceptée avec la syntaxe suivante :

mon $name = $article ? -> auteur ? -> nom ;

L'opérateur null safe a été accepté pour PHP 8 :

$name 
= 
$article ?-> auteur ?-> nom ;

Appel de méthode sécurisée :

mon 
$name = $article .? auteur .? nom ; 

Ruby prend en charge l' &.opérateur de navigation sécurisée (également appelé opérateur solitaire ) depuis la version 2.3.0 :

nom = article &. auteur &. nom

Rust fournit un ?opérateur qui peut sembler être un opérateur de navigation sûr. Cependant, une différence clé est que lorsqu'il ?rencontre une Nonevaleur, il n'évalue pas à None. Au lieu de cela, il se comporte comme une returninstruction, ce qui fait que la fonction ou la fermeture englobante renvoie immédiatement None.

Les Optionméthodes map()et and_then()peuvent être utilisées pour une navigation sécurisée, mais cette option est plus détaillée qu'un opérateur de navigation sécurisée :

fn 
print_author ( article : Option < Article > ) { println! ( "Auteur : {}" , article . and_then ( | y | y . author ) . map ( | z | z . name ) . unwrap_or ( "Inconnu" . to_owned ()) ); }

Une implémentation utilisant ?n'imprimera rien (pas même "Auteur :") si articleest Noneou article.unwrap().authorest None. Dès que ?voit un None, la fonction retourne.

fn 
try_print_author ( article : Option < Article > ) -> Option < () > { 
println! ( "Auteur : {}" , article ? . auteur ? . nom ); Some (()) }

L'opérateur null-safe en Scala est fourni par la bibliothèque Dsl.scala.

val nom = article . ? . auteur . ? . nom : @ ?

L' @ ?annotation peut être utilisée pour désigner une valeur nullable.

classe de cas Tree ( gauche : Tree @ ? = null , droite : Tree @ ? = null , valeur : String @ ? = null )
val root : Tree @ ? = Tree ( left = Tree ( left = Tree ( value = "gauche-gauche" ), right = Tree ( value = "gauche-droite" ) ), right = Tree ( value = "droite" ) )

La normale .en Scala n'est pas null-safe, lors de l'exécution d'une méthode sur une nullvaleur.

une [ NullPointerException ] doit être levée par { root . right . left . right . value // root.right.left est null! }

L'exception peut être évitée en utilisant ?l'opérateur sur la valeur nullable à la place :

racine . ? . droite . ? . gauche . ? . la valeur doit être ( null )

L'expression entière est nulltelle que l'une des ?opérations est effectuée sur une nullvaleur.

La limite d'un nullopérateur sûr ?est l'expression englobante la plus proche dont le type est annoté comme @ ?.

( "Bonjour " + ( "monde " + racine . ? . droite . ? . gauche . ? . valeur )) devrait être ( "Bonjour tout le monde null" ) ( "Bonjour " + (( "monde " + racine . ? . droite . ? . gauche . ? . valeur . ? ): @ ? )) devrait être ( "Bonjour null" ) (( "Bonjour " + ( "monde " + racine . ? . droite . ? . gauche . ? . valeur . ? )): @ ? ) devrait être ( null )

Opérateur de chaînage facultatif, opérateur d'indice et appel :

laissez 
le nom 
= 
article ?. auteurs ?[ 0 ]. nom 
laissez 
le résultat 
= 
protocolVar ?. optionalRequirement ?()

L'opérateur de chaînage facultatif a été inclus dans la version Typescript 3.7 :

soit x = foo ? . bar ? . [ 0 ] ? . baz ();

Visual Basic 14 et les versions ultérieures disposent de ?.(l' opérateur d'accès aux membres conditionnels nuls ) et ?()(l' opérateur d'index conditionnel nul ), similaires à C#. Ils ont le même comportement que les opérateurs équivalents en C#.

L’instruction suivante se comporte de manière identique à l’exemple C# ci-dessus.

Nom Dim = articles ? ( 0 ) ? . Auteur ? . Nom