ජාවාස්ක්‍රිප්ට් හි බහු අගයන් ආපසු ලබා දෙනවාද?

මම ජාවාස්ක්‍රිප්ට් හි අගයන් දෙකක් ආපසු ලබා දීමට උත්සාහ කරමි . මෙය කළ හැකිද?

var newCodes = function() {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return dCodes, dCodes2;
};

නැත, නමුත් ඔබට ඔබේ අගයන් අඩංගු අරාවක් ආපසු ලබා දිය හැකිය:

function getValues() {
    return [getFirstValue(), getSecondValue()];
}

එවිට ඔබට ඒවාට ප්‍රවේශ විය හැකිය:

var values = getValues();
var first = values[0];
var second = values[1];

නවතම ECMAScript 6 සින්ටැක්ස් * සමඟ, ඔබට ප්‍රතිලාභ අගය වඩාත් බුද්ධිමත්ව විනාශ කළ හැකිය:

const [first, second] = getValues();

ආපසු ලබා දුන් එක් එක් අගයන් මත "ලේබල්" දැමීමට ඔබට අවශ්‍ය නම් (නඩත්තු කිරීමට පහසුය), ඔබට වස්තුවක් ආපසු ලබා දිය හැකිය:

function getValues() {
    return {
        first: getFirstValue(),
        second: getSecondValue(),
    };
}

ඒවාට ප්‍රවේශ වීම සඳහා:

var values = getValues();
var first = values.first;
var second = values.second;

හෝ ES6 සින්ටැක්ස් සමඟ:

const {first, second} = getValues();

^{* බ්‍රව්සරයේ අනුකූලතාව සඳහා මෙම වගුව බලන්න . මූලික වශයෙන්, IE හැරුණු කොට සියලුම නවීන බ්‍රව්සර් මෙම වාක්‍ය ඛණ්ඩයට සහය දක්වයි, නමුත් බාබෙල් වැනි මෙවලම් සමඟ ගොඩනඟන වේලාවේදී ඔබට ES6 කේතය IE- අනුකූල ජාවාස්ක්‍රිප්ට් දක්වා සම්පාදනය කළ හැකිය .}

ඔබට ECMAScript 6 සිට අරා සහ "පැවරුම් විනාශ කිරීම" භාවිතා කළ හැකිය . මේවා පැරණි ජාවාස්ක්‍රිප්ට් අනුවාදවල නොමැති බව සලකන්න (අර්ථය - ECMAScript 3 වන හෝ 5 වන සංස්කරණ සමඟ නොවේ).

එකවර 1+ විචල්‍යයන්ට පැවරීමට එය ඔබට ඉඩ දෙයි:

var [x, y] = [1, 2];
x; // 1
y; // 2

// or

[x, y] = (function(){ return [3, 4]; })();
x; // 3
y; // 4

වස්තුවක ප්‍රතිලාභ අගයන් නම් කිරීමට සහ ඔබට අවශ්‍ය ඒවා තෝරා ගැනීමට ඔබට දේපල වටිනාකම් කෙටිමං සමඟ ඒකාබද්ධව වස්තු විනාශ කිරීම භාවිතා කළ හැකිය :

let {baz, foo} = (function(){ return {foo: 3, bar: 500, baz: 40} })();
baz; // 40
foo; // 3

මාර්ගය වන විට, ECMAScript ඔබට ඉඩ දී ඇති බවට රැවටෙන්න එපා return 1, 2, .... එහි ඇත්ත වශයෙන්ම සිදුවන්නේ පෙනෙන දේ නොවේ. ආපසු ප්රකාශය ප්රකාශනයක් - 1, 2, 3- නමුත් මේ කිසිවක් කොමා ක්රියාකරු සංඛ්යාත්මක literals ඉල්ලුම් කර ( 1, 2සහ 3- අනුපිලිවෙලට, අවසානයේ එහි අවසාන ප්රකාශනය වටිනාකම අගය ලබා ගැනීම වන) 3. return 1, 2, 3ක්‍රියාකාරී ලෙස ඊට වඩා වැඩි යමක් සමාන වන්නේ එබැවිනි return 3.

return 1, 2, 3;
// becomes
return 2, 3;
// becomes
return 3;

වස්තුවක් වචනානුසාරයෙන් ආපසු එවන්න

function newCodes(){
    var dCodes = fg.codecsCodes.rs; // Linked ICDs  
    var dCodes2 = fg.codecsCodes2.rs; //Linked CPTs       
    return {
        dCodes: dCodes, 
        dCodes2: dCodes2
    };  
}


var result = newCodes();
alert(result.dCodes);
alert(result.dCodes2);

ES6 සිට ඔබට මෙය කළ හැකිය

let newCodes = function() {  
    const dCodes = fg.codecsCodes.rs
    const dCodes2 = fg.codecsCodes2.rs
    return {dCodes, dCodes2}
};

