क्या जावास्क्रिप्ट में एक नल-कोलेसिंग (एल्विस) ऑपरेटर या सुरक्षित नेविगेशन ऑपरेटर है?

Question

मैं उदाहरण के द्वारा समझाता हूँ:

एल्विस ऑपरेटर (?)

"एल्विस ऑपरेटर" जावा के टर्नरी ऑपरेटर का एक छोटा हिस्सा है। एक उदाहरण जहां यह काम है एक 'समझदार डिफ़ॉल्ट' मान वापस करने के लिए है अगर एक अभिव्यक्ति झूठी या अशक्त करने के लिए हल करता है। एक साधारण उदाहरण इस तरह लग सकता है:

def gender = user.male ? "male" : "female"  //traditional ternary operator usage

def displayName = user.name ?: "Anonymous"  //more compact Elvis operator

सुरक्षित नेविगेशन ऑपरेटर (?)

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

def user = User.find( "admin" )           //this might be null if 'admin' does not exist
def streetName = user?.address?.street    //streetName will be null if user or user.address is null - no NPE thrown

Comments

'एल्विस ऑपरेटर' C # में मौजूद है, लेकिन इसे नल कोलेसिंग ऑपरेटर कहा जाता है (बहुत कम रोमांचक) :-)

— कैमरन

यदि आप एक वैकल्पिक वाक्यविन्यास चाहते हैं तो आप कोफ़स्क्रिप्ट

— लाइम

यह सवाल एक गड़बड़ की तरह है ... यह 3 अलग-अलग ऑपरेटरों को मिला रहा है? : (टर्नरी ऑपरेटर, प्रश्न में वर्तनी, संभवतः एक टाइपो), ?? (अशक्त सहवास, जो जावास्क्रिप्ट में मौजूद है) और? (एल्विस) जो जावास्क्रिप्ट में मौजूद नहीं है। उत्तर इस भेद को बहुत अच्छी तरह से स्पष्ट नहीं करते हैं।

— जोएलफैन

@JoelFan आप ??जावास्क्रिप्ट में उचित नल-सह-अवधि ( ) के बारे में प्रलेखन के लिए एक लिंक प्रदान कर सकते हैं ? अब तक मुझे जो कुछ भी मिल रहा है, उससे पता चलता है कि जेएस में केवल "फाल्सी" कोलेसिंग (उपयोग करना ||) है।

— चार्ल्स वुड

खैर, मेरे कहने का मतलब यह नहीं था कि जेएस का शाब्दिक अर्थ था ?? लेकिन यह है कि यह अशक्त-भ्रष्ट था ... लेकिन वहां भी मैं गलत था। कहा जा रहा है, मैंने JS कोड का एक बहुत कुछ देखा है जो उपयोग करता है || एक अशक्त सम्मिलित, falsey नुकसान के बावजूद के रूप में

— JoelFan

Answer 1

आप एल्विस ऑपरेटर के स्थान पर तार्किक 'OR' ऑपरेटर का उपयोग कर सकते हैं:

उदाहरण के लिए displayname = user.name || "Anonymous"।

लेकिन जावास्क्रिप्ट वर्तमान में अन्य कार्यक्षमता नहीं है। यदि आप एक वैकल्पिक वाक्यविन्यास चाहते हैं तो मैं कॉफ़ीस्क्रिप्ट देखने की सलाह दूंगा । यह कुछ आशुलिपि है जो आप के लिए देख रहे हैं के समान है।

उदाहरण के लिए अस्तित्ववादी संचालक

zip = lottery.drawWinner?().address?.zipcode

फ़ंक्शन शॉर्टकट

()->  // equivalent to function(){}

सेक्सी फंक्शन कॉलिंग

func 'arg1','arg2' // equivalent to func('arg1','arg2')

