Esiste un nulloperatore di accesso alla proprietà sicuro (propagazione / esistenza nulla) in ES6 (ES2015 / JavaScript.next / Harmony) come ad esempio ?.in CoffeeScript ? O è previsto per ES7?

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

Questo sarà approssimativamente come:

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

Idealmente la soluzione non dovrebbe essere assegnata (nemmeno undefined) a aThingif possiblyNullisnull

Aggiornamento (2020-01-31): sembra che la gente stia ancora trovando questo, ecco la storia attuale:

• Specifiche di concatenamento opzionali (Fase 4): https://github.com/tc39/proposal-optional-chaining
• babel-preset-env: Questo è probabilmente quello che vuoi https://babeljs.io/docs/en/babel-preset-env
• Plugin Babel v7: https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

Aggiornamento (01-08-2017): se desideri utilizzare un plug-in ufficiale, puoi provare la build alpha di Babel 7 con la nuova trasformazione. Il tuo chilometraggio può variare

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

Originale :

Una funzionalità che è attualmente in fase 1: Concatenamento opzionale.

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

Se vuoi usarlo oggi, c'è un plugin Babel che lo realizza.

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

Non è bello come il?. operatore, ma per ottenere un risultato simile potresti fare:

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

Poiché nulle undefinedsono entrambi valori falsi ( vedere questo riferimento ), &&si accede alla proprietà dopo l' operatore solo se il precedente non è nullo o indefinito.

In alternativa, potresti scrivere una funzione come questa:

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

Uso:

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

Oppure, con un valore di fallback:

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

No. Puoi usare lodash # get o qualcosa del genere per questo in JavaScript.

Alternativa alla vaniglia per un accesso sicuro alle proprietà

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

Il compito condizionale più conciso sarebbe probabilmente questo

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

No, non esiste un operatore di propagazione null in ES6. Dovrai seguire uno dei modelli noti .

Potresti essere in grado di usare la destrutturazione, tuttavia:

({thing: aThing} = possiblyNull);

Ci sono molte discussioni (ad esempio questo ) per aggiungere un tale operatore in ES7, ma nessuna è decollata.

Andando dall'elenco qui , al momento non esiste alcuna proposta per aggiungere attraversamenti sicuri a Ecmascript. Quindi non solo non c'è un bel modo per farlo, ma non verrà aggiunto nel prossimo futuro.

// 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);

Concatenamento opzionale ?. e coalescente nullo??

Ora puoi utilizzare direttamente ?.inline per testare in sicurezza l'esistenza. Tutti i browser moderni lo supportano.

?? può essere utilizzato per impostare un valore predefinito se non definito o nullo.

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

Se esiste una proprietà, ?.passa al controllo successivo o restituisce il valore valido. Qualsiasi guasto si interromperà immediatamente e ritornerà 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

Per garantire un valore predefinito definito, è possibile utilizzare ??. Se si richiede il primo valore di verità, è possibile utilizzare ||.

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

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

Se non si verifica un caso, la proprietà sul lato sinistro deve esistere. In caso contrario, genererà un'eccezione.

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

?.Supporto browser - 78%, luglio 2020

??Supporto browser - 78%

Documentazione Mozilla

-

Assegnazione nullo logica, soluzione 2020+

I nuovi operatori sono attualmente in fase aggiunti ai browser, ??=, ||=e &&=. Non fanno esattamente quello che stai cercando, ma potrebbero portare allo stesso risultato a seconda dell'obiettivo del tuo codice.

NOTA: Queste non sono comuni nelle versioni pubbliche del browser ancora , ma Babel dovrebbero transpile bene. Si aggiornerà come cambia la disponibilità.

??=controlla se il lato sinistro è indefinito o nullo, corto circuito se già definito. In caso contrario, al lato sinistro viene assegnato il valore del lato destro. ||=e &&=sono simili, ma basati sugli operatori ||e &&.

Esempi di base

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

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

Esempi di oggetti / array

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" }

Supporto browser luglio 2020 - .03%

Documentazione Mozilla

Un metodo deep get sicuro sembra un adattamento naturale per underscore.js ma il problema è evitare la programmazione di stringhe. Modifica della risposta di @ Felipe per evitare la programmazione di stringhe (o almeno rimanda i caratteri limite al chiamante):

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

Esempio:

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

So che questa è una domanda JavaScript, ma penso che Ruby lo gestisca in tutti i modi richiesti, quindi penso che sia un punto di riferimento rilevante.

.&, trye && hanno i loro punti di forza e potenziali insidie. Un grande riassunto di queste opzioni qui: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; La conclusione di Rubyists è che digè sia più facile per gli occhi sia una garanzia più forte che un valore o nullverrà assegnato.

Ecco una semplice implementazione in 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
}

Può essere utilizzato per qualsiasi profondità di annidamento e gestisce le funzioni.

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

L' tryapproccio è ugualmente piacevole da leggere in JS, come mostrato nelle risposte precedenti. Inoltre non richiede il looping, che è uno svantaggio di questa implementazione.

Ho pensato che questa domanda avesse bisogno di un po 'di aggiornamento per il 2018. Questo può essere fatto bene senza l'uso di alcuna libreria Object.defineProperty()e può essere usato come segue:

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

Lo considero sicuro (ed etico) a causa delle definizioni writeablee enumerableora disponibili per il definePropertymetodo di Object, come documentato in MDN

definizione della funzione di seguito:

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);
    }
});

Ho dimostrato un jsBin con l'output della console per dimostrarlo. Si noti che nella versione jsBin ho anche aggiunto un'eccezione personalizzata per valori vuoti. Questo è facoltativo, quindi l'ho lasciato fuori dalla definizione minima sopra.

I miglioramenti sono i benvenuti