Gibt es nullin ES6 (ES2015 / JavaScript.next / Harmony) einen Operator für den Zugriff auf sichere Eigenschaften (Null-Weitergabe / Existenz), wie beispielsweise ?.in CoffeeScript ? Oder ist es für ES7 geplant?

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

Dies wird ungefähr so ​​sein:

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

Idealerweise sollte die Lösung nicht (gerade undefined) aThingif zugeordnet possiblyNullwerdennull

Update (2020-01-31): Es scheint, dass die Leute dies immer noch finden. Hier ist die aktuelle Geschichte:

• Optionale Verkettungsspezifikation (Stufe 4): https://github.com/tc39/proposal-optional-chaining
• babel-preset-env: Dies ist wahrscheinlich das, was Sie wollen https://babeljs.io/docs/en/babel-preset-env
• Babel v7 Plugin: https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

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

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

Original :

Eine Funktion, die dies erreicht, befindet sich derzeit in Stufe 1: Optionale Verkettung.

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

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

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

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

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

Da nullund undefinedbeide falsche 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önnen Sie eine Funktion wie die folgende schreiben:

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

Verwendung:

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

Oder mit einem Fallback-Wert:

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

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

Vanille-Alternative für sicheren Zugang zu Eigentum

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

Die prägnanteste bedingte Zuordnung wäre wahrscheinlich diese

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

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

Möglicherweise können Sie jedoch die Destrukturierung verwenden:

({thing: aThing} = possiblyNull);

Es gibt viele Diskussionen (z. B. diese ), um einen solchen Operator in ES7 hinzuzufügen, aber keine hat sich wirklich durchgesetzt.

Anhand der Liste hier gibt es derzeit keinen Vorschlag, Ecmascript um eine sichere Durchquerung zu erweitern. Es gibt also nicht nur keinen guten Weg, dies zu tun, sondern es wird in absehbarer Zeit auch nicht hinzugefügt.

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

Optionale Verkettung ?.und Nullish Coalescing??

Sie können jetzt direkt ?.Inline verwenden, um die Existenz sicher zu testen. Alle modernen Browser unterstützen dies.

?? kann verwendet werden, um einen Standardwert festzulegen, wenn undefiniert oder null.

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

Wenn eine Eigenschaft vorhanden ist, fahren Sie ?.mit der nächsten Prüfung fort oder geben Sie den gültigen Wert zurück. Jeder Fehler wird sofort kurzgeschlossen und kehrt zurück 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

Um einen standardmäßig definierten Wert sicherzustellen, können Sie verwenden ??. Wenn Sie den ersten Wahrheitswert benötigen, können Sie verwenden ||.

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

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

Wenn Sie einen Fall nicht überprüfen, muss die Eigenschaft auf der linken Seite vorhanden sein. Wenn nicht, wird eine Ausnahme ausgelöst.

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

?.Browser-Unterstützung - 78%, Juli 2020

??Browser-Unterstützung - 78%

Mozilla-Dokumentation

- -

Logische Nullzuweisung, 2020+ Lösung

Derzeit werden den Browsern neue Operatoren hinzugefügt ??=, ||=und &&=. Sie tun nicht ganz das, wonach Sie suchen, können jedoch je nach Ziel Ihres Codes zu demselben Ergebnis führen.

HINWEIS: Diese sind in öffentlichen Browserversionen noch nicht üblich , aber Babel sollte sich gut transpilieren lassen. Wird aktualisiert, wenn sich die Verfügbarkeit ändert.

??=prüft, ob die linke Seite undefiniert oder null ist, kurzgeschlossen, falls bereits definiert. Wenn nicht, wird der linken Seite der Wert für die rechte Seite zugewiesen. ||=und &&=sind ähnlich, basieren jedoch auf den Operatoren ||und &&.

Grundlegende Beispiele

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

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

Objekt- / Array-Beispiele

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-Unterstützung Juli 2020 - 0,03%

Mozilla-Dokumentation

Eine sichere Deep-Get-Methode scheint eine natürliche Passform für underscore.js zu sein, aber dort besteht das Problem darin, die Zeichenfolgenprogrammierung zu vermeiden. Ändern der Antwort von @ Felipe, um die Programmierung von Zeichenfolgen zu vermeiden (oder zumindest Randfälle an den Aufrufer zurückzuschieben):

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

Beispiel:

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

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

.&, tryUnd && ihre Stärken und mögliche Gefahren haben. Eine große Auswahl dieser Optionen finden Sie hier: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; Die Schlussfolgerung der Rubyisten ist, dass dies digsowohl augenschonender als auch eine stärkere Garantie dafür ist, dass ein Wertnull zugewiesen wird oder 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 Verschachtelungstiefe verwendet werden und behandelt Funktionen.

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

Der tryAnsatz ist in JS ebenso gut zu lesen, wie in den vorherigen Antworten gezeigt. Es ist auch keine Schleife erforderlich, was ein Nachteil dieser Implementierung ist.

Ich dachte, diese Frage müsste für 2018 etwas aktualisiert werden. Dies kann ohne Verwendung von Bibliotheken problemlos durchgeführt werden Object.defineProperty()und kann wie folgt verwendet werden:

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

Ich halte dies für sicher (und js-ethisch) aufgrund der writeableund enumerableDefinitionen, die jetzt für die definePropertyMethode von verfügbar sind Object, 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 einen 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 Minimaldefinition herausgelassen.

Verbesserungen sind willkommen