जावास्क्रिप्ट में संदर्भ द्वारा चर को पास करें

Question

मैं जावास्क्रिप्ट में संदर्भ द्वारा चर कैसे पास करूं? मेरे पास 3 चर हैं जिन्हें मैं कई ऑपरेशन करना चाहता हूं, इसलिए मैं उन्हें एक लूप में रखना चाहता हूं और हर एक को ऑपरेशन करना चाहता हूं।

छद्म कोड:

myArray = new Array(var1, var2, var3);
for (var x = 0; x < myArray.length; x++){
    //do stuff to the array
    makePretty(myArray[x]);
}
//now do stuff to the updated vars

इसे करने का बेहतरीन तरीका क्या है?

Comments

आप 'संदर्भ द्वारा पास' के बारे में बात कर रहे हैं, लेकिन आपके पास अपने उदाहरण में कोई फ़ंक्शन कॉल नहीं है, इसलिए आपके उदाहरण में कोई भी पासिंग नहीं है। कृपया स्पष्ट करें कि आप क्या करने की कोशिश कर रहे हैं।

— ९

गलतफहमी के लिए खेद है। मुझे विशेष रूप से एक फ़ंक्शन लिखने की ज़रूरत नहीं थी इसलिए 'पास बाय रेफरेंस' शब्दों का एक खराब विकल्प था। मैं बस लेखन के बिना चर के लिए कुछ संचालन करने में सक्षम होना चाहता हूं makePretty(var1); makePretty(var2); makePretty(var3); ...

— BFTrick

आपकी टिप्पणी के आधार पर: arr = [var1, var2, var3]; for (var i = 0, len = arr.length; i < len; i++) { arr[i] = makePretty(arr[i]); }- आपको केवल makePrettyसरणी में स्लॉट में वापस लौटाए गए मूल्य को संग्रहीत करने की आवश्यकता है।

— dylnmc

Answer 1

जावास्क्रिप्ट में कोई "पास बाय रेफरेंस" उपलब्ध नहीं है। आप एक ऑब्जेक्ट पास कर सकते हैं (जो कहना है, आप किसी ऑब्जेक्ट के संदर्भ में पास-बाय-वैल्यू कर सकते हैं) और फिर एक फंक्शन को ऑब्जेक्ट कंटेंट को संशोधित करें:

function alterObject(obj) {
  obj.foo = "goodbye";
}

var myObj = { foo: "hello world" };

alterObject(myObj);

alert(myObj.foo); // "goodbye" instead of "hello world"

आप एक संख्यात्मक सूचकांक के साथ एक सरणी के गुणों पर पुनरावृति कर सकते हैं और यदि आप चाहें, तो सरणी के प्रत्येक सेल को संशोधित कर सकते हैं।

var arr = [1, 2, 3];

for (var i = 0; i < arr.length; i++) { 
    arr[i] = arr[i] + 1; 
}

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

 function swap(a, b) {
   var tmp = a;
   a = b;
   b = tmp; //assign tmp to b
 }

 var x = 1, y = 2;
 swap(x, y);

 alert("x is " + x + ", y is " + y); // "x is 1, y is 2"

सी की तरह एक भाषा ++ में, यह है कि क्योंकि उस भाषा करना संभव नहीं है करता है (तरह-के) पास-दर-संदर्भ है।