इसमें बहुस्तरीय टिप्पणियां और कक्षाएं भी हैं। जाहिर है आपको इसे जावास्क्रिप्ट में संकलित करना होगा या पृष्ठ में सम्मिलित करना होगा <script type='text/coffeescript>'लेकिन यह बहुत अधिक कार्यक्षमता जोड़ता है :)। उपयोग करना <script type='text/coffeescript'>वास्तव में केवल विकास के लिए है न कि उत्पादन के लिए।

Comments

तार्किक या काफी मामलों में जरूरी चीज नहीं है, जैसा कि आप चाहते हैं कि यह सही ऑपरेंड लेने के लिए केवल अगर बाएं अपरिभाषित है, लेकिन तब नहीं जब यह परिभाषित और झूठा हो।

— user2451227

क्या यह मेरी गलती है, या यह वास्तव में है <script type='coffee/script>'?

— JCCM

CoffeeScript होम पेज का उपयोग करता है <script type="text/coffeescript">।

— इलायस ज़मरिया

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

— जिंगलेथुला

क्या मैं केले जा रहा हूं? निश्चित रूप से उपयोगकर्ता 2451227 (वर्तमान में 4 वोटों के साथ) की आपत्ति अमान्य है क्योंकि टर्निरी के मध्य ऑपरेंड (यानी एल्विस ऑपरेटर के साथ दाहिने ऑपरेंड) को समान रूप से नहीं चुना जाएगा यदि अभिव्यक्ति / बाएं ऑपरेंड को परिभाषित किया गया है और झूठा है। दोनों ही मामलों में आपको जाना होगा x === undefined।

— माईक कृंतक

Answer 2

मुझे लगता है कि निम्नलिखित सुरक्षित नेविगेशन ऑपरेटर के बराबर है, हालांकि थोड़ा लंबा है:

var streetName = user && user.address && user.address.street;

streetNameतो या तो का मूल्य हो जाएगा user.address.streetया undefined।

यदि आप इसे किसी और चीज़ के लिए डिफ़ॉल्ट करना चाहते हैं तो आप उपरोक्त शॉर्टकट के साथ जोड़ सकते हैं या दे सकते हैं:

var streetName = (user && user.address && user.address.street) || "Unknown Street";

Comments

शून्य प्रसार और अशक्त सहानुभूति दोनों के महान उदाहरण के लिए एक प्लस!

— जय विक

यह काम करता है सिवाय इसके कि आपको पता नहीं चलेगा कि क्या आपको अशक्त या अनिर्दिष्ट है

— डेव कजिनो

Answer 3

जावास्क्रिप्ट का तार्किक OR ऑपरेटर है शॉर्ट सर्किट और अपने "एल्विस" ऑपरेटर बदल सकते हैं:

var displayName = user.name || "Anonymous";

हालाँकि, मेरे ज्ञान के लिए आपके ?.ऑपरेटर के बराबर कोई नहीं है ।

Comments

+1, मैं भूल गया ||कि इस तरह से इस्तेमाल किया जा सकता है। ध्यान रखें कि यह न केवल संगठित होगा जब अभिव्यक्ति है रहो null, लेकिन यह भी जब यह अपरिभाषित है, false, 0, या खाली स्ट्रिंग।

— कैमरून

@Cameron, वास्तव में, लेकिन यह प्रश्न में उल्लिखित है और प्रश्नकर्ता की मंशा प्रतीत होती है। ""या 0अप्रत्याशित हो सकता है, हालांकि :)

— Frédéric Hamidi

Answer 4

मैंने कभी-कभी निम्नलिखित मुहावरे को उपयोगी पाया है:

a?.b?.c

के रूप में फिर से लिखा जा सकता है:

((a||{}).b||{}).c

यह इस तथ्य का लाभ उठाता है कि किसी वस्तु पर अज्ञात विशेषताओं को प्राप्त करना अपरिभाषित होता है, बजाय एक अपवाद को फेंकने के, जैसा कि वह करता है nullया करता है undefined, इसलिए हम नेविगेट करने से पहले रिक्त वस्तु के साथ अशक्त और अपरिभाषित को प्रतिस्थापित करते हैं।

Comments

