Js でオブジェクトのディープ オブジェクトを安全に取得するメソッドの例

定数オブジェクト = {
    品：
        名前: 'a',
     タグ: {
            名前: 'Fast'、
         id: 1,
         タグタイプ: {
                名前: 'ラベル'
           }
       }
   }
}

(obj.goods !== nullの場合
    && obj.goods.tags !== null
    && obj.goods.tags.tagType !== null) {
 
 }

name = obj?.goods?.tags?.tageType?.name; とします。

_.get(オブジェクト, パス, [デフォルト値])

var オブジェクト = { 'a': [{ 'b': { 'c': 3 } }] };
​
_.get(オブジェクト、'a[0].b.c');
// => 3 
​
_.get(オブジェクト、['a', '0', 'b', 'c']);
// => 3
​
_.get(オブジェクト, 'abc', 'デフォルト');
// => 'デフォルト'

関数 get(オブジェクト, パス, デフォルト値) {
  const 結果 = オブジェクト == null ? 未定義 : baseGet(オブジェクト、パス)
  結果を返す === undefined ? defaultValue : 結果
}

関数baseGet(オブジェクト、パス) {
  //入力文字列パスを配列に変換します。
  パス = castPath(パス、オブジェクト)
​
  インデックスを0にする
  定数長さ = パス.長さ
  // 配列を走査してオブジェクトの各レイヤーを取得します while (object != null && index < length) {
    object = object[toKey(path[index++])] // toKeyメソッド}
  戻り値 (インデックス && インデックス == 長さ) ? オブジェクト: 未定義
}
​

/** さまざまな `Number` 定数の参照として使用されます。 */
定数無限大 = 1 / 0
​
/**
 * `value` が文字列またはシンボルでない場合は、文字列キーに変換します。
 *
 * @プライベート
 * @param {*} value 検査する値。
 * @returns {string|symbol} キーを返します。
 */
関数toKey(値) {
  if (typeof value === 'string' || isSymbol(value)) {
    戻り値
  }
  const 結果 = `${値}`
  戻り値 (結果 == '0' && (1 / 値) == -INFINITY) ? '-0' : 結果
}

'./isKey.js' から isKey をインポートします。
'./stringToPath.js' から stringToPath をインポートします。
​
/**
 * `value` がパス配列でない場合はパス配列にキャストします。
 *
 * @プライベート
 * @param {*} value 検査する値。
 * @param {Object} [object] キーを照会するオブジェクト。
 * @returns {Array} キャストプロパティパス配列を返します。
 */
関数castPath(値、オブジェクト) {
  Array.isArray(値)の場合{
    戻り値
  }
  isKey(値、オブジェクト)を返します? [値] : stringToPath(値)
}
​

'./memoizeCapped.js' から memoizeCapped をインポートします。
​
const charCodeOfDot = '.'.charCodeAt(0)
定数 reEscapeChar = /\(\)?/g
定数rePropName = 正規表現(
  // ドットまたは括弧以外のものに一致します。
  '[^.[\]]+' + '|' +
  // または、括弧内のプロパティ名を一致させます。
  '\[(?:' +
    // 文字列以外の式に一致します。
    '([^"'][^[]*)' + '|' +
    // または文字列に一致します (エスケープ文字をサポートします)。
    '(["'])((?:(?!\2)[^\\]|\\.)*?)\2' +
  ')\]'+ '|' +
  // または、連続するドットまたは空の括弧の間のスペースとして "" と一致します。
  '(?=(?:\.|\[\])(?:\.|\[\]|$))'
  、 'g')
​
/**
 * `string` をプロパティ パス配列に変換します。
 *
 * @プライベート
 * @param {string} string 変換する文字列。
 * @returns {Array} プロパティ パス配列を返します。
 */
const stringToPath = memoizeCapped((文字列) => {
  定数結果 = []
  （文字列.charCodeAt（0）=== charCodeOfDot）の場合{
    結果.push('')
  }
  string.replace(rePropName, (一致, 式, 引用符, 部分文字列) => {
    キー = 一致させる
    （引用）の場合{
      キー = subString.replace(reEscapeChar, '$1')
   }
    そうでない場合 (式) {
      キー = 式.trim()
   }
    結果.push(キー)
  })
  結果を返す
})
​

