Methodenbeispiel zum sicheren Abrufen tiefer Objekte von Object in Js

const obj = {
    Waren:
        Name: "a",
     Schlagworte: {
            Name: 'Schnell',
         ID: 1,
         tagTyp: {
                Name: "Bezeichnung"
           }
       }
   }
}

wenn (obj.goods !== null
    && obj.goods.tags !== null
    && obj.goods.tags.tagType !== null) {
 
 }

let name = obj?.Waren?.Tags?.Tagestyp?.Name;

_.get(Objekt, Pfad, [Standardwert])

var Objekt = { 'a': [{ 'b': { 'c': 3 } }] };
​
_.get(Objekt, 'a[0].b.c');
// => 3 
​
_.get(Objekt, ['a', '0', 'b', 'c']);
// => 3
​
_.get(Objekt, 'abc', 'Standard');
// => 'Standard'

Funktion get(Objekt, Pfad, Standardwert) {
  const Ergebnis = Objekt == null? undefiniert: baseGet(Objekt, Pfad)
  Rückgabeergebnis === undefiniert? Standardwert: Ergebnis
}

Funktion baseGet(Objekt, Pfad) {
  //Konvertiere den Eingabestring path in ein Array,
  Pfad = castPath(Pfad, Objekt)
​
  lass Index = 0
  Konstante Länge = Pfadlänge
  // Durchlaufe das Array, um alle Objektebenen abzurufen while (object != null && index < length) {
    Objekt = Objekt[toKey(Pfad[index++])] // toKey-Methode}
  return (Index && Index == Länge)? Objekt: undefiniert
}
​

/** Wird als Referenz für verschiedene `Number`-Konstanten verwendet. */
Konstante UNENDLICHKEIT = 1 / 0
​
/**
 * Wandelt „Wert“ in einen String-Schlüssel um, wenn es sich nicht um einen String oder ein Symbol handelt.
 *
 * @Privat
 * @param {*} Wert Der zu prüfende Wert.
 * @returns {string|symbol} Gibt den Schlüssel zurück.
 */
Funktion toKey(Wert) {
  wenn (Typ des Wertes === 'Zeichenfolge' || istSymbol(Wert)) {
    Rückgabewert
  }
  const Ergebnis = `${Wert}`
  return (Ergebnis == '0' und (1 / Wert) == -UNENDLICH) ? '-0' : Ergebnis
}

importiere isKey aus './isKey.js'
importiere stringToPath aus „./stringToPath.js“
​
/**
 * Wandelt „Wert“ in ein Pfad-Array um, wenn es keins ist.
 *
 * @Privat
 * @param {*} Wert Der zu prüfende Wert.
 * @param {Object} [Objekt] Das Objekt, dessen Schlüssel abgefragt werden sollen.
 * @returns {Array} Gibt das Array mit dem Pfad der gegossenen Eigenschaft zurück.
 */
Funktion castPath(Wert, Objekt) {
  wenn (Array.isArray(Wert)) {
    Rückgabewert
  }
  returniere isKey(Wert, Objekt) ? [Wert] : stringToPath(Wert)
}
​

importiere memoizeCapped aus „./memoizeCapped.js“
​
const charCodeOfDot = '.'.charCodeAt(0)
const reEscapeChar = /\(\)?/g
const rePropName = RegExp(
  // Findet eine Übereinstimmung mit allem, was kein Punkt oder keine Klammer ist.
  '[^.[\]]+' + '|' +
  // Oder passen Sie die Eigenschaftsnamen in Klammern an.
  '\[(?:' +
    //Passt auf einen Ausdruck, der kein String ist.
    '([^"'][^[]*)' + '|' +
    // Oder Zeichenfolgen abgleichen (unterstützt das Escapen von Zeichen).
    '(["'])((?:(?!\2)[^\\]|\\.)*?)\2' +
  ')\]'+ '|' +
  // Oder "" als Leerzeichen zwischen aufeinanderfolgenden Punkten oder leeren Klammern abgleichen.
  '(?=(?:\.|\[\])(?:\.|\[\]|$))'
  , 'G')
​
/**
 * Konvertiert „String“ in ein Eigenschaftspfad-Array.
 *
 * @Privat
 * @param {string} string Der zu konvertierende String.
 * @returns {Array} Gibt das Eigenschaftspfad-Array zurück.
 */
const stringToPath = memoizeCapped((string) => {
  const Ergebnis = []
  wenn (string.charCodeAt(0) === charCodeOfDot) {
    Ergebnis.push('')
  }
  string.replace(rePropName, (Übereinstimmung, Ausdruck, Anführungszeichen, Teilzeichenfolge) => {
    let key = match
    wenn (Zitat) {
      Schlüssel = Teilstring.replace(reEscapeChar, '$1')
   }
    sonst wenn (Ausdruck) {
      Schlüssel = Ausdruck.trim()
   }
    Ergebnis.push(Schlüssel)
  })
  Ergebnis zurückgeben
})
​

