मेरे पास एक कार्यक्षमता है जहां मैं उपयोगकर्ता को जेसन ऑब्जेक्ट को संपादित करने में सक्षम बनाता हूं और फिर इसे अपने कोड में सत्यापित करता हूं, इसलिए मेरे पास तुलना करने और सत्यापित करने के लिए 2 जेसन ऑब्जेक्ट्स हैं (प्रारंभिक और संपादित एक), मैं जेसन ऑब्जेक्ट से सभी चाबियों को दबा रहा हूं 2 अलग-अलग सरणियों में और फिर पहली सरणी की दूसरी से तुलना करना और लापता कुंजियों को फ़िल्टर करना।

कोड बाकी परिदृश्यों के लिए काम करता है (यदि मैं उन कुंजियों को हटाता हूं जिनमें एक वस्तु है) लेकिन विफल हो जाता है यदि जसन के पास एक कुंजी है जिसमें वस्तुओं की एक सरणी है और उन कुंजियों को फ़िल्टर करना भी शुरू कर देता है जिन्हें हटाया नहीं गया है।

उदा: सशर्त, हटाए जाने पर आदेश फ़िल्टर किए गए सशर्त के अंतर्गत सभी कुंजियों को दिखाना शुरू कर देता है

लेकिन अगर मैं अलर्ट के तहत चाबियां हटाता हूं या ऑफसेट करता हूं तो यह सही संख्या और फ़िल्टर की गई चाबियों का नाम दिखाता है।

नोट:- स्टैकब्लिट्ज उदाहरण के लिए मैंने एक ही फ़ंक्शन को दो बार लिखा है

let defaultJsonFormFields = [];
let editedJsonFormFields = []

function keyList1(obj){
    Object.keys(obj).forEach(function (key) {
        defaultJsonFormFields.push(key);
        if (typeof (obj[key]) == 'object') {
            keyList1(obj[key]);
        }
    });
};

function keyList2(obj){
    Object.keys(obj).forEach(function (key) {
        editedJsonFormFields.push(key);
        if (typeof (obj[key]) == 'object') {
            keyList2(obj[key]);
        }
    });
};


keyList1(defaultjson);
keyList2(editedjson);

console.log(defaultJsonFormFields);
console.log(editedJsonFormFields);

let result = defaultJsonFormFields.filter(item => editedJsonFormFields.indexOf(item) == -1)

console.log(result)

[स्टैकब्लिट्जलिंक] https://stackblitz.com/edit/js-qkgdoa?file=index. जेएस

let defaultjson =
 {
    "conditionals": [
        {
            "order": "1",
            "key": "gefvsgwer",
            "value": "dghthdffbhrthrdvgrthtuem",
            "grpOperation": "wrfllkwjflmefveveveve",
            "condition": ">"
        }
    ],
    "offset": "15",
    "alert": {
    "mAlertType": "so new thing",
    "mTitle": "abcdef",
    "mMessage": "ok so be it",
    "mNotificationMsg": "whatever",
    "mSeverity": "LOW",
    "mEnabled": "true"
    }
}

let editedjson = {
    "": [
        {
            "": "1",
            "key": "gefvsgwer",
            "value": "dghthdffbhrthrdvgrthtuem",
            "grpOperation": "wrfllkwjflmefveveveve",
            "condition": ">"
         }
    ],
    "": "15",
    "": {
    "": "so new thing",
    "mTitle": "abcdef",
    "mMessage": "ok so be it",
    "mNotificationMsg": "whatever",
    "mSeverity": "LOW",
    "mEnabled": "true"
    }
}

वास्तविक कार्यक्षमता के साथ स्टैकब्लिट्ज लिंक

https://stackblitz.com/edit/angular-mat-tooltip-x1gtcp?file=app%2Fjson-input.component.ts