संपादित करें - यह हाल ही में (मार्च 2015) Reddit पर एक ब्लॉग पोस्ट पर फिर से लिखा गया था, जैसा कि नीचे उल्लेख किया गया है, हालांकि इस मामले में जावा के बारे में। यह रेडिट टिप्पणियों में आगे-पीछे पढ़ते समय मेरे साथ हुआ था कि भ्रम का एक बड़ा हिस्सा "संदर्भ" शब्द से जुड़े दुर्भाग्यपूर्ण टकराव से उपजा है। शब्दावली "संदर्भ से गुजरती है" और "पास से मूल्य" प्रोग्रामिंग भाषाओं में काम करने के लिए "ऑब्जेक्ट" होने की अवधारणा से पहले होती है। यह वास्तव में वस्तुओं के बारे में नहीं है; यह फ़ंक्शन मापदंडों के बारे में है, और विशेष रूप से फ़ंक्शन पैरामीटर कॉलिंग वातावरण में "कनेक्टेड" (या नहीं) हैं। विशेष रूप से,, और यह जावास्क्रिप्ट में जैसा दिखता है ठीक वैसा ही होगा। हालाँकि, कोई व्यक्ति कॉलिंग परिवेश में ऑब्जेक्ट संदर्भ को संशोधित करने में भी सक्षम होगा , और यह वह महत्वपूर्ण चीज़ है जो आप जावास्क्रिप्ट में नहीं कर सकते हैं । एक पास-बाय-रेफरेंस लैंग्वेज खुद रेफरेंस नहीं, बल्कि रेफरेंस रेफरेंस होगी ।

edit - यहाँ विषय पर एक ब्लॉग पोस्ट है। (उस पोस्ट पर टिप्पणी पर ध्यान दें जो बताती है कि C ++ में वास्तव में पास-पास-संदर्भ नहीं है। यह सच है। C ++ में क्या है, हालांकि, सादे चर के संदर्भ बनाने की क्षमता है, या तो स्पष्ट रूप से फ़ंक्शन के बिंदु पर। किसी कार्य को कॉल करते समय एक पॉइंटर बनाने के लिए, या अंतर्निहित रूप से , जिसके तर्क के लिए हस्ताक्षर टाइप करने के लिए कॉल किया जाना चाहिए। वे प्रमुख चीजें हैं जो जावास्क्रिप्ट समर्थन नहीं करती हैं।)

Comments

आप एक ऑब्जेक्ट या एक सरणी के संदर्भ को पास कर सकते हैं जो आपको मूल ऑब्जेक्ट या सरणी को बदलने की अनुमति देता है जो मुझे लगता है कि ओपी वास्तव में क्या पूछ रहा है।

— ०५:३५ पर jfriend00

ठीक है, ओपी ने शब्दावली का उपयोग किया था लेकिन वास्तविक कोड किसी भी "गुजर" को शामिल नहीं करता है :-) मुझे वास्तव में यकीन नहीं है कि वह क्या करने की कोशिश कर रहा है।

— १ty

एक संदर्भ पासिंग मूल्य से गुजर के समान नहीं है संदर्भ द्वारा , हालांकि यह इस जैसे कुछ परिस्थितियों में तो दिखाई दे सकते हैं।

— ट्रैविस वेब

आपका ब्लॉगर सी ++, जिसके बारे में गलत है करता है पास-दर-संदर्भ, और अपने पद कोई मतलब नहीं है। यह अप्रासंगिक है कि आप आरंभ के बाद एक संदर्भ के मूल्य को बदल नहीं सकते हैं; कि 'पास बाई रेफरेंस' से कोई लेना-देना नहीं है। उनका कथन है कि '' पास से संदर्भ '' शब्दार्थ को C # के माध्यम से वापस खोजा जा सकता है, में एक खतरे की घंटी बजनी चाहिए।

— ईएमएल

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

— ताज

Answer 2

1. आदिम प्रकार के चर जैसे तार और संख्या हमेशा मूल्य द्वारा पारित किए जाते हैं।

2. एरे और ऑब्जेक्ट्स को इन शर्तों के आधार पर संदर्भ या मूल्य द्वारा पारित किया जाता है:

   • यदि आप किसी ऑब्जेक्ट या एरे के मान को सेट कर रहे हैं तो यह पास बाय वैल्यू है।

     object1 = {prop: "car"}; array1 = [1,2,3];

   • यदि आप किसी ऑब्जेक्ट या ऐरे की प्रॉपर्टी की वैल्यू बदल रहे हैं तो वह Pass by Reference है।

     object1.prop = "car"; array1[0] = 9;

कोड

