javascript जावास्क्रिप्ट में कार्यों को परिभाषित करने के लिए कास्ट का उचित उपयोग




function const (6)

मुझे दिलचस्पी है अगर जावास्क्रिप्ट में किसी विशेष कार्य में किस प्रकार के मूल्य निर्धारित किए जा सकते हैं। क्या यह मान्य है? दी यह काम करता है, लेकिन क्या यह किसी भी कारण से बुरा माना जाता है?

const doSomething = () => {
   ...
}

क्या सभी कार्यों को ईएस 6 में इस तरह परिभाषित किया जाना चाहिए? ऐसा नहीं लगता कि इस पर पकड़ा गया है, यदि ऐसा है।

किसी भी टिप्पणी के लिए धन्यवाद!

https://code.i-harness.com


अपने अनुभव के लिए, मैं ES6 में विरासत का उपयोग करने का सुझाव दूंगा:

class Animal {
	constructor(_type) {
		this._type = _type;
	}
	speak() {
		console.log(this._type === 'dog' ? 'Grruuu' : 'Meowww');
	}
}

class Dog extends Animal {
	constructor() {
		super('dog');
	}
	set speak(value) {
		return super.speak;
		// or throw any exception message here...
        // throw new Error('This method cannot be overriden.');
	}
	get speak() {
		return (...args) => super.speak.call(this, ...args);
	}
}

class Cat extends Animal {
	constructor() {
		super('cat');
	}
	set speak(value) {
		return super.speak;
	}
	get speak() {
		return (...args) => super.speak.call(this, ...args);
	}
}

let dog = new Dog();
dog.speak();

let cat = new Cat();
cat.speak();

cat.speak = 'foo';

cat.speak(); // Meowww


आपके द्वारा किए गए कार्यों से कोई समस्या नहीं है, लेकिन आपको फ़ंक्शन की घोषणाओं और फ़ंक्शन अभिव्यक्तियों के बीच का अंतर याद रखना चाहिए।

एक फ़ंक्शन घोषणा, जो है:

function doSomething () {}

पूरी तरह से दायरे के शीर्ष पर फहराया जाता है (और let और const तरह वे ब्लॉक स्कूप्ड भी होते हैं)।

इसका मतलब है कि निम्नलिखित काम करेगा:

doSomething() // works!
function doSomething() {}

एक फ़ंक्शन अभिव्यक्ति, जो है:

