ජාවාස්ක්‍රිප්ට් ශ්‍රිතයක් සඳහා පෙරනිමි පරාමිති අගයක් සකසන්න

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

def read_file(file, delete_after = false)
  # code
end

මෙය ජාවාස්ක්‍රිප්ට් හි ක්‍රියාත්මක වේද?

function read_file(file, delete_after = false) {
  // Code
}

ES6 / ES2015 සිට , පෙරනිමි පරාමිතීන් භාෂා පිරිවිතරයේ ඇත.

function read_file(file, delete_after = false) {
  // Code
}

වැඩ කරනවා.

යොමුව: පෙරනිමි පරාමිතීන් - MDN

පෙරනිමි ශ්‍රිත පරාමිතීන් කිසිදු අගයක් හෝ නිර්වචනය කර නොමැති නම් විධිමත් පරාමිතීන් පෙරනිමි අගයන් සමඟ ආරම්භ කිරීමට ඉඩ දෙයි .

විනාශ කිරීම හරහා ඔබට පෙරනිමි නම් කළ පරාමිතීන් අනුකරණය කළ හැකිය :

// the `= {}` below lets you call the function without any parameters
function myFor({ start = 5, end = 1, step = -1 } = {}) { // (A)
    // Use the variables `start`, `end` and `step` here
    ···
}

පෙර ES2015 ,

ක්‍රම රාශියක් ඇත, නමුත් මෙය මා වඩාත් කැමති ක්‍රමයයි - එය ව්‍යාජ හෝ ශුන්‍ය ඇතුළුව ඔබට අවශ්‍ය ඕනෑම දෙයක් සමත් වීමට ඉඩ සලසයි. ( typeof null == "object")

function foo(a, b) {
  a = typeof a !== 'undefined' ? a : 42;
  b = typeof b !== 'undefined' ? b : 'default_b';
  ...
}

function read_file(file, delete_after) {
    delete_after = delete_after || "my default here";
    //rest of code
}

මෙම පැවරුම් delete_afterවටිනාකම delete_afterඑය නොවේ නම් falsey එය වැල පවරයි එසේ අගය "my default here". වැඩි විස්තර සඳහා, ඩග් ක්‍රොක්ෆර්ඩ්ගේ භාෂාව පිළිබඳ සමීක්ෂණය බලන්න සහ ක්‍රියාකරුවන් පිළිබඳ කොටස බලන්න .

මෙම ප්රවේශය නැහැ ඔයා සමත් කිරීමට අවශ්ය නම් වැඩ කරන්නේ falsey අගය එනම් false, null, undefined, 0හෝ "". ඔබට අවශ්ය නම්, falsey ඔබ සම්මත කිරීමට වටිනාකම් ක්රමය භාවිතා කිරීමට අවශ්ය වනු ඇත ටොම් Ritter පිළිතුර .

ශ්‍රිතයකට පරාමිති ගණනාවක් සමඟ කටයුතු කරන විට, බොහෝ විට පාරිභෝගිකයාට වස්තුවක පරාමිති තර්ක සම්මත කිරීමට ඉඩ දීම සහ පසුව ශ්‍රිතය සඳහා පෙරනිමි අගයන් අඩංගු වස්තුවක් සමඟ මෙම අගයන් ඒකාබද්ධ කිරීම ප්‍රයෝජනවත් වේ.

function read_file(values) {
    values = merge({ 
        delete_after : "my default here"
    }, values || {});

    // rest of code
}

// simple implementation based on $.extend() from jQuery
function merge() {
    var obj, name, copy,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length;

    for (; i < length; i++) {
        if ((obj = arguments[i]) != null) {
            for (name in obj) {
                copy = obj[name];

                if (target === copy) {
                    continue;
                }
                else if (copy !== undefined) {
                    target[name] = copy;
                }
            }
        }
    }

    return target;
};

භාවිතා කිරීමට

// will use the default delete_after value
read_file({ file: "my file" }); 

// will override default delete_after value
read_file({ file: "my file", delete_after: "my value" }); 

පෞද්ගලිකව වඩා සංක්ෂිප්ත හා කියවිය හැකි මේ වගේ සරල දෙයක් මට පෙනේ.

function pick(arg, def) {
   return (typeof arg == 'undefined' ? def : arg);
}

function myFunc(x) {
  x = pick(x, 'my default');
} 