function passVar(obj1, obj2, num) {
    obj1.prop = "laptop"; // will CHANGE original
    obj2 = { prop: "computer" }; //will NOT affect original
    num = num + 1; // will NOT affect original
}

var object1 = {
    prop: "car"
};
var object2 = {
    prop: "bike"
};
var number1 = 10;

passVar(object1, object2, number1);
console.log(object1); //output: Object {item:"laptop"}
console.log(object2); //output: Object {item:"bike"}
console.log(number1); //ouput: 10

Comments

यह "संदर्भ द्वारा पास" का अर्थ नहीं है। इस शब्द का वास्तव में वस्तुओं से कोई लेना-देना नहीं है, लेकिन एक बुलाए गए फ़ंक्शन और कॉलिंग वातावरण में चर के बीच संबंधों के साथ।

— पोइंट्टी

सब कुछ हमेशा मूल्य से पारित किया जाता है। गैर-आदिम के साथ, पारित किया गया मूल्य एक संदर्भ है। संदर्भ को सौंपना उस संदर्भ को बदल देता है - स्वाभाविक रूप से, चूंकि यह एक मूल्य है - और इस प्रकार मूल रूप से संदर्भित दूसरी वस्तु को बदल नहीं सकता है। पॉइंट-टू-ऑब्जेक्ट को म्यूट करके रेफरेंस कृत्यों द्वारा इंगित ऑब्जेक्ट को ठीक उसी तरह से बदलना, जैसा आप अपेक्षा करेंगे। दोनों परिदृश्य पूरी तरह से सुसंगत हैं, और न ही जादुई रूप से यह बताता है कि जावास्क्रिप्ट कैसे समय में वापस जाकर काम करता है और यह बताता है कि फ़ंक्शन में कैसे पारित किया गया।

— मैथ्यू

इस उत्तर ने पिछले एक को स्पष्ट किया, जो कि, भले ही उसके पास वोट अधिक हो (लेखन के इस समय 287 और यह भी स्वीकृत है) जेएस के संदर्भ में वास्तव में इसे कैसे पारित किया जाए, यह पर्याप्त नहीं था। संक्षेप में, इस उत्तर में कोड ने काम किया, जो जवाब अधिक वोट एकत्र करता था, वह नहीं था।

— पैप

Answer 3

संदर्भ द्वारा चर को पास करने के लिए समाधान:

var a = 1;
inc = function(variableName) {
  window[variableName] += 1;
};

inc('a');

alert(a); // 2

संपादित करें

हाँ, वास्तव में आप इसे वैश्विक उपयोग के बिना कर सकते हैं

inc = (function () {
    var variableName = 0;

    var init = function () {
        variableName += 1;
        alert(variableName);
    }

    return init;
})();

inc();

Comments

@ वैश्विक / विंडो मूल्यों के बारे में सावधान रहना अच्छा है, लेकिन कुछ समय पर हम ब्राउज़र में जो कुछ भी कर रहे हैं वह विंडो ऑब्जेक्ट का एक बच्चा या वंशज है। नोडज में, सब कुछ ग्लोबल का वंशज है। संकलित वस्तु भाषाओं में, यह एक निहितार्थ है यदि स्पष्ट मूल वस्तु नहीं है, क्योंकि ऐसा करने से ढेर प्रबंधन अधिक जटिल हो जाता है (और किस लिए?)।

— dkloke

@ डब्लूके: हाँ, अंततः विंडो ऑब्जेक्ट को टच करने की आवश्यकता होती है- जैसे jQuery विंडो का उपयोग करता है। $ / window.jQuery और अन्य विधियां इसके अंतर्गत हैं। मैं वैश्विक नामस्थान के प्रदूषण के बारे में बात कर रहा था जहाँ आप इसे एक एकीकृत नाम स्थान के तहत लाने के बजाय इसमें बहुत अधिक चर जोड़ते हैं।

— फिल

मैं यह

— बताने के

मैं अंतिम समाधान (संपादित संस्करण) से प्यार करता हूं, यहां तक ​​कि यह संदर्भ द्वारा चर को पारित नहीं करता है। यह लाभ है क्योंकि आप सीधे चर का उपयोग कर सकते हैं।

