Có một nulltoán tử truy cập thuộc tính an toàn (tuyên truyền / tồn tại null) trong ES6 (ES2015 / JavaScript.next / Harmony) như ?.trong CoffeeScript chẳng hạn? Hay là nó được lên kế hoạch cho ES7?

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

Điều này sẽ đại khái như:

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

Lý tưởng nhất là giải pháp không nên gán (chẵn undefined) cho aThingnếu possiblyNulllànull

Cập nhật (2020-01-31): Có vẻ như mọi người vẫn đang tìm thấy điều này, đây là câu chuyện hiện tại:

• Đặc tả chuỗi tùy chọn (Giai đoạn 4): https://github.com/tc39/projection-optional-chained
• babel-preset-env: Đây có lẽ là những gì bạn muốn https://babeljs.io/docs/en/babel-preset-env
• Plugin Babel v7: https://babeljs.io/docs/en/babel-plugin-proposed-optional-chained

Cập nhật (2017-08-01): Nếu bạn muốn sử dụng một plugin chính thức, bạn có thể thử bản dựng alpha của Babel 7 với biến đổi mới. Số dặm của bạn có thể thay đổi

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

Bản gốc :

Một tính năng hoàn thành hiện đang ở giai đoạn 1: Chuỗi tùy chọn.

https://github.com/tc39/proposed-optional-chained

Nếu bạn muốn sử dụng nó ngay hôm nay, có một plugin Babel thực hiện điều đó.

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

Nó không đẹp như? toán tử, nhưng để đạt được kết quả tương tự bạn có thể làm:

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

Kể từ nullvà undefinedđều falsy giá trị ( xem tài liệu tham khảo này ), tài sản sau khi &&khai thác được chỉ được truy cập nếu tiền lệ nó không phải null hoặc không xác định.

Ngoài ra, bạn có thể viết một chức năng như thế này:

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

Sử dụng:

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

Hoặc, với giá trị dự phòng:

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

Không. Bạn có thể sử dụng lodash # get hoặc một cái gì đó tương tự cho điều này trong JavaScript.

Vanilla thay thế để truy cập tài sản an toàn

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

Nhiệm vụ có điều kiện ngắn gọn nhất có lẽ sẽ là

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

Không, không có toán tử lan truyền null trong ES6. Bạn sẽ phải đi với một trong những mẫu đã biết .

Bạn có thể sử dụng phá hủy, mặc dù:

({thing: aThing} = possiblyNull);

Có nhiều cuộc thảo luận (ví dụ như điều này ) để thêm một toán tử như vậy trong ES7, nhưng không có cuộc thảo luận nào thực sự diễn ra.

Đi theo danh sách ở đây , hiện tại không có đề xuất nào để thêm giao dịch an toàn vào Ecmascript. Vì vậy, không chỉ không có cách hay để làm điều này, mà nó sẽ không được thêm vào trong tương lai gần.

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

Tùy chọn Chaining ?.và Nullish Coalescing??

Bây giờ bạn có thể trực tiếp sử dụng ?.nội tuyến để kiểm tra sự tồn tại một cách an toàn. Tất cả các trình duyệt hiện đại đều hỗ trợ nó.

?? có thể được sử dụng để đặt giá trị mặc định nếu không xác định hoặc null.

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

Nếu một tài sản tồn tại, ?.tiến hành kiểm tra tiếp theo hoặc trả về giá trị hợp lệ. Bất kỳ thất bại sẽ ngay lập tức ngắn mạch và trở lại 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

Để đảm bảo giá trị được xác định mặc định, bạn có thể sử dụng ??. Nếu bạn yêu cầu giá trị trung thực đầu tiên, bạn có thể sử dụng ||.

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

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

Nếu bạn không kiểm tra trường hợp, thuộc tính bên trái phải tồn tại. Nếu không, nó sẽ ném một ngoại lệ.

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

?.Hỗ trợ trình duyệt - 78%, tháng 7 năm 2020

??Hỗ trợ trình duyệt - 78%

Tài liệu Mozilla

-

Phân công logic nullish, giải pháp 2020+

Các nhà khai thác mới hiện đang được thêm vào các trình duyệt ??=, ||=và &&=. Họ không làm những gì bạn đang tìm kiếm, nhưng có thể dẫn đến kết quả tương tự tùy thuộc vào mục tiêu của mã của bạn.

Chú ý: Đây không phải là phổ biến ở các phiên bản trình duyệt nào được nêu ra , nhưng Babel nên transpile tốt. Sẽ cập nhật khi thay đổi sẵn có.

??=kiểm tra nếu bên trái là không xác định hoặc null, ngắn mạch nếu đã được xác định. Nếu không, bên trái được gán giá trị bên phải. ||=và &&=tương tự, nhưng dựa trên ||và các &&nhà khai thác.

Ví dụ cơ bản

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

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

Ví dụ đối tượng / mảng

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

Hỗ trợ trình duyệt tháng 7 năm 2020 - 0,03%

Tài liệu Mozilla

Một phương thức nhận sâu an toàn có vẻ như phù hợp tự nhiên với underscore.js nhưng vấn đề là tránh lập trình chuỗi. Sửa đổi câu trả lời của @ Felipe để tránh lập trình chuỗi (hoặc ít nhất là đẩy các trường hợp cạnh trở lại cho người gọi):

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

Thí dụ:

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

Tôi biết đây là một câu hỏi JavaScript, nhưng tôi nghĩ Ruby xử lý vấn đề này theo tất cả các cách được yêu cầu, vì vậy tôi nghĩ đó là một điểm tham chiếu có liên quan.

.&, tryvà && có những điểm mạnh và những cạm bẫy tiềm năng. Rất nhiều lựa chọn tuyệt vời ở đây: http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/

TLDR; Kết luận của Rubyists diglà vừa dễ nhìn hơn vừa đảm bảo mạnh mẽ hơn rằng giá trị hoặc nullsẽ được chỉ định.

Đây là một cải tiến đơn giản trong 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
}

Điều này có thể được sử dụng cho bất kỳ độ sâu của chức năng lồng và xử lý.

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

Cách trytiếp cận cũng tốt đẹp để đọc trong JS, như được hiển thị trong các câu trả lời trước. Nó cũng không yêu cầu lặp, đó là một nhược điểm của việc thực hiện này.

Tôi nghĩ rằng câu hỏi này cần một chút làm mới cho năm 2018. Điều này có thể được thực hiện độc đáo mà không cần bất kỳ thư viện nào sử dụng Object.defineProperty()và có thể được sử dụng như sau:

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

Tôi coi điều này là an toàn (và js-ethical) vì các định nghĩa writeablevà enumerablehiện có sẵn cho definePropertyphương pháp Object, như được ghi trong MDN

định nghĩa hàm dưới đây:

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

Tôi đã kết hợp một jsBin với đầu ra giao diện điều khiển để chứng minh điều này. Lưu ý rằng trong phiên bản jsBin, tôi cũng đã thêm một ngoại lệ tùy chỉnh cho các giá trị trống. Đây là tùy chọn và vì vậy tôi đã bỏ nó khỏi định nghĩa tối thiểu ở trên.

Cải tiến được hoan nghênh