¿Hay un nulloperador de acceso a propiedad seguro (propagación / existencia nula) en ES6 (ES2015 / JavaScript.next / Harmony) como ?.en CoffeeScript, por ejemplo? ¿O está planeado para ES7?

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

Esto será más o menos como:

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

Idealmente, la solución no debería asignar (incluso undefined) a aThingif possiblyNullisnull

Actualización (2020-01-31): Parece que la gente todavía está encontrando esto, aquí está la historia actual:

• Especificación de encadenamiento opcional (Etapa 4): https://github.com/tc39/proposal-optional-chaining
• babel-preset-env: Esto es probablemente lo que quieres https://babeljs.io/docs/en/babel-preset-env
• Complemento Babel v7: https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

Actualización (2017-08-01): si desea utilizar un complemento oficial, puede probar la compilación alfa de Babel 7 con la nueva transformación. Su experiencia puede ser diferente

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

Original :

Una característica que logra que se encuentra actualmente en la etapa 1: Encadenamiento opcional.

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

Si quiere usarlo hoy, hay un complemento de Babel que lo logra.

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

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

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

Desde nully undefinedson ambos Falsy valores ( ver esta referencia ), la propiedad después de que el &&operador sólo se accede si el precedente que no nulo o sin definir.

Alternativamente, podría 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. Puede usar lodash # get o algo así para esto en JavaScript.

Alternativa a la vainilla para un 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 operador de propagación nulo en ES6. Tendrá que ir con uno de los patrones conocidos .

Sin embargo, puede utilizar la desestructuración:

({thing: aThing} = possiblyNull);

Hay muchas discusiones (por ejemplo, esto ) para agregar dicho operador en ES7, pero ninguna realmente despegó.

Yendo por la lista aquí , actualmente no hay una propuesta para agregar un recorrido seguro a Ecmascript. Entonces, no solo no hay una buena manera de hacer esto, sino que no se agregará en el futuro previsible.

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

Encadenamiento opcional ?.y fusión nula??

Ahora puede usar directamente en ?.línea para probar la existencia de forma segura. Todos los navegadores modernos lo admiten.

?? se puede usar para establecer un valor predeterminado si no está definido o es nulo.

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

Si existe una propiedad, ?.pasa a la siguiente verificación o devuelve el valor válido. Cualquier falla provocará un cortocircuito y regresará de inmediato 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

Para garantizar un valor definido predeterminado, puede usar ??. Si necesita el primer valor verdadero, puede usarlo ||.

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

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

Si no marca un caso, la propiedad del lado izquierdo debe existir. Si no, arrojará una excepción.

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

?.Soporte de navegador : 78%, julio de 2020

??Soporte de navegador : 78%

Documentación de Mozilla

-

Asignación nula lógica, solución 2020+

Actualmente se están agregando nuevos operadores a los navegadores ??=, ||=y &&=. No hacen exactamente lo que está buscando, pero podrían conducir al mismo resultado dependiendo del objetivo de su código.

NOTA: Todavía no son comunes en las versiones de navegador público , pero Babel debería compilarse bien. Se actualizará a medida que cambie la disponibilidad.

??=comprueba si el lado izquierdo es indefinido o nulo, cortocircuito si ya está definido. Si no, al lado izquierdo se le asigna el valor del lado derecho. ||=y &&=son similares, pero se basan en los operadores ||y &&.

Ejemplos básicos

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

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

Ejemplos de objeto / matriz

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

Soporte de navegador Julio 2020 - .03%

Documentación de Mozilla

Un método seguro de obtención profunda parece un ajuste natural para underscore.js, pero el problema es evitar la programación de cadenas. Modificando la respuesta de @ Felipe para evitar la programación de cadenas (o al menos retrasa los casos límite a la persona que llama):

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('.'))  

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

.&, tryY && tienen sus puntos fuertes y los peligros potenciales. Un gran descuido de esas opciones aquí: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; La conclusión es que Rubyistas diges tanto más fácil en los ojos y una garantía más fuerte que un valor o nullse le asignará.

Aquí hay una implementació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 utilizar para cualquier profundidad de anidamiento y funciones de manejo.

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

El tryenfoque es igualmente agradable de leer en JS, como se muestra en las respuestas anteriores. Tampoco requiere bucles, lo cual 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 el uso de bibliotecas Object.defineProperty()y se puede usar de la siguiente manera:

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

Considero que esto es seguro (y js-ético) debido a las definiciones writeabley enumerableahora disponibles para el definePropertymétodo de Object, como se documenta en MDN

definición de la 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 agregado una excepción personalizada para valores vacíos. Esto es opcional, por lo que lo he dejado fuera de la definición mínima anterior.

Las mejoras son bienvenidas