ප්‍රාථමික වර්ග (අංකය, නූල්, ආදිය) අගය අනුව සම්මත වේ, නමුත් වස්තූන් නොදන්නා බැවින් ඒවා දෙකම අගය අනුව සම්මත කළ හැකිය (වස්තුවක් රඳවාගෙන සිටින විචල්‍යයක් ඇත්ත වශයෙන්ම වස්තුවට යොමු කිරීමක් යැයි අපි සලකමු ) සහ සම්මතයෙන්-යොමු කිරීම (වස්තුවට විචල්‍යය වස්තුව රඳවාගෙන සිටින බව අප සලකන විට).

අවසානයේ එය ඇත්ත වශයෙන්ම වැදගත් නොවුනත්, සම්මුති සම්මත කරමින් තර්ක ඉදිරිපත් කිරීමට නිවැරදි ක්‍රමය කුමක්දැයි දැන ගැනීමට මට අවශ්‍යය. ජාවාස්ක්‍රිප්ට් පිරිවිතරයෙන් උපුටා ගත් කොටසක් තිබේද, එය අර්ථ නිරූපණය කළ යුත්තේ කුමක් ද යන්න නිර්වචනය කරයි.

එය ජාවාස්ක්‍රිප්ට් හි සිත්ගන්නා සුළුය. මෙම උදාහරණය සලකා බලන්න:

function changeStuff(a, b, c)
{
  a = a * 10;
  b.item = "changed";
  c = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};

changeStuff(num, obj1, obj2);

console.log(num);
console.log(obj1.item);
console.log(obj2.item);

මෙය ප්‍රතිදානය නිපදවයි:

10
changed
unchanged

• obj1කිසිසේත් යොමු කිරීමක් නොවේ නම් , වෙනස් කිරීම ශ්‍රිතයෙන් පිටත obj1.itemකිසිදු බලපෑමක් ඇති නොකරනු ඇත obj1.
• තර්කය නිසි යොමු කිරීමක් නම්, සියල්ල වෙනස් වීමට ඉඩ තිබුණි. numවනු ඇත 100, සහ obj2.itemකියවනු "changed"ඇත.

ඒ වෙනුවට, තත්වය නම් සම්මත කරන ලද අයිතමය අගය අනුව සම්මත වීමයි. නමුත් අගය මගින් සම්මත කරන ලද අයිතමයම යොමු කිරීමකි. තාක්ෂණික වශයෙන්, මෙය ඇමතුම්-බෙදාගැනීම ලෙස හැඳින්වේ .

ප්‍රායෝගිකව ගත් කල, මෙයින් අදහස් වන්නේ ඔබ පරාමිතියම වෙනස් කළහොත් (මෙන් numසහ obj2), එය පරාමිතියට පෝෂණය කළ අයිතමයට බලපාන්නේ නැති බවයි. නමුත් ඔබ පරාමිතියේ අභ්‍යන්තරය වෙනස් කළහොත්, එය උපස්ථය ප්‍රචාරණය කරනු ඇත (මෙන් obj1).

එය සැමවිටම අගය අනුව ගමන් කරයි, නමුත් වස්තූන් සඳහා විචල්‍යයේ අගය යොමු කිරීමකි. මේ හේතුව නිසා, ඔබ යම් වස්තුවක් පසු කර එහි සාමාජිකයන් වෙනස් කරන විට , එම වෙනස්කම් ශ්‍රිතයෙන් පිටත පවතී. මෙය යොමු කිරීම හරහා ගමන් කිරීමක් ලෙස පෙනේ. නමුත් ඔබ ඇත්ත වශයෙන්ම වස්තු විචල්‍යයේ අගය වෙනස් කළහොත් වෙනස නොපවතින බව ඔබට පෙනෙනු ඇත.

උදාහරණයක්:

function changeObject(x) {
  x = { member: "bar" };
  console.log("in changeObject: " + x.member);
}

function changeMember(x) {
  x.member = "bar";
  console.log("in changeMember: " + x.member);
}

var x = { member: "foo" };

console.log("before changeObject: " + x.member);
changeObject(x);
console.log("after changeObject: " + x.member); /* change did not persist */

console.log("before changeMember: " + x.member);
changeMember(x);
console.log("after changeMember: " + x.member); /* change persists */

ප්‍රතිදානය:

before changeObject: foo
in changeObject: bar
after changeObject: foo

before changeMember: foo
in changeMember: bar
after changeMember: bar

විචල්‍යය වස්තුව "රඳවා නොගනී"; එය යොමු කිරීමක් දරයි. ඔබට එම යොමු කිරීම වෙනත් විචල්‍යයකට පැවරිය හැකි අතර දැන් දෙකම එකම වස්තුවක් යොමු කරයි. එය සැමවිටම අගය අනුව ගමන් කරයි (එම අගය යොමු කිරීමක් වුවද ...).

පරාමිතියක් ලෙස සම්මත කරන ලද විචල්‍යයක අගය වෙනස් කිරීමට ක්‍රමයක් නොමැත, එය ජාවාස්ක්‍රිප්ට් මඟින් යොමු කිරීම සඳහා සහය දක්වන්නේ නම් එය කළ හැකිය.

මගේ ශත දෙක ... මම එය තේරුම් ගන්නා ආකාරය මෙයයි. (මා වැරදියි නම් මාව නිවැරදි කිරීමට නිදහස් වන්න)

අගය / යොමු කිරීම අනුව ඔබ දන්නා සියල්ල ඉවත දැමීමට කාලයයි.

ජාවාස්ක්‍රිප්ට් හි, එය අගය හෝ යොමු කිරීම හෝ වෙනත් දෙයක් මගින් සම්මත වී ඇත්ද යන්න ගැටළුවක් නොවේ. වැදගත් වන්නේ විකෘතියට එදිරිව පරාමිතීන් ශ්‍රිතයකට පැවරීමයි.

හරි, මා අදහස් කරන දේ පැහැදිලි කිරීමට මගේ උපරිමය කිරීමට මට ඉඩ දෙන්න. අපි ඔබට වස්තු කිහිපයක් ඇති බව කියමු.

var object1 = {};
var object2 = {};

අප කර ඇත්තේ "පැවරුම" යන්නයි ... අපි "object1" සහ "object2" යන විචල්යයන් සඳහා වෙනම හිස් වස්තු 2 ක් පවරා ඇත.

දැන් අපි කියමු අපි object1 වඩා හොඳට කැමතියි ... ඉතින්, අපි නව විචල්‍යයක් "පවරමු".

var favoriteObject = object1;

ඊළඟට, කුමන හේතුවක් නිසා හෝ, අපි වස්තුව 2 වඩා හොඳට තීරණය කරමු. ඉතින්, අපි ටිකක් නැවත පැවරීමක් කරන්නෙමු.

favoriteObject = object2;

Object1 හෝ object2 ට කිසිවක් සිදු නොවීය. අපි කිසිසේත් දත්ත වෙනස් කර නැත. අප කළේ අපගේ ප්‍රියතම වස්තුව කුමක්ද යන්න නැවත පැවරීමයි. Object2 සහ favoriteObject යන දෙකම එකම වස්තුවකට පවරා ඇති බව දැන ගැනීම වැදගත්ය. එම විචල්‍යයන්ගෙන් එකක් හරහා අපට එම වස්තුව වෙනස් කළ හැකිය.

object2.name = 'Fred';
console.log(favoriteObject.name) // Logs Fred
favoriteObject.name = 'Joe';
console.log(object2.name); // Logs Joe

හරි, දැන් අපි උදාහරණයක් ලෙස නූල් වැනි ප්‍රාථමිකයන් දෙස බලමු

var string1 = 'Hello world';
var string2 = 'Goodbye world';

නැවතත්, අපි ප්රියතම එකක් තෝරා ගනිමු.

var favoriteString = string1;

අපගේ ප්‍රියතම ස්ට්‍රිං සහ ස්ට්‍රිං 1 විචල්‍යයන් දෙකම 'හෙලෝ වර්ල්ඩ්' වෙත පවරා ඇත. දැන්, අපේ ප්‍රියතම ස්ට්‍රිං වෙනස් කිරීමට අවශ්‍ය නම් කුමක් කළ යුතුද ??? කුමක් සිදුවේවිද???

favoriteString = 'Hello everyone';
console.log(favoriteString); // Logs 'Hello everyone'
console.log(string1); // Logs 'Hello world'