[const | let | var] = function () {} (or () =>

एक अनाम फ़ंक्शन ( function () {} ) और एक चर का निर्माण है, और फिर उस चर के लिए उस अनाम फ़ंक्शन का असाइनमेंट है।

तो एक दायरे के भीतर परिवर्तनशील होर्डिंग के आस-पास के सामान्य नियम - ब्लॉक-स्कोप्ड वैरिएबल ( let और const ) अपने ब्लॉक स्कोप के शीर्ष पर undefined नहीं होते हैं।

इसका मतलब है की:

if (true) {
    doSomething() // will fail
    const doSomething = function () {}
}

तब तक असफल रहेंगे जब तक doSomething को परिभाषित नहीं किया जाता है। (यह एक ReferenceError फेंक देंगे)

यदि आप var का उपयोग करने के लिए स्विच करते हैं, तो आपको वेरिएबल का अपना उत्थापन मिल जाता है, लेकिन इसे undefined किया जाएगा, ताकि ऊपर कोड का ब्लॉक अभी भी काम न करे। (जब आप कॉल करते हैं तो doSomething उस समय कोई फ़ंक्शन नहीं doSomething है क्योंकि यह एक TypeError फेंक देगा)

जहां तक ​​मानक प्रथाओं की बात है, आपको हमेशा नौकरी के लिए उचित उपकरण का उपयोग करना चाहिए।

Axel Rauschmayer का दायरा बहुत बड़ा है और इसमें es6 शब्दार्थ भी शामिल हैं: ES6 में वेरिएबल्स और स्कूपिंग


इस सवाल को पूछे जाने में तीन साल हो गए हैं, लेकिन मैं अभी इसके पार आ रहा हूं। चूंकि यह उत्तर ढेर के नीचे है, कृपया मुझे इसे दोहराने की अनुमति दें:

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

मुझे एक स्पष्ट जावास्क्रिप्ट कोडर के निरीक्षण के बाद कुछ शोध करने के लिए प्रेरित किया गया था, जो हमेशा functions लिए const स्टेटमेंट का उपयोग करता है, भले ही कोई स्पष्ट कारण / लाभ न हो।

" क्या यह किसी भी कारण से बुरा व्यवहार माना जाता है? " के जवाब में, मुझे कहना चाहिए, IMO, हाँ यह है, या कम से कम, function स्टेटमेंट का उपयोग करने के फायदे हैं।

यह मुझे लगता है कि यह काफी हद तक प्राथमिकता और शैली का विषय है। ऊपर कुछ अच्छे तर्क प्रस्तुत किए गए हैं, लेकिन इतना स्पष्ट नहीं है जितना इस लेख में किया गया है:

लगातार भ्रम: मैं अभी भी माध्यम से जावास्क्रिप्ट फ़ंक्शन स्टेटमेंट का उपयोग क्यों करता हूं। medium.freecodecamp.org/Bill Sourour, JavaScript गुरु, सलाहकार और शिक्षक।

मैं सभी से उस लेख को पढ़ने का आग्रह करता हूं, भले ही आपने पहले ही निर्णय कर लिया हो।

यहाँ मुख्य बिंदु हैं:

समारोह कथनों में दो स्पष्ट फायदे हैं [कांस्ट] फंक्शन एक्सप्रेशन:

लाभ # 1: इरादे की स्पष्टता

जब कोड की हजारों लाइनों को एक दिन में स्कैन किया जाता है, तो यह प्रोग्रामर के इरादे को जितनी जल्दी हो सके और आसानी से पता लगाने में सक्षम हो सकता है।

लाभ # 2: घोषणा का आदेश == निष्पादन का आदेश

आदर्श रूप में, मैं अपने कोड को कम से कम उस क्रम में घोषित करना चाहता हूं जिससे मुझे उम्मीद है कि इसे निष्पादित किया जाएगा।

मेरे लिए यह शोस्टॉपर है: कास्ट कीवर्ड का उपयोग करके घोषित कोई भी मूल्य तब तक अप्राप्य है जब तक निष्पादन उस तक नहीं पहुंचता।

जो मैंने ऊपर वर्णित किया है वह हमें कोड लिखने के लिए मजबूर करता है जो उल्टा दिखता है। हमें सबसे निचले स्तर के समारोह से शुरुआत करनी होगी और अपने तरीके से काम करना होगा।

मेरा दिमाग इस तरह से काम नहीं करता है। मैं विवरण से पहले संदर्भ चाहता हूं।

अधिकांश कोड मनुष्यों द्वारा लिखे गए हैं। तो यह समझ में आता है कि ज्यादातर लोगों के आदेश को समझने में मोटे तौर पर ज्यादातर कोड ऑफ एक्जीक्यूशन का पालन होता है।


एक और परिदृश्य है जहाँ एक स्थिर कार्य उपयोगी हो सकता है। यदि आपके पास अपने कोड में बहुत सारे स्थिरांक हैं और एक फ़ंक्शन की आवश्यकता है जो विशेष रूप से उन स्थिरांक पर कार्य करता है, तो उस फ़ंक्शन को निरंतर में बदलना एक अच्छा विचार हो सकता है:

const FLAG_ONE   = 1;
const FLAG_TWO   = 2;
const FLAG_THREE = 4;
// etc.

// resolves flag into string for debugging purposes:
const FLAG_NAME = flag => {
    switch ( flag ) {
        case FLAG_ONE: return 'one';
        // etc.
    }
};

यह FLAG_NAME को एक स्थिर के रूप में परिभाषित करने के लिए किसी भी तरह से आवश्यक नहीं है , लेकिन ऐसा करने के लिए आपके कोड की सुगमता में सुधार होगा।


यद्यपि फ़ंक्शंस को परिभाषित करने के लिए const का उपयोग करना हैक की तरह लगता है, लेकिन यह कुछ महान फायदे के साथ आता है जो इसे बेहतर बनाते हैं (मेरी राय में)

  1. यह फ़ंक्शन को अपरिवर्तनीय बनाता है, इसलिए आपको उस फ़ंक्शन को किसी अन्य कोड के कोड द्वारा बदले जाने के बारे में चिंता करने की आवश्यकता नहीं है।

  2. आप वसा तीर सिंटैक्स का उपयोग कर सकते हैं, जो छोटा और क्लीनर है।

  3. एरो फ़ंक्शंस का उपयोग करना आपके लिए this बंधन का ख्याल रखता है।

function साथ उदाहरण

// define a function
function add(x, y) { return x + y; }

// use it
console.log(add(1, 2)); // 3

// oops, someone mutated your function
add = function (x, y) { return x - y; };

// now this is not what you expected
console.log(add(1, 2)); // -1

const साथ एक ही उदाहरण है

// define a function (wow! that is 8 chars shorter)
const add = (x, y) => x + y;

// use it
console.log(add(1, 2)); // 3

// someone tries to mutate the function
add = (x, y) => x - y; // Uncaught TypeError: Assignment to constant variable.
// the intruder fails and your function remains unchanged


const के उपयोग के लिए कुछ बहुत ही महत्वपूर्ण लाभ हैं और कुछ लोग कहेंगे कि इसका उपयोग जहां भी संभव हो, जानबूझकर और संकेत के कारण किया जाना चाहिए।

यह है, जहाँ तक मैं बता सकता हूँ, जावास्क्रिप्ट में चर के सबसे अधिक सूचक और अनुमानित घोषणा है, और सबसे उपयोगी में से एक, यह कैसे विवश है। क्यूं कर? क्योंकि यह var और उपलब्ध घोषणाओं के लिए उपलब्ध कुछ संभावनाओं को समाप्त कर देता है।

जब आप एक const पढ़ते हैं तो आप क्या अनुमान लगा सकते हैं? आप निम्नलिखित सभी को सिर्फ const डिक्लेरेशन स्टेटमेंट पढ़कर जानते हैं, और उस वेरिएबल के अन्य संदर्भों के लिए स्कैन किए बिना:

  • मान उस चर के लिए बाध्य है (हालांकि इसकी अंतर्निहित वस्तु गहरी अपरिवर्तनीय नहीं है)
  • इसे तुरंत उसके ब्लॉक से बाहर नहीं पहुँचा जा सकता है
  • अस्थायी रूप से मृत क्षेत्र (TDZ) नियमों के कारण, बाध्यकारी को घोषणा से पहले कभी एक्सेस नहीं किया जाता है।

निम्नलिखित उद्धरण एक लेख से let और const के लाभों का तर्क है। यह कीवर्ड के अवरोधों / सीमाओं के बारे में आपके प्रश्न का सीधे उत्तर देता है:

उन बाधाओं जैसे कि let और const द्वारा पेश किए गए कोड को समझने में आसान बनाने का एक शक्तिशाली तरीका है। आपके द्वारा लिखे गए कोड में इनमें से कई बाधाओं को प्राप्त करने का प्रयास करें। अधिक घोषणात्मक सीमाएं जो एक टुकड़ा का मतलब सीमित कर सकती हैं, भविष्य में मनुष्यों के पढ़ने, समझने और कोड के एक टुकड़े को समझने के लिए आसान और तेज़ है।

दी गई है, वहाँ एक var घोषणा की तुलना में एक const घोषणा करने के लिए और अधिक नियम हैं: ब्लॉक-स्कोप्ड, TDZ, घोषणा में असाइन करें, कोई पुनर्मूल्यांकन नहीं। जबकि var स्टेटमेंट केवल सिग्नल फंक्शन स्कूपिंग करते हैं। नियम-गिनती, हालांकि, बहुत अधिक जानकारी नहीं देती है। जटिलता के संदर्भ में इन नियमों को तौलना बेहतर है: क्या नियम जटिलता को जोड़ता या घटाता है? कांस्टेबल के मामले में, ब्लॉक स्कूपिंग का मतलब फ़ंक्शन स्कूपिंग की तुलना में एक संकीर्ण गुंजाइश है, TDZ का अर्थ है कि हमें घोषणा से पहले उपयोग को स्पॉट करने के लिए स्कोप को पीछे से स्कैन करने की आवश्यकता नहीं है, और असाइनमेंट नियमों का मतलब है कि बंधन हमेशा संरक्षित रहेगा। एक ही संदर्भ।

और अधिक विवश बयान, सरल कोड का एक टुकड़ा बन जाता है। जैसा कि हम एक बयान का मतलब है कि बाधाओं को जोड़ सकते हैं, कोड कम अप्रत्याशित हो जाता है। यह सबसे बड़ी वजहों में से एक है कि सांख्यिकीय रूप से टाइप किए गए कार्यक्रमों को आमतौर पर गतिशील रूप से टाइप किए गए लोगों की तुलना में पढ़ना आसान है। स्टेटिक टाइपिंग प्रोग्राम राइटर पर एक बड़ी बाधा डालती है, लेकिन यह प्रोग्राम की व्याख्या कैसे की जा सकती है, इसके कोड को समझने के लिए आसान बनाने पर एक बड़ी बाधा डालती है।

इन तर्कों को ध्यान में रखते हुए, यह अनुशंसा की जाती है कि आप जहां संभव हो, const उपयोग करें, क्योंकि यह वह कथन है जो हमें सोचने के लिए कम से कम संभावनाएं देता है।

स्रोत: https://ponyfoo.com/articles/var-let-const





ecmascript-6