कराटे - जावास्क्रिप्ट के समान कराटे में प्रत्येक के लिए नेस्टेड का उपयोग कैसे करें

Question

मैं नेस्टेड जसन संरचना के माध्यम से लूप करना चाहता हूं और सभी आवश्यक क्षेत्रों को अपडेट करना चाहता हूं, हालांकि मैं इसे टाइपस्क्रिप्ट के माध्यम से प्राप्त कर सकता हूं, लेकिन कराटे जेएस में ऐसा करना चाहता हूं, मुझे कोई उदाहरण नहीं दिखता है कि प्रत्येक काम के लिए नेस्टेड कैसे करना है।

मैं 26 पीरियड डेटा (यहां पठनीयता के लिए मैंने 3 का उपयोग किया है) को अपडेट करना चाहता हूं, इंडेक्स के आधार पर मैं पीरियड फील्ड को अपडेट करना चाहता हूं, अगर (इंडेक्स == कुंजी), तो ये 26 अवधि प्रत्येक कार विशेषता के तहत हैं। (नोट: आपके पास फिर से है। कई कारों और कई कार विशेषताओं और प्रत्येक कार विशेषता आपके पास 26 अवधियों का डेटा है)

मैं इस कराटे का उपयोग नहीं कर सकता - दो डायनेमिक प्रतिक्रियाओं से तभी मिलान करें जब आपके पास एकल सरणी सूची हो और कम डेटा हो

  [
      {
        "cars": [
          {
            "name": "car 1",
            "periodsData": [
              {
                "period": "5ed73ed31a775d1ab0c9fb5c",
                "index": 1
              },
              {
                "period": "5ed73ed31a775d1ab0c9fb5d",
                "index": 2
              },
              {
                "period": "5ed73ed31a775d1ab0c9fb5e",
                "index": 3
              }
            ]
          },
          {
            "name": "car 2",
            "periodsData": [
              {
                "period": "5ed73ed31a775d1ab0c9fb5c",
                "index": 1
              },
              {
                "period": "5ed73ed31a775d1ab0c9fb5d",
                "index": 2
              },
              {
                "period": "5ed73ed31a775d1ab0c9fb5e",
                "index": 3
              }
            ]
          },
          {
            "name": "car 3",
            "periodsData": [
              {
                "period": "5ed73ed31a775d1ab0c9fb5c",
                "index": 1
              },
              {
                "period": "5ed73ed31a775d1ab0c9fb5d",
                "index": 2
              },
              {
                "period": "5ed73ed31a775d1ab0c9fb5e",
                "index": 3
              }
            ]
          }
        ],
        "totalPeriodEprps": [
          {
            "period": "5ed73ed31a775d1ab0c9fb5c",
            "index": 1
          },
          {
            "period": "5ed73ed31a775d1ab0c9fb5d",
            "index": 2
          },
          {
            "period": "5ed73ed31a775d1ab0c9fb5e",
            "index": 3
          }
        ]
       }
     carId ="dfd"
    ]

This above array repeats

स्क्रिप्ट कोड टाइप करें

//periods is a map of index and values

  async modifyCarsData(mid, id, periods, campaignData) {

//carData is a json file
    carData.forEach(element => {
      element.carId= id;

      // Update all egrp periods
      element.totalPeriodEGRPs.forEach(eGrpPeriod => {
        // egrprd.period =
        if (periods.size === element.totalPeriodEGRPs.length) {
          periods.forEach((value, key) => {
            if (key === eGrpPeriod.index.toString()) {
              eGrpPeriod.period = value;
              return true;
            }
          });
        }
      });

      element.cars.forEach(carCell => {
        

        // Logic for updating periods data
        carCell .periodsData.forEach(periodAttribute => {
          if (periods.size === carCell.periodsData.length) {
            periods.forEach((value, key) => {
              if (key === periodAttribute.index.toString()) {
                periodAttribute.period = value;
                return true;
              }
            });
          }
        });
      });
    });

Answer 1

इसे अद्यतन के रूप में मत समझिए, बल्कि एक परिवर्तन के रूप में। मैं आपके उदाहरण का उपयोग नहीं कर रहा हूं क्योंकि यह संयुक्त राष्ट्र-जटिल है। यहां एक सरल उदाहरण दिया गया है जो आपको उन सभी अवधारणाओं को देता है जिनकी आपको आवश्यकता है:

* def data = [{ name: 'one', periods: [{ index: 1, value: 'a' },{ index: 2, value: 'b' }]}, { name: 'two', periods: [{ index: 1, value: 'c' },{ index: 2, value: 'd' }]}]
* def fnPeriod = function(x){ x.value = x.value + x.index; return x }
* def fnData = function(x){ return { name: x.name, periods: karate.map(x.periods, fnPeriod) } }
* def converted = karate.map(data, fnData)
* print converted

कौन सा प्रिंट:

[
  {
    "name": "one",
    "periods": [
      {
        "index": 1,
        "value": "a1"
      },
      {
        "index": 2,
        "value": "b2"
      }
    ]
  },
  {
    "name": "two",
    "periods": [
      {
        "index": 1,
        "value": "c1"
      },
      {
        "index": 2,
        "value": "d2"
      }
    ]
  }
]

यदि यह आपके लिए काम नहीं करता है, तो कृपया अन्य टूल देखें। कराटे को परीक्षण और अभिकथन के लिए डिज़ाइन किया गया है, जो आप सामान्य रूप से प्रोग्रामिंग भाषाओं में नहीं करते हैं। और मुझे संदेह है कि आप "ओवर-स्मार्ट परीक्षण" लिखने के जाल में पड़ गए हैं, इसलिए कृपया इसे पढ़ें:https://stackoverflow.com/a/54126724/143475