Existe-t-il un nullopérateur d'accès aux propriétés -safe (propagation / existence nulles) dans ES6 (ES2015 / JavaScript.next / Harmony) comme ?.dans CoffeeScript par exemple? Ou est-ce prévu pour ES7?

var aThing = getSomething()
...
aThing = possiblyNull?.thing

Ce sera à peu près comme:

if (possiblyNull != null) aThing = possiblyNull.thing

Idéalement, la solution ne doit pas attribuer (même undefined) à aThingif possiblyNullisnull

Mise à jour (2020-01-31): Il semble que les gens trouvent toujours ceci, voici l'histoire actuelle:

• Spécification de chaînage facultative (étape 4): https://github.com/tc39/proposal-optional-chaining
• babel-preset-env: C'est probablement ce que vous voulez https://babeljs.io/docs/en/babel-preset-env
• Plugin Babel v7: https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

Mise à jour (01/08/2017): Si vous souhaitez utiliser un plugin officiel, vous pouvez essayer la version alpha de Babel 7 avec la nouvelle transformation. Votre kilométrage peut varier

https://www.npmjs.com/package/babel-plugin-transform-optional-chaining

Original :

Une fonctionnalité qui accomplit qui est actuellement à l'étape 1: Chaînage facultatif.

https://github.com/tc39/proposal-optional-chaining

Si vous souhaitez l'utiliser aujourd'hui, il existe un plugin Babel qui accomplit cela.

https://github.com/davidyaha/ecmascript-optionals-proposal

Ce n'est pas aussi beau que le?. opérateur, mais pour obtenir un résultat similaire, vous pouvez faire:

user && user.address && user.address.postcode

Puisque nullet undefinedsont tous les deux des valeurs fausses ( voir cette référence ), la propriété après l' &&opérateur n'est accessible que si le précédent n'est pas nul ou indéfini.

Vous pouvez également écrire une fonction comme celle-ci:

function _try(func, fallbackValue) {
    try {
        var value = func();
        return (value === null || value === undefined) ? fallbackValue : value;
    } catch (e) {
        return fallbackValue;
    }
}

Usage:

_try(() => user.address.postcode) // return postcode or undefined 

Ou, avec une valeur de repli:

_try(() => user.address.postcode, "none") // return postcode or a custom string

Non. Vous pouvez utiliser lodash # get ou quelque chose comme ça pour cela en JavaScript.

Alternative à la vanille pour un accès sécurisé à la propriété

(((a.b || {}).c || {}).d || {}).e

L'affectation conditionnelle la plus concise serait probablement celle-ci

try { b = a.b.c.d.e } catch(e) {}

Non, il n'y a pas d'opérateur de propagation nul dans ES6. Vous devrez suivre l'un des modèles connus .

Vous pouvez cependant utiliser la déstructuration:

({thing: aThing} = possiblyNull);

Il y a beaucoup de discussions (par exemple ceci ) pour ajouter un tel opérateur dans ES7, mais aucune n'a vraiment décollé.

En parcourant la liste ici , il n'y a actuellement aucune proposition pour ajouter une traversée sûre à Ecmascript. Donc, non seulement il n'y a pas de bon moyen de le faire, mais cela ne sera pas ajouté dans un avenir prévisible.

// Typescript
static nullsafe<T, R>(instance: T, func: (T) => R): R {
    return func(instance)
}

// Javascript
function nullsafe(instance, func) {
    return func(instance);
};

// use like this
const instance = getSomething();
let thing = nullsafe(instance, t => t.thing0.thing1.thingx);

Chaînage ?.et coalescence nul en option??

Vous pouvez maintenant utiliser directement en ?.ligne pour tester en toute sécurité l'existence. Tous les navigateurs modernes le prennent en charge.

?? peut être utilisé pour définir une valeur par défaut si non définie ou nulle.

aThing = possiblyNull ?? aThing
aThing = a?.b?.c ?? possiblyNullFallback ?? aThing

Si une propriété existe, ?.passe à la vérification suivante ou renvoie la valeur valide. Toute panne sera immédiatement court-circuitée et retournée undefined.

const example = {a: ["first", {b:3}, false]}

example?.a  // ["first", {b:3}, false]
example?.b  // undefined

example?.a?.[0]     // "first"
example?.a?.[1]?.a  // undefined
example?.a?.[1]?.b  // 3

domElement?.parentElement?.children?.[3]?.nextElementSibling

null?.()                // undefined
validFunction?.()       // result
(() => {return 1})?.()  // 1

Pour garantir une valeur définie par défaut, vous pouvez utiliser ??. Si vous avez besoin de la première valeur de vérité, vous pouvez utiliser ||.

