Acceso a propiedades null-safe (y asignación condicional) en ES6/2015

No es tan agradable como el ?. operador, pero para lograr un resultado similar se podría hacer:

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

Dado que null y undefined son ambos valores falsy ( ver esta referencia), la propiedad después del operador && solo se accede si el precedente no es nulo o indefinido.

Alternativamente, puedes escribir una función como esta:

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 

O, con un valor de reserva:

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

No. Puedes usar lodash#get o algo así para esto en JavaScript.

Alternativa Vanilla para el acceso seguro a la propiedad

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

La asignación condicional más concisa probablemente sería esta

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

No, no hay ningún operador de propagación nulo en ES6. Tendrás que ir con uno de los patrones conocidos.

Usted puede ser capaz de utilizar desestructuración, aunque:

({thing: aThing} = possiblyNull);

Hay muchas discusiones (por ejemplo, este) para agregar tal operador en ES7, pero ninguno realmente despegó.

Siguiendo la lista aquí, actualmente no hay ninguna propuesta para agregar recorrido seguro a Ecmascript. Así que no solo no hay una buena manera de hacer esto, sino que no se va a agregar en el futuro previsible.

Sé que esta es una pregunta de JavaScript, pero creo que Ruby maneja esto de todas las maneras solicitadas, así que creo que es un punto de referencia relevante.

.&, try, y & & tienen sus fortalezas y potenciales trampas. Un gran resumen de esas opciones aquí: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby /

TLDR; La conclusión de los rubyistas es que dig es más fácil para los ojos y una garantía más fuerte de que un valor o null será asignar.

Aquí hay una explicación simple en 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
}

Esto se puede usar para cualquier profundidad de anidamiento y maneja funciones.

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

El enfoque try es igualmente agradable de leer en JS, como se muestra en las respuestas anteriores. Tampoco requiere bucles, que es un inconveniente de esta implementación.

Pensé que esta pregunta necesitaba un poco de actualización para 2018. Esto se puede hacer muy bien sin ninguna biblioteca usando Object.defineProperty() y se puede usar de la siguiente manera:

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

Considero esto seguro (y js-ético) debido a las definiciones writeable y enumerable ahora disponibles para el método defineProperty de Object, como documentado en MDN

Definición de función a continuación:

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

He reunido un jsBin con salida de consola para demostrar esto. Tenga en cuenta que en la versión jsBin También he añadido una excepción personalizada para los valores vacíos. Esto es opcional, así que lo he dejado fuera de la definición mínima anterior.

Las mejoras son bienvenidas

Un método de deep get seguro parece un ajuste natural para underscore.js pero allí el problema es evitar la programación de cadenas. Modificando la respuesta de @Felipe para evitar la programación de cadenas (o al menos devuelve los casos extremos al llamante):

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

Ejemplo:

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