අහ් .... මොකද උනේ. ප්‍රියතම ස්ට්‍රිං වෙනස් කිරීමෙන් අපට string1 වෙනස් කළ නොහැක ... ඇයි ?? මොකද අපි අපේ නූල් වස්තුව වෙනස් කළේ නැහැ . අප කළේ නව නූලකට කැමතිම ස්ට්‍රිං විචල්‍යය "RE ASSIGN" පමණි . මෙය අත්‍යවශ්‍යයෙන්ම එය string1 වෙතින් විසන්ධි කරන ලදි. පෙර උදාහරණයේ දී, අපි අපගේ වස්තුව නැවත නම් කළ විට, අපි කිසිවක් පවරා නැත. (හොඳයි, ඉදිරිපත් කිරීමට නොහැකි විචල්ය ම , ... අපි කළේ, කෙසේ වෙතත්, දේපල නම නව සංගීත අනුයුක්ත.) ඒ වෙනුවට, අප හුදෙක් විචල්ය 2 හා යටින් වස්තූන් අතර ඇති සම්බන්ධතා කරයි වන වස්තුවක් වැඩෙහි යෙදවීම. (වෙනස් කිරීම හෝ කිරීමට අපට අවශ්ය සිටියත් විකෘති මාදිලි වැල වස්තුව ම, අපට තිබිය නොහැක, මන්ද ජාවාස්ක්‍රිප්ට් හි නූල් සැබවින්ම වෙනස් කළ නොහැක.)

දැන්, ශ්‍රිතයන් හා සම්මත පරාමිතීන් වෙත .... ඔබ ශ්‍රිතයක් අමතා පරාමිතියක් පසු කරන විට, ඔබ අත්‍යවශ්‍යයෙන්ම කරන්නේ නව විචල්‍යයකට “පැවරුමක්” වන අතර එය හරියටම ඔබ භාවිතයෙන් පවරා ඇති ආකාරයටම ක්‍රියා කරයි සමාන (=) ලකුණ.

මෙම උදාහරණ ගන්න.

var myString = 'hello';

// Assign to a new variable (just like when you pass to a function)
var param1 = myString;
param1 = 'world'; // Re assignment

console.log(myString); // Logs 'hello'
console.log(param1);   // Logs 'world'

දැන්, එකම දේ, නමුත් ශ්‍රිතයක් සමඟ

function myFunc(param1) {
    param1 = 'world';

    console.log(param1);   // Logs 'world'
}

var myString = 'hello';
// Calls myFunc and assigns param1 to myString just like param1 = myString
myFunc(myString);

console.log(myString); // logs 'hello'

හරි, දැන් අපි ඒ වෙනුවට වස්තු භාවිතා කරමින් උදාහරණ කිහිපයක් ලබා දෙමු ... පළමුව, ශ්‍රිතය නොමැතිව.

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Assign to a new variable (just like when you pass to a function)
var otherObj = myObject;

// Let's mutate our object
otherObj.firstName = 'Sue'; // I guess Joe decided to be a girl

console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Sue'

// Now, let's reassign the variable
otherObj = {
    firstName: 'Jack',
    lastName: 'Frost'
};

// Now, otherObj and myObject are assigned to 2 very different objects
// And mutating one object has no influence on the other
console.log(myObject.firstName); // Logs 'Sue'
console.log(otherObj.firstName); // Logs 'Jack';

දැන්, එකම දේ, නමුත් ක්‍රියාකාරී ඇමතුමක් සමඟ

function myFunc(otherObj) {

    // Let's mutate our object
    otherObj.firstName = 'Sue';
    console.log(otherObj.firstName); // Logs 'Sue'

    // Now let's re-assign
    otherObj = {
        firstName: 'Jack',
        lastName: 'Frost'
    };
    console.log(otherObj.firstName); // Logs 'Jack'

    // Again, otherObj and myObject are assigned to 2 very different objects
    // And mutating one object doesn't magically mutate the other
}

var myObject = {
    firstName: 'Joe',
    lastName: 'Smith'
};

// Calls myFunc and assigns otherObj to myObject just like otherObj = myObject
myFunc(myObject);

console.log(myObject.firstName); // Logs 'Sue', just like before

හරි, ඔබ මෙම සම්පූර්ණ ලිපිය කියවා බැලුවහොත්, ජාවාස්ක්‍රිප්ට් හි ක්‍රියාකාරී ඇමතුම් ක්‍රියා කරන්නේ කෙසේද යන්න පිළිබඳව ඔබට දැන් හොඳ අවබෝධයක් ඇත. යමක් යොමු කිරීමෙන් හෝ වටිනාකමින් සම්මත වී ඇත්ද යන්න ගැටළුවක් නොවේ ... වැදගත් වන්නේ පැවරුම හා විකෘතියට එරෙහිව ය.

ඔබ ශ්‍රිතයකට විචල්‍යයක් පසු කරන සෑම අවස්ථාවකම, ඔබ සමාන (=) ලකුණ භාවිතා කළාක් මෙන්, පරාමිති විචල්‍යයේ නම කුමක් වුවත් “පැවරීම” කරයි.

සමාන ලකුණ (=) යන්නෙන් අදහස් කරන්නේ පැවරුම බව සැමවිටම මතක තබා ගන්න. ජාවාස්ක්‍රිප්ට් හි ශ්‍රිතයක් සඳහා පරාමිතියක් යැවීම යන්නෙන් අදහස් කරන්නේ පැවරුම යන්නයි. ඒවා එක හා සමාන වන අතර විචල්යයන් 2 එකම ආකාරයකින් සම්බන්ධ වේ (එනම් ඒවා එකම වස්තුවකට පවරා ඇති බව ඔබ ගණන් නොගන්නේ නම්) ඒවා එසේ නොවේ.

