Angular 8 Native Typescript без сбоев, сокращение доступа

Я предпочитаю логические выражения.

let object = {
  accessor: {
    accessor: {
      accessor: "test"
    }
  }
}

if (object
   && object.accessor
   && object.accessor.accessor
   && object.accessor.accessor.accessor) {
  console.log(object.accessor.accessor.accessor);
} else {
  console.log(null);
}

Если вас не волнует проверка ошибок во время компиляции, вы можете сделать что-то странное. Я бы не рекомендовал это.

function tryGetValue(obj, propertiesPath) {
  if (!obj) {
    return null;
  }

  if (!propertiesPath) {
    return obj;
  }

  let current = obj;
  let properties = propertiesPath.split(".");
  for (let i = 0; i < properties.length; i++) {
    if (current[properties[i]] !== undefined) {
      current = current[properties[i]];
    } else {
      current = null;
      break;
    }
  }

  if (current !== undefined) {
    return current;
  } else {
    return null;
  }
}

console.log(tryGetValue(object, "accessor.accessor.accessor"));

для этого существует пакет npm с именем snq(Safe Navigation Query) от armanozak. Очень простое и надежное решение.

Вы можете использовать это так

snq(() => object.accessor.accessor.accessor, anyDefaultValueIfYouLike);

И если вам интересно, как это работает, вот исходный код, который я скопировал из репозитория github.

export default function snq<T = any>(callback: () => T, defaultValue?: T) {
  try {
    const result = callback();
    return typeof result === 'undefined' ? defaultValue : result;
  } catch (err) {
    if (err instanceof TypeError) {
      return defaultValue;
    }

    throw err;
  }
}

Вы можете просто сделать следующее

// Sample object

const object = {
    someKey: 'First Level Value',
    accessor: {
        someKey: 'Second Level Value',
        accessor: {
            someKey: 'Third Level Value',
            accessor: 'Accessor Value'
        }
    }
};

// Using ternary expression to do conditional validation check
// Usage --> condition to check ? 'Do this if condition is true' : 'Do this if condition is false'

const accessorValue = object ? // first (?) operator
    object.accessor ? // second (?) operator
        object.accessor.accessor ? // third (?) operator
            object.accessor.accessor ? // fourth (?) operator
                object.accessor.accessor.accessor :
                null : // to match the first (?) operator
            null : // to match the second (?) operator
        null : // to match the third (?) operator
    null; // to match the fourth (?) operator

console.log(accessorValue); // Accessor Value

Мне нравится использовать функцию пути Ramda в моих угловых проектах.

import * as R from 'ramda';

const leaf = R.path(['accessor', 'accessor', 'accessor'], object);

Другой подход, который я использовал, чтобы избежать сбоя, если дочерний элемент пуст (когда ramda нет рядом), исходит от операторов swifts .? и ?? по умолчанию для чего-то, если дочерний элемент пуст.

Вам не нужны причудливые функции, этот единственный лайнер защитит от сбоев

const leaf = (((object || {}).accessor || {}).accessor || {}).accessor;

In action:

const wrongObject = { accessor: null };
const validObject = { 
  accessor: {
    accessor: {
      accessor: 'your leaf value'
    }
  }
};

// crash proof, returning: undefined
const wrongLeaf = (((wrongObject || {}).accessor || {}).accessor || {}).accessor
console.log(wrongLeaf);

// or even with fallback / default value
const defaultLeaf = (((wrongObject || {}).accessor || {}).accessor || {}).accessor || 'default 123';
console.log(defaultLeaf);

const validLeaf = (((validObject || {}).accessor || {}).accessor || {}).accessor
console.log(validLeaf);

Я полагаю, вы могли бы сделать что-то подобное в качестве стенографии, что позволило бы пропускать типы.

const value = (() => {try{return object.accessor.accessor.accessor}catch(e){return yourDefault;}})();