Existe um nulloperador de acesso à propriedade -safe (propagação / existência nula) no ES6 (ES2015 / JavaScript.next / Harmony) como ?.no CoffeeScript, por exemplo? Ou está planejado para o ES7?

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

Isso será mais ou menos como:

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

Idealmente, a solução não deve atribuir (mesmo undefined) a aThingse possiblyNullénull

Atualização (2020-01-31): Parece que as pessoas ainda estão encontrando isso, aqui está a história atual:

• Especificação de encadeamento opcional (estágio 4): https://github.com/tc39/proposal-optional-chaining
• babel-preset-env: Provavelmente é isso que você deseja https://babeljs.io/docs/en/babel-preset-env
• Babel v7 Plugin: https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

Atualização (01/08/2017): Se você deseja usar um plug-in oficial, pode tentar a versão alfa do Babel 7 com a nova transformação. Sua milhagem pode variar

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

Original :

Um recurso que realiza o que está atualmente no estágio 1: encadeamento opcional.

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

Se você quiser usá-lo hoje, existe um plugin Babel que realiza isso.

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

Não é tão bom quanto o. operador, mas para obter um resultado semelhante, você pode:

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

Como nulle undefinedsão ambos valores falsos ( consulte esta referência ), a propriedade após o &&operador é acessada apenas se o precedente não for nula ou indefinida.

Como alternativa, você pode escrever uma função 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 

Ou, com um valor de fallback:

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

Não. Você pode usar lodash # get ou algo parecido para isso em JavaScript.

Alternativa de baunilha para acesso seguro à propriedade

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

A atribuição condicional mais concisa provavelmente seria essa

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

Não, não há operador de propagação nulo no ES6. Você terá que seguir um dos padrões conhecidos .

Você pode usar a desestruturação, no entanto:

({thing: aThing} = possiblyNull);

Existem muitas discussões (por exemplo, isso ) para adicionar um operador no ES7, mas nenhuma realmente decolou.

Indo pela lista aqui , atualmente não há nenhuma proposta para adicionar uma travessia segura ao Ecmascript. Portanto, não apenas não há uma maneira agradável de fazer isso, mas não será adicionado em um futuro próximo.

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

Encadeamento opcional ?. e coalescência nula??

Agora você pode usar diretamente ?. inline para testar com segurança a existência. Todos os navegadores modernos são compatíveis.

?? pode ser usado para definir um valor padrão se indefinido ou nulo.

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

Se existir uma propriedade, ?.prossiga para a próxima verificação ou retorne o valor válido. Qualquer falha irá imediatamente causar um curto-circuito e retornar 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 garantir um valor definido padrão, você pode usar ??. Se você precisar do primeiro valor de verdade, poderá usar ||.

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

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

Se você não verificar um caso, a propriedade do lado esquerdo deverá existir. Caso contrário, lançará uma exceção.

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

?.Suporte do navegador - 78%, julho de 2020

??Suporte ao navegador - 78%

Documentação Mozilla

-

Designação nula lógica, solução 2020+

Novos operadores estão sendo adicionados aos navegadores, ??=, ||=e &&=. Eles não fazem exatamente o que você está procurando, mas podem levar ao mesmo resultado, dependendo do objetivo do seu código.

NOTA: Estas não são comuns nas versões públicas do navegador ainda , mas Babel deve transpile bem. Será atualizado conforme a disponibilidade for alterada.

??=verifica se o lado esquerdo está indefinido ou nulo, em curto-circuito, se já definido. Caso contrário, o lado esquerdo recebe o valor do lado direito. ||=e &&=são semelhantes, mas com base no ||e &&operadores.

Exemplos básicos

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

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

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

Suporte para navegadores julho de 2020 - 0,03%

Documentação Mozilla

Um método deep get seguro parece um ajuste natural para o underscore.js, mas o problema é evitar a programação de strings. Modificando a resposta de @ Felipe para evitar a programação de strings (ou pelo menos empurra as bordas de volta ao chamador):

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

Exemplo:

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

Sei que essa é uma pergunta sobre JavaScript, mas acho que Ruby lida com isso de todas as formas solicitadas, então acho que é um ponto de referência relevante.

.&, tryE && têm seus pontos fortes e potenciais armadilhas. Um excelente resumo dessas opções aqui: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; A conclusão dos rubiístas é que digé mais fácil aos olhos e uma garantia mais forte de que um valor ou nullserá atribuído.

Aqui está uma implementação simples no 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
}

Isso pode ser usado para qualquer profundidade de aninhamento e manipula funções.

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

A tryabordagem é igualmente agradável de ler em JS, como mostrado nas respostas anteriores. Também não requer loop, que é uma desvantagem desta implementação.

Eu pensei que essa pergunta precisava de uma atualização para 2018. Isso pode ser feito sem a necessidade de bibliotecas Object.defineProperty()e pode ser usado da seguinte maneira:

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

Considero isso seguro (e js-ético) por causa das definições writeablee enumerableagora disponíveis para o definePropertymétodo de Object, conforme documentado no MDN

definição da função abaixo:

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

Reuni um jsBin com a saída do console para demonstrar isso. Observe que na versão jsBin também adicionei uma exceção personalizada para valores vazios. Isso é opcional e, portanto, deixei de fora da definição mínima acima.

Melhorias são bem-vindas