“විචල්‍යයක් වෙනස් කිරීම” වෙනස් විචල්‍යයකට බලපාන එකම අවස්ථාව වන්නේ යටින් පවතින වස්තුව විකෘති වූ විටය (එවැනි අවස්ථාවකදී ඔබ විචල්‍යය වෙනස් කර නැත, නමුත් වස්තුවම වේ.

වස්තූන් සහ ප්‍රාථමිකයන් අතර වෙනසක් ඇති කිරීමේ තේරුමක් නැත, මන්ද එය ඔබට ශ්‍රිතයක් නොමැති ආකාරයටම ක්‍රියා කරන අතර නව විචල්‍යයකට පැවරීම සඳහා සමාන ලකුණ භාවිතා කළ බැවිනි.

එකම ගොචා යනු ඔබ ශ්‍රිතයට ඇතුළු කරන විචල්‍යයේ නම ශ්‍රිත පරාමිතියේ නමට සමාන වන විට ය. මෙය සිදු වූ විට, ඔබ ශ්‍රිතය තුළ ඇති පරාමිතිය ශ්‍රිතයට සම්පූර්ණයෙන්ම නව විචල්‍යයක් ලෙස සැලකිය යුතුය (මන්ද එය)

function myFunc(myString) {
    // myString is private and does not affect the outer variable
    myString = 'hello';
}

var myString = 'test';
myString = myString; // Does nothing, myString is still 'test';

myFunc(myString);
console.log(myString); // Logs 'test'

පහත සඳහන් කරුණු සලකා බලන්න:

1. විචල්යයන්, සූචක මතකයේ වටිනාකම්.
2. විචල්‍යයක් නැවත පැවරීම මඟින් එම ලක්ෂ්‍යය නව අගයකට යොමු කරයි.
3. විචල්‍යයක් නැවත පැවරීම එම වස්තුව දෙසට යොමු වූ වෙනත් විචල්‍යයන්ට කිසි විටෙකත් බලපාන්නේ නැත

එබැවින්, "යොමු කිරීම / අගය පසු කිරීම" ගැන අමතක කරන්න, "යොමු කිරීම / අගය අනුව ගමන් කිරීම" මත රැඳී නොසිටින්න:

1. මෙම වචන භාවිතා කරනුයේ භාෂාවක හැසිරීම විස්තර කිරීම සඳහා මිස සත්‍ය වශයෙන්ම යටින් පවතින ක්‍රියාත්මක කිරීම නොවේ. මෙම සාරාංශයේ ප්‍රති As ලයක් ලෙස, යහපත් පැහැදිලි කිරීමක් සඳහා අත්‍යවශ්‍ය වන විවේචනාත්මක තොරතුරු නැති වී යන අතර, එය අනිවාර්යයෙන්ම එක් යෙදුමක් සත්‍ය හැසිරීම ප්‍රමාණවත් ලෙස විස්තර නොකරන වත්මන් තත්වයට මඟ පෙන්වන අතර අතිරේක තොරතුරු සැපයිය යුතුය
2. මෙම සංකල්ප මුලින් නිර්වචනය කර ඇත්තේ විශේෂයෙන් ජාවාස්ක්‍රිප්ට් විස්තර කිරීමේ අභිප්‍රායෙනි. එබැවින් ඒවා ව්‍යාකූලත්වයට පමණක් එකතු වූ විට ඒවා භාවිතා කිරීමට මට බල කෙරෙන්නේ නැත.

ඔබේ ප්‍රශ්නයට පිළිතුරු සැපයීම සඳහා: දර්ශක සම්මත කර ඇත.

// code
var obj = {
    name: 'Fred',
    num: 1
};

// illustration
               'Fred'
              /
             /
(obj) ---- {}
             \
              \
               1

// code
obj.name = 'George';


// illustration
                 'Fred'


(obj) ---- {} ----- 'George'
             \
              \
               1

// code
obj = {};

// illustration
                 'Fred'


(obj)      {} ----- 'George'
  |          \
  |           \
 { }            1

// code
var obj = {
    text: 'Hello world!'
};

/* function parameters get their own pointer to 
 * the arguments that are passed in, just like any other variable */
someFunc(obj);


// illustration
(caller scope)        (someFunc scope)
           \             /
            \           /
             \         /
              \       /
               \     /
                 { }
                  |
                  |
                  |
            'Hello world'

අවසාන අදහස් කිහිපයක්:

• වස්තූන් නොමැති අතර ප්‍රාථමිකයන් විශේෂ නීති මගින් බලාත්මක වේ යැයි සිතීමට පෙළඹේ , නමුත් ප්‍රාථමිකයන් යනු හුදෙක් දර්ශක දාමයේ අවසානයයි.
• අවසාන නිදසුනක් ලෙස, අරාව ඉවත් කිරීමට පොදු උත්සාහයක් බලාපොරොත්තු වූ පරිදි ක්‍රියාත්මක නොවන්නේ මන්දැයි සලකා බලන්න.

var a = [1,2];
var b = a;

a = [];
console.log(b); // [1,2]
// doesn't work because `b` is still pointing at the original array

ශ්‍රිතයකට පිටතින් ඇති වස්තුවක් ශ්‍රිතයට සම්ප්‍රේෂණය වන්නේ බාහිර වස්තුවට යොමු කිරීමෙනි.

එහි වස්තුව හැසිරවීමට ඔබ එම යොමුව භාවිතා කරන විට, පිටත වස්තුව මෙලෙස බලපායි. කෙසේ වෙතත්, ශ්‍රිතය තුළ ඔබ වෙනත් දෙයකට යොමු කිරීමට තීරණය කළහොත්, ඔබ කිසිසේත් පිටත වස්තුවට බලපෑමක් නොකළේය, මන්ද ඔබ කළ සියල්ලම වෙනත් දෙයකට යොමු කිරීම නැවත යොමු කිරීම පමණි.

මේ ආකාරයට සිතන්න: එය සැමවිටම අගය අනුව ගමන් කරයි. කෙසේ වෙතත්, වස්තුවක වටිනාකම වස්තුවම නොව එම වස්තුවට යොමු කිරීමකි.

මෙන්න උදාහරණයක්, අංකයක් පසු කිරීම (ප්‍රාථමික වර්ගයක්)

function changePrimitive(val) {
    // At this point there are two '10's in memory.
    // Changing one won't affect the other
    val = val * 10;
}
var x = 10;
changePrimitive(x);
// x === 10

වස්තුවක් සමඟ මෙය නැවත කිරීමෙන් විවිධ ප්‍රති results ල ලැබේ:

function changeObject(obj) {
    // At this point there are two references (x and obj) in memory,
    // but these both point to the same object.
    // changing the object will change the underlying object that
    // x and obj both hold a reference to.
    obj.val = obj.val * 10;
}
var x = { val: 10 };
changeObject(x);
// x === { val: 100 }

තවත් එක් උදාහරණයක්:

function changeObject(obj) {
    // Again there are two references (x and obj) in memory,
    // these both point to the same object.
    // now we create a completely new object and assign it.
    // obj's reference now points to the new object.
    // x's reference doesn't change.
    obj = { val: 100 };
}
var x = { val: 10 };
changeObject(x);
// x === { val: 10}

අගය හා සඳහනක් විසින් පිටපත් පසුකර සසඳා ගැන ඉතා සවිස්තරාත්මක පැහැදිලි කිරීමක් වේ මෙම පරිච්ඡේදයේ පිළිබඳ ය: "මාර්ගෝපදේශනය JavaScript" පොත.

වස්තූන් සහ අරා හැසිරවීම යන මාතෘකාවෙන් සමුගැනීමට පෙර, නාමකරණයේ කරුණක් අප විසින් ඉවත් කළ යුතුය.

"යොමු කිරීම හරහා යන්න" යන යෙදුමට අර්ථ කිහිපයක් තිබිය හැකිය. සමහර පා readers කයන්ට, වාක්‍ය ඛණ්ඩය මඟින් ශ්‍රිතයකට එහි තර්ක වලට නව අගයන් පැවරීමට සහ එම වෙනස් කළ අගයන් ශ්‍රිතයෙන් පිටත දෘශ්‍යමාන කිරීමට ඉඩ සලසන ශ්‍රිත ආයාචනා තාක්‍ෂණයකි. මෙම පොතේ මෙම පදය භාවිතා කරන ආකාරය මෙය නොවේ.

මෙහිදී අපි සරලවම අදහස් කරන්නේ වස්තුවකට හෝ අරාවකට යොමු කිරීම - වස්තුවම නොව - ශ්‍රිතයකට යොමු කිරීමයි. ශ්‍රිතයකට වස්තුවෙහි ගුණාංග හෝ අරාවේ මූලද්‍රව්‍ය වෙනස් කිරීමට යොමු කිරීම භාවිතා කළ හැකිය. නමුත් ශ්‍රිතය නව වස්තුවකට හෝ අරාවකට යොමු කිරීමක් සමඟ යොමු කිරීම නැවත ලියන්නේ නම්, එම වෙනස් කිරීම ශ්‍රිතයෙන් පිටත නොපෙනේ.

මෙම යෙදුමේ අනෙක් අරුත හුරුපුරුදු පා ers කයන්ට වස්තූන් සහ අරා අගය මගින් සම්මත කර ඇති බව පැවසීමට කැමති විය හැකි නමුත් සම්මත කළ අගය ඇත්ත වශයෙන්ම වස්තුවට වඩා යොමු කිරීමකි.

ජාවාස්ක්‍රිප්ට් සෑම විටම අගය අනුව ය ; සෑම දෙයක්ම වටිනාකමින් යුක්තය.

වස්තූන් යනු අගයන් වන අතර වස්තූන්ගේ සාමාජික ශ්‍රිතයන්ම අගයන් වේ (කාර්යයන් ජාවාස්ක්‍රිප්ට් හි පළමු පන්තියේ වස්තු බව මතක තබා ගන්න). එසේම, ජාවාස්ක්‍රිප්ට් හි ඇති සියල්ල වස්තුවක් යන සංකල්පය සම්බන්ධයෙන් ; මේක වැරදියි. නූල්, සංකේත, අංක, බූලියන්, ශුන්‍ය සහ නිර්වචනය නොකළ ඒවා ප්‍රාථමික වේ.

ඇතැම් විට ඔවුන්ගේ මූලික මූලාකෘති වලින් උරුම වූ සමහර සාමාජික කාර්යයන් සහ ගුණාංග උත්තේජනය කළ හැකි නමුත් මෙය පහසුව සඳහා පමණි. එයින් අදහස් කරන්නේ ඒවා තමන් විසින්ම වස්තූන් බවයි. යොමු කිරීම සඳහා පහත සඳහන් දෑ උත්සාහ කරන්න:

x = "test";
alert(x.foo);
x.foo = 12;
alert(x.foo);

ඇඟවීම් දෙකෙහිම ඔබ නිර්වචනය කළ යුතු අගය සොයා ගනු ඇත.

ජාවාස්ක්‍රිප්ට් හි, එම අගය පවරනු ලබන්නේ අගය-පිටපතක් ද නැතිනම් යොමු-පිටපතක් ද යන්න පමණක් පාලනය කරයි .

ප්‍රාථමික අගයන් සැමවිටම පවරනු ලබන්නේ / සම්මත කරන්නේ අගය පිටපතෙනි :

• null
• undefined
• නූල්
• අංකය
• බූලියන්
• සංකේතය ES6

සංයුක්ත අගයන් සෑම විටම යොමු-පිටපත මගින් පවරනු ලැබේ / සම්මත කරනු ලැබේ

• වස්තු
• අරා
• ශ්‍රිතය

උදාහරණයක් වශයෙන්

var a = 2;
var b = a; // `b` is always a copy of the value in `a`
b++;
a; // 2
b; // 3

var c = [1,2,3];
var d = c; // `d` is a reference to the shared `[1,2,3]` value
d.push( 4 );
c; // [1,2,3,4]
d; // [1,2,3,4]

ඉහත ස්නිපටයේ, 2පරිමාණ ප්‍රාථමික බැවින්, aඑම අගයේ එක් ආරම්භක පිටපතක් තබා ඇති අතර, වටිනාකමේ bතවත් පිටපතක් පවරනු ලැබේ. වෙනස් bවන විට , ඔබ කිසිසේත් වටිනාකම වෙනස් නොකරයි a.

නමුත් දෙකම cසහ dඑකම හවුල් අගයට වෙනම යොමු කිරීම් [1,2,3]වන අතර එය සංයුක්ත අගයකි. වටිනාකම cහෝ dවැඩි ගණනක් "අයිති" නොවන බව සැලකිල්ලට ගැනීම වැදගත්ය [1,2,3]- දෙකම වටිනාකමට සමාන සම වයස් යොමු කිරීම් පමණි. එබැවින්, .push(4)සත්‍ය හවුල් arrayවටිනාකම වෙනස් කිරීමට ( ) යොමු කිරීමක් භාවිතා කරන විට , එය එක් හවුල් අගයකට පමණක් බලපාන අතර යොමු දෙකම අලුතින් වෙනස් කරන ලද අගය සඳහන් [1,2,3,4]කරයි.

var a = [1,2,3];
var b = a;
a; // [1,2,3]
b; // [1,2,3]

// later
b = [4,5,6];
a; // [1,2,3]
b; // [4,5,6]

අපි පැවරුම සිදු කරන විට b = [4,5,6], අපි aතවමත් යොමු කර ඇති ස්ථානයට ( [1,2,3]) යොමු කිරීමට කිසිසේත්ම කිසිවක් නොකරමු . එය සිදු bකිරීම සඳහා, යොමු aකිරීමකට වඩා යොමු කාරකයක් විය යුතුය array- නමුත් එවැනි හැකියාවක් JS හි නොමැත!

function foo(x) {
    x.push( 4 );
    x; // [1,2,3,4]

    // later
    x = [4,5,6];
    x.push( 7 );
    x; // [4,5,6,7]
}

var a = [1,2,3];

foo( a );

a; // [1,2,3,4]  not  [4,5,6,7]

අප තර්කය පසු කරන විට a, එය aයොමු පිටපතක් පවරයි x. xසහ aඑකම [1,2,3]අගයට යොමු වන වෙනම යොමු කිරීම් වේ. දැන්, ශ්‍රිතය තුළ, අපට එම යොමුව අගය විකෘති කිරීමට භාවිතා කළ හැකිය ( push(4)). නමුත් අපි පැවරුම සිදු කරන විට x = [4,5,6], මෙය මුලික යොමුව යොමු aවන ස්ථානයට කිසිසේත් බලපාන්නේ නැත - තවමත් (දැන් වෙනස් කරන ලද) [1,2,3,4]අගයට යොමු කරයි.

arrayඅගය-පිටපතක් මගින් සංයුක්ත අගයක් (වැනි ) effectively ලදායී ලෙස සම්මත කිරීම සඳහා , ඔබ විසින් එහි පිටපතක් අතින් සෑදිය යුතුය, එවිට සම්මත කරන ලද සඳහන තවමත් මුල් පිටපතට යොමු නොවේ. උදාහරණයක් වශයෙන්:

foo( a.slice() );

විමර්ශන-පිටපත මගින් සම්මත කළ හැකි සංයුක්ත අගය (වස්තුව, අරාව යනාදිය)

function foo(wrapper) {
    wrapper.a = 42;
}

var obj = {
    a: 2
};

foo( obj );

obj.a; // 42

මෙන්න, objපරිමාණ ප්‍රාථමික දේපල සඳහා ආවරණයක් ලෙස ක්‍රියා කරයි a. වෙත යොමු foo(..)වූ විට, objයොමු පිටපතක් ඇතුල් කර wrapperපරාමිතියට සකසා ඇත . wrapperහවුල් වස්තුවට ප්‍රවේශ වීමට සහ එහි දේපල යාවත්කාලීන කිරීමට අපට දැන් යොමු කිරීම භාවිතා කළ හැකිය . ශ්‍රිතය අවසන් වූ පසු, obj.aයාවත්කාලීන කළ අගය පෙනෙනු ඇත 42.

මූලාශ්රය

හොඳයි, එය 'කාර්ය සාධනය' සහ 'වේගය' සහ ක්‍රමලේඛන භාෂාවක 'මතක කළමනාකරණය' යන සරල වචනයෙන්.

ජාවාස්ක්රිප්ට් අපි ස්ථරය දෙක තුළ සාරධර්ම කළ හැකි: type1 - objectsහා type2 වැනි අගය සියල්ලෙන්ම වෙනත් වර්ග stringසහ booleanසහ ආදිය

මතකය චතුරස්රයට වඩා පහළින් යැයි ඔබ සිතන්නේ නම්, ඒ සෑම එකක් තුළම එක් වර්ග 2 ක අගයක් පමණක් ඉතිරි කළ හැකිය:

සෑම වර්ගයකම අගය (කොළ) තනි චතුරස්රයක් වන අතර ටයිප් 1 අගය (නිල්) ඒවායින් සමූහයකි :

කාරණය නම්, ඔබට ටයිප් 2-අගයක් දැක්වීමට අවශ්‍ය නම්, ලිපිනය සරල ය, නමුත් ඔබට ටයිප් 1 අගය සඳහා එකම දේ කිරීමට අවශ්‍ය නම් එය කිසිසේත් පහසු නොවේ! :

සහ වඩාත් සංකීර්ණ කතාවක:

එබැවින් මෙහි යොමු කිරීම් අපව ගලවා ගත හැකිය:

මෙහි හරිත ඊතලය සාමාන්‍ය විචල්‍යයක් වන අතර, දම් පාට යනු වස්තු විචල්‍යයකි, එබැවින් හරිත ඊතලය (සාමාන්‍ය විචල්‍යය) සතුව ඇත්තේ එක් කාර්යයක් පමණක් වන අතර (එය සාමාන්‍ය අගයක් පෙන්නුම් කරයි) අපට එහි වටිනාකම වෙන් කිරීමට අවශ්‍ය නැත ඒ නිසා අපි හරිත ඊතලය කොතැනට ගියත් එහි වටිනාකම සහ සියලු පැවරුම්, කාර්යයන් සහ යනාදිය සමඟ චලනය කරමු ...

නමුත් අපට දම් පැහැති ඊතලය සමඟ එකම දේ කළ නොහැක, අපට මෙහි 'ජෝන්' කොටුව හෝ වෙනත් බොහෝ දේ ගෙනයාමට අවශ්‍ය විය හැකිය ..., එබැවින් දම් ඊතලය එහි ස්ථානයට ඇලී සිටින අතර එයට පවරා ඇති සාමාන්‍ය ඊතල පමණක් චලනය වේ ...

ඉතා අවුල් සහගත තත්වයක් නම්, ඔබේ යොමු විචල්‍යය වෙනස් වන ආකාරය ඔබට තේරුම් ගත නොහැකි වීමයි, අපි ඉතා හොඳ උදාහරණයක් දෙස බලමු:

let arr = [1, 2, 3, 4, 5]; //arr is an object now and a purple arrow is indicating it
let obj2 = arr; // now, obj2 is another purple arrow that is indicating the value of arr obj
let obj3 = ['a', 'b', 'c'];
obj2.push(6); // first pic below - making a new hand for the blue circle to point the 6
//obj2 = [1, 2, 3, 4, 5, 6]
//arr = [1, 2, 3, 4, 5, 6]
//we changed the blue circle object value (type1-value) and due to arr and obj2 are indicating that so both of them changed
obj2 = obj3; //next pic below - changing the direction of obj2 array from blue circle to orange circle so obj2 is no more [1,2,3,4,5,6] and it's no more about changing anything in it but we completely changed its direction and now obj2 is pointing to obj3
//obj2 = ['a', 'b', 'c'];
//obj3 = ['a', 'b', 'c'];

අගය පසු කිරීම සහ යොමු කිරීම (ජාවාස්ක්‍රිප්ට්) සඳහා මෙය තව ටිකක් පැහැදිලි කිරීමකි. මෙම සංකල්පය තුළ, ඔවුන් කතා කරන්නේ විචල්‍යය යොමු කිරීම හා විචල්‍යය යොමු කිරීම හරහා ය.

අගය අනුව ගමන් කරන්න (ප්‍රාථමික වර්ගය)

var a = 3;
var b = a;

console.log(a); // a = 3
console.log(b); // b = 3

a=4;
console.log(a); // a = 4
console.log(b); // b = 3

• ජාවාස්ක්‍රිප්ට් හි ඇති සියලුම ප්‍රාථමික වර්ග වලට අදාළ වේ (නූල්, අංකය, බූලියන්, නිර්වචනය නොකළ සහ ශුන්‍ය).
• a ට මතකයක් වෙන් කර ඇත (0x001 කියන්න) සහ b මතකයේ අගයෙහි පිටපතක් සාදයි (0x002 කියන්න).
• එබැවින් විචල්‍යයක අගය වෙනස් කිරීම අනෙකාට බලපාන්නේ නැත, මන්ද ඔවුන් දෙදෙනාම වෙනස් ස්ථාන දෙකක වාසය කරයි.

යොමු (වස්තු) පසු කරන්න

var c = { "name" : "john" };
var d = c;

console.log(c); // { "name" : "john" }
console.log(d); // { "name" : "john" }

c.name = "doe";

console.log(c); // { "name" : "doe" }
console.log(d); // { "name" : "doe" }

• ජාවාස්ක්‍රිප්ට් එන්ජිම වස්තුව විචල්‍යයට පවරන අතර cඑය යම් මතකයකට යොමු කරයි, කියන්න (0x012).
• D = c විට, මෙම පියවරේදී dඑකම ස්ථානයට (0x012) යොමු වේ.
• විචල්ය දෙකම සඳහා ඕනෑම වෙනස්වීම් අගයක අගය වෙනස් කිරීම.
• කාර්යයන් යනු වස්තු ය

විශේෂ අවස්ථාව, යොමු (වස්තු) පසු කරන්න

c = {"name" : "jane"};
console.log(c); // { "name" : "jane" }
console.log(d); // { "name" : "doe" }

• සමාන (=) ක්‍රියාකරු නව මතක අවකාශයක් හෝ ලිපිනයක් සකසයි

ජාවාස්ක්‍රිප්ට් හි යොමු කිරීම් ගැන මා දන්නා දේ බෙදා ගැනීම

ජාවාස්ක්‍රිප්ට් හි, විචල්‍යයකට වස්තුවක් පැවරීමේදී, විචල්‍යයට පවරා ඇති අගය වස්තුවට යොමු කිරීමකි:

var a = {
  a: 1,
  b: 2,
  c: 3
};
var b = a;

// b.c is referencing to a.c value
console.log(b.c) // Output: 3
// Changing value of b.c
b.c = 4
// Also changes the value of a.c
console.log(a.c) // Output: 4

අර්ථ නිරූපණය !! එකම වචන හා වාක්‍ය ඛණ්ඩ භාවිතා කරන විට පවා එකම දේ විස්තර නොකිරීම නිසා නිශ්චිත අර්ථ දැක්වීම් සැකසීම අනිවාර්යයෙන්ම සමහර පිළිතුරු හා අදහස් නොගැලපේ, නමුත් ව්‍යාකූලතාවයෙන් මිදීම ඉතා වැදගත් වේ (විශේෂයෙන් නව ක්‍රමලේඛකයින් සඳහා).

පළමුවෙන්ම, සෑම කෙනෙකුම ග්‍රහණය කර නොගන්නා වියුක්ත මට්ටම් ගණනාවක් තිබේ. 4 වන හෝ 5 වන පරම්පරාවේ භාෂාවන් ඉගෙන ගෙන ඇති නව ක්‍රමලේඛකයන්ට එකලස් කිරීමට හුරුපුරුදු සංකල්ප වටා තම මනස එතීමට අපහසු විය හැකිය. පාස්-බයි-යොමු කිරීම යනු හුදෙක් ක්‍රියාකාරී පරාමිති විචල්‍යයක් භාවිතා කර යොමු කරන ලද වස්තුවක් වෙනස් කිරීමේ හැකියාව නොවේ.

විචල්යය : මතකයේ නිශ්චිත ස්ථානයක අගය සඳහන් කරන සංකේතයක ඒකාබද්ධ සංකල්පය. මෙම පදය සාමාන්‍යයෙන් විස්තර සාකච්ඡා කිරීමේදී තනිවම භාවිතා කළ නොහැක.

සංකේතය : විචල්යය (එනම් විචල්යයේ නම) යොමු කිරීමට භාවිතා කරන පෙළ නූල.

අගය : විශේෂිත බිටු මතකයේ ගබඩා කර ඇති අතර විචල්ය සංකේතය භාවිතයෙන් යොමු කෙරේ.

මතක පිහිටීම : විචල්‍යයක අගය ගබඩා කර ඇති තැන. (ස්ථානයම ගබඩා කර ඇති අගයෙන් වෙන් වූ අංකයකින් නිරූපණය වේ.)

ශ්‍රිත පරාමිතිය : ශ්‍රිතය අර්ථ දක්වා ඇති විචල්‍යය, ශ්‍රිතයට සම්මත විචල්‍යයන් යොමු කිරීම සඳහා භාවිතා කරයි.

ශ්‍රිත තර්කය : අමතන්නා විසින් ශ්‍රිතයට ලබා දෙන ශ්‍රිතයෙන් පිටත විචල්‍යය.

වස්තු විචල්‍යය : විචල්‍යයේ මූලික යටින් පවතින අගය “වස්තුව” නොවේ, ඒ වෙනුවට එහි වටිනාකම වස්තුවේ සත්‍ය දත්ත ගබඩා කර ඇති මතකයේ වෙනත් ස්ථානයකට දර්ශකයක් (මතක ස්ථාන අගය) වේ. බොහෝ ඉහළ පරම්පරාවේ භාෂාවල, විවිධ සන්දර්භයන්හි ස්වයංක්‍රීයව යොමු කිරීම මගින් “දර්ශක” අංගය effectively ලදායී ලෙස සැඟවී ඇත.

ප්‍රාථමික විචල්‍යය : විචල්‍යයේ වටිනාකම සත්‍ය අගයයි. මෙම සංකල්පය පවා විවිධ භාෂාවල ස්වයංක්‍රීය බොක්සිං හා වස්තු වැනි සන්දර්භයන් මගින් සංකීර්ණ කළ හැකි නමුත් සාමාන්‍ය අදහස් වන්නේ විචල්‍යයේ අගය යනු වෙනත් මතක ස්ථානයකට යොමු කරන්නෙකුට වඩා විචල්‍යයේ සංකේතය මගින් නිරූපණය වන සත්‍ය අගයයි.

ක්‍රියාකාරී තර්ක සහ පරාමිතීන් එකම දෙයක් නොවේ. එසේම, විචල්යයේ අගය විචල්යයේ වස්තුව නොවේ (දැනටමත් විවිධ පුද්ගලයින් විසින් පෙන්වා දී ඇති නමුත් පෙනෙන පරිදි නොසලකා හරිනු ලැබේ). නිසි අවබෝධය සඳහා මෙම වෙනස්කම් ඉතා වැදගත් වේ.

පසු-අගය හෝ ඇමතුමකින් බෙදාගැනීම (වස්තු සඳහා): ශ්‍රිත පරාමිතිය සංකේතය මඟින් යොමු කර ඇති වෙනත් මතක ස්ථානයකට ශ්‍රිත තර්කයේ අගය පිටපත් කර ඇත (එය තොගයේ හෝ ගොඩවල තිබේද යන්න නොසලකා). වෙනත් වචන වලින් කිවහොත්, ශ්‍රිත පරාමිතියට සම්මත කරන ලද තර්කයේ වටිනාකමේ පිටපතක් ලැබුණි ... සහ (විවේචනාත්මක) තර්කයේ වටිනාකම ඇමතුම් ශ්‍රිතය මගින් යාවත්කාලීන නොකෙරේ / වෙනස් කර නැත / වෙනස් කර ඇත. මතක තබා ගන්න, වස්තු විචල්‍යයක අගය වස්තුවම නොවේ, ඒ වෙනුවට එය වස්තුවට දර්ශකය වේ, එබැවින් වස්තු විචල්‍යයක් අගය අනුව ගමන් කිරීමෙන් දර්ශකය ශ්‍රිත පරාමිති විචල්‍යයට පිටපත් කරයි. ශ්‍රිත පරාමිතියේ අගය මතකයේ ඇති එකම වස්තුව වෙත යොමු කරයි. වස්තු දත්ත සෘජුවම ශ්‍රිත පරාමිතිය හරහා වෙනස් කළ හැකිය, නමුත් ශ්‍රිත තර්කයේ අගය යාවත්කාලීන නොකෙරේ, එබැවින් එය දිගටම එකම දෙසට යොමු වේශ්‍රිත ඇමතුම පුරාවටම හා පසුව පවා (එහි වස්තුවේ දත්ත වෙනස් කළද හෝ ක්‍රියාකාරී පරාමිතිය වෙනත් වස්තුවක් පවරා තිබුණද). ශ්‍රිත පරාමිති විචල්‍යය හරහා යොමු කරන ලද වස්තුව යාවත්කාලීන කළ හැකි බැවින් ශ්‍රිත තර්කය යොමු කිරීම මගින් නිගමනය කිරීම වැරදිය.

අමතන්න / පසු-යොමු කිරීම : ශ්‍රිත තර්කයේ අගය අනුරූප ශ්‍රිත පරාමිතිය මඟින් කෙලින්ම යාවත්කාලීන කළ හැකිය. එය උදව් කරන්නේ නම්, ශ්‍රිත පරාමිතිය තර්කය සඳහා "අන්වර්ථයක්" බවට පත්වේ - ඒවා එකම මතක ස්ථානයක එකම අගය වෙත effectively ලදායී ලෙස යොමු කරයි. ශ්‍රිත පරාමිතිය වස්තු විචල්‍යයක් නම්, ශ්‍රිත පරාමිතිය තවමත් තර්කය හා සමාන වස්තුවකට යොමු වන බැවින් වස්තුවේ දත්ත වෙනස් කිරීමේ හැකියාව පාස්-බයි-අගය නඩුවට වඩා වෙනස් නොවේ. නමුත් වස්තු විචල්‍ය අවස්ථාවෙහිදී, ශ්‍රිත පරාමිතිය සම්පූර්ණයෙන්ම වෙනස් වස්තුවකට සකසා තිබේ නම්, තර්කය ද වෙනස් වස්තුවකට යොමු කරයි - මෙය පාස්-බයි-අගය නඩුවේ සිදු නොවේ.

ජාවාස්ක්‍රිප්ට් යොමු කිරීම මඟින් සම්මත නොවේ. ඔබ සමීපව කියවන්නේ නම්, සියලු ප්‍රතිවිරුද්ධ මතයන් මඟින් වටිනාකමින් අදහස් කරන්නේ කුමක්ද යන්න වරදවා වටහාගෙන ඇති අතර, ව්‍යාජ පරාමිතිය හරහා වස්තුවක දත්ත යාවත්කාලීන කිරීමේ හැකියාව “සම්මතයෙන්-වටිනාකමට” සමාන බව ඔවුන් ව්‍යාජ ලෙස නිගමනය කරයි.

වස්තු ක්ලෝන / පිටපත : නව වස්තුවක් නිර්මාණය කර මුල් වස්තුවේ දත්ත පිටපත් කරනු ලැබේ. මෙය ගැඹුරු පිටපතක් හෝ නොගැඹුරු පිටපතක් විය හැකි නමුත් කාරණය වන්නේ නව වස්තුවක් නිර්මාණය වීමයි. වස්තුවක පිටපතක් සෑදීම යනු අගය අනුව වෙනම සංකල්පයකි. සමහර භාෂා පන්ති වස්තුව සහ ව්‍යුහයන් (හෝ ඒ හා සමාන) අතර වෙනස හඳුනාගෙන ඇති අතර විවිධ වර්ගවල විචල්‍යයන් පසු කිරීම සඳහා වෙනස් හැසිරීම් තිබිය හැකිය. නමුත් ජාවාස්ක්‍රිප්ට් වස්තු විචල්‍යයන් පසු කරන විට ස්වයංක්‍රීයව මෙවැනි දෙයක් නොකරයි. නමුත් ස්වයංක්‍රීය වස්තු ක්ලෝනකරණය නොමැති වීම පසු-යොමු කිරීමකට පරිවර්තනය නොවේ.

ජාවාස්ක්‍රිප්ට් විසින් ප්‍රාථමික වර්ගයන් අගය අනුව ද වස්තු වර්ග යොමු කිරීම මඟින් ද සම්මත කරයි

දැන්, ජාවා සහ වෙනත් දේ විස්තර කිරීමට නිවැරදි ක්‍රමය “යොමු කිරීම හරහා ගමන් කිරීම” යන්න ගැන මිනිසුන් නිමක් නැතිව කතා කිරීමට කැමතියි. ඇත්ත වශයෙන්ම කරන්න. කාරණය මෙයයි:

1. වස්තුවක් පසු කිරීමෙන් වස්තුව පිටපත් නොවේ.
2. ශ්‍රිතයකට සම්ප්‍රේෂණය කරන ලද වස්තුවකට එහි සාමාජිකයන් ශ්‍රිතය මගින් වෙනස් කළ හැකිය.
3. ශ්‍රිතයකට ලබා දුන් ප්‍රාථමික අගයක් ශ්‍රිතය මගින් වෙනස් කළ නොහැක. පිටපතක් සාදා ඇත.

මගේ පොතේ එය යොමු කිරීම ලෙස හැඳින්වේ.

- බ්‍රයන් බයි - යොමු මඟින් සම්මත කරන වැඩසටහන් ක්‍රම මොනවාද?

යාවත්කාලීන කරන්න

මෙන්න මේ සඳහා තරවටු කිරීමකි:

JavaScript හි "pass by reference" නොමැත.

මෙය තේරුම් ගැනීමට මගේ සරල ක්‍රමය ...

• ශ්‍රිතයක් අමතන විට, ඔබ තර්ක කරන්නේ විචල්‍යයන් නොව තර්ක විචල්‍යයන්ගේ අන්තර්ගතය (යොමුව හෝ අගය) ය.

  var var1 = 13;
  var var2 = { prop: 2 };
  
  //13 and var2's content (reference) are being passed here
  foo(var1, var2); 

• ශ්‍රිතය ඇතුළත, පරාමිති විචල්‍යයන් inVar1සහ inVar2සම්මත කරන ලද අන්තර්ගතයන් ලබා ගන්න.

  function foo(inVar1, inVar2){
      //changing contents of inVar1 and inVar2 won't affect variables outside
      inVar1 = 20;
      inVar2 = { prop: 7 };
  }

• inVar2යොමු කිරීම ලැබුණු දා සිට { prop: 2 }, ඔබට වස්තුවේ දේපලෙහි වටිනාකම වෙනස් කළ හැකිය.

  function foo(inVar1, inVar2){
      inVar2.prop = 7; 
  }

ජාවාස්ක්‍රිප්ට් හි ශ්‍රිතයක් සඳහා තර්ක ඉදිරිපත් කිරීම C හි දර්ශක අගය අනුව පරාමිතීන් පසු කිරීමට සමාන වේ:

/*
The following C program demonstrates how arguments
to JavaScript functions are passed in a way analogous
to pass-by-pointer-value in C. The original JavaScript
test case by @Shog9 follows with the translation of
the code into C. This should make things clear to
those transitioning from C to JavaScript.

function changeStuff(num, obj1, obj2)
{
    num = num * 10;
    obj1.item = "changed";
    obj2 = {item: "changed"};
}

var num = 10;
var obj1 = {item: "unchanged"};
var obj2 = {item: "unchanged"};
changeStuff(num, obj1, obj2);
console.log(num);
console.log(obj1.item);    
console.log(obj2.item);

This produces the output:

10
changed
unchanged
*/

#include <stdio.h>
#include <stdlib.h>

struct obj {
    char *item;
};

void changeStuff(int *num, struct obj *obj1, struct obj *obj2)
{
    // make pointer point to a new memory location
    // holding the new integer value
    int *old_num = num;
    num = malloc(sizeof(int));
    *num = *old_num * 10;
    // make property of structure pointed to by pointer
    // point to the new value
    obj1->item = "changed";
    // make pointer point to a new memory location
    // holding the new structure value
    obj2 = malloc(sizeof(struct obj));
    obj2->item = "changed";
    free(num); // end of scope
    free(obj2); // end of scope
}

int num = 10;
struct obj obj1 = { "unchanged" };
struct obj obj2 = { "unchanged" };

int main()
{
    // pass pointers by value: the pointers
    // will be copied into the argument list
    // of the called function and the copied
    // pointers will point to the same values
    // as the original pointers
    changeStuff(&num, &obj1, &obj2);
    printf("%d\n", num);
    puts(obj1.item);
    puts(obj2.item);
    return 0;
}

ක්‍රමලේඛන භාෂා නීති yers යින් සඳහා, මම ECMAScript 5.1 හි පහත දැක්වෙන කොටස් හරහා ගොස් ඇත (එය නවතම සංස්කරණයට වඩා කියවීමට පහසුය), සහ එය ECMAScript තැපැල් ලැයිස්තුවෙන් විමසන තාක් දුරට යන්න .

TL; DR : සෑම දෙයක්ම අගය අනුව සම්මත කර ඇත, නමුත් වස්තූන්ගේ ගුණාංග යොමු කිරීම් වන අතර, වස්තුවෙහි අර්ථ දැක්වීම රහසිගතව ප්‍රමිතියෙන් තොරය.

තර්ක ලැයිස්තු ඉදිකිරීම

11.2.4 වගන්තියේ “තර්ක ලැයිස්තු” මඟින් තර්ක 1 ක් පමණක් අඩංගු තර්ක ලැයිස්තුවක් ඉදිරිපත් කිරීම පිළිබඳ පහත සඳහන් දේ සඳහන් වේ:

නිෂ්පාදන තර්ක ලැයිස්තුව: පැවරුම් එක්ස්ප්‍රස්ෂන් පහත පරිදි ඇගයීමට ලක් කෙරේ:

1. AssignmentExpression තක්සේරු කිරීමේ ප්‍රති result ලය ref ලෙස සලකමු.
2. GetValue (ref) වීමට තර්ක කරමු.
3. එකම අයිතමය වන ආගන්තුක ලැයිස්තුවක් ආපසු එවන්න.

තර්ක ලැයිස්තුවේ තර්ක 0 හෝ> 1 ඇති අවස්ථා ද මෙම කොටසේ දක්වා ඇත.

මේ අනුව, සෑම දෙයක්ම යොමු කිරීම මගින් සම්මත වේ.

වස්තු දේපල වලට ප්‍රවේශ වීම

11.2.1 කොටස "දේපල ප්රවේශයන්"

MemberExpression: MemberExpression [ප්‍රකාශනය] නිෂ්පාදනය පහත පරිදි ඇගයීමට ලක් කෙරේ:

1. MemberExpression තක්සේරු කිරීමේ ප්‍රති result ලයක් ලෙස baseReference ඉඩ දෙන්න.
2. BaseValue GetValue (baseReference) වීමට ඉඩ දෙන්න.
3. ප්‍රකාශනය තක්සේරු කිරීමේ ප්‍රති result ලයක් ලෙස දේපල නාම ලේඛනයට ඉඩ දෙන්න.
4. PropertyNameValue GetValue (propertyNameReference) වීමට ඉඩ දෙන්න.
5. CheckObjectCoercible (baseValue) අමතන්න.
6. PropertyNameString ToString (propertyNameValue) වීමට ඉඩ දෙන්න.
7. ඇගයීමට ලක් කරන සින්ටැක්ටික් නිෂ්පාදනය දැඩි මාදිලියේ කේතයක අඩංගු නම්, දැඩි ලෙස සත්‍ය වීමට ඉඩ දෙන්න, එසේ නොමැතිනම් දැඩි ලෙස අසත්‍ය විය යුතුය.
8. වර්ගය විමර්ශන එහි වටිනාකම නැවත සිය පදනම අගය baseValue කාගේ නමෙන්ම නම propertyNameString වන අතර, එහි දැඩි මාදිලිය ධජය දැඩි වේ.

මේ අනුව, වස්තූන්ගේ ගුණාංග සෑම විටම යොමු ලෙස ලබා ගත හැකිය.

යොමුව මත

8.7 වගන්තියේ “විමර්ශන පිරිවිතර වර්ගය” හි විස්තර කර ඇති අතර, යොමු කිරීම් භාෂාවේ සැබෑ වර්ග නොවන බව - ඒවා භාවිතා කරනුයේ මකාදැමීමේ, ටයිප් ඔෆ් සහ පැවරුම් ක්‍රියාකරුවන්ගේ හැසිරීම විස්තර කිරීමට පමණි.

"වස්තුව" අර්ථ දැක්වීම

5.1 සංස්කරණයේ අර්ථ දැක්වෙන්නේ “වස්තුවක් යනු දේපල එකතුවකි” යන්නයි. එමනිසා, අපට අනුමාන කළ හැකිය, වස්තුවේ වටිනාකම එකතුව බව, නමුත් එකතුවෙහි වටිනාකම කුමක්ද යන්න පිරිවිතරයේ දුර්වල ලෙස අර්ථ දක්වා ඇති අතර එය තේරුම් ගැනීමට සුළු උත්සාහයක් අවශ්‍ය වේ.

එම්ඩීඑන් ලියකියවිලි ඉතා වාචිකව තොරව පැහැදිලිව විස්තර කරයි:

ශ්‍රිත ඇමතුමක පරාමිතීන් ශ්‍රිතයේ තර්ක වේ. කාර්යයන් සඳහා තර්ක සම්මත කරනු ලැබේඅගය අනුව ලැබේ . ශ්‍රිතය තර්කයක වටිනාකම වෙනස් කරන්නේ නම්, මෙම වෙනස ගෝලීයව හෝ ඇමතුම් ශ්‍රිතය තුළ පිළිබිඹු නොවේ. කෙසේ වෙතත්, වස්තු යොමු කිරීම් ද අගයන් වන අතර ඒවා විශේෂිත ය: ශ්‍රිතය මඟින් යොමු කරන ලද වස්තුවේ ගුණාංග වෙනස් කරන්නේ නම්, එම වෙනස ශ්‍රිතයෙන් පිටත දැකිය හැකිය, (...)

මුලාශ්‍රය: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#Description

මට හමු වූ වඩාත්ම සංක්ෂිප්ත පැහැදිලි කිරීම එයාර් බීඑන්බී විලාසිතාවේ මාර්ගෝපදේශයයි :

• ප්‍රාථමික : ඔබ ප්‍රාථමික වර්ගයකට ප්‍රවේශ වන විට එහි වටිනාකම මත කෙලින්ම ක්‍රියා කරයි

  • නූල්
  • අංකය
  • බූලියන්
  • ශුන්‍යයි
  • නිර්වචනය නොකළ

උදා:

var foo = 1,
    bar = foo;

bar = 9;

console.log(foo, bar); // => 1, 9

• සංකීර්ණය : ඔබ සංකීර්ණ වර්ගයකට ප්‍රවේශ වන විට එහි වටිනාකම පිළිබඳ සඳහනක් මත වැඩ කරයි

  • වස්තුව
  • අරාව
  • ශ්‍රිතය

උදා:

var foo = [1, 2],
    bar = foo;

bar[0] = 9;

console.log(foo[0], bar[0]); // => 9, 9

එනම් effectively ලදායී ලෙස ප්‍රාථමික වර්ග අගය මගින් සම්මත වන අතර සංකීර්ණ වර්ග යොමු කරනු ලැබේ.

පහත් මට්ටමේ භාෂාවක, ඔබට විචල්‍යයක් යොමු කිරීමකින් සම්මත කිරීමට අවශ්‍ය නම්, ශ්‍රිතය නිර්මාණය කිරීමේදී ඔබට නිශ්චිත වාක්‍ය ඛණ්ඩයක් භාවිතා කළ යුතුය:

int myAge = 14;
increaseAgeByRef(myAge);
function increaseAgeByRef(int &age) {
  *age = *age + 1;
}

එම &age සැඳහුම වේ myAge, එහෙත් ඔබ අගය අවශ්ය නම් ඔබට යොමු පරිවර්තනය කිරීමට ඇති, භාවිතා*age .

ජාවාස්ක්‍රිප්ට් යනු ඔබ වෙනුවෙන් මෙම පරිවර්තනය කරන ඉහළ මට්ටමේ භාෂාවකි. එබැවින්, වස්තූන් යොමු කිරීම මඟින් සම්මත වුවද, භාෂාව යොමු පරාමිතිය අගය බවට පරිවර්තනය කරයි. ඔබට භාවිතා කිරීමට අවශ්‍ය නැත&ශ්‍රිත අර්ථ දැක්වීම මත එය යොමු නොවේ *, ක්‍රියාකාරී ශරීරය මත, යොමු අගය වටිනාකමට පරිවර්තනය කිරීම සඳහා, JS එය ඔබ වෙනුවෙන් කරයි.

ශ්‍රිතයක් තුළ වස්තුවක් වෙනස් කිරීමට උත්සාහ කරන විට, එහි අගය ප්‍රතිස්ථාපනය කිරීමෙන් (එනම් age = {value:5} ) වෙනස නොපවතිනු ඇත, නමුත් ඔබ එහි ගුණාංග (එනම් age.value = 5) වෙනස් කළහොත් එය සිදු වේ.

වැඩිදුර ඉගෙන ගන්න

මම මෙම පිළිතුරු කිහිප වතාවක් කියවා ඇත්තෙමි, නමුත් බාබරා ලිස්කොව් විසින් හඳුන්වන පරිදි "බෙදාගැනීමෙන් අමතන්න" යන්නෙහි තාක්ෂණික අර්ථ දැක්වීම ගැන දැන ගන්නා තෙක් එය ඇත්ත වශයෙන්ම නොලැබුණි.

ශ්‍රිතය තුළ ඇති ක්‍රියාකාරී තර්ක සඳහා වන පැවරුම්වල ඇමතුම අනුව ඇමතුමට වඩා වෙනස් වන්නේ ඇමතුමෙහි අර්ථ නිරූපණය, ඇමතුම්කරුට නොපෙනේ (යොමු අර්ථ නිරූපණයට වඩා වෙනස්ව) [උපුටා දැක්වීම අවශ්‍යයි], එබැවින් උදා: විචල්‍යයක් සම්මත වුවහොත් එය කළ නොහැක. අමතන්නාගේ විෂය පථය තුළ එම විචල්‍යය මත පැවරුමක් අනුකරණය කිරීමට. කෙසේ වෙතත්, ශ්‍රිතයට ඇමතුම්කරුට සමාන වස්තුවකට ප්‍රවේශය ඇති හෙයින් (කිසිදු පිටපතක් සාදනු නොලැබේ), එම වස්තූන් සඳහා වන විකෘති, වස්තූන් විකෘති නම්, ශ්‍රිතය තුළ ඇමතුම්කරුට දෘශ්‍යමාන වන අතර, එය ඇමතුමට වඩා වෙනස් බව පෙනේ. අර්ථ නිරූපණය. ශ්‍රිතය තුළ විකෘති වස්තුවක විකෘති ඇමතුම්කරුට පෙනෙන්නේ එම වස්තුව පිටපත් කිරීම හෝ ක්ලෝන නොකිරීම නිසා ය - එය බෙදා ගැනේ.

එනම්, ඔබ ගොස් පරාමිති අගයට ප්‍රවේශ වන්නේ නම් පරාමිති යොමු කිරීම් වෙනස් කළ හැකිය. අනෙක් අතට, පරාමිතියකට පැවරීම ඇගයීමෙන් පසු අතුරුදහන් වන අතර එය ක්‍රියාකාරී ඇමතුම්කරුට ප්‍රවේශ විය නොහැක.

මම සොයාගෙන ඇත දීර්ඝ ක්රමය පිළිබඳ Underscore.js පුස්තකාල මම පරාමිතිය එක්කෝ ඇති ෙහෝ ෙවනස් කර ඇති ෙහෝ මුලුමනින්ම විස්ථාපනය කළ හැකි ලෙස වස්තුවක් තුළ සම්මත කිරීමට අවශ්ය වන විට ඉතා ප්රයෝජනවත්.

function replaceOrModify(aObj) {
  if (modify) {

    aObj.setNewValue('foo');

  } else {

   var newObj = new MyObject();
   // _.extend(destination, *sources) 
   _.extend(newObj, aObj);
  }
}

මම කියන්නේ එය පිටපතක් ලෙසයි -

තර්ක සලකා බලන්න සහ විචල්‍ය වස්තූන් යනු ශ්‍රිත ආයාචනයේ ආරම්භයේ දී නිර්මාණය කරන ලද ක්‍රියාත්මක කිරීමේ සන්දර්භය තුළ නිර්මාණය කරන ලද වස්තූන් වන අතර ඔබේ සත්‍ය අගය / ශ්‍රිතය ශ්‍රිතයට ඇතුළත් කිරීම මෙම තර්ක + විචල්‍ය වස්තු තුළ ගබඩා වේ.

සරලව කිවහොත්, ප්‍රාථමික වර්ග සඳහා, ශ්‍රිත ඇමතුම ආරම්භයේදීම අගයන් පිටපත් වේ, වස්තු වර්ගය සඳහා, යොමු කිරීම පිටපත් වේ.

බොහෝ දුරට සරලම ක්‍රමය

// Copy JS object without reference
var first = {"a":"value1","b":"value2"};
var clone = JSON.parse( JSON.stringify( first ) ); 

var second = ["a","b","c"];
var clone = JSON.parse( JSON.stringify( second ) ); 

ජාවාස්ක්‍රිප්ට් හි “පාස් බයි රීෆරන්ස්” යන යෙදුම භාවිතා කිරීම පිළිබඳව මෙහි යම් සාකච්ඡාවක් ඇත , නමුත් ඔබේ ප්‍රශ්නයට පිළිතුරු දීමට:

වස්තුවක් නිශ්චිතවම සඳහන් කිරීමකින් තොරව ස්වයංක්‍රීයව යොමු කිරීමකින් සම්මත වේ

(ඉහත සඳහන් කළ ලිපියෙන්.)

යමක් "යොමු කිරීම හරහා ගමන් කරන්නේද" යන්න තීරණය කිරීමට පහසු ක්‍රමයක් නම් ඔබට "swap" ශ්‍රිතයක් ලිවිය හැකිද යන්නයි. උදාහරණයක් ලෙස, C හි ඔබට කළ හැක්කේ:

void swap(int *i, int *j)
{
    int t;
    t = *i;
    *i = *j;
    *j = t;
}

ඔබට ජාවාස්ක්‍රිප්ට් හි ඊට සමාන දෙයක් කළ නොහැකි නම්, එය “යොමු කිරීම හරහා ගමන් කිරීම” නොවේ.

1. ප්‍රාථමික ආකාරයේ විචල්‍යය වන නූල්, අංකය සෑම විටම අගය අනුව සම්මත වේ.

2. මෙම කොන්දේසි දෙක මත පදනම්ව අරාව සහ වස්තුව යොමු කිරීමක් ලෙස හෝ අගය අනුව සම්මත වේ.

   • ඔබ එම වස්තුවේ හෝ අරාවේ වටිනාකම නව වස්තුවක් හෝ අරාවකින් වෙනස් කරන්නේ නම් එය අගය මගින් සම්මත වේ.

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

   මෙන්න ඔබ නව වස්තුවක් හෝ අරාවක් පරණ එකකට පවරයි. ඔබ පැරණි වස්තුවක දේපලවල වටිනාකම වෙනස් නොකරයි. එබැවින් එය අගය අනුව ගමන් කරයි.

   • ඔබ වස්තුවක හෝ අරාවක දේපල වටිනාකම වෙනස් කරන්නේ නම් එය යොමු කිරීම මඟින් සම්මත වේ.

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

   මෙන්න ඔබ පරණ වස්තුවක දේපල වටිනාකමක් වෙනස් කරයි.ඔබ නව වස්තුවක් හෝ අරාවක් පරණ එකකට පවරන්නේ නැත.

කේතය

    function passVar(object1, object2, number1) {

        object1.key1= "laptop";
        object2 = {
            key2: "computer"
        };
        number1 = number1 + 1;
    }

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

    passVar(object1, object2, number1);
    console.log(object1.key1);
    console.log(object2.key2);
    console.log(number1);

Output: -
    laptop
    bike
    10

1. ප්‍රාථමික (අංකය, බූලියන්, ආදිය) අගය අනුව සම්මත වේ.
   • නූල් වෙනස් කළ නොහැකි බැවින් ඒවා ඇත්ත වශයෙන්ම වැදගත් නොවේ.
2. වස්තු යොමු කරනු ලබන්නේ යොමු කිරීමෙනි (යොමුව අගය මගින් සම්මත වේ).

ශ්‍රිත තුළ ඇති සරල අගයන් ශ්‍රිතයෙන් පරිබාහිරව එම අගයන් වෙනස් නොකරනු ඇත (ඒවා අගය අනුව සම්මත වේ), නමුත් සංකීර්ණ ඒවා (ඒවා යොමු කිරීම මඟින් සම්මත වේ).

function willNotChange(x) {

    x = 1;
}

var x = 1000;

willNotChange(x);

document.write('After function call, x = ' + x + '<br>'); // Still 1000

function willChange(y) {

    y.num = 2;
}

var y = {num: 2000};

willChange(y);
document.write('After function call y.num = ' + y.num + '<br>'); // Now 2, not 2000