let {dCodes, dCodes2} = newCodes()

ප්‍රතිලාභ ප්‍රකාශනය {dCodes, dCodes2}යනු දේපල වටිනාකම කෙටිකාලීන වන අතර මෙයට සමාන වේ {dCodes: dCodes, dCodes2: dCodes2}.

අන්තිම පේළියේ මෙම පැවරුම වස්තු විනාශ කිරීමේ පැවරුම ලෙස හැඳින්වේ . එය වස්තුවක දේපල වටිනාකම උකහා ගෙන එය එකම නමක විචල්‍යයට පවරයි. විවිධ නාමවල විචල්‍යයන්ට ප්‍රතිලාභ අගයන් පැවරීමට ඔබ කැමති නම් ඔබට එය මේ ආකාරයෙන් කළ හැකියlet {dCodes: x, dCodes2: y} = newCodes()

එක්මාස්ක්‍රිප්ට් 6 හි “පැවරුම් විනාශ කිරීම” (කැන්ගක්ස් සඳහන් කළ පරිදි) ඇතුළත් වේ, එබැවින් සියලුම බ්‍රව්සර්වල (ෆයර්ෆොක්ස් පමණක් නොව) ඒවා අල්ලා ගැනීමේ එකම අරමුණ සඳහා නම් කරන ලද අරාවක් හෝ වස්තුවක් සෑදීමෙන් තොරව ඔබට වටිනාකම් රාශියක් ග්‍රහණය කර ගත හැකිය.

//so to capture from this function
function myfunction()
{
 var n=0;var s=1;var w=2;var e=3;
 return [n,s,w,e];
}

//instead of having to make a named array or object like this
var IexistJusttoCapture = new Array();
IexistJusttoCapture = myfunction();
north=IexistJusttoCapture[0];
south=IexistJusttoCapture[1];
west=IexistJusttoCapture[2];
east=IexistJusttoCapture[3];

//you'll be able to just do this
[north, south, west, east] = myfunction(); 

ඔබට දැනටමත් ෆයර්ෆොක්ස් හි එය අත්හදා බැලිය හැකිය!

අළුතින් හඳුන්වා දුන් (ඊඑස් 6) වාක්‍ය ඛණ්ඩය සඳහන් කළ යුතු තවත් කරුණක් නම්, පැවරුම් විනාශ කිරීමට අමතරව වස්තු නිර්මාණය කිරීමේ කෙටිමං භාවිතා කිරීමයි.

function fun1() {
  var x = 'a';
  var y = 'b';
  return { x, y, z: 'c' };
  // literally means { x: x, y: y, z: 'c' };
}

var { z, x, y } = fun1(); // order or full presence is not really important
// literally means var r = fun1(), x = r.x, y = r.y, z = r.z;
console.log(x, y, z);

මෙම සින්ටැක්ස් පැරණි බ්‍රව්සර් සඳහා බාබල් හෝ වෙනත් ජේඑස් පොලිෆිලර් සමඟ බහුකාර්ය කළ හැකි නමුත් වාසනාවකට මෙන් දැන් ක්‍රෝම් සහ ෆයර්ෆොක්ස් හි මෑත සංස්කරණ සමඟ දේශීයව ක්‍රියා කරයි.

නමුත් නව වස්තුවක් සෑදීමේදී, මතක වෙන් කිරීම (සහ අවසානයේ gc භාරය) මෙහි සම්බන්ධ වන බැවින්, එයින් වැඩි කාර්ය සාධනයක් බලාපොරොත්තු නොවන්න. කෙසේ වෙතත් ඉහළ ප්‍රශස්ත දේවල් සංවර්ධනය කිරීම සඳහා ජාවාස්ක්‍රිප්ට් හොඳම භාෂාව නොවන නමුත් එය අවශ්‍ය නම්, ඔබේ ප්‍රති result ලය අවට ඇති වස්තුවක් හෝ ජාවාස්ක්‍රිප්ට්, ජාවා සහ වෙනත් භාෂා අතර පොදු කාර්ය සාධන උපක්‍රම වන එවැනි ශිල්පීය ක්‍රම මත තැබීම සලකා බැලිය හැකිය.

මේ සඳහා හොඳම ක්‍රමය නම්

function a(){
     var d=2;
     var c=3;
     var f=4;
     return {d:d,c:c,f:f}
}

ඉන්පසු භාවිතා කරන්න

a().f

ආපසු 4

ES6 හි ඔබට මෙම කේතය භාවිතා කළ හැකිය

function a(){
      var d=2;
      var c=3;
      var f=4;
      return {d,c,f}
}