ECMAScript 6 හි ඔබට ඇත්ත වශයෙන්ම ඔබ සතුව ඇති දේ හරියටම ලිවීමට හැකි වනු ඇත:

function read_file(file, delete_after = false) {
  // Code
}

මෙය නොපවතී නම් මෙය සකසනු delete_afterඇත . අද ඔබට බාබෙල් වැනි ප්‍රවාහකයන් සමඟ මෙවැනි ES6 විශේෂාංග භාවිතා කළ හැකිය .falseundefined

වැඩි විස්තර සඳහා MDN ලිපිය බලන්න .

පෙරනිමි පරාමිති අගයන්

ES6 සමඟ, JavaScriptශ්‍රිත පරාමිතියක් සඳහා පෙරනිමි අගයක් සැකසීමට අදාළව ඔබට වඩාත් පොදු මෝඩයන්ගෙන් එකක් කළ හැකිය . අපි වසර ගණනාවක් තිස්සේ මෙය කර ඇති ආකාරය හුරුපුරුදු විය යුතුය:

function foo(x,y) {
 x = x || 11;
 y = y || 31;
 console.log( x + y );
}
foo(); // 42
foo( 5, 6 ); // 11
foo( 5 ); // 36
foo( null, 6 ); // 17

මෙම රටාව වැඩිපුරම භාවිතා වන නමුත් අප වැනි අගයන් පසු කරන විට එය භයානක ය

foo(0, 42)
foo( 0, 42 ); // 53 <-- Oops, not 42

මන්ද? මක්නිසාද යත් 0 is falsy, x || 11 results in 11කෙලින්ම 0 දී සම්මත නොවූ නිසා ය . මෙම ගොචා නිවැරදි කිරීම සඳහා, සමහර අය ඒ වෙනුවට චෙක්පත වඩාත් වාචිකව ලියනු ඇත:

function foo(x,y) {
 x = (x !== undefined) ? x : 11;
 y = (y !== undefined) ? y : 31;
 console.log( x + y );
}
foo( 0, 42 ); // 42
foo( undefined, 6 ); // 17

ES6නැතිවූ තර්ක සඳහා පෙරනිමි අගයන් පැවරීම විධිමත් කිරීම සඳහා එකතු කරන ලද හොඳ ප්‍රයෝජනවත් වාක්‍ය ඛණ්ඩයක් දැන් අපට පරීක්ෂා කළ හැකිය :

function foo(x = 11, y = 31) {
 console.log( x + y );
}

foo(); // 42
foo( 5, 6 ); // 11
foo( 0, 42 ); // 42
foo( 5 ); // 36
foo( 5, undefined ); // 36 <-- `undefined` is missing
foo( 5, null ); // 5 <-- null coerces to `0`
foo( undefined, 6 ); // 17 <-- `undefined` is missing
foo( null, 6 ); // 6 <-- null coerces to `0`

x = 11ශ්‍රිත ප්‍රකාශනයක x !== undefined ? x : 11දී වඩාත් පොදු මෝඩයට වඩා සමාන යx || 11

පෙරනිමි අගය ප්‍රකාශන

Functionපෙරනිමි අගයන් 31 වැනි සරල අගයන්ට වඩා වැඩි විය හැකිය; ඒවා ඕනෑම වලංගු ප්‍රකාශනයක් විය හැකිය, a function call:

function bar(val) {
 console.log( "bar called!" );
 return y + val;
}
function foo(x = y + 3, z = bar( x )) {
 console.log( x, z );
}
var y = 5;
foo(); // "bar called"
 // 8 13
foo( 10 ); // "bar called"
 // 10 15
y = 6;
foo( undefined, 10 ); // 9 10

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

පෙරනිමි අගය ප්‍රකාශනය පේළිගත ශ්‍රිත ප්‍රකාශන ඇමතුමක් විය හැකිය - පොදුවේ හැඳින්වෙන්නේ ක්ෂණිකව ආයාචිත ශ්‍රිත ප්‍රකාශනය ලෙස ය (IIFE):

function foo( x =
 (function(v){ return v + 11; })( 31 )
) {
 console.log( x );
}
foo(); // 42

එම විසඳුම js හි මට වැඩකි:

function read_file(file, delete_after) {
    delete_after = delete_after || false;
    // Code
}