importiere Memoize aus „../memoize.js“
​
/** Wird als maximale Memoize-Cachegröße verwendet. */
const MAX_MEMOIZE_SIZE = 500
​
/**
 * Eine spezielle Version von `memoize`, die die gespeicherten Daten der Funktion löscht.
 * Cache, wenn „MAX_MEMOIZE_SIZE“ überschritten wird.
 *
 * @Privat
 * @param {Function} func Die Funktion, deren Ausgabe gespeichert werden soll.
 * @returns {Function} Gibt die neue gespeicherte Funktion zurück.
 */
Funktion memoizeCapped(Funktion) {
  const Ergebnis = memoize(Funktion, (Schlüssel) => {
    const { cache } = Ergebnis
    wenn (cache.size === MAX_MEMOIZE_SIZE) {
      cache.löschen()
   }
    Eingabetaste
  })
​
  Ergebnis zurückgeben
}
​
Export-Standard-MemoizeCapped
​

Funktion memoize(Funktion, Resolver) {
  wenn (Typ der Funktion !== 'Funktion' || (Resolver != null und Typ des Resolvers !== 'Funktion')) {
    throw new TypeError('Eine Funktion erwartet')
  }
  const memoized = Funktion(...args) {
    const Schlüssel = Resolver? Resolver.apply(diese, Argumente) : Argumente[0]
    const cache = memoized.cache
​
    wenn (cache.hat(Schlüssel)) {
      returniere cache.get(Schlüssel)
   }
    const Ergebnis = func.apply(diese, Argumente)
    memoized.cache = cache.set(Schlüssel, Ergebnis) || Cache
    Ergebnis zurückgeben
  }
  memoized.cache = neu (memoize.Cache || Map)
  Rückkehr auswendig gelernt
}
​
memoize.Cache = Karte

/**
   * Ruft den Wert unter `path` von `object` ab. Wenn der aufgelöste Wert
   * „undefined“, stattdessen wird „defaultValue“ zurückgegeben.
   * @Beispiel
   * const Objekt = { 'a': [{ 'b': { 'c': 3 } }] }
   *
   * bekomme(Objekt, 'a[0].b.c')
   * // => 3
   *
   * bekomme(Objekt, ['a', '0', 'b', 'c'])
   * // => 3
   *
   * bekomme(Objekt, 'abc', 'Standard')
   * // => 'Standard'
   */
  safeGet (Objekt, Pfad, Standardwert) {
    Ergebnis lassen
    wenn (Objekt != null) {
      if (!Array.isArray(Pfad)) {
        const type = Typ des Pfads
        wenn (Typ === 'Zahl' || Typ === 'Boolesch' || Pfad == null ||
        /^\w*$/.test(Pfad) || !(/.|[(?:[^[]]*|(["'])(?:(?!\1)[^\]|\.)*?\1)]/.test(Pfad)) ||
       (Objekt != null && Pfad in Objekt(Objekt))) {
          Pfad = [Pfad]
       } anders {
          const Ergebnis = []
          wenn (Pfad.charCodeAt(0) === '.'.charCodeAt(0)) {
            Ergebnis.push('')
         }
          const rePropName = RegExp(
            // Findet eine Übereinstimmung mit allem, was kein Punkt oder keine Klammer ist.
            '[^.[\]]+|\[(?:([^"'][^[]*)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))'
           , 'G')
          Pfad.ersetzen(rePropName, (Übereinstimmung, Ausdruck, Zitat, Teilzeichenfolge) => {
            let key = match
            wenn (Zitat) {
              Schlüssel = Teilstring.replace(/\(\)?/g, '$1')
           } sonst wenn (Ausdruck) {
              Schlüssel = Ausdruck.trim()
           }
            Ergebnis.push(Schlüssel)
         })
          Pfad = Ergebnis
       }
     }
      lass Index = 0
      Konstante Länge = Pfadlänge
      const toKey = (Wert) => {
        wenn (Typ des Wertes === 'Zeichenfolge') {
          Rückgabewert
       }
        const Ergebnis = `${Wert}`
        return (Ergebnis === '0' && (1 / Wert) === -(1 / 0)) ? '-0' : Ergebnis
     }
      während (Objekt != null und Index < Länge) {
        Objekt = Objekt[toKey(Pfad[Index++])]
     }
      Ergebnis = (Index && Index === Länge)? Objekt: undefiniert
   }
    Rückgabeergebnis === undefiniert? Standardwert: Ergebnis
  }