— जॉन बो

Answer 4

सरल वस्तु

var ref = { value: 1 };

function Foo(x) {
    x.value++;
}

Foo(ref);
Foo(ref);

alert(ref.value); // Alert: 3

---

कस्टम वस्तु

वस्तु rvar

function rvar (name, value, context) {
    if (this instanceof rvar) {
        this.value = value;
        Object.defineProperty(this, 'name', { value: name });
        Object.defineProperty(this, 'hasValue', { get: function () { return this.value !== undefined; } });
        if ((value !== undefined) && (value !== null))
            this.constructor = value.constructor;
        this.toString = function () { return this.value + ''; };
    } else {
        if (!rvar.refs)
            rvar.refs = {};
        if (!context)
            context = window;
        // Private
        rvar.refs[name] = new rvar(name, value);
        // Public
        Object.defineProperty(context, name, {
            get: function () { return rvar.refs[name]; },
            set: function (v) { rvar.refs[name].value = v; },
            configurable: true
        });

        return context[name];
    }
}

परिवर्तनीय घोषणा

rvar('test_ref');
test_ref = 5; // test_ref.value = 5

या:

rvar('test_ref', 5); // test_ref.value = 5

टेस्ट कोड

rvar('test_ref_number');
test_ref_number = 5;
function Fn1 (v) { v.value = 100; }
console.log("rvar('test_ref_number');");
console.log("test_ref_number = 5;");
console.log("function Fn1 (v) { v.value = 100; }");
console.log('test_ref_number.value === 5', test_ref_number.value === 5);
console.log(" ");

Fn1(test_ref_number);
console.log("Fn1(test_ref_number);");
console.log('test_ref_number.value === 100', test_ref_number.value === 100);
console.log(" ");

test_ref_number++;
console.log("test_ref_number++;");
console.log('test_ref_number.value === 101', test_ref_number.value === 101);
console.log(" ");

test_ref_number = test_ref_number - 10;
console.log("test_ref_number = test_ref_number - 10;");
console.log('test_ref_number.value === 91', test_ref_number.value === 91);

console.log(" ");
console.log("---------");
console.log(" ");

rvar('test_ref_str', 'a');
console.log("rvar('test_ref_str', 'a');");
console.log('test_ref_str.value === "a"', test_ref_str.value === 'a');
console.log(" ");

test_ref_str += 'bc';
console.log("test_ref_str += 'bc';");
console.log('test_ref_str.value === "abc"', test_ref_str.value === 'abc');

टेस्ट कंसोल परिणाम

rvar('test_ref_number');
test_ref_number = 5;
function Fn1 (v) { v.value = 100; }
test_ref_number.value === 5 true

Fn1(test_ref_number);
test_ref_number.value === 100 true

test_ref_number++;
test_ref_number.value === 101 true

test_ref_number = test_ref_number - 10;
test_ref_number.value === 91 true

---------

rvar('test_ref_str', 'a');
test_ref_str.value === "a" true

test_ref_str += 'bc';
test_ref_str.value === "abc" true 

Answer 5

फिर भी संदर्भ द्वारा किसी भी (स्थानीय, आदिम) चर को पास करने के लिए एक और दृष्टिकोण है, चर को "मक्खी पर" बंद करने के साथ चर लपेटकर eval। यह "सख्त उपयोग" के साथ भी काम करता है। (ध्यान दें: ध्यान रखें कि evalजेएस ऑप्टिमाइज़र के अनुकूल नहीं है, चर नाम के आसपास के उद्धरण भी गायब हो सकते हैं अप्रत्याशित परिणाम हो सकते हैं)

"use strict"

//return text that will reference variable by name (by capturing that variable to closure)
function byRef(varName){
    return "({get value(){return "+varName+";}, set value(v){"+varName+"=v;}})";
}

//demo

//assign argument by reference
function modifyArgument(argRef, multiplier){
    argRef.value = argRef.value * multiplier;
}

