javascript name Null-sichere Eigenschaft Zugriff(und bedingte Zuweisung) in ES6/2015




javascript object name (8)

Ein Feature, das dies erreicht, befindet sich derzeit in Stufe 1: Optionales Verketten.

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

Wenn Sie es heute verwenden möchten, gibt es ein Babel-Plugin, das das erreicht.

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

Update (01.08.2017): Wenn Sie ein offizielles Plugin verwenden möchten, können Sie das Alpha-Build von Babel 7 mit der neuen Transformation ausprobieren. Ihre Laufleistung kann variieren

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

Gibt es in ES6 (ES2015 / JavaScript.next / Harmony) einen null Safe-Property-Access-Operator (Null-Propagation / Existieren) ?. in CoffeeScript zum Beispiel? Oder ist es für ES7 geplant?

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

Das wird ungefähr so ​​aussehen:

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

Idealerweise sollte die Lösung (wenn undefined ) aThing ( null ) zu aThing (nicht undefined ) aThing


Ich weiß, dass dies eine JavaScript-Frage ist, aber ich denke, dass Ruby dies auf alle angeforderten Arten behandelt, also denke ich, dass es ein relevanter Bezugspunkt ist.

.& , try und && haben ihre Stärken und potentiellen Fallstricke. Ein großer Rückgang dieser Optionen hier: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; Die Schlussfolgerung der Rubyists ist, dass das Ausgraben sowohl für die Augen einfacher ist als auch eine stärkere Garantie, dass ein Wert oder eine null zugewiesen wird.

Hier ist eine einfache Implementierung 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
}

Dies kann für jede Tiefe der Verschachtelungs- und Handhabungsfunktionen verwendet werden.

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

Der try Ansatz ist in JS gleich gut zu lesen, wie in früheren Antworten gezeigt. Es erfordert auch keine Schleife, was ein Nachteil dieser Implementierung ist.


Vanillealternative für den sicheren Zugang zu Eigentum

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

Die prägnanteste bedingte Zuordnung wäre wahrscheinlich dies

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

Wenn man sich here die Liste anschaut, gibt es derzeit keinen Vorschlag, eine sichere Traversierung zu Ecmascript hinzuzufügen. Es gibt also nicht nur keine gute Möglichkeit, dies zu tun, sondern es wird in absehbarer Zukunft nicht hinzugefügt werden.


Nein. Sie können lodash#get oder ähnliches in JavaScript verwenden.


Ich dachte, dass diese Frage für 2018 ein wenig Object.defineProperty() werden musste. Dies kann schön ohne Bibliotheken mit Object.defineProperty() und kann wie folgt verwendet werden:

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

Ich halte dies für sicher (und js-ethisch) aufgrund der beschreibbaren und enumerable Definitionen, die jetzt für die Methode defineProperty von Object verfügbar sind, wie in MDN dokumentiert

Funktionsdefinition unten:

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

Ich habe ein jsBin mit Konsolenausgabe zusammengestellt, um dies zu demonstrieren. Beachten Sie, dass ich in der JsBin-Version auch eine benutzerdefinierte Ausnahme für leere Werte hinzugefügt habe. Dies ist optional und deshalb habe ich es aus der obigen Definition herausgelassen.

Verbesserungen sind willkommen


Nein, in ES6 gibt es keinen Null-Propagierungsoperator. Sie müssen mit einem der bekannten Muster gehen .

Sie können jedoch Destrukturierung verwenden, obwohl:

({thing: aThing} = possiblyNull);

Es gibt viele Diskussionen (z. B. this ), um einen solchen Operator in ES7 hinzuzufügen, aber keiner ist wirklich gestartet.


Es ist nicht so schön wie das?. Operator, aber um ein ähnliches Ergebnis zu erzielen, könnten Sie Folgendes tun:

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

Da null und undefined beide Falsy- Werte sind ( siehe diese Referenz ), wird auf die Eigenschaft nach dem Operator && nur zugegriffen, wenn der Präzedenzfall nicht null oder undefiniert ist.

Alternativ könnten Sie eine Funktion wie folgt schreiben:

function try(func, fallbackValue) {
    try {
        return func();
    } catch (e) {
        return fallbackValue;
    }
}

Verwendung:

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

Oder mit einem Fallback-Wert:

try(() => user.address.postcode, "") // return postcode or empty string




babeljs