Apakah ada nulloperator properti akses -safe (propagasi nol / keberadaan) di ES6 (ES2015 / JavaScript.next / Harmony) seperti ?.di CoffeeScript misalnya? Atau apakah direncanakan untuk ES7?

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

Ini kira-kira akan seperti:

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

Idealnya solusinya tidak boleh menetapkan (datar undefined) aThingjika possiblyNulladanull

Pembaruan (2020-01-31): Sepertinya orang masih menemukan ini, inilah kisahnya saat ini:

• Spesifikasi rantai opsional (Tahap 4): https://github.com/tc39/proposal-optional-chaining
• babel-preset-env: Ini mungkin yang Anda inginkan https://babeljs.io/docs/en/babel-preset-env
• Plugin Babel v7: https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

Pembaruan (2017-08-01): Jika Anda ingin menggunakan plugin resmi, Anda dapat mencoba alpha build Babel 7 dengan transformasi baru. Jarak tempuh Anda mungkin beragam

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

Asli :

Fitur yang mencapai yang saat ini dalam tahap 1: Chaining Opsional.

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

Jika Anda ingin menggunakannya hari ini, ada plugin Babel yang menyelesaikannya.

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

Ini tidak sebaik? operator, tetapi untuk mencapai hasil yang serupa dapat Anda lakukan:

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

Karena nulldan undefinedkeduanya nilai-nilai palsu ( lihat referensi ini ), properti setelah &&operator hanya diakses jika presedennya tidak nol atau tidak terdefinisi.

Atau, Anda dapat menulis fungsi seperti ini:

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

Pemakaian:

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

Atau, dengan nilai cadangan:

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

Tidak. Anda dapat menggunakan lodash # get atau sesuatu seperti itu untuk ini dalam JavaScript.

Alternatif vanila untuk akses properti aman

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

Tugas bersyarat yang paling ringkas mungkin adalah ini

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

Tidak, tidak ada operator propagasi nol di ES6. Anda harus menggunakan salah satu pola yang dikenal .

Anda mungkin dapat menggunakan destrrukturisasi, meskipun:

({thing: aThing} = possiblyNull);

Ada banyak diskusi (misalnya ini ) untuk menambahkan operator seperti itu di ES7, tetapi tidak ada yang benar-benar berjalan.

Pergi dengan daftar di sini , saat ini tidak ada proposal untuk menambahkan traversal aman ke Ecmascript. Jadi tidak hanya tidak ada cara yang baik untuk melakukan ini, tetapi itu tidak akan ditambahkan di masa mendatang.

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

Chaining Opsional ?.dan Penggabungan Nullish??

Anda sekarang dapat langsung menggunakan ?.inline untuk menguji keberadaan dengan aman. Semua browser modern mendukungnya.

?? dapat digunakan untuk menetapkan nilai default jika tidak terdefinisi atau nol.

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

Jika ada properti, ?.lanjutkan ke pemeriksaan berikutnya, atau mengembalikan nilai yang valid. Kegagalan akan segera terjadi korsleting dan kembali 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

Untuk memastikan nilai standar yang ditentukan, Anda dapat menggunakan ??. Jika Anda membutuhkan nilai kebenaran pertama, Anda dapat menggunakannya ||.

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

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

Jika Anda tidak memeriksa kasus, properti sisi kiri harus ada. Jika tidak, itu akan melempar pengecualian.

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

?.Dukungan Browser - 78%, Juli 2020

??Dukungan Browser - 78%

Dokumentasi Mozilla

-

Penugasan nullish yang logis, solusi 2020+

Operator baru sedang ditambahkan ke browser ??=,, ||=dan &&=. Mereka tidak melakukan apa yang Anda cari, tetapi dapat menghasilkan hasil yang sama tergantung pada tujuan kode Anda.

CATATAN: Ini tidak umum di versi browser publik belum , tetapi Babel harus transpile dengan baik. Akan diperbarui jika ketersediaan berubah.

??=memeriksa apakah sisi kiri tidak terdefinisi atau nol, korsleting jika sudah ditentukan. Jika tidak, sisi kiri diberi nilai sisi kanan. ||=dan &&=serupa, tetapi didasarkan pada ||dan &&operator.

Contoh dasar

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

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

Contoh Obyek / Array

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

Dukungan Browser Juli 2020 - .03%

Dokumentasi Mozilla

Metode deep deep get sepertinya cocok untuk underscore.js tetapi ada masalah menghindari pemrograman string. Memodifikasi jawaban @ Felipe untuk menghindari pemrograman string (atau setidaknya mendorong kasus tepi kembali ke pemanggil):

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

Contoh:

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

Saya tahu ini adalah pertanyaan JavaScript, tapi saya pikir Ruby menangani ini dengan semua cara yang diminta, jadi saya pikir itu adalah titik referensi yang relevan.

.&,, try& && memiliki kekuatan dan potensi jebakan mereka. Hebatnya opsi di sini: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; Kesimpulan Rubyists adalah bahwa diglebih mudah di mata dan jaminan yang lebih kuat bahwa nilai atau nullakan diberikan.

Berikut ini adalah penerapan sederhana dalam 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
}

Ini dapat digunakan untuk setiap kedalaman fungsi persarangan dan pegangan.

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

The trypendekatan adalah sama-sama baik untuk membaca di JS, seperti yang ditunjukkan dalam jawaban sebelumnya. Ini juga tidak memerlukan perulangan, yang merupakan salah satu kelemahan dari implementasi ini.

Saya pikir pertanyaan ini membutuhkan sedikit penyegaran untuk tahun 2018. Ini dapat dilakukan dengan baik tanpa menggunakan perpustakaan Object.defineProperty()dan dapat digunakan sebagai berikut:

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

Saya menganggap ini aman (dan js-etika) karena writeabledan enumerabledefinisi sekarang tersedia untuk definePropertymetode Object, seperti yang didokumentasikan dalam MDN

definisi fungsi di bawah ini:

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

Saya telah mengumpulkan jsBin dengan output konsol untuk menunjukkan ini. Perhatikan bahwa dalam versi jsBin saya juga menambahkan pengecualian khusus untuk nilai kosong. Ini opsional, jadi saya tidak menggunakan definisi minimal di atas.

Perbaikan disambut