නිර්වචනය නොකළ පැහැදිලි සංසන්දනයක් භාවිතා කරන්න.

function read_file(file, delete_after)
{
    if(delete_after === undefined) { delete_after = false; }
}

ජාවාස්ක්‍රිප්ට් හි පෙරනිමි පරාමිති අගයන් භාවිතා කිරීමේදී මම අතිශයින්ම ප්‍රවේශම් වන්නෙමි. වැනි ඉහළ ගණයේ කාර්යයන් සමඟ එක්ව භාවිතා කරන විට එය බොහෝ විට දෝෂ නිර්මාණය forEach, mapහා reduce. උදාහරණයක් ලෙස, මෙම කේත රේඛාව සලකා බලන්න:

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

parseInt හට විකල්ප දෙවන පරාමිති function parseInt(s, [රේඩික්ස් ඇත,=10]) නමුත් සිතියම් parseIntතර්ක තුනක් සමඟ අමතයි : ( මූලද්‍රව්‍යය , දර්ශකය සහ අරාව ).

ඔබේ විකල්ප / පෙරනිමි වටිනා තර්ක වලින් ඔබට අවශ්‍ය පරාමිතීන් වෙන් කිරීමට මම යෝජනා කරමි. පෙරනිමි අගයක් තේරුමක් නැති ඔබේ ශ්‍රිතය අවශ්‍ය පරාමිති 1,2 ක් හෝ 3 ක් ගනී නම්, ඒවා ශ්‍රිතයට ස්ථානීය පරාමිතීන් බවට පත් කරන්න, ඕනෑම විකල්ප පරාමිතියක් තනි වස්තුවක නම් කළ ගුණාංග ලෙස අනුගමනය කළ යුතුය. ඔබේ ශ්‍රිතයට 4 ක් හෝ ඊට වැඩි කාලයක් ගත වුවහොත්, සමහර වස්තු පරාමිතිවල ගුණාංග හරහා සියලු තර්ක සැපයීම අර්ථවත් කරයි.

ඔබේ නඩුව මම ඔයාට මේ වගේ ඔබේ deleteFile කාර්යය ලියන්න යෝජනා කරන්නේ: ( එක් සංස්කරණය instead ගේ අදහස් ) ...

// unsafe
function read_file(fileName, deleteAfter=false) {
    if (deleteAfter) {
        console.log(`Reading and then deleting ${fileName}`);
    } else {
        console.log(`Just reading ${fileName}`);
    }
}

// better
function readFile(fileName, options) {
  const deleteAfter = !!(options && options.deleteAfter === true);
  read_file(fileName, deleteAfter);
}

console.log('unsafe...');
['log1.txt', 'log2.txt', 'log3.txt'].map(read_file);

console.log('better...');
['log1.txt', 'log2.txt', 'log3.txt'].map(readFile);

ඉහත ස්නිපටය ධාවනය කිරීමෙන් නිරූපණය වන්නේ භාවිතයට නොගත් පරාමිතීන් සඳහා පෙරනිමි තර්ක අගයන් පිටුපස සැඟවී ඇති අන්තරායන් ය.

යාවත්කාලීනයක් ලෙස ... ECMAScript 6 සමඟින් ඔබට ක්‍රියා පරාමිති ප්‍රකාශනයන්හි පෙරනිමි අගයන් අවසාන වශයෙන් සැකසිය හැකිය :

function f (x, y = 7, z = 42) {
  return x + y + z
}

f(1) === 50

සඳහන් කර ඇති පරිදි - http://es6-features.org/#DefaultParameterValues

දීර් ++ කාලයක් C ++ සංවර්ධකයෙකු වීම (වෙබ් සංවර්ධනයට රූකි :)), මම මෙම තත්වය මුලින්ම හමු වූ විට, පහත දැක්වෙන පරිදි, ප්‍රශ්නයේ සඳහන් කර ඇති පරිදි, ශ්‍රිත අර්ථ දැක්වීමේ පරාමිති පැවරුම මම කළෙමි.

function myfunc(a,b=10)