वैसे, यह पढ़ना मुश्किल है लेकिन यह उस क्रिया &&विधि से बेहतर है । +1।

— shriek

यह वास्तव में जावास्क्रिप्ट में केवल वास्तविक सुरक्षित ऑपरेटर है। ऊपर उल्लिखित तार्किक 'OR' ऑपरेटर कुछ और है।

— vasilakisfil

@ फीलिपोस आप तार्किक या बनाम && विधि में विभिन्न व्यवहार का एक उदाहरण दे सकते हैं? मैं एक अंतर के बारे में नहीं सोच सकता

— लाल मटर

यह पहले एक चर को निर्दिष्ट किए बिना एक अनाम मान नेविगेट करने की अनुमति देता है।

— मैट जेनकिन्स

इसे प्यार करना! यदि आप किसी सरणी.find () ऑपरेशन के बाद किसी ऑब्जेक्ट की संपत्ति प्राप्त करना चाहते हैं तो वास्तव में उपयोगी है जो किसी भी परिणाम को वापस नहीं कर सकता है

— शिराज़

Answer 5

मुझे लगता है कि लताश _.get()यहां, जैसे _.get(user, 'name')और अधिक जटिल कार्यों में मदद कर सकता है_.get(o, 'a[0].b.c', 'default-value')

Comments

इस विधि के साथ मेरा मुख्य मुद्दा यह है कि चूंकि गुणों का नाम स्ट्रिंग है, आप अपने आईडीई की

— रीफ्रैक्टिंग

Answer 6

वर्तमान में एक मसौदा कल्पना है:

https://github.com/tc39/proposal-optional-chaining

https://tc39.github.io/proposal-optional-chaining/

अभी के लिए, हालांकि, मैं का उपयोग करना चाहते lodashget(object, path [,defaultValue]) या dlvdelve(obj, keypath)

अपडेट (23 दिसंबर, 2019 तक):

वैकल्पिक श्रृंखलन चरण 4 में चला गया है

Comments

जावास्क्रिप्ट में Lodash मेकअप प्रोग्रामिंग अधिक स्वादिष्ट

— गेको

वैकल्पिक श्रृंखलन अभी हाल ही में चरण 4 में चली गई है , इसलिए हम इसे ES2020 में देखेंगे

— निक पार्सन

@NickParsons धन्यवाद! उत्तर को अद्यतन किया है।

— जैक टक

Answer 7

2019 अपडेट

जावास्क्रिप्ट में अब एल्विस ऑपरेटर और सुरक्षित नेविगेशन ऑपरेटर दोनों के लिए समकक्ष हैं।

---

सुरक्षित संपत्ति पहुंच

वैकल्पिक श्रृंखलन ऑपरेटर ( ?.) वर्तमान में एक है चरण 4 ECMAScript प्रस्ताव । आप इसे आज बैबल के साथ उपयोग कर सकते हैं ।

// `undefined` if either `a` or `b` are `null`/`undefined`. `a.b.c` otherwise.
const myVariable = a?.b?.c;

तार्किक AND ऑपरेटर ( &&) "पुराने", अधिक-वर्बोज़ इस परिदृश्य को संभालने के लिए रास्ता है।

const myVariable = a && a.b && a.c;

एक डिफ़ॉल्ट प्रदान करना

Nullish कोलेसिंग ऑपरेटर ( ??) वर्तमान में एक है चरण 3 ECMAScript प्रस्ताव । आप इसे आज बैबल के साथ उपयोग कर सकते हैं । यह आपको डिफ़ॉल्ट मान सेट करने की अनुमति देता है यदि ऑपरेटर के बाएं हाथ एक शून्य मान ( null/ undefined) है।

const myVariable = a?.b?.c ?? 'Some other value';

// Evaluates to 'Some other value'
const myVariable2 = null ?? 'Some other value';

// Evaluates to ''
const myVariable3 = '' ?? 'Some other value';