example?.c ?? "c"  // "c"
example?.c || "c"  // "c"

example?.a?.[2] ?? 2  // false
example?.a?.[2] || 2  // 2

Si vous ne cochez pas de cas, la propriété de gauche doit exister. Sinon, il lèvera une exception.

example?.First         // undefined
example?.First.Second  // Uncaught TypeError: Cannot read property 'Second' of undefined

?.Support du navigateur - 78%, juillet 2020

??Prise en charge du navigateur - 78%

Documentation Mozilla

-

Affectation logique nulle, solution 2020+

De nouveaux opérateurs sont actuellement ajoutés aux navigateurs ??=, ||=et &&=. Ils ne font pas tout à fait ce que vous recherchez, mais pourraient conduire au même résultat en fonction de l'objectif de votre code.

NOTE: Ce ne sont pas communs dans les versions de navigateur publics encore , mais Babel devraient transpile bien. Sera mis à jour à mesure que la disponibilité change.

??=vérifie si le côté gauche est indéfini ou nul, court-circuit s'il est déjà défini. Sinon, le côté gauche reçoit la valeur du côté droit. ||=et &&=sont similaires, mais basés sur les opérateurs ||et &&.

Exemples de base

let a          // undefined
let b = null
let c = false

a ??= true  // true
b ??= true  // true
c ??= true  // false

Exemples d'objets / de tableaux

let x = ["foo"]
let y = { foo: "fizz" }

x[0] ??= "bar"  // "foo"
x[1] ??= "bar"  // "bar"

y.foo ??= "buzz"  // "fizz"
y.bar ??= "buzz"  // "buzz"

x  // Array [ "foo", "bar" ]
y  // Object { foo: "fizz", bar: "buzz" }

Browser Support Juillet 2020 - .03%

Documentation Mozilla

Une méthode sécurisée de deep get semble être un ajustement naturel pour underscore.js mais là, le problème est d'éviter la programmation de chaînes. Modifier la réponse de @ Felipe pour éviter la programmation de chaînes (ou au moins repousser les cas de bord vers l'appelant):

function safeGet(obj, props) {
   return (props.length==1) ? obj[keys[0]] :safeGet(obj[props[0]], props.slice(1))
}

Exemple:

var test = { 
  a: { 
    b: 'b property value',
    c: { }
  } 
}
safeGet(test, ['a', 'b']) 
safeGet(test, "a.b".split('.'))  

Je sais que c'est une question JavaScript, mais je pense que Ruby gère cela de toutes les manières demandées, donc je pense que c'est un point de référence pertinent.

.&, tryEt && ont leurs points forts et les pièges potentiels. Un bon aperçu de ces options ici: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; La conclusion des rubisistes digest à la fois plus facile pour les yeux et une garantie plus forte qu'une valeur ou nullsera attribuée.

Voici une implémentation simple dans TypeScript:

export function dig(target: any, ...keys: Array<string>): any {
  let digged = target
  for (const key of keys) {
    if (typeof digged === 'undefined') {
      return undefined // can also return null or a default value
    }
    if (typeof key === 'function') {
      digged = key(digged)
    } else {
      digged = digged[key]
    }
  }
  return digged
}

Cela peut être utilisé pour n'importe quelle profondeur d'imbrication et gère les fonctions.

a = dig(b, 'c', 'd', 'e');
foo = () => ({});
bar = dig(a, foo, 'b', 'c')

L' tryapproche est également agréable à lire dans JS, comme indiqué dans les réponses précédentes. Il ne nécessite pas non plus de bouclage, ce qui est un inconvénient de cette implémentation.

Je pensais que cette question avait besoin d'un peu de rafraîchissement pour 2018. Cela peut être fait bien sans aucune bibliothèque Object.defineProperty()et peut être utilisé comme suit:

myVariable.safeGet('propA.propB.propC');

Je considère cela comme sûr (et js-éthique) en raison des définitions writeableet des enumerabledéfinitions maintenant disponibles pour la definePropertyméthode de Object, comme documenté dans MDN

définition de fonction ci-dessous:

Object.defineProperty(Object.prototype, 'safeGet', { 
    enumerable: false,
    writable: false,
    value: function(p) {
        return p.split('.').reduce((acc, k) => {
            if (acc && k in acc) return acc[k];
            return undefined;
        }, this);
    }
});

J'ai mis en place un jsBin avec une sortie de console pour le démontrer. Notez que dans la version jsBin, j'ai également ajouté une exception personnalisée pour les valeurs vides. Ceci est facultatif, et je l'ai donc laissé en dehors de la définition minimale ci-dessus.

Les améliorations sont les bienvenues