නමුත් එය බ්‍රව්සර් හරහා නිරන්තරයෙන් ක්‍රියාත්මක නොවන බවට පරිස්සම් වන්න. මට එය මගේ ඩෙස්ක්ටොප් එකේ ක්‍රෝම් මත වැඩ කළ නමුත් ඇන්ඩ්‍රොයිඩ් හි ක්‍රෝම් මත ක්‍රියා කළේ නැත. බොහෝ දෙනා ඉහත සඳහන් කළ පරිදි ආරක්ෂිත විකල්පය නම් -

    function myfunc(a,b)
    {
    if (typeof(b)==='undefined') b = 10;
......
    }

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

මයික්‍රොසොෆ්ට් එජ් හි කේත වැඩ කිරීමට කැමති ඕනෑම කෙනෙකුට, ක්‍රියාකාරී පරාමිතීන් තුළ පෙරනිමි භාවිතා නොකරන්න.

function read_file(file, delete_after = false) {
    #code
}

එම උදාහරණයේ දී එඩ්ජ් විසින් "අපේක්ෂා කිරීම") ""

මෙම භාවිතය වළක්වා ගැනීමට

function read_file(file, delete_after) {
  if(delete_after == undefined)
  {
    delete_after = false;
  }
  #code
}

2016 අගෝස්තු 08 වන විට මෙය තවමත් ගැටළුවක්

වාක්‍ය ඛණ්ඩයට අනුව

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

විධිමත් පරාමිතීන්ගේ පෙරනිමි අගය ඔබට අර්ථ දැක්විය හැකිය. ටයිප් ඔෆ් ශ්‍රිතය භාවිතයෙන් නිර්වචනය නොකළ අගය ද පරීක්ෂා කරන්න .

function helloWorld(name, symbol = '!!!') {
    name = name || 'worlds';
    console.log('hello ' + name + symbol);
}

helloWorld(); // hello worlds!!!

helloWorld('john'); // hello john!!!

helloWorld('john', '(>.<)'); // hello john(>.<)

helloWorld('john', undefined); // hello john!!!

helloWorld(undefined, undefined); // hello worlds!!!

ඔබට නවතම ECMA6සින්ටැක්ස් භාවිතා කිරීමට අවශ්‍ය නම් මෙය භාවිතා කරන්න :