तार्किक OR ऑपरेटर ( ||) एक वैकल्पिक समाधान है थोड़ा अलग व्यवहार के साथ । यह आपको डिफ़ॉल्ट मान सेट करने की अनुमति देता है यदि ऑपरेटर के बाएं हाथ में झूठा है । ध्यान दें कि myVariable3नीचे का परिणाम myVariable3ऊपर से अलग है ।

const myVariable = a?.b?.c || 'Some other value';

// Evaluates to 'Some other value'
const myVariable2 = null || 'Some other value';

// Evaluates to 'Some other value'
const myVariable3 = '' || 'Some other value';

Comments

इस उत्तर को और अधिक बढ़ाने की जरूरत है। Nullish Coalescing Operator अब स्टेज 4. में है

— यरके

Answer 8

पूर्व के लिए, आप उपयोग कर सकते हैं ||। जावास्क्रिप्ट "तार्किक या" ऑपरेटर, केवल डिब्बाबंद सच्चे और झूठे मूल्यों को वापस करने के बजाय, अपने बाएं तर्क को वापस करने के नियम का पालन करता है यदि यह सत्य है, और अन्यथा मूल्यांकन और अपने सही तर्क को वापस करता है। जब आप केवल सत्य मूल्य में रुचि रखते हैं यह एक ही बाहर काम करता है, लेकिन यह भी मतलब है कि foo || bar || bazरिटर्न कि एक सच्चे मान foo, बार, या baz की सबसे बाईं ओर एक ।

आपको ऐसा कोई भी नहीं मिलेगा, जो झूठे को शून्य से अलग कर सके, हालांकि, और 0 और खाली स्ट्रिंग गलत मूल्य हैं, इसलिए value || defaultनिर्माण का उपयोग करने से बचें जहां valueवैध रूप से 0 या हो सकता है ""।

Comments

अच्छा काम यह देखते हुए कि यह अनपेक्षित व्यवहार का परिणाम हो सकता है जब बाएं ऑपरेंड एक गैर-अशांति वाला गलत मूल्य है।

— शोग

Answer 9

हाँ वहाँ है! 🍾

वैकल्पिक चेनिंग चरण 4 में है और यह आपको user?.address?.streetसूत्र का उपयोग करने में सक्षम बनाता है।

यदि आप रिलीज का इंतजार नहीं कर सकते हैं, तो इंस्टॉल करें @babel/plugin-proposal-optional-chainingऔर आप इसका उपयोग कर सकते हैं। यहाँ मेरी सेटिंग्स हैं जो मेरे लिए काम करती हैं, या सिर्फ निम्मो का लेख पढ़ें ।

// package.json

{
  "name": "optional-chaining-test",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {
    "@babel/plugin-proposal-optional-chaining": "7.2.0",
    "@babel/core": "7.2.0",
    "@babel/preset-env": "^7.5.5"
  }
  ...
}

// .babelrc

{
  "presets": [
    [
      "@babel/preset-env",
      {
        "debug": true
      }
    ]
  ],
  "plugins": [
    "@babel/plugin-proposal-optional-chaining"
  ]
}

// index.js

console.log(user?.address?.street);  // it works

Comments

उसने पूछा कि क्या एक है, न कि आप एक जोड़ सकते हैं। मुझे लगता है कि यह सबसे उपयोगी नहीं है जो इसके बारे में पूछा गया था।

— डीनएमवेके

यह ECMAScript मानकीकरण प्रक्रिया के चरण 3 तक पहुंच गया। es2020 el - babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

— wedi

मुझे लगता है कि यह उत्तर भ्रामक है।

— लियोनार्डो राएले

यह उत्तर काफी सही नहीं है! वैकल्पिक चरण अभी भी चरण 3 में है और ES2020 को अभी तक जारी या अंतिम रूप नहीं दिया गया है। कम से कम आपने उल्लेख किया है कि कोई भी इसे जारी किए बिना इंतजार किए बिना इसका उपयोग कैसे कर सकता है।

— मैक्सी बर्कमैन