අනෙක් අය නිර්දේශ කර ඇති පරිදි අරාවක් හෝ වස්තුවක් ආපසු ලබා දීමට අමතරව, ඔබට එකතු කරන්නාගේ ශ්‍රිතයක් ද භාවිතා කළ හැකිය ( ද ලිට්ල් ස්කීමර් හි ඇති ආකාරයටම ):

function a(collector){
  collector(12,13);
}

var x,y;
a(function(a,b){
  x=a;
  y=b;
});

ක්‍රම තුනෙන් එකක් වේගවත් වන්නේ දැයි බැලීමට මම jsperf පරීක්ෂණයක් කළෙමි. අරාව වේගවත් වන අතර එකතු කරන්නා මන්දගාමී වේ.

http://jsperf.com/returning-multiple-values-2

JS හි, අපට පහසුවෙන් අරාව හෝ වස්තුවක් සහිත ටුපල් එකක් ආපසු ලබා දිය හැකිය, නමුත් අමතක නොකරන්න! => JS යනු callbackනැඹුරු භාෂාවක් වන අතර කිසිවෙකු මෙතෙක් සඳහන් කර නොමැති “බහු අගයන් ආපසු ලබා දීම” සඳහා මෙහි කුඩා රහසක් ඇත, මෙය උත්සාහ කරන්න:

var newCodes = function() {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return dCodes, dCodes2;
};

බවට පත්වේ

var newCodes = function(fg, cb) {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    cb(null, dCodes, dCodes2);
};

:)

බාම්! මෙය හුදෙක් ඔබේ ගැටලුව විසඳීමේ තවත් ක්‍රමයකි.

ජාවාස්ක්‍රිප්ට් හි බහු අගයන් නැවත ලබා දීමට ඉතා පොදු ක්‍රමයක් වන්නේ වස්තු වචනාර්ථය භාවිතා කිරීමයි , එබැවින් මෙවැනි දෙයක්:

const myFunction = () => {
  const firstName = "Alireza", 
        familyName = "Dezfoolian",
        age = 35;
  return { firstName, familyName, age};
}

මේ වගේ අගයන් ලබා ගන්න:

myFunction().firstName; //Alireza
myFunction().familyName; //Dezfoolian
myFunction().age; //age

හෝ කෙටි ක්‍රමයක්:

const {firstName, familyName, age} = myFunction();

ඒවා තනි තනිව ලබා ගන්න:

firstName; //Alireza
familyName; //Dezfoolian
age; //35

සෙවුම් ප්‍රති .ලවල එන බැවින් මෙම ප්‍රශ්නය සම්පූර්ණ සම්පතක් බවට පත් කිරීම සඳහා නැතිවූ වැදගත් කොටස් එකතු කිරීම.

වස්තු විනාශ කිරීම

වස්තු විනාශ කිරීමේදී, ඔබේ විචල්‍ය නාමයට සමාන යතුරු අගයක් භාවිතා කිරීම අවශ්‍ය නොවේ, පහත දැක්වෙන පරිදි අර්ථ දැක්වීමෙන් ඔබට වෙනත් විචල්‍ය නාමයක් පැවරිය හැකිය:

const newCodes = () => {  
    let dCodes = fg.codecsCodes.rs;
    let dCodes2 = fg.codecsCodes2.rs;
    return { dCodes, dCodes2 };
};

//destructuring
let { dCodes: code1, dCodes2: code2 } = newCodes();

//now it can be accessed by code1 & code2
console.log(code1, code2);

අරා විනාශ කිරීම

අරාව විනාශ කිරීමේදී, ඔබට අවශ්‍ය නොවන අගයන් මඟ හැරිය හැක.

const newCodes = () => {  
    //...
    return [ dCodes, dCodes2, dCodes3 ];
};

let [ code1, code2 ] = newCodes(); //first two items
let [ code1, ,code3 ] = newCodes(); //skip middle item, get first & last
let [ ,, code3 ] = newCodes(); //skip first two items, get last
let [ code1, ...rest ] = newCodes(); //first item, and others as an array

...restඅනෙක් සියල්ල එකතු වූ පසු කිසිවක් විනාශ කිරීමට තේරුමක් නැති බැවින් එය සැමවිටම අවසානයේ තිබිය යුතු බව වටහා ගැනීම වටීrest .

මෙය මෙම ප්‍රශ්නයට යම් වටිනාකමක් එක් කරනු ඇතැයි මම බලාපොරොත්තු වෙමි :)

ඔබට ද කළ හැකිය:

function a(){
  var d=2;
  var c=3;
  var f=4;
  return {d:d,c:c,f:f}
}

const {d,c,f} = a()

ඔබට "වස්තුව" භාවිතා කළ හැකිය

function newCodes(){
    var obj= new Object();
    obj.dCodes = fg.codecsCodes.rs;
    obj.dCodes2 = fg.codecsCodes2.rs;

    return obj;
}