function myFunction(someValue = "This is DEFAULT!") {
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

එය හැඳින්වේ default function parameters. කිසිදු අගයක් හෝ නිර්වචනය කර නොමැති නම් විධිමත් පරාමිතීන් පෙරනිමි අගයන් සමඟ ආරම්භ කිරීමට එය ඉඩ දෙයි. සටහන : එය ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හෝ පැරණි බ්‍රව්සර් සමඟ ක්‍රියා නොකරයි.

හැකි උපරිම අනුකූලතාව සඳහා මෙය භාවිතා කරන්න:

function myFunction(someValue) {
  someValue = (someValue === undefined) ? "This is DEFAULT!" : someValue;
  console.log("someValue --> ", someValue);
}

myFunction("Not A default value") // calling the function without default value
myFunction()  // calling the function with default value

මෙම එක් එක් උදාහරණය රඳා පවතින්නේ එම ශ්‍රිතය ඇමතීමේදී undefinedකිසිදු පරාමිති අගයක් සම්මත නොකළේ නම් පරාමිති විචල්‍යය වනු ඇති බැවිනි .

ES6: බොහෝ පිළිතුරු වල දැනටමත් සඳහන් කර ඇති පරිදි, ES6 හි, ඔබට සරලවම අගය සමඟ පරාමිතියක් ආරම්භ කළ හැකිය.

ES5: දී ඇති පිළිතුරු බොහොමයක් මම එහිදී වැනි falsey වටිනාකම් සමත් වීමට සිදු විය හැකිය අවස්ථා නැති නිසා මට නොවේ ප්රමානවත් වේ 0, nullහා undefinedඋත්සවයකට කිරීමට. පරාමිතියක් නිර්වචනය කර නොමැතිද යන්න තීරණය කිරීම සඳහා එය නිර්වචනය නොකිරීම වෙනුවට මා සම්මත කළ අගයයි.

function foo (param1, param2) {
   param1 = arguments.length >= 1 ? param1 : "default1";
   param2 = arguments.length >= 2 ? param2 : "default2";
}

function throwIfNoValue() {
throw new Error('Missing argument');
}
function foo(argValue = throwIfNoValue()) {
return argValue ;
}

මෙහිදී foo () යනු argValue නම් පරාමිතියක් ඇති ශ්‍රිතයකි. ශ්‍රිත ඇමතුමෙහි අප කිසිවක් සමත් නොවන්නේ නම්, එවිට ශ්‍රිතය විසි කිරීම ඉෆ්නෝවාලූ () කැඳවනු ලබන අතර ලැබෙන ප්‍රති result ලය එකම තර්කය වන ආර්ග් අගය වෙත පවරනු ලැබේ. පෙරනිමි පරාමිතියක් ලෙස ශ්‍රිත ඇමතුමක් භාවිතා කළ හැකි ආකාරය මෙයයි. එමඟින් කේතය වඩාත් සරල හා කියවිය හැකි වේ.

මෙම උදාහරණය මෙතැනින් ගෙන ඇත

ඔබ භාවිතා කරන්නේ නම් ඔබට ES6+පෙරනිමි පරාමිතීන් පහත පරිදි සැකසිය හැකිය:

function test (foo = 1, bar = 2) {
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

ඔබට ES5සින්ටැක්ස් අවශ්‍ය නම් ඔබට එය පහත පරිදි කළ හැකිය:

function test(foo, bar) {
  foo = foo || 2;
  bar = bar || 0;
  
  console.log(foo, bar);
}

test(5); // foo gets overwritten, bar remains default parameter

ඉහත වාක්‍ය ඛණ්ඩය තුළ ORක්‍රියාකරු භාවිතා වේ. මෙම ORමෙම පරිවර්තනය කළ හැකි නම් ක්රියාකරු හැම විටම පළමු අගය නැවත trueඑය righthandside අගය ආපහු නම්. අනුරූප තර්කයක් නොමැතිව ශ්‍රිතය කැඳවූ විට පරාමිති විචල්‍යය ( barඅපගේ උදාහරණයේ) undefinedJS එන්ජිම මඟින් සකසා ඇත . undefinedපසුව එය සාවද්‍ය බවට පරිවර්තනය වන අතර එමඟින් ORක්‍රියාකරු 0 අගය ලබා දෙයි.

ඔව්, පෙරනිමි පරාමිතීන් භාවිතා කිරීම ES6 හි පූර්ණ සහය දක්වයි :

function read_file(file, delete_after = false) {
  // Code
}

හෝ

const read_file = (file, delete_after = false) => {
    // Code
}

නමුත් ES5 ට පෙර ඔබට මෙය පහසුවෙන් කළ හැකිය:

function read_file(file, delete_after) {
  var df = delete_after || false;
  // Code
}

එයින් අදහස් වන්නේ අගය තිබේ නම්, අගය භාවිතා කරන්න, එසේ නොමැති නම්, ||මෙහෙයුමෙන් පසු දෙවන අගය එකම දේ කරන ...

සටහන: එසේම ඔබ ES6 එකක් වෙත වටිනාකමක් ලබා දුන්නොත් ඒවා අතර විශාල වෙනසක් ඇත, එහි වටිනාකම පවා ව්‍යාජ වේ, එය නව අගයක් මගින් ප්‍රතිස්ථාපනය වේ, වැනි දෙයක් nullහෝ ""... නමුත් ES5 එකක් ප්‍රතිස්ථාපනය වන්නේ සම්මත අගය පමණක් නම් පමණි සත්‍යය, එයට හේතුව ||වැඩ කරන ආකාරයයි ...

යම් හේතුවක් නිසා නම්, ඔබ නොවන ES6 හා ඇත භාවිතා lodashමෙතන හරහා කාර්යයන් සඳහා වන පරාමිතීන් පැහර සංක්ෂිප්ත ක්රමයකි _.defaultToක්රමය:

var fn = function(a, b) {
  a = _.defaultTo(a, 'Hi')
  b = _.defaultTo(b, 'Mom!')

  console.log(a, b)
}

fn()                 // Hi Mom!
fn(undefined, null)  // Hi Mom!
fn(NaN, NaN)         // Hi Mom!
fn(1)                // 1 "Mom!"
fn(null, 2)          // Hi 2
fn(false, false)     // false false
fn(0, 2)             // 0 2

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

වත්මන් අගය NaN , ශුන්‍ය හෝ නිර්වචනය නොකළහොත් පෙරනිමිය සැකසෙනු ඇත

අනාගත ශබ්ද

අනාගතයේ දී, ඔබට එක් වස්තුවක් තවත් වස්තුවකට "පැතිරවීමට" හැකි වනු ඇත (දැනට 2019 වන විට එඩ්ජ් සහාය නොදක්වයි !) - ඇණවුම නොසලකා හොඳ පෙරනිමි විකල්ප සඳහා එය භාවිතා කරන්නේ කෙසේද යන්න නිරූපණය කරන්න:

function test(options) {
    var options = {
       // defaults
       url: 'defaultURL',
       some: 'somethingDefault',
       // override with input options
       ...options
    };
    
    var body = document.getElementsByTagName('body')[0];
    body.innerHTML += '<br>' + options.url + ' : ' + options.some;
}
test();
test({});
test({url:'myURL'});
test({some:'somethingOfMine'});
test({url:'overrideURL', some:'andSomething'});
test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

MDN යොමුව: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Sread_syntax

... මේ අතර එඩ්ජ්ගේ සහාය වන්නේ Object.assign () (IE එසේ නොවේ, නමුත් මම විශ්වාස කරනවා අපට IE අතහැර දැමිය හැකිය :))

ඒ හා සමානව ඔබට කළ හැකිය

    function test(options) {
        var options = Object.assign({
           // defaults
           url: 'defaultURL',
           some: 'somethingDefault',
        }, options); // override with input options
        
        var body = document.getElementsByTagName('body')[0];
        body.innerHTML += '<br>' + options.url + ' : ' + options.some;
    }
    test();
    test({});
    test({url:'myURL'});
    test({some:'somethingOfMine'});
    test({url:'overrideURL', some:'andSomething'});
    test({url:'overrideURL', some:'andSomething', extra:'noProblem'});

සංස්කරණය: හේතුවෙන් සම්බන්ධයෙන් අදහස් දක්වා constවිකල්ප - එම ශ්රිතයේ සෙසු ප්රදේශවල නිරන්තර විකල්ප භාවිතා කර ඇති ප්රශ්නය සත්ය වන නොවේ වනු ඔබ - ඔබ ඒක කරන්න නොහැකි බව, ඔබ එහි ම ප්රකාශ තුල නිරන්තර විචල්ය භාවිතා කළ නොහැකි පමණක් බව ය ආදාන නම් කිරීම වැනි දෙයකට වෙනස් කිරීමට

function test(input_options){
   const options = {
     // defaults
     someKey:    'someDefaultValue',
     anotherKey: 'anotherDefaultValue',

     // merge-in input options
     ...input_options
   };

   // from now on use options with no problem
}

මගේ කුසලතා ප්‍රදර්ශනය කිරීම සඳහා (lol), ඉහත ශ්‍රිතය පහත පරිදි නම් නොකර තර්ක ලිවිය හැකිය:

ES5 සහ ඊට වැඩි

function foo() {
    a = typeof arguments[0] !== 'undefined' ? a : 42;
    b = typeof arguments[1] !== 'undefined' ? b : 'default_b';
    ...
}

ES6 සහ ඊට වැඩි

function foo(...rest) {
    a = typeof rest[0] !== 'undefined' ? a : 42;
    b = typeof rest[1] !== 'undefined' ? b : 'default_b';
    ...
}

def read_file(file, delete_after = false)
  # code
end

ECMAScript 6 (ES6) මෙන්ම පෙර සංස්කරණ ද ඇතුළුව පහත දැක්වෙන කේතය මෙම තත්වය තුළ ක්‍රියා කළ හැකිය.

function read_file(file, delete_after) {
    if(delete_after == undefined)
        delete_after = false;//default value

    console.log('delete_after =',delete_after);
}
read_file('text1.txt',true);
read_file('text2.txt');

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

ඔව් මෙය පෙරනිමි පරාමිතියක් ලෙස හැඳින්වේ

පෙරනිමි ශ්‍රිත පරාමිතීන් කිසිදු අගයක් හෝ නිර්වචනය කර නොමැති නම් විධිමත් පරාමිතීන් පෙරනිමි අගයන් සමඟ ආරම්භ කිරීමට ඉඩ දෙයි.

වාක්‍ය ඛණ්ඩය:

function [name]([param1[ = defaultValue1 ][, ..., paramN[ = defaultValueN ]]]) {
   statements
}

විස්තර:

ශ්‍රිතවල පරාමිතීන් පෙරනිමියෙන් නිර්වචනය කර නැත කෙසේ වෙතත්, අවස්ථා වලදී වෙනස් පෙරනිමි අගයක් සැකසීම ප්‍රයෝජනවත් විය හැකිය. පෙරනිමි පරාමිතීන් උදව් කළ හැකි ස්ථානය මෙයයි.

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

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

වෙනස්කම් සඳහා උදාහරණය:

// OLD METHOD
function multiply(a, b) {
  b = (typeof b !== 'undefined') ?  b : 1;
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5


// NEW METHOD
function multiply(a, b = 1) {
  return a * b;
}

multiply(5, 2); // 10
multiply(5, 1); // 5
multiply(5);    // 5

විවිධ සින්ටැක්ස් උදාහරණ:

වෙනත් ව්‍යාජ අගයන්ට එරෙහිව නිර්වචනය නොකළ පැඩින් කිරීම:

ඇමතීමේදී අගය පැහැදිලිවම සකසා තිබුණද, සංඛ්‍යා තර්කයේ අගය පෙරනිමිය වේ.

function test(num = 1) {
  console.log(typeof num);
}

test();          // 'number' (num is set to 1)
test(undefined); // 'number' (num is set to 1 too)

// test with other falsy values:
test('');        // 'string' (num is set to '')
test(null);      // 'object' (num is set to null)

ඇමතුම් වේලාවේදී ඇගයීම:

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

function append(value, array = []) {
  array.push(value);
  return array;
}

append(1); //[1]
append(2); //[2], not [1, 2]


// This even applies to functions and variables
function callSomething(thing = something()) {
 return thing;
}

function something() {
  return 'sth';
}

callSomething();  //sth

පෙරනිමි පරාමිතීන් පසුකාලීන පෙරනිමි පරාමිතීන් සඳහා ලබා ගත හැකිය:

දැනටමත් හමු වී ඇති පරාමිතීන් පසුකාලීන පෙරනිමි පරාමිතීන් සඳහා ලබා ගත හැකිය

function singularAutoPlural(singular, plural = singular + 's',
                        rallyingCry = plural + ' ATTACK!!!') {
  return [singular, plural, rallyingCry];
}

//["Gecko","Geckos", "Geckos ATTACK!!!"]
singularAutoPlural('Gecko');

//["Fox","Foxes", "Foxes ATTACK!!!"]
singularAutoPlural('Fox', 'Foxes');

//["Deer", "Deer", "Deer ... change."]
singularAutoPlural('Deer', 'Deer', 'Deer peaceably and respectfully \ petition the government for positive change.')

ක්‍රියාකාරී ශරීරය තුළ අර්ථ දක්වා ඇති කාර්යයන්:

හූනන් 33 හි හඳුන්වා දී ඇත (ෆයර්ෆොක්ස් 33 / තණ්ඩර්බර්ඩ් 33 / සීමොන්කි 2.30). ශ්‍රිත ශරීරයේ ප්‍රකාශිත කාර්යයන් පෙරනිමි පරාමිතීන් තුළ සඳහන් කළ නොහැකි අතර විමර්ශන දෝෂයක් විසි කරන්න (දැනට ස්පයිඩර් මොන්කි හි ටයිප් එර්රර්, දෝෂ 1022967 බලන්න). පෙරනිමි පරාමිතීන් සෑම විටම පළමුව ක්‍රියාත්මක කරනු ලැබේ, ශ්‍රිත ශරීරය තුළ ක්‍රියාකාරී ප්‍රකාශන පසුව ඇගයීමට ලක් කරයි.

// Doesn't work! Throws ReferenceError.
function f(a = go()) {
  function go() { return ':P'; }
}

පෙරනිමි පරාමිතීන් පසු පෙරනිමි රහිත පරාමිතීන්:

හූනන් 26 ට පෙර (ෆයර්ෆොක්ස් 26 / තණ්ඩර්බර්ඩ් 26 / සීමොන්කි 2.23 / ෆයර්ෆොක්ස් ඕඑස් 1.2), පහත කේතය සින්ටැක්ස් දෝෂයක් ඇති කිරීමට හේතු විය. මෙය දෝෂ 777060 හි සවි කර ඇති අතර පසුකාලීන අනුවාද වල අපේක්ෂිත පරිදි ක්‍රියා කරයි. පරාමිතීන් තවමත් වමේ සිට දකුණට සකසා ඇති අතර පෙරනිමි පරාමිතීන් පෙරනිමියෙන් තොරව වුවද නැවත ලියයි.

function f(x = 1, y) {
  return [x, y];
}

f(); // [1, undefined]
f(2); // [2, undefined]

පෙරනිමි අගය පැවරීම සහිත විනාශ වූ පරාමිතිය:

විනාශකාරී පැවරුම් අංකනය සමඟ ඔබට පෙරනිමි අගය පැවරුම භාවිතා කළ හැකිය

function f([x, y] = [1, 2], {z: z} = {z: 3}) {
  return x + y + z;
}

f(); // 6

පෙරනිමි පරාමිතීන් සැකසීමට වෙනස් ප්‍රවේශයක් වන්නේ සෘජුවම තර්ක වෙනුවට තර්ක වල වස්තු සිතියම භාවිතා කිරීමයි. උදාහරණයක් වශයෙන්,

const defaultConfig = {
 category: 'Animals',
 legs: 4
};

function checkOrganism(props) {
 const category = props.category || defaultConfig.category;
 const legs = props.legs || defaultConfig.legs;
}

මේ ආකාරයෙන්, තර්ක විස්තාරණය කිරීම පහසු වන අතර තර්ක දිග නොගැලපීම ගැන කරදර නොවන්න.

පිළිතුර ඔව්. ඇත්ත වශයෙන්ම, පෙරනිමි පරාමිතීන් සඳහා සහය දක්වන බොහෝ භාෂා ඇත. පයිතන් ඒවායින් එකකි:

def(a, enter="Hello"):
   print(a+enter)

වරහන් නිසා මෙය පයිතන් 3 කේතය වුවද, ශ්‍රිතවල පෙරනිමි පරාමිතීන් JS හි ද ක්‍රියා කරයි.

උදාහරණයක් ලෙස, සහ ඔබේ නඩුවේදී:

function read_file(file, deleteAfter=false){
  console.log(deleteAfter);
}

read_file("test.txt");

නමුත් සමහර විට ඔබට පෙරනිමි පරාමිතීන් අවශ්‍ය නොවේ.

ශ්‍රිතය ආරම්භ වූ වහාම ඔබට විචල්‍යය අර්ථ දැක්විය හැකිය, මේ ආකාරයට:

function read_file(file){
  var deleteAfter = false;
  console.log(deleteAfter);
}

read_file("test.txt");

මගේ උදාහරණ දෙකෙහිම, එය එකම දේ ලබා දෙයි. නමුත් සමහර විට ඒවා ඇත්ත වශයෙන්ම ප්‍රයෝජනවත් විය හැකිය.

එබැවින්, අවසාන වශයෙන්, පෙරනිමි පරාමිති අගයන් JS හි භාවිතා කළ හැකිය. නමුත් එය ශ්‍රිතය ආරම්භ වූ වහාම විචල්‍යයක් නිර්වචනය කිරීම හා සමාන වේ. කෙසේ වෙතත්, සමහර විට ඒවා තවමත් ඉතා ප්රයෝජනවත් වේ. ඔබ දැක ඇති පරිදි, පෙරනිමි පරාමිති අගයන් ශ්‍රිතය ආරම්භ වූ වහාම පරාමිතිය නිර්වචනය කරන සම්මත ක්‍රමයට වඩා 1 අඩු කේත රේඛාවක් ගනී.

සංස්කරණය කරන්න: මෙය ඉතා වැදගත් වේ! මෙයIE හි ක්‍රියා නොකරනු ඇත. ප්‍රලේඛනය බලන්න. එබැවින් IE සමඟ ඔබ "ශ්‍රිතයට ඉහළින් විචල්‍යය නිර්වචනය කරන්න" ක්‍රමය භාවිතා කළ යුතුය. පෙරනිමි පරාමිතීන් IE හි ක්‍රියා නොකරනු ඇත.

ඔව්, මෙය ජාවාස්ක්‍රිප්ට් හි ක්‍රියාත්මක වේ. ඔබට එය ද කළ හැකිය:

function func(a=10,b=20)
{
    alert (a+' and '+b);
}

func(); // Result: 10 and 20

func(12); // Result: 12 and 20

func(22,25); // Result: 22 and 25