@gazdagergo कोई समस्या नहीं :)।

— मैक्सी बर्कमैन

Answer 10

यहाँ एक साधारण एल्विस ऑपरेटर समतुल्य है:

function elvis(object, path) {
    return path ? path.split('.').reduce(function (nestedObject, key) {
        return nestedObject && nestedObject[key];
    }, object) : object;
}

> var o = { a: { b: 2 }, c: 3 };
> elvis(o)

{ a: { b: 2 }, c: 3 }

> elvis(o, 'a');

{ b: 2 }

> elvis(o, 'a.b');

2

> elvis(o, 'x');

undefined

Answer 11

UPDATE SEP 2019

हाँ, JS अब इसका समर्थन करता है। वैकल्पिक पढ़ने के लिए v8 जल्द ही आ रहा है

Comments

समान नहीं है। ओपी null coalescing के बारे में है, लेकिन फिर भी अच्छा जवाब है।

— मैक्सी बर्कमैन

Answer 12

यह आमतौर पर एक अशक्त-सहवर्ती ऑपरेटर के रूप में जाना जाता है। जावास्क्रिप्ट में एक नहीं है।

Comments

सख्त अर्थों में सच है, लेकिन जैसा कि अन्य उत्तरों ने उल्लेख किया है कि जावास्क्रिप्ट के तार्किक या ऑपरेटर एक गलत- संचालन ऑपरेटर के रूप में व्यवहार कर सकते हैं , जिससे आप कई स्थितियों में एक ही संक्षिप्तता प्राप्त कर सकते हैं।

— शोग

यह एक नल-coalescing ऑपरेटर नहीं है। Null-coalescing केवल एक ही मूल्य पर काम करती है, न कि प्रॉपर्टी एक्सेस / फंक्शन इनवॉक्शंस की चेन पर। आप पहले से ही तार्किक या ऑपरेटर के साथ जावास्क्रिप्ट में अशक्त-सहूलियत कर सकते हैं।

नहीं, आप तार्किक या जावास्क्रिप्ट के साथ गलत-तालमेल कर सकते हैं।

— और

Answer 13

आप यह कहकर लगभग एक ही प्रभाव प्राप्त कर सकते हैं:

var displayName = user.name || "Anonymous";

Answer 14

मेरे पास इसका एक समाधान है, इसे अपनी जरूरतों के लिए, मेरे एक परिवाद से एक अंश:

    elvisStructureSeparator: '.',

    // An Elvis operator replacement. See:
    // http://coffeescript.org/ --> The Existential Operator
    // http://fantom.org/doc/docLang/Expressions.html#safeInvoke
    //
    // The fn parameter has a SPECIAL SYNTAX. E.g.
    // some.structure['with a selector like this'].value transforms to
    // 'some.structure.with a selector like this.value' as an fn parameter.
    //
    // Configurable with tulebox.elvisStructureSeparator.
    //
    // Usage examples: 
    // tulebox.elvis(scope, 'arbitrary.path.to.a.function', fnParamA, fnParamB, fnParamC);
    // tulebox.elvis(this, 'currentNode.favicon.filename');
    elvis: function (scope, fn) {
        tulebox.dbg('tulebox.elvis(' + scope + ', ' + fn + ', args...)');

        var implicitMsg = '....implicit value: undefined ';

        if (arguments.length < 2) {
            tulebox.dbg(implicitMsg + '(1)');
            return undefined;
        }

        // prepare args
        var args = [].slice.call(arguments, 2);
        if (scope === null || fn === null || scope === undefined || fn === undefined 
            || typeof fn !== 'string') {
            tulebox.dbg(implicitMsg + '(2)');
            return undefined;   
        }

        // check levels
        var levels = fn.split(tulebox.elvisStructureSeparator);
        if (levels.length < 1) {
            tulebox.dbg(implicitMsg + '(3)');
            return undefined;
        }

        var lastLevel = scope;

        for (var i = 0; i < levels.length; i++) {
            if (lastLevel[levels[i]] === undefined) {
                tulebox.dbg(implicitMsg + '(4)');
                return undefined;
            }
            lastLevel = lastLevel[levels[i]];
        }

        // real return value
        if (typeof lastLevel === 'function') {
            var ret = lastLevel.apply(scope, args);
            tulebox.dbg('....function value: ' + ret);
            return ret;
        } else {
            tulebox.dbg('....direct value: ' + lastLevel);
            return lastLevel;
        }
    },

