javascript - name - Null-sicherer Eigenschaftenzugriff(und bedingte Zuweisung) in ES6/2015




javascript object name (7)

Gibt es einen nullsicheren Eigenschaftszugriffsoperator (null propagation / existence) in ES6 (ES2015 / JavaScript.next / Harmony) wie ?. 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

Im Idealfall sollte die Lösung aThing nicht zuordnen (auch nicht undefined ), wenn aThing den aThing null


Eine sichere deep get-Methode scheint eine natürliche Passform für underscore.js zu sein, aber hier geht es darum, die String-Programmierung zu vermeiden. Ändern der Antwort von @ Felipe, um das Programmieren von Zeichenfolgen zu vermeiden (oder zumindest die Groß- und Kleinschreibung 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('.'))  

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 null und undefined beide falsche Werte sind ( siehe diese Referenz ), wird auf die Eigenschaft nach dem Operator && nur zugegriffen, wenn der Präzedenzfall nicht null oder undefined ist.

Alternativ können Sie eine Funktion wie diese schreiben:

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

Verwendungszweck:

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

Oder mit einem Fallback-Wert:

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

Ich weiß, dass dies eine JavaScript-Frage ist, aber ich denke, Ruby geht damit auf alle erforderlichen Arten um, und ich denke, es ist ein relevanter Bezugspunkt.

.& , try und && haben ihre Stärken und potenziellen Fallstricke. Eine große Auswahl dieser Optionen hier: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; Die Schlussfolgerung der Rubyisten ist, dass dig sowohl die Augen schont als auch eine stärkere Garantie dafür darstellt, dass ein Wert oder eine null zugewiesen wird.

Hier ist eine einfache Implementierung in TypeScript:

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

Dies kann für jede Verschachtelungstiefe verwendet werden und führt Funktionen aus.

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

Der try Ansatz ist ebenso schön in JS zu lesen, wie in vorherigen Antworten gezeigt. Es ist auch keine Schleife erforderlich, was ein Nachteil dieser Implementierung ist.


Nach der Liste here gibt es derzeit keinen Vorschlag, Ecmascript sicherer zu machen. Es gibt also nicht nur keinen guten Weg, dies zu tun, sondern es wird in absehbarer Zeit auch nicht hinzugefügt.


Nein. In JavaScript können Sie hierfür lodash#get oder ähnliches verwenden.


Vanille-Alternative für den sicheren Zugang zu Eigentum

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

Die prägnanteste bedingte Zuweisung wäre wahrscheinlich diese

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

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
}




babeljs