नीचे एक JSON ऑब्जेक्ट है जो मुझे प्रतिक्रिया में प्राप्त होता है। कुछ टिप्पणियाँ:

  • यह वस्तु का सिर्फ एक हिस्सा है
  • ऑब्जेक्ट में सभी कंपनियों के लिए समान कुंजी नहीं होती है

JSON:

{
    "company": {
        "result": [
            {
                "profile": {
                    "address": "One Microsoft Way",
                    "bosses": [
                        {
                            "name": "Mr. Satya  Nadella",
                            "age": 53,
                            "totalPay": {
                                "raw": 13603180,
                                "fmt": "13.6M",
                                "longFmt": "13,603,180"
                            }
                        },
                        {
                            "name": "Mr. Bradford L. Smith",
                            "age": 61,
                            "title": "Pres & Chief Legal Officer",
                            "totalPay": {
                                "raw": 4265576,
                                "fmt": "4.27M",
                                "longFmt": "4,265,576"
                            }
                        }
                    ],
                    "auditRisk": 1,
                },
                "statistics": {
                    "enterpriseValue": {
                        "raw": 1570244395008,
                        "fmt": "1.57T",
                    },
                    "profitMargins": {
                        "raw": 0.32285
                    },
                    "financialCurrency": "USD"
                }
            }
        ],
        "error": null
    }
}

मैं:

  • इस ऑब्जेक्ट में कई पथ जांचें
  • यदि पथ एक स्ट्रिंग मान को इंगित करता है, तो मौजूद होने पर मान लौटाएं
  • यदि पथ किसी सरणी को इंगित करता है, तो प्रत्येक सरणी तत्व के लिए पथ वापस करने के लिए सरणी के माध्यम से लूप करें
  • यदि पथ में किसी विशिष्ट तत्व का नाम दिया गया है, तो केवल वही लौटाएं
  • उचित त्रुटि प्रबंधन की आवश्यकता है

लिपि

var json = JSON.parse(response.getContentText());

var paths = arr[
    "profile/address",                 <-- return the value
    "profile/sector",                  <-- does not exist, return false
    "profile/bosses/name",             <-- is an array with 2 elements, return both names
    "profile/bosses/1/age"             <-- only return age of second element
    "statistics/enterpriseValue/fmt",  <-- return the value
    "profitMargins/fmt",               <-- does not exist, return false
]

अपेक्षित उत्पादन:

One Microsoft Way
false
Mr. Satya Nadella
Mr. Bradford L. Smith
53
false

मैंने काफी समय से कोशिश की, लेकिन भ्रमित हो रहा हूं। क्या तुम मेरी मदद कर सकते हो?

for (path in paths) {
    var steps = path.split('/')
    
    for (step in steps) {
        if (step.hasOwnProperty(steps[step+1])) {
            if (typeof path[step] === "object") {
                // array, so loop again?
            }
            if (typeof path[step] === undefined) {
                // value doesn't exist?
                
                return false;
            }
            if (typeof path[step] !== undefined) {
                return path[step].value;
            }
        }
    }
}
1
Pr0no 13 जिंदा 2021, 23:42

3 जवाब

सबसे बढ़िया उत्तर

मुझे लगता है कि पहले कुछ बातों पर विचार किया जाना है, इसलिए मैं केवल निम्नलिखित पथ पर वस्तु को खोजना शुरू करता हूं

getPath( data, 'company/result/0' )

इससे मेरे लिए आपके निर्दिष्ट पथों की खोज शुरू करना बहुत आसान हो जाता है।

मुझे लगता है कि गुणों के लिए आपके द्वारा चुना गया वाक्यविन्यास सबसे आसान नहीं हो सकता है, क्योंकि यह तय करना थोड़ा कठिन है कि सभी तत्वों या सरणी में केवल एक आइटम खोजना है या नहीं (कहें, आप कुछ ढूंढ रहे होंगे length किसी आइटम का)।

इस परिणाम में उप सरणियाँ अभी भी मौजूद हैं, लेकिन यदि आप चाहते हैं तो आप परिणामों को समतल कर सकते हैं।