एक जादू की तरह काम करता है। कम दर्द का आनंद लें!

Comments

होनहार लगता है, क्या आप कृपया पूर्ण स्रोत प्रस्तुत कर सकते हैं? क्या आपके पास यह कहीं भी सार्वजनिक है? (उदाहरण गीथहब)

— एरन मेडन

मैं उस कोड का एक छोटा सा अंश बनाऊँगा जिसका मैं इसमें उपयोग करता हूँ और एक या एक सप्ताह में इसे GitHub पर पोस्ट करूँगा।

— बैलाजस्ट

Answer 15

आप अपना स्वयं का रोल कर सकते हैं:

function resolve(objectToGetValueFrom, stringOfDotSeparatedParameters) {
    var returnObject = objectToGetValueFrom,
        parameters = stringOfDotSeparatedParameters.split('.'),
        i,
        parameter;

    for (i = 0; i < parameters.length; i++) {
        parameter = parameters[i];

        returnObject = returnObject[parameter];

        if (returnObject === undefined) {
            break;
        }
    }
    return returnObject;
};

और इसे इस तरह उपयोग करें:

var result = resolve(obj, 'a.b.c.d'); 

* परिणाम अपरिभाषित है यदि कोई भी, बी, सी या डी में से कोई एक अपरिभाषित है।

Answer 16

मैंने इस लेख ( https://www.beyondjava.net/elvis-operator-aka-safe-navigation-javascript-typescript ) को पढ़ा और प्रोक्सीज़ का उपयोग करके समाधान को संशोधित किया।

function safe(obj) {
    return new Proxy(obj, {
        get: function(target, name) {
            const result = target[name];
            if (!!result) {
                return (result instanceof Object)? safe(result) : result;
            }
            return safe.nullObj;
        },
    });
}

safe.nullObj = safe({});
safe.safeGet= function(obj, expression) {
    let safeObj = safe(obj);
    let safeResult = expression(safeObj);

    if (safeResult === safe.nullObj) {
        return undefined;
    }
    return safeResult;
}

आप इसे इस तरह कहते हैं:

safe.safeGet(example, (x) => x.foo.woo)

परिणाम एक अभिव्यक्ति के लिए अपरिभाषित होगा जो अपने मार्ग के साथ अशक्त या अपरिभाषित है। आप जंगली जा सकते हैं और ऑब्जेक्ट प्रोटोटाइप को संशोधित कर सकते हैं !

Object.prototype.getSafe = function (expression) {
    return safe.safeGet(this, expression);
};

example.getSafe((x) => x.foo.woo);

Answer 17

बहुत देर से कूदते हुए, स्टेज 2 पर वर्तमान में वैकल्पिक चैनिंग के लिए एक प्रस्ताव [1] है, जिसमें एक बैबल प्लगइन [2] उपलब्ध है। यह वर्तमान में मेरे द्वारा ज्ञात किसी भी ब्राउज़र में नहीं है।

1. https://github.com/tc39/proposal-optional-chaining
2. https://www.npmjs.com/package/@babel/plugin-proposal-optional-chaining

Answer 18

यह मेरे लिए लंबे समय से एक समस्या थी। मुझे एक समाधान के साथ आना पड़ा, जिसे एल्विस ऑपरेटर या कुछ और प्राप्त करने के बाद आसानी से माइग्रेट किया जा सकता है।

यही है वह जो मेरे द्वारा उपयोग किया जाता है; दोनों सरणियों और वस्तुओं के लिए काम करता है

इसे tools.js फ़ाइल या कुछ और में रखें

// this will create the object/array if null
Object.prototype.__ = function (prop) {
    if (this[prop] === undefined)
        this[prop] = typeof prop == 'number' ? [] : {}
    return this[prop]
};

// this will just check if object/array is null
Object.prototype._ = function (prop) {
    return this[prop] === undefined ? {} : this[prop]
};

उपयोग उदाहरण:

let student = {
    classes: [
        'math',
        'whatev'
    ],
    scores: {
        math: 9,
        whatev: 20
    },
    loans: [
        200,
        { 'hey': 'sup' },
        500,
        300,
        8000,
        3000000
    ]
}

// use one underscore to test

console.log(student._('classes')._(0)) // math
console.log(student._('classes')._(3)) // {}
console.log(student._('sports')._(3)._('injuries')) // {}
console.log(student._('scores')._('whatev')) // 20
console.log(student._('blabla')._('whatev')) // {}
console.log(student._('loans')._(2)) // 500 
console.log(student._('loans')._(1)._('hey')) // sup
console.log(student._('loans')._(6)._('hey')) // {} 

// use two underscores to create if null

student.__('loans').__(6)['test'] = 'whatev'

console.log(student.__('loans').__(6).__('test')) // whatev

अच्छी तरह से मुझे पता है कि यह कोड को थोड़ा अपठनीय बनाता है लेकिन यह एक सरल एक लाइनर समाधान है और बढ़िया काम करता है। मुझे आशा है कि यह किसी की मदद करता है :)