तालिका में पहले कॉलम पर होवर करने पर, एक टूलटिप दिखाई देता है, बटन के क्लिक पर डायलॉग बॉक्स खुलता है जिसमें एडिट जोंस सेक्शन होता है, ऐड ऐज न्यू अलर्ट के क्लिक पर मैं यह जांचना चाहता हूं कि डिफ़ॉल्ट जोंस से सभी कीज को हटा दिया गया है।

-1
Enthu 27 मार्च 2020, 12:42
अंत में, आपके पास किसी वस्तु में समान गुणों का केवल अंतिम मान हो सकता है। कृपया प्रश्न में डेटा भी जोड़ें।
 – 
Nina Scholz
30 मार्च 2020, 12:52
हाँ निश्चित रूप से डेटा जोड़ देगा
 – 
Enthu
30 मार्च 2020, 12:58
लेकिन यह उस तरह काम नहीं करता है। कृपया डेटा के साथ आरंभ करने के बाद डेटा पर एक नज़र डालें।
 – 
Nina Scholz
30 मार्च 2020, 13:03
1
console.log(editedjson) के साथ एक नज़र डालें। सरणी चला गया है।
 – 
Nina Scholz
30 मार्च 2020, 13:06
1
आपके दूसरे जेसन, यानी संपादित जेसन के साथ समस्या, सभी चाबियाँ "" हैं, इसलिए जब जेएस ऑब्जेक्ट कुंजियां डुप्लिकेट नहीं हो सकती हैं। उस स्थिति में यह केवल अंतिम "" :{} को वस्तु की केवल कुंजी मानता है। आपको इससे किसी भी तरह बचने की जरूरत है।
 – 
Gourav Garg
7 अप्रैल 2020, 12:33

2 जवाब

अपडेट 2:

थोड़ा सोचने के बाद मैंने महसूस किया कि RegExp-s आपके मामले में बिना किसी झंझट के काम कर सकता है।

JSON की कुंजियों को स्ट्रिंग मानों से अलग करना अपेक्षाकृत आसान है:

function test(str, regexp) {
  console.log(
    Array.from(str.matchAll(regexp), m => m[1])
  )
}
// to match a key
test(`{"key1": 1, "key2": 2}`, /\"(.*?)\":/g)
// to match a key followed by spases
test(`{"key1" \n: 1, "key2"\t: 2}`, /\"(.*?)\"\s*:/g)
// to ignore string values
test(`{"key1": "qwer", "key2": 2}`, /\"([^"]*?)\"\s*:/g)
// to ignore escapes in string values
test(`{"key1": "\\"not_a_key\\":", "key2": 2}`, /(?<!\\)\"([^"]*?)(?<!\\)\"\s*:/g)

तो वापस अपने कोड पर... आप निम्न स्निपेट में सही परिणाम देख सकते हैं:

let defaultJsonFormFields = [
  "conditionals", "order", "key", "value", "grpOperation", "condition",
  "offset",
  "alert",
  "mAlertType", "mTitle", "mMessage", "mNotificationMsg", "mSeverity", "mEnabled",
]

const editedjson_str = '{\
  "": [{\
    "": "1",\
    "key": "gefvsgwer",\
    "value": "dghthdffbhrthrdvgrthtuem",\
    "grpOperation": "wrfllkwjflmefveveveve",\
    "condition": ">"\
  }],\
  "": "15",\
  "": {\
    "": "so new thing",\
    "mTitle": "abcdef",\
    "mMessage": "ok so be it",\
    "mNotificationMsg": "whatever",\
    "mSeverity": "LOW",\
    "mEnabled": "true"\
  }\
}'

let editedjson
// before checking the keys, try to  parse editedjson_str
// - no need to report key errors if JSON is invalid in general
//try {
    editedjson = JSON.parse(editedjson_str)
//} catch() { ... }

const editedJsonFormFields = Array.from(editedjson_str.matchAll(/(?<!\\)\"([^"]*?)(?<!\\)\"\s*:/g), m => m[1])
let result = defaultJsonFormFields.filter(item => editedJsonFormFields.indexOf(item) == -1)
console.log(result)

लेकिन फिर भी यह दृष्टिकोण एक गंदे हैक की तरह लगता है।