(function(){

var x = 10;

alert("x before: " + x);
modifyArgument(eval(byRef("x")), 42);
alert("x after: " + x);

})()

लाइव नमूना https://jsfiddle.net/t3k4403w/

Comments

यह कमाल है

— hard_working_ant

Answer 6

वहाँ वास्तव में एक बहुत कुछ है:

function updateArray(context, targetName, callback) {
    context[targetName] = context[targetName].map(callback);
}

var myArray = ['a', 'b', 'c'];
updateArray(this, 'myArray', item => {return '_' + item});

console.log(myArray); //(3) ["_a", "_b", "_c"]

Answer 7

मैं व्यक्तिगत रूप से विभिन्न प्रोग्रामिंग भाषाओं द्वारा प्रस्तुत "संदर्भ द्वारा पास" कार्यक्षमता को नापसंद करता हूं। शायद ऐसा इसलिए है क्योंकि मैं केवल कार्यात्मक प्रोग्रामिंग की अवधारणाओं की खोज कर रहा हूं, लेकिन मुझे हमेशा गोज़बंप्स मिलते हैं जब मुझे ऐसे कार्य दिखाई देते हैं जो साइड इफेक्ट का कारण बनते हैं (जैसे संदर्भ द्वारा पारित मापदंडों में हेरफेर)। मैं व्यक्तिगत रूप से "एकल जिम्मेदारी" सिद्धांत को दृढ़ता से गले लगाता हूं।

IMHO, एक फ़ंक्शन को रिटर्न कीवर्ड का उपयोग करके केवल एक परिणाम / मान वापस करना चाहिए। एक पैरामीटर / तर्क को संशोधित करने के बजाय, मैं बस संशोधित पैरामीटर / तर्क मान वापस करूंगा और कॉलिंग कोड तक किसी भी वांछित पुनर्मूल्यांकन को छोड़ दूंगा।

लेकिन कभी-कभी (उम्मीद से बहुत कम ही), एक ही फ़ंक्शन से दो या अधिक परिणाम मान वापस करना आवश्यक है। उस स्थिति में, मैं उन सभी परिणामी मूल्यों को एक संरचना या वस्तु में शामिल करने का विकल्प चुनूंगा। फिर से, किसी भी पुन: असाइनमेंट को संसाधित करना कॉलिंग कोड तक होना चाहिए।

उदाहरण:

मान लीजिए कि पासिंग मापदंडों को तर्क सूची में एक विशेष कीवर्ड जैसे 'रेफरी' का उपयोग करके समर्थित किया जाएगा। मेरा कोड कुछ इस तरह दिख सकता है:

//The Function
function doSomething(ref value) {
    value = "Bar";
}

//The Calling Code
var value = "Foo";
doSomething(value);
console.log(value); //Bar

इसके बजाय, मैं वास्तव में ऐसा कुछ करना पसंद करूंगा:

//The Function
function doSomething(value) {
    value = "Bar";
    return value;
}

//The Calling Code:
var value = "Foo";
value = doSomething(value); //Reassignment
console.log(value); //Bar

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

//The Function
function doSomething(ref value) {
    value = "Bar";

    //Do other work
    var otherValue = "Something else";

    return otherValue;
}

//The Calling Code
var value = "Foo";
var otherValue = doSomething(value);
console.log(value); //Bar
console.log(otherValue); //Something else

इसके बजाय, मैं वास्तव में एक वस्तु के अंदर दोनों नए मूल्यों को वापस करना पसंद करूंगा, जैसे:

//The Function
function doSomething(value) {
    value = "Bar";

    //Do more work
    var otherValue = "Something else";

    return {
        value: value,
        otherValue: otherValue
    };
}

//The Calling Code:
var value = "Foo";
var result = doSomething(value);
value = result.value; //Reassignment
console.log(value); //Bar
console.log(result.otherValue);