Answer 19

यह कुछ मिश्रक का उपयोग कर सुरक्षित नेविगेशन ऑपरेटर के लिए एक दिलचस्प समाधान था।

http://jsfiddle.net/avernet/npcmv/

  // Assume you have the following data structure
  var companies = {
      orbeon: {
          cfo: "Erik",
          cto: "Alex"
      }
  };

  // Extend Underscore.js
  _.mixin({ 
      // Safe navigation
      attr: function(obj, name) { return obj == null ? obj : obj[name]; },
      // So we can chain console.log
      log: function(obj) { console.log(obj); }
  });

  // Shortcut, 'cause I'm lazy
  var C = _(companies).chain();

  // Simple case: returns Erik
  C.attr("orbeon").attr("cfo").log();
  // Simple case too, no CEO in Orbeon, returns undefined
  C.attr("orbeon").attr("ceo").log();
  // IBM unknown, but doesn't lead to an error, returns undefined
  C.attr("ibm").attr("ceo").log();

Answer 20

मैंने एक पैकेज बनाया जो इसे उपयोग करने में बहुत आसान बनाता है।

एनपीएम jsdig Github jsdig

आप सरल चीजों को संभाल सकते हैं जैसे कि और वस्तु:

const world = {
  locations: {
    europe: 'Munich',
    usa: 'Indianapolis'
  }
};

world.dig('locations', 'usa');
// => 'Indianapolis'

world.dig('locations', 'asia', 'japan');
// => 'null'

या थोड़ा और अधिक जटिल:

const germany = () => 'germany';
const world = [0, 1, { location: { europe: germany } }, 3];
world.dig(2, 'location', 'europe') === germany;
world.dig(2, 'location', 'europe')() === 'germany';

Answer 21

व्यक्तिगत रूप से मैं का उपयोग करें

function e(e,expr){try{return eval(expr);}catch(e){return null;}};

और उदाहरण के लिए सुरक्षित प्राप्त करें:

var a = e(obj,'e.x.y.z.searchedField');

Comments

सबसे पहले आपको वास्तव में eval का उपयोग नहीं करना चाहिए । दूसरे यह भी काम नहीं करता है: e({a:{b:{c:{d:'test'}}}}, 'a.b.c.d')रिटर्न null।

— 14

@Pylinux मूल रूप से क्या काम करेगा e = eval, है var a = eval('obj.a.b.c.d')। evalएक दूसरा पैरामीटर भी नहीं लेता है ... developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— Dorian