සියල්ල නිවැරදිය. returnතාර්කිකව වමේ සිට දකුණට ක්‍රියාවට නංවන අතර අවසාන අගය ලබා දෙයි.

function foo(){
    return 1,2,3;
}

>> foo()
>> 3

නවතම විනාශකාරී පැවරුම භාවිතා කිරීමට මම යෝජනා කරමි (නමුත් එය ඔබගේ පරිසරය තුළ සහය දක්වන බවට වග බලා ගන්න )

var newCodes = function () {
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return {firstCodes: dCodes, secondCodes: dCodes2};
};
var {firstCodes, secondCodes} = newCodes()

මෙය කිරීමට ක්‍රම දෙකක් මම දනිමි: 1. අරාව ලෙස ආපසු යන්න 2. වස්තුව ලෙස ආපසු යන්න

මෙන්න මම සොයාගත් උදාහරණයක්:

<script>
// Defining function
function divideNumbers(dividend, divisor){
    var quotient = dividend / divisor;
    var arr = [dividend, divisor, quotient];
    return arr;
}

// Store returned value in a variable
var all = divideNumbers(10, 2);

// Displaying individual values
alert(all[0]); // 0utputs: 10
alert(all[1]); // 0utputs: 2
alert(all[2]); // 0utputs: 5
</script>



<script>
// Defining function
function divideNumbers(dividend, divisor){
    var quotient = dividend / divisor;
    var obj = {
        dividend: dividend,
        divisor: divisor,
        quotient: quotient
    };
    return obj;
}

// Store returned value in a variable
var all = divideNumbers(10, 2);

// Displaying individual values
alert(all.dividend); // 0utputs: 10
alert(all.divisor); // 0utputs: 2
alert(all.quotient); // 0utputs: 5
</script>

දින කිහිපයකට පෙර මා විසින් නිර්මාණය කරන ලද ශ්‍රිතයකින් බහු ප්‍රතිලාභ අගයන් ලබා ගැනීමේ සමාන අවශ්‍යතාවයක් මට තිබුණි.

බොහෝ ප්‍රතිලාභ අගයන්ගෙන්, මට අවශ්‍ය වූයේ යම් කොන්දේසියක් සඳහා නිශ්චිත අගයක් පමණක් ලබා දීම සහ වෙනත් කොන්දේසියකට අනුරූපව වෙනත් ප්‍රතිලාභ අගය පමණි.

මෙන්න මම එය කළ ආකාරය පිළිබඳ උදාහරණය:

කාර්යය:

function myTodayDate(){
    var today = new Date();
    var day = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
    var month = ["January","February","March","April","May","June","July","August","September","October","November","December"];
    var myTodayObj = 
    {
        myDate : today.getDate(),
        myDay : day[today.getDay()],
        myMonth : month[today.getMonth()],
        year : today.getFullYear()
    }
    return myTodayObj;
}

ශ්‍රිතය මඟින් ආපසු ලබා දුන් වස්තුවෙන් අවශ්‍ය ප්‍රතිලාභ අගය ලබා ගැනීම:

var todayDate = myTodayDate().myDate;
var todayDay = myTodayDate().myDay;
var todayMonth = myTodayDate().myMonth;
var todayYear = myTodayDate().year;

මෙම ප්‍රශ්නයට පිළිතුරු සැපයීමේ සම්පූර්ණ කරුණ නම් දිනය හොඳ ආකෘතියකින් ලබා ගැනීමේ මෙම ප්‍රවේශය බෙදා ගැනීමයි. එය ඔබට උදව් කළා යැයි සිතමි :)

මම මෙහි අලුත් දෙයක් එකතු කිරීම මිස වෙනත් විකල්ප ක්‍රමයක් නොවේ.

 var newCodes = function() {
     var dCodes = fg.codecsCodes.rs;
     var dCodes2 = fg.codecsCodes2.rs;
     let [...val] = [dCodes,dCodes2];
     return [...val];
 };

හොඳයි, ඔබේ උත්සාහය අපට හරියටම කළ නොහැක. නමුත් පහතින් ඇති දෙයක් කළ හැකිය.

function multiReturnValues(){
    return {x:10,y:20};
}

ඉන්පසු ක්‍රමය අමතන විට

const {x,y} = multiReturnValues();

console.log(x) ---> 10
console.log(y) ---> 20

`$ {}` අච්චු වචන භාවිතා කරමින් බොහෝ අගයන් සහ විචල්‍යයන් සහිත නූලක් ආපසු ලබා දිය හැකිය

මෙන්:

var newCodes = function() {  
    var dCodes = fg.codecsCodes.rs;
    var dCodes2 = fg.codecsCodes2.rs;
    return `${dCodes}, ${dCodes2}`;
};

එය කෙටි හා සරල ය.