मूल उत्तर:

केवल एक चीज जो आपको चाहिए वह है log अपने editedjson और आप देखेंगे कि यह वह नहीं है जिसकी आप अपेक्षा करते हैं। इसे अजमाएं:

let editedjson = {
    "": [{
            "": "1",
            "key": "gefvsgwer",
            "value": "dghthdffbhrthrdvgrthtuem",
            "grpOperation": "wrfllkwjflmefveveveve",
            "condition": ">"
        }],
    "": "15",
    "": {
        "": "so new thing",
        "mTitle": "abcdef",
        "mMessage": "ok so be it",
        "mNotificationMsg": "whatever",
        "mSeverity": "LOW",
        "mEnabled": "true"
    }
}
console.log(editedjson)

इसका कारण यह है कि वस्तुओं में एक ही कुंजी (और JSON भी) के लिए अलग-अलग मान नहीं हो सकते हैं। इस मामले में आपके पास समान मान "" के साथ editedjson 3 कुंजी की जड़ में है, और केवल अंतिम रहता है। अन्य अधिलेखित हैं।

यदि आप स्पष्ट करेंगे कि आप किस सटीक व्यवहार को प्राप्त करने का प्रयास कर रहे हैं, तो मैं अपना उत्तर उस कोड के साथ अपडेट कर सकता हूं जो करेगा।

मुख्य समस्या यह है कि आप किसी उपयोगकर्ता से एक ऑब्जेक्ट प्राप्त नहीं कर सकते हैं, जिसमें ऐसी कुंजियाँ हैं जो अद्वितीय नहीं हैं। लेकिन आप एक स्ट्रिंग प्राप्त कर सकते हैं (और इसे शायद JSON नहीं कहा जाना चाहिए)... लेकिन आपको वास्तव में ऐसा नहीं करना चाहिए, क्योंकि आपको इसे इसके द्वारा पार्स करना होगा स्वयं। इसलिए आपको उस डेटा के लिए दूसरा प्रारूप चुनना होगा जिसकी आप किसी उपयोगकर्ता से अपेक्षा करते हैं।

अपडेट करें:

आपके प्रश्न के अपडेट के बाद मैंने आपके का अनुसरण किया वास्तविक कार्यक्षमता के लिए दूसरा लिंक और महसूस किया कि मुझे "वह कोड जो करेगा" का सुझाव देने के लिए जल्दी था। जैसा कि मैंने देखा, आप एक उपयोगकर्ता से एक स्ट्रिंग प्राप्त करते हैं, और जैसा कि मैंने कहा आपको वास्तव में ऐसा नहीं करना चाहिए। आपको JSON.parse() के साथ कहीं नहीं मिलेगा। और मैं आपको एक एक JSON भी नहीं के लिए एक पूर्ण पार्सर नहीं दे सकता जिसमें मनमानी त्रुटियां हों। इस मामले में मैं केवल सुझाव दे सकता हूं:

  1. सर्वोत्तम समाधान: प्रत्येक मान के लिए अलग-अलग फ़ील्ड के साथ प्रपत्रों का उपयोग करें। जैसा कि मैंने उदाहरण में देखा, डेटा की एक स्थिर संरचना होती है (आप इसकी तुलना पूर्वनिर्धारित defaultjson से भी करते हैं)। यदि ऐसा है - तो उपयोगकर्ता के लिए और अपने लिए चीजों को जटिल बनाने का कोई कारण नहीं है
  2. यह जांचने के लिए regexp-s का उपयोग करें कि क्या स्ट्रिंग में defaultJsonFormFields की कोई कुंजी गुम है। या अगर डुप्लीकेट चाबियां हैं। और उसके बाद ही JSON.parse() करने का प्रयास करें। लेकिन आपके पास बहुत सारे किनारे के मामलों के साथ कठिन समय होगा। उदा. ख़ास

    { ... "key": "some text" ... }
    

    से

    { ... "wrong key": "key" ... }
    
  3. मनमानी संरचना के डेटा के लिए, त्रुटि रिपोर्टिंग के लिए अपना दृष्टिकोण बदलें: यदि कोई editedjson.conditionals नहीं है - इसकी रिपोर्ट करें, और यह रिपोर्ट करने का प्रयास न करें कि editedjson.conditionals.order भी गायब है, लेकिन किसी तरह सब कुछ ठीक है editedjson.conditionals.grpOperation (क्योंकि ऐसा नहीं है - editedjson.conditionals.grpOperation जैसा कोई रास्ता भी नहीं है)