ये कोड उदाहरण काफी सरल हैं, लेकिन यह मोटे तौर पर दर्शाता है कि मैं व्यक्तिगत रूप से इस तरह के सामान को कैसे संभालूंगा। यह मुझे विभिन्न जिम्मेदारियों को सही जगह पर रखने में मदद करता है।

खुश कोडिंग। :)

Comments

सामान (किसी भी प्रकार की जाँच के बिना) को पुन: सौंपना और सौंपना भी मुझे गोसेबंप देता है। जिम्मेदारी के रूप में, मुझे उम्मीद है कि doSomething (), उस चीज़ को करने के लिए, उस चीज़ को प्लस न करें और एक वस्तु प्लस बनाएं और गुणों के लिए मेरे चर असाइन करें। मान लीजिए कि मेरे पास एक सरणी है, जिसे खोजा जाना है। मुझे दूसरी सारणी में रखे गए मिलान आइटम पसंद आएंगे और मैं जानना चाहता हूं कि कितने पाए गए। एक मानक समाधान इस तरह से एक फ़ंक्शन को कॉल करना होगा: 'var फाउंडअरे; if ((findStuff (inArray, & foundArray))> 1) {// प्रक्रिया foundArray} '। उस परिदृश्य में एक नई, अज्ञात वस्तु वांछनीय या आवश्यक है।

— एलीस वैन लोईज

@ElisevanLooij आपके उदाहरण के मामले में, मैं findStuffकेवल परिणामी सरणी वापस करना पसंद करूंगा । आपको भी घोषणा करनी होगीfoundArray चर करना होगा, इसलिए मैं इसके परिणामस्वरूप परिणाम को सीधे बताऊंगा var foundArray = findStuff(inArray); if (foundArray.length > 0) { /* process foundArray */ }:। यह 1) कॉलिंग कोड को अधिक पठनीय / समझने योग्य बनाता है, और 2) findStuffविधि की आंतरिक कार्यक्षमता (और इस प्रकार परीक्षण करने योग्य) को काफी सरल करता है , जिससे यह वास्तव में विभिन्न (पुनः) उपयोग-मामलों / परिदृश्यों में बहुत अधिक लचीला हो जाता है।

— बार्ट हॉफलैंड

@ElisevanLooij हालांकि, मैं इस बात से सहमत हूं कि पुनर्मूल्यांकन (मेरे जवाब में) वास्तव में एक "कोड गंध" है और मैं वास्तव में जितना संभव हो उतना उन लोगों से बचना चाहूंगा। मैं अपने जवाब को इस तरह से संपादित (या यहां तक ​​कि सुधार) के बारे में सोचूंगा कि यह विषय पर मेरी वास्तविक राय को बेहतर ढंग से प्रतिबिंबित करेगा। आपकी प्रतिक्रिया के लिए धन्यवाद। :)

— बार्ट हॉफलैंड

Answer 8

मैं इस तरह की बात करने के लिए सिंटैक्स के साथ खेल रहा हूं, लेकिन इसके लिए कुछ सहायकों की आवश्यकता है जो थोड़े असामान्य हैं। यह 'var' का उपयोग नहीं करने के साथ शुरू होता है, लेकिन एक साधारण 'DECLARE' सहायक जो एक स्थानीय चर बनाता है और एक अनाम कॉलबैक के माध्यम से इसके लिए एक गुंजाइश को परिभाषित करता है। चर को कैसे घोषित किया जाता है इसे नियंत्रित करके, हम उन्हें वस्तुओं में लपेटने का विकल्प चुन सकते हैं ताकि वे हमेशा संदर्भ से पारित हो सकें, अनिवार्य रूप से। यह ऊपर एडुआर्डो क्युमो के उत्तर में से एक के समान है, लेकिन नीचे दिए गए समाधान को चर पहचानकर्ताओं के रूप में तारों का उपयोग करने की आवश्यकता नहीं है। यहाँ कुछ न्यूनतम कोड अवधारणा दिखाने के लिए है।

function Wrapper(val){
    this.VAL = val;
}
Wrapper.prototype.toString = function(){
    return this.VAL.toString();
}