const data = {
    "company": {
        "result": [
            {
                "profile": {
                    "address": "One Microsoft Way",
                    "bosses": [
                        {
                            "name": "Mr. Satya  Nadella",
                            "age": 53,
                            "totalPay": {
                                "raw": 13603180,
                                "fmt": "13.6M",
                                "longFmt": "13,603,180"
                            }
                        },
                        {
                            "name": "Mr. Bradford L. Smith",
                            "age": 61,
                            "title": "Pres & Chief Legal Officer",
                            "totalPay": {
                                "raw": 4265576,
                                "fmt": "4.27M",
                                "longFmt": "4,265,576"
                            }
                        }
                    ],
                    "auditRisk": 1,
                },
                "statistics": {
                    "enterpriseValue": {
                        "raw": 1570244395008,
                        "fmt": "1.57T",
                    },
                    "profitMargins": {
                        "raw": 0.32285
                    },
                    "financialCurrency": "USD"
                }
            }
        ],
        "error": null
    }
};

const pathsToFind = [
  "profile/address",
  "profile/sector",                 
  "profile/bosses/name",            
  "profile/bosses/1/age",            
  "statistics/enterpriseValue/fmt",
  "profitMargins/fmt"
];



function getPath( obj, path ) {
  if (!path || !obj) {
    return null;
  }
  const [currentPath, ...rest] = path.split('/');
  const nextPath = rest.join('/');
  const currentObj = obj[currentPath];
  
  // final path, exit here
  if (nextPath.length === 0) {
    return currentObj;
  }
  
  if (Array.isArray( currentObj )) {
    // does an element exit at the next level
    if ( currentObj[nextPath[0]] ) {
      // will continue reading for 1 element
      return getPath( currentObj, nextPath );
    }
    // return all the subpaths, skip the ones that are falsy
    return currentObj.map( item => getPath( item, nextPath ) ).filter( v => v );
  }
  // get the next part of the object
  return getPath( currentObj, nextPath );
}

function getMatchingValues( obj, paths ) {
  return paths.flatMap( path => getPath( obj, path ) ?? false );
}

console.log( getMatchingValues( getPath( data, 'company/result/0' ), pathsToFind ) );
1
Icepickle 14 जिंदा 2021, 02:57

आपके समाधान के लिए कई समाधान हैं, लेकिन मुझे लगता है कि आप JSONPath समाधान को अपने JSON ऑब्जेक्ट को क्वेरी करने का एक मानक तरीका मान सकते हैं।

इसे देखें npm JSONPath गाइड

0
Soroosh Khodami 13 जिंदा 2021, 23:52

समाधान

let data = {
  profile: {
    address: "One Microsoft Way",
    bosses: [
      {
        name: "Mr. Satya  Nadella",
        age: 53,
        totalPay: {
          raw: 13603180,
          fmt: "13.6M",
          longFmt: "13,603,180",
        },
      },
      {
        name: "Mr. Bradford L. Smith",
        age: 61,
        title: "Pres & Chief Legal Officer",
        totalPay: {
          raw: 4265576,
          fmt: "4.27M",
          longFmt: "4,265,576",
        },
      },
    ],
    auditRisk: 1,
  },
  statistics: {
    enterpriseValue: {
      raw: 1570244395008,
      fmt: "1.57T",
    },
    profitMargins: {
      raw: 0.32285,
    },
    financialCurrency: "USD",
  },
};

let paths = [
  "profile/address",
  "profile/sector",
  "profile/bosses/name",
  "profile/bosses/1/age",
  "statistics/enterpriseValue/fmt",
  "profitMargins/fmt",
];

let GenratedResult = paths
  .map((p) => p.split("/"))
  .reduce((allResults, c) => {
    let curRes = c.reduce((innerResults, innerCur) => {
      if (typeof innerResults === "object" && innerResults.length) {
        if (!isNaN(innerCur * 1)) {
          return innerResults[innerCur] || false;
        } else {
          let R = innerResults
            .map((v) => v[innerCur] || false)
            .filter((i) => i);
          return R.length ? R : false;
        }
      }

      return innerResults && innerResults[innerCur]
        ? innerResults[innerCur]
        : false;
    }, data);

    return [...allResults, curRes];
  }, [])
  .flatMap((i) => i);

console.log(GenratedResult);
0
MUHAMMAD ILYAS 14 जिंदा 2021, 00:51