Pfade in einem verschachtelten Objekt abrufen und überprüfen – Util-Funktionen Nr. 2

Gestern habe ich mit Ihnen eine Hilfsfunktion geteilt, mit der Sie ein Objekt in JS wiederkehrend in einer Schleife ausführen können. Eine der Funktionen besteht darin, dass Sie ein Array mit einem Pfad zum verschachtelten Objekt erhalten können wird gerade geloopt. Wenn Sie jedoch mit verschachtelten Objekten arbeiten, möchten Sie möglicherweise zu einem bestimmten Zeitpunkt Daten von einem bestimmten Pfad abrufen oder überprüfen. Genau das tun die heutigen Dienstprogrammfunktionen.

• getDataFromObj(obj, path): Daten von einem bestimmten Pfad in einem Objekt abrufen
• isValidObjPath(obj, path):überprüfen, ob ein bestimmter Pfad in einem Objekt vorhanden ist

getDataFromObj(obj, Pfad)

Sie können diesen Code gerne kopieren und einfügen

/**
 * Retrieves data from an object on a given path
 * @param {Object} obj the object to get the data from
 * @param {string[]} path an array of strings containing the keys of the object to look at
 * @returns {*} the retrieved data or a Reference Error if not found
 */

function getDataFromObj(obj, path){
  // Validate arguments
  if(getType(obj) != "object"){
    throw TypeError("The `obj` argument is not an object");
  }
  if(getType(path) != "array"){
    throw TypeError("The `path` argument is not an array");
  }

  // Get the data or a ReferenceError if not found
  const data = (()=>{
    let currentData = obj;

    for(let i = 0; i < path.length; i +=1 ){
      if(Object.keys(currentData).includes(path[i])){
        currentData = currentData[path[i]];
        continue;
      } else{
        currentData = ReferenceError("The object path is not defined");
        break;
      }
    }
    return currentData;
  })();

  return data;
}

/**
 * A method to detect data types more accurately
 * Credits: Chris Ferdinandi, https://gomakethings.com/
 * @param {*} data the data to be verified
 * @returns {String} the data type
 */
function getType(data){
  return Object.prototype.toString.call(data).toLowerCase().slice(8, -1)
}

/**
 * License: MIT, https://opensource.org/license/mit
 * Copyright (c) 2024 Rodrigo Isaias Calix
 */

Verwendung:

Sie müssen 2 Argumente übergeben:
obj: Das Objekt, von dem Sie die Daten abrufen möchten
Pfad: Ein Array, das die zu befolgende Sequenz angibt

Wenn der Pfad vorhanden ist, wird der Wert zurückgegeben (auch wenn der Wert undefiniert ist). Wenn der Pfad nicht vorhanden ist, wird ein ReferenceError-Objekt zurückgegeben. Es wird kein Fehler ausgegeben, sondern nur das Fehlerobjekt.

const products = {
  computers: {
    laptop: 20,
    desktop: 15,
    mini: 8
  },
  cameras: 20,
  externalDevices: {
    keyboard: {
      usb: 45,
      bluetooth: 25,
      other: undefined
    }
  }
}

// This would log 25
console.log(getDataFromObj(products, ["externalDevices", "keyboard", "bluetooth"]))

// this would return a ReferenceError object (not a throw, just the error object)
console.log(getDataFromObj(products, ["externalDevices", "mouse"]))

// this would return `undefined`
console.log(getDataFromObj(products, ["externalDevices", "keyboard", "other"]))

isValidObjPath(obj, Pfad)

Der Dienstprogrammcode:

/**
 * verify if an object has an specific path
 * @param {Object} obj the object to be verified
 * @param {string[]} path an array of strings containing the keys of the object to look at
 * @returns {Boolean} `true` if found, otherwise `false`
 */
function isValidObjPath(obj, path){
  // Validate arguments
  if(getType(obj) != "object"){
    throw TypeError("The `obj` argument is not an object");
  }
  if(getType(path) != "array"){
      throw TypeError("The `path` argument is not an array");
  }

  // shallow copy of the object to be verified
  let currentData = obj;

  // Verify the path
  for(let i = 0; i < path.length; i +=1 ){
    if(Object.keys(currentData).includes(path[i])){
      currentData = currentData[path[i]];
      continue;
    } else{
      return false;
    }
  }

  return true;
}

/**
 * A method to detect data types more accurately
 * Credits: Chris Ferdinandi, https://gomakethings.com/
 * @param {*} data the data to be verified
 * @returns {String} the data type
 */
function getType(data){
  return Object.prototype.toString.call(data).toLowerCase().slice(8, -1)
}

/**
 * License: MIT, https://opensource.org/license/mit
 * Copyright (c) 2024 Rodrigo Isaias Calix
 */

Verwendung:

Sie müssen 2 Argumente übergeben:
obj: Das Objekt, bei dem Sie überprüfen möchten, ob ein Pfad vorhanden ist
Pfad: Ein Array, das die zu befolgende Sequenz angibt

Wenn der von Ihnen gesuchte Pfad existiert, wird „true“ zurückgegeben, andernfalls wird „false“ zurückgegeben

const products = {
  computers: {
    laptop: 20,
    desktop: 15,
    mini: 8
  },
  cameras: 20,
  externalDevices: {
    keyboard: {
      usb: 45,
      bluetooth: 25,
      other: undefined
    }
  }
}

// This would log true
console.log(isValidObjPath(products, ["externalDevices", "keyboard", "bluetooth"]))

// this would log false
console.log(isValidObjPath(products, ["externalDevices", "mouse"]))

// this would log true
console.log(isValidObjPath(products, ["externalDevices", "keyboard", "other"]))

Warum ein Array als Pfad anstelle einer Zeichenfolge mit Schrägstrichen oder Punkten? (z. B. „computers.laptop“)

Da Objekteigenschaftsnamen auch eine Zeichenfolge mit einem großen Zeichensatz sein können, der Punkte enthält, wäre beispielsweise „computers.laptop“: {[...]} ein gültiges Objekt, ein Array würde mehr Flexibilität und Genauigkeit ermöglichen.

---

Wenn Sie dies nützlich fanden, werde ich weitere Inhalte wie diesen auf DEV teilen!

Sie finden mich auch aufX: https://x.com/schemetastic

Und denken Sie daran, es für später aufzubewahren ?

Das obige ist der detaillierte Inhalt vonPfade in einem verschachtelten Objekt abrufen und überprüfen – Util-Funktionen Nr. 2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!