1
x00 4 अप्रैल 2020, 15:39
मैं उपयोगकर्ता को प्रस्तुत डिफ़ॉल्ट जेसन ऑब्जेक्ट के बीच लापता कुंजी दिखाना चाहता हूं और जब उपयोगकर्ता जेसन ऑब्जेक्ट को संपादित करना शुरू करता है तो संपादित जेसन ऑब्जेक्ट, इसलिए मैं डिफ़ॉल्ट जेसन ऑब्जेक्ट और संपादित जेसन ऑब्जेक्ट के बीच लापता कुंजी को फ़िल्टर करना चाहता हूं।
 – 
Enthu
3 अप्रैल 2020, 18:51
जब ऑफसेट, अलर्ट, mAlertType (अलर्ट के तहत बाकी कुंजियाँ) जैसी कुंजियाँ हटा दी जाती हैं, तो डिफ़ॉल्ट json और संपादित json के बीच तुलना करने पर पुनर्निर्मित कुंजियाँ दिखाई देती हैं, लेकिन यदि पहली कुंजी 'सशर्त' और 'आदेश' को विशेष रूप से एक साथ निकालना शुरू करें तो डिफ़ॉल्ट जेसन के साथ संपादित जेसन की तुलना पर मुझे उन चाबियों को दिखाता है जिन्हें हटाया नहीं गया है (अनिवार्य रूप से 'सशर्त' सरणी के अंदर सभी कुंजियां, मुझे वह मिलता है क्योंकि मूल कुंजी मौजूद नहीं है इसलिए यह बाकी को फ़िल्टर करती है और इसके नीचे की चाबियों को फ़िल्टर करती है लेकिन है वहाँ किसी भी तरह से जिससे मैं हटाई गई चाबियां प्राप्त कर सकता हूं
 – 
Enthu
3 अप्रैल 2020, 18:57
वास्तविक कार्यक्षमता के साथ स्टैकब्लिट्ज लिंक stackblitz.com /संपादित करें/…, तालिका में पहले कॉलम पर मँडराने पर, एक टूलटिप दिखाई देता है, बटन के क्लिक पर डायलॉग बॉक्स खुलता है जिसमें एडिट जोंस सेक्शन था, ऐड ऐज़ न्यू अलर्ट के क्लिक पर मैं यह देखना चाहता हूं कि सभी क्या हैं कुंजियाँ डिफ़ॉल्ट json से हटा दी गई हैं
 – 
Enthu
3 अप्रैल 2020, 19:00
क्षमा करें, मैं कोणीय में नहीं हूं, मैं एक प्रतिक्रिया प्रकार का लड़का हूं
 – 
x00
5 अप्रैल 2020, 15:35
इस दृष्टिकोण के साथ समस्या यह है कि आपके पास यह संपादित जेसन ही नहीं हो सकता है। आपको इसे किसी तरह बनाने की जरूरत है।
 – 
Gourav Garg
7 अप्रैल 2020, 12:33

मुझे इस JSON को पार्स करने का कोई तरीका नहीं दिख रहा है क्योंकि इसे अद्वितीय कुंजियों की आवश्यकता है और पूर्व डुप्लिकेट कुंजियों को हटा देगा।

मूल रूप से JSON पार्सर इस संपादित जेसन को एकल संपत्ति वाले देखेगा

let editedjson = {
"": [
    {
        "": "1",
        "key": "gefvsgwer",
        "value": "dghthdffbhrthrdvgrthtuem",
        "grpOperation": "wrfllkwjflmefveveveve",
        "condition": ">"
     }
],
"": "15",
"": {
     "": "so new thing",
     "mTitle": "abcdef",
     "mMessage": "ok so be it",
     "mNotificationMsg": "whatever",
     "mSeverity": "LOW",
     "mEnabled": "true"
    }
}

उत्पादन

let editedjson = {
"": {
      "": "so new thing",
      "mTitle": "abcdef",
      "mMessage": "ok so be it",
      "mNotificationMsg": "whatever",
      "mSeverity": "LOW",
      "mEnabled": "true"
    }
}

और इन हटाए गए गुणों को वापस पाने का कोई तरीका नहीं है।

हालांकि आपके मौजूदा एप्लिकेशन में इन चाबियों को खोते रहने का एक तरीका है। मैंने उस एप्लिकेशन में कुछ बदलाव किए हैं

मैंने टेक्स्ट एरिया के "ऑन चेंज" ईवेंट पर एक और फ़ंक्शन जोड़ा जो इस ऑब्जेक्ट परिवर्तन को ट्रैक करेगा और जहां भी उपयोगकर्ता ने इस जेसन से हटा दिया था, वहां 'कुंजी' + i (जहां मैं वृद्धिशील संख्या होगी) जोड़ देगा।

उस समय यह संपादित जोंस इस तरह दिखेगा:

let editedjson = {
"key1": [
    {
        "key0": "1",
        "key": "gefvsgwer",
        "value": "dghthdffbhrthrdvgrthtuem",
        "grpOperation": "wrfllkwjflmefveveveve",
        "condition": ">"
     }
],
"key2": "15",
"key4": {
     "key3": "so new thing",
     "mTitle": "abcdef",
     "mMessage": "ok so be it",
     "mNotificationMsg": "whatever",
     "mSeverity": "LOW",
     "mEnabled": "true"
    }
}

तब आप आसानी से अपने पिछले मूल्य से तुलना कर सकते हैं और यह सटीक होना चाहिए।

ये है स्टैकब्लिट्ज लिंक

0
Gourav Garg 7 अप्रैल 2020, 13:43
यदि कोई उपयोगकर्ता "" के बजाय दो डुप्लीकेट कुंजी दर्ज करता है, तो उनमें से एक को हटाया जाएगा, और न केवल editedjson में, बल्कि उपयोगकर्ता के लिए भी अदृश्य हो जाएगा। साथ ही सभी संपादन "कीएन" की ओर नहीं ले जाते हैं... यह थोड़ा अराजक है, इसलिए यह नहीं कह सकता कि कैसे, लेकिन एक से अधिक बार मैं कई "" चाबियों के रूप में दर्ज करने में कामयाब रहा। और टेक्स्ट फ़ील्ड में कॉपी-पेस्ट मूल दृष्टिकोण के समान मुद्दों के साथ विफल हो जाएगा।
 – 
x00
9 अप्रैल 2020, 21:21
किसी समस्या को हल करने के कई तरीके हैं। मैं यह नहीं कह रहा हूं कि यह सही है लेकिन इसमें सुधार किया जा सकता है। हां एक ऐसा मामला है जहां सभी प्रकार की कार्यक्षमता को प्रतिस्थापित करने से यह टूट सकता है। सभी संपादन बिना किसी संदेह के keyN की ओर ले जाएंगे। साथ ही ये चाबियां किसी काम की नहीं हो सकती हैं। यह प्रोग्रामर है जिसे तय करना है कि क्या यह उसकी समस्या का समाधान करेगा।
 – 
Gourav Garg
9 अप्रैल 2020, 21:27
मैंने देखा लेकिन कोशिश नहीं की, यह एक अच्छा तरीका दिखता है, बॉक्स से बाहर सोच रहा है और सरल दृष्टिकोण, अपडेट होगा, धन्यवाद :)
 – 
Enthu
17 अप्रैल 2020, 00:29