'../memoize.js' から memoize をインポートします。
​
/** 最大メモ化キャッシュサイズとして使用されます。 */
定数 MAX_MEMOIZE_SIZE = 500
​
/**
 * メモ化された関数の内容をクリアする`memoize`の特殊バージョン
 * `MAX_MEMOIZE_SIZE` を超えるとキャッシュされます。
 *
 * @プライベート
 * @param {Function} func 出力をメモ化する関数。
 * @returns {Function} 新しくメモ化された関数を返します。
 */
関数 memoizeCapped(func) {
  const 結果 = memoize(func, (キー) => {
    const { キャッシュ } = 結果
    （キャッシュサイズ === MAX_MEMOIZE_SIZE）の場合{
      キャッシュをクリアする()
   }
    リターンキー
  })
​
  結果を返す
}
​
エクスポートデフォルトmemoizeCapped
​

関数 memoize(func, リゾルバ) {
  if (typeof func !== 'function' || (resolver != null && typeofresolver !== 'function')) {
    throw new TypeError('関数が必要です')
  }
  const メモ化 = 関数(...引数) {
    const key = リゾルバ ? リゾルバ.apply(this, args) : args[0]
    const キャッシュ = メモ化されたキャッシュ
​
    キャッシュにキーがある場合
      cache.get(キー) を返す
   }
    const 結果 = func.apply(this, args)
    memoized.cache = cache.set(キー、結果) || キャッシュ
    結果を返す
  }
  memoized.cache = new (memoize.Cache || Map)
  メモ化されたものを返す
}
​
memoize.Cache = マップ

/**
   * `object`の`path`にある値を取得します。解決された値が
   * `undefined` の場合、代わりに `defaultValue` が返されます。
   * @例
   * 定数オブジェクト = { 'a': [{ 'b': { 'c': 3 } }] }
   *
   * get(オブジェクト、'a[0].b.c')
   * // => 3
   *
   * get(オブジェクト、['a', '0', 'b', 'c'])
   * // => 3
   *
   * get(オブジェクト、'abc'、'default')
   * // => 'デフォルト'
   */
  safeGet (オブジェクト、パス、デフォルト値) {
    結果を出す
    オブジェクトが null ではない場合
      if (!Array.isArray(path)) {
        const type = typeof パス
        if (type === 'number' || type === 'boolean' || path == null ||
        /^\w*$/.test(パス) || !(/.|[(?:[^[]]*|(["'])(?:(?!\1)[^\]|\.)*?\1)]/.test(パス)) ||
       (オブジェクト != null && Object(オブジェクト) 内のパス)) {
          パス = [パス]
       } それ以外 {
          定数結果 = []
          （path.charCodeAt(0) === '.'.charCodeAt(0)の場合）{
            結果.push('')
         }
          定数rePropName = 正規表現(
            // ドットまたは括弧以外の任意の文字に一致します。
            '[^.[\]]+|\[(?:([^"'][^[]*)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))'
           、 'g')
          path.replace(rePropName, (一致, 式, 引用符, 部分文字列) => {
            キー = 一致させる
            （引用）の場合{
              キー = subString.replace(/\(\)?/g, '$1')
           } else if (式) {
              キー = 式.trim()
           }
            結果.push(キー)
         })
          パス = 結果
       }
     }
      インデックスを0にする
      定数長さ = パス.長さ
      const toKey = (値) => {
        if (typeof value === 'string') {
          戻り値
       }
        const 結果 = `${値}`
        戻り値 (結果 === '0' && (1 / 値) === -(1 / 0)) ? '-0' : 結果
     }
      while (オブジェクト != null && インデックス < 長さ) {
        オブジェクト = オブジェクト[toKey(パス[インデックス++])]
     }
      結果 = (インデックス && インデックス === 長さ) ? オブジェクト: 未定義
   }
    結果を返す === undefined ? defaultValue : 結果
  }