function DECLARE(val, callback){
    var valWrapped = new Wrapper(val);    
    callback(valWrapped);
}

function INC(ref){
    if(ref && ref.hasOwnProperty('VAL')){
        ref.VAL++; 
    }
    else{
        ref++;//or maybe throw here instead?
    }

    return ref;
}

DECLARE(5, function(five){ //consider this line the same as 'let five = 5'
console.log("five is now " + five);
INC(five); // increment
console.log("five is incremented to " + five);
});

Answer 9

वास्तव में यह वास्तव में आसान है,

समस्या यह समझ रही है कि एक बार क्लासिक तर्कों को पारित करने के बाद, आपको दूसरे में स्कोप किया जाता है, केवल-पढ़ने के क्षेत्र ।

समाधान जावास्क्रिप्ट के ऑब्जेक्ट-ओरिएंटेड डिज़ाइन का उपयोग करके तर्क पास करना है,

यह एक वैश्विक / scoped चर में आर्गन के रूप में ही है, लेकिन बेहतर ...

function action(){
  /* process this.arg, modification allowed */
}

action.arg = [ ["empty-array"],"some string",0x100,"last argument" ];
action();

आप अच्छी तरह से ज्ञात श्रृंखला का आनंद लेने के लिए सामान का वादा भी कर सकते हैं : यहां पूरी बात है, वादे जैसी संरचना के साथ

function action(){
  /* process this.arg, modification allowed */
  this.arg = ["a","b"];
}

action.setArg = function(){this.arg = arguments; return this;}

action.setArg(["empty-array"],"some string",0x100,"last argument")()

या बेहतर अभी तक .. action.setArg(["empty-array"],"some string",0x100,"last argument").call()

Comments

this.argकेवल actionउदाहरण के साथ काम करता है । यह काम नहीं करता।

— एडुआर्डो क्यूमो

Answer 10

जावास्क्रिप्ट एक फ़ंक्शन के अंदर सरणी आइटम को संशोधित कर सकता है (इसे ऑब्जेक्ट / सरणी के संदर्भ के रूप में पारित किया जाता है)।

function makeAllPretty(items) {
   for (var x = 0; x < myArray.length; x++){
      //do stuff to the array
      items[x] = makePretty(items[x]);
   }
}

myArray = new Array(var1, var2, var3);
makeAllPretty(myArray);

यहाँ एक और उदाहरण है:

function inc(items) {
  for (let i=0; i < items.length; i++) {
    items[i]++;
  }
}

let values = [1,2,3];
inc(values);
console.log(values);
// prints [2,3,4]

Answer 11

जेएस मजबूत प्रकार नहीं है, यह आपको कई अलग-अलग तरीकों से समस्याओं को हल करने की अनुमति देता है, जैसा कि इस चलने में लगता है।

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

यदि आपको लगता है कि चर को संदर्भ द्वारा पारित करने की आवश्यकता है, तो आप बेहतर हो सकते हैं, उन्हें ऑब्जेक्ट IMHO में बिल्डिंग कर सकते हैं।

Answer 12

पास-दर-संदर्भ चर्चा को अलग रखते हुए, जो अभी भी बताए गए प्रश्न का हल खोज रहे हैं, वे उपयोग कर सकते हैं:

const myArray = new Array(var1, var2, var3);
myArray.forEach(var => var = makePretty(var));

Answer 13

मुझे सही में पता है तुम्हारा क्या मतलब है। स्विफ्ट में एक ही बात कोई समस्या नहीं होगी। निचला रेखा उपयोग letनहीं है var।

तथ्य यह है कि प्राथमिकताओं को मूल्य से पारित किया जाता है लेकिन तथ्य यह है कि var iपुनरावृत्ति के बिंदु पर मूल्य को अनाम फ़ंक्शन में कॉपी नहीं किया जाता है, कम से कम कहने के लिए काफी आश्चर्यजनक है।

for (let i = 0; i < boxArray.length; i++) {
  boxArray[i].onclick = function() { console.log(i) }; // correctly prints the index
}