javascript - জাভাস্ক্রিপ্ট বই pdf




জাভাস্ক্রিপ্ট ফাংশন overloading-সর্বোত্তম অনুশীলন (20)

জাভাস্ক্রিপ্ট জাল ফাংশন ওভারলোডিং সেরা উপায় (গুলি) কি?

আমি জানি যে জাভাস্ক্রিপ্টে অন্যান্য ভাষার মতো ফাংশন ওভারলোড করা সম্ভব নয়। যদি আমার দুটি ফাংশন foo(x) এবং foo(x,y,z) ব্যবহার করে একটি ফাংশন দরকার যা সর্বোত্তম / পছন্দের উপায়:

  1. প্রথম স্থানে বিভিন্ন নাম ব্যবহার করে
  2. y = y || 'default' মত ঐচ্ছিক আর্গুমেন্ট ব্যবহার করে y = y || 'default'
  3. আর্গুমেন্ট সংখ্যা ব্যবহার করে
  4. আর্গুমেন্ট ধরনের চেক
  5. আর কীভাবে?

যদি আমার দুটি ফাংশন (x) এবং foo (x, y, z) ব্যবহার করে একটি ফাংশন দরকার, যা সর্বোত্তম / পছন্দের উপায়?

সমস্যাটি জাভাস্ক্রিপ্ট নেটিভ পদ্ধতির ওভারলোডিং সমর্থন করে না। সুতরাং, যদি এটি একই নামের সাথে দুটি বা তার বেশি ফাংশন দেখে / পার্স করে তবে এটি শেষ সংজ্ঞায়িত ফাংশনটিকে বিবেচনা করবে এবং পূর্ববর্তীগুলির উপরে ওভাররাইট করবে।

আমার মনে হয় যে বেশিরভাগ ক্ষেত্রেই উপযুক্ত মনে হয় -

আপনি পদ্ধতি আছে বলুন

function foo(x)
{
} 

জাভাস্ক্রিপ্টে সম্ভব নয় এমন ওভারলোড পদ্ধতির পরিবর্তে আপনি একটি নতুন পদ্ধতি সংজ্ঞায়িত করতে পারেন

fooNew(x,y,z)
{
}

এবং তারপর অনুসরণ হিসাবে 1 ম ফাংশন সংশোধন করুন -

function foo(arguments)
{
  if(arguments.length==2)
  {
     return fooNew(arguments[0],  arguments[1]);
  }
} 

যদি আপনার এমন অনেক বেশি লোড হওয়া পদ্ধতি রয়েছে if-else বিবৃতিগুলির চেয়ে switch ব্যবহার বিবেচনা করুন।

( আরো বিস্তারিত )

পিএস: উপরের লিঙ্কটি আমার ব্যক্তিগত ব্লগে চলেছে যার অতিরিক্ত বিশদ রয়েছে।


ফরওয়ার্ডিং প্যাটার্ন => JS overloading সেরা অনুশীলন

তৃতীয় ফাংশন থেকে চতুর্থ ও চতুর্থ পয়েন্টে যে নামটি তৈরি করা হয়েছে তা ফরোয়ার্ড করুন:

  1. আর্গুমেন্ট সংখ্যা ব্যবহার করে
  2. আর্গুমেন্ট ধরনের চেক
window['foo_'+arguments.length+'_'+Array.from(arguments).map((arg)=>typeof arg).join('_')](...arguments)

আপনার ক্ষেত্রে আবেদন:

 function foo(){
          return window['foo_'+arguments.length+Array.from(arguments).map((arg)=>typeof arg).join('_')](...arguments);

  }
   //------Assuming that `x` , `y` and `z` are String when calling `foo` . 

  /**-- for :  foo(x)*/
  function foo_1_string(){
  }
  /**-- for : foo(x,y,z) ---*/
  function foo_3_string_string_string(){

  }

অন্যান্য জটিল নমুনা:

      function foo(){
          return window['foo_'+arguments.length+Array.from(arguments).map((arg)=>typeof arg).join('_')](...arguments);
       }

        /** one argument & this argument is string */
      function foo_1_string(){

      }
       //------------
       /** one argument & this argument is object */
      function foo_1_object(){

      }
      //----------
      /** two arguments & those arguments are both string */
      function foo_2_string_string(){

      }
       //--------
      /** Three arguments & those arguments are : id(number),name(string), callback(function) */
      function foo_3_number_string_function(){
                let args=arguments;
                  new Person(args[0],args[1]).onReady(args[3]);
      }

       //--- And so on ....   

আপনি এই ভাল পদ্ধতির সাথে যোগাযোগ করতে পারেন দুটি উপায় আছে:

  1. আপনি একটি নমনীয়তা অনেক ছেড়ে দিতে চান তাহলে একটি অভিধান (সহযোগী অ্যারে) পাস করুন

  2. যুক্তি হিসাবে একটি বস্তু নিন এবং নমনীয়তা যোগ করার জন্য প্রোটোটাইপ ভিত্তিক উত্তরাধিকার ব্যবহার করুন।


আপনি জন রেজিগ থেকে 'addMethod' ব্যবহার করতে পারেন। এই পদ্ধতির সাথে আপনি আর্গুমেন্ট গণনার উপর ভিত্তি করে "ওভারলোড" পদ্ধতিগুলি করতে পারেন।

// addMethod - By John Resig (MIT Licensed)
function addMethod(object, name, fn){
    var old = object[ name ];
    object[ name ] = function(){
        if ( fn.length == arguments.length )
            return fn.apply( this, arguments );
        else if ( typeof old == 'function' )
            return old.apply( this, arguments );
    };
}

আমি এই পদ্ধতিতে একটি বিকল্প তৈরি করেছি যা ফাংশনের বৈচিত্র ধারণ করতে ক্যাশিং ব্যবহার করে। পার্থক্য এখানে বর্ণনা করা হয়

// addMethod - By Stavros Ioannidis
function addMethod(obj, name, fn) {
  obj[name] = obj[name] || function() {
    // get the cached method with arguments.length arguments
    var method = obj[name].cache[arguments.length];

    // if method exists call it 
    if ( !! method)
      return method.apply(this, arguments);
    else throw new Error("Wrong number of arguments");
  };

  // initialize obj[name].cache
  obj[name].cache = obj[name].cache || {};

  // Check if a method with the same number of arguments exists  
  if ( !! obj[name].cache[fn.length])
    throw new Error("Cannot define multiple '" + name +
      "' methods with the same number of arguments!");

  // cache the method with fn.length arguments
  obj[name].cache[fn.length] = function() {
    return fn.apply(this, arguments);
  };
}

আমি শুধু এই চেষ্টা, সম্ভবত এটি আপনার প্রয়োজন suits। আর্গুমেন্ট সংখ্যা উপর নির্ভর করে, আপনি একটি ভিন্ন ফাংশন অ্যাক্সেস করতে পারেন। আপনি এটি কল যখন প্রথম আপনি এটি আরম্ভ। এবং ফাংশন মানচিত্র বন্ধ লুকানো হয়।

TEST = {};

TEST.multiFn = function(){
    // function map for our overloads
    var fnMap = {};

    fnMap[0] = function(){
        console.log("nothing here");
        return this;    //    support chaining
    }

    fnMap[1] = function(arg1){
        //    CODE here...
        console.log("1 arg: "+arg1);
        return this;
    };

    fnMap[2] = function(arg1, arg2){
        //    CODE here...
        console.log("2 args: "+arg1+", "+arg2);
        return this;
    };

    fnMap[3] = function(arg1,arg2,arg3){
        //    CODE here...
        console.log("3 args: "+arg1+", "+arg2+", "+arg3);
        return this;
    };

    console.log("multiFn is now initialized");

    //    redefine the function using the fnMap in the closure
    this.multiFn = function(){
        fnMap[arguments.length].apply(this, arguments);
        return this;
    };

    //    call the function since this code will only run once
    this.multiFn.apply(this, arguments);

    return this;    
};

এটা পরীক্ষা করো.

TEST.multiFn("0")
    .multiFn()
    .multiFn("0","1","2");

আমি সর্বোত্তম অনুশীলন সম্পর্কে নিশ্চিত নই, তবে এখানে আমি কীভাবে এটি করি:

/*
 * Object Constructor
 */
var foo = function(x) {
    this.x = x;
};

/*
 * Object Protoype
 */
foo.prototype = {
    /*
     * f is the name that is going to be used to call the various overloaded versions
     */
    f: function() {

        /*
         * Save 'this' in order to use it inside the overloaded functions
         * because there 'this' has a different meaning.
         */   
        var that = this;  

        /* 
         * Define three overloaded functions
         */
        var f1 = function(arg1) {
            console.log("f1 called with " + arg1);
            return arg1 + that.x;
        }

        var f2 = function(arg1, arg2) {
             console.log("f2 called with " + arg1 + " and " + arg2);
             return arg1 + arg2 + that.x;
        }

        var f3 = function(arg1) {
             console.log("f3 called with [" + arg1[0] + ", " + arg1[1] + "]");
             return arg1[0] + arg1[1];
        }

        /*
         * Use the arguments array-like object to decide which function to execute when calling f(...)
         */
        if (arguments.length === 1 && !Array.isArray(arguments[0])) {
            return f1(arguments[0]);
        } else if (arguments.length === 2) {
            return f2(arguments[0], arguments[1]);
        } else if (arguments.length === 1 && Array.isArray(arguments[0])) {
            return f3(arguments[0]);
        }
    } 
}

/* 
 * Instantiate an object
 */
var obj = new foo("z");

/*
 * Call the overloaded functions using f(...)
 */
console.log(obj.f("x"));         // executes f1, returns "xz"
console.log(obj.f("x", "y"));    // executes f2, returns "xyz"
console.log(obj.f(["x", "y"]));  // executes f3, returns "xy"

এই পোস্টে ইতিমধ্যে বিভিন্ন সমাধান রয়েছে যা আমি ভাবলাম আমি অন্য একটি পোস্ট করি।

function onlyUnique(value, index, self) {
    return self.indexOf(value) === index;
}

function overload() {
   var functions = arguments;
   var nroffunctionsarguments = [arguments.length];
    for (var i = 0; i < arguments.length; i++) {
        nroffunctionsarguments[i] = arguments[i].length;
    }
    var unique = nroffunctionsarguments.filter(onlyUnique);
    if (unique.length === arguments.length) {
        return function () {
            var indexoffunction = nroffunctionsarguments.indexOf(arguments.length);
            return functions[indexoffunction].apply(this, arguments);
        }
    }
    else throw new TypeError("There are multiple functions with the same number of parameters");

}

নীচের দেখানো হিসাবে এই ব্যবহার করা যেতে পারে:

var createVector = overload(
        function (length) {
            return { x: length / 1.414, y: length / 1.414 };
        },
        function (a, b) {
            return { x: a, y: b };
        },
        function (a, b,c) {
            return { x: a, y: b, z:c};
        }
    );
console.log(createVector(3, 4));
console.log(createVector(3, 4,5));
console.log(createVector(7.07));

এই সমাধানটি নিখুঁত নয় কিন্তু আমি কেবল এটি কীভাবে করা যেতে পারে তা প্রদর্শন করতে চাই।


এখানে এমন একটি পদ্ধতি রয়েছে যা নীচে দেখানো প্যারামিটার প্রকার ব্যবহার করে আসল পদ্ধতির ওভারলোডিংয়ের অনুমতি দেয়:

Func(new Point());
Func(new Dimension());
Func(new Dimension(), new Point());
Func(0, 0, 0, 0);

সম্পাদনা (2018) : ২011 সালে এই লেখাটি লিখিত হয়েছিল, কারণ সরাসরি পদ্ধতির গতিগুলি ব্যাপকভাবে বৃদ্ধি পেয়েছে যখন ওভারলোড পদ্ধতিগুলির গতি নেই।

এটি কোনও পদ্ধতি নয় যা আমি সুপারিশ করব, তবে আপনি কীভাবে এই ধরণের সমস্যার সমাধান করতে পারেন সে সম্পর্কে চিন্তা করা একটি উপযুক্ত চিন্তা অনুশীলন।

এখানে বিভিন্ন পদ্ধতির একটি বেঞ্চমার্ক - https://jsperf.com/function-overloading । এটি দেখায় যে ফাংশন ওভারলোডিং (অ্যাকাউন্টগুলিতে অ্যাকাউন্টগুলি গ্রহণ করা) Google Chrome এর V8 এর মধ্যে 16.0 (বিটা) হিসাবে প্রায় 13 বার ধীর হতে পারে।

পাশাপাশি একটি বস্তু (অর্থাৎ {x: 0, y: 0} ) পাশাপাশি, যখন উপযুক্ত হয় তখন সি সি পদ্ধতিতেও নামকরণ করতে পারে। উদাহরণস্বরূপ, ভেক্টর। অ্যাডভেক্টর (ভেক্টর), ভেক্টর। AddIntegers (x, y, z, ...) এবং ভেক্টর। AddArray (integerArray)। আপনি অনুপ্রেরণা নামকরণের জন্য OpenGL যেমন সি লাইব্রেরিতে দেখতে পারেন।

সম্পাদন : আমি বস্তুটি এবং arg.hasOwnProperty('param') এবং arg.hasOwnProperty('param') উভয় 'param' in arg arg.hasOwnProperty('param') 'param' in arg ব্যবহার করে বস্তুর জন্য পরীক্ষা করার জন্য একটি বেঞ্চমার্ক যোগ করেছি এবং ফাংশন ওভারলোডিং একটি বস্তুর পাশে এবং বৈশিষ্ট্যের জন্য পরীক্ষা করার চেয়ে অনেক দ্রুত অন্তত এই বেঞ্চমার্ক)।

একটি নকশা দৃষ্টিকোণ থেকে, ফাংশন ওভারলোডিং শুধুমাত্র বৈধ বা লজিক্যাল যদি ওভারলোড করা পরামিতি একই পদক্ষেপের সাথে সম্পর্কিত হয়। সুতরাং এটি এমন একটি অন্তর্নিহিত পদ্ধতি থাকা উচিত কারণ নির্দিষ্ট বিবরণের সাথে শুধুমাত্র উদ্বিগ্ন, অন্যথা এটি অনুপযুক্ত নকশা পছন্দগুলি নির্দেশ করতে পারে। সুতরাং একটি তথ্য একটি সম্পর্কিত বস্তু রূপান্তর করে ফাংশন ওভারলোডিং ব্যবহার সমাধান করতে পারে। অবশ্যই আপনার সমস্যার উদ্দেশ্যটি বিবেচনা করা উচিত কারণ আপনার অভিপ্রায় কেবল একটি নাম মুদ্রণ করার প্রয়োজন নেই তবে বিস্তৃত ডিজাইনের প্রয়োজন নেই তবে ফ্রেমওয়ার্ক এবং লাইব্রেরিগুলির ডিজাইনের জন্য এই ধরনের ধারণাটি ন্যায্য।

আমার উদাহরণ একটি আয়তক্ষেত্র বাস্তবায়ন থেকে আসে - তাই মাত্রা এবং পয়েন্ট উল্লেখ। সম্ভবত আয়তক্ষেত্রটি GetRectangle() এবং Point প্রোটোটাইপে একটি GetRectangle() পদ্ধতি যোগ করতে পারে এবং তারপরে ফাংশন ওভারলোডিং সমস্যাটি সাজানো হয়। এবং primitives সম্পর্কে কি? আচ্ছা, আমাদের যুক্তিযুক্ত দৈর্ঘ্য রয়েছে, যা এখন একটি বৈধ পরীক্ষা যা বস্তুর একটি GetRectangle() পদ্ধতি আছে।

function Dimension() {}
function Point() {}

var Util = {};

Util.Redirect = function (args, func) {
  'use strict';
  var REDIRECT_ARGUMENT_COUNT = 2;

  if(arguments.length - REDIRECT_ARGUMENT_COUNT !== args.length) {
    return null;
  }

  for(var i = REDIRECT_ARGUMENT_COUNT; i < arguments.length; ++i) {
    var argsIndex = i-REDIRECT_ARGUMENT_COUNT;
    var currentArgument = args[argsIndex];
    var currentType = arguments[i];
    if(typeof(currentType) === 'object') {
      currentType = currentType.constructor;
    }
    if(typeof(currentType) === 'number') {
      currentType = 'number';
    }
    if(typeof(currentType) === 'string' && currentType === '') {
      currentType = 'string';
    }
    if(typeof(currentType) === 'function') {
      if(!(currentArgument instanceof currentType)) {
        return null;
      }
    } else {
      if(typeof(currentArgument) !== currentType) {
        return null;
      }
    } 
  }
  return [func.apply(this, args)];
}

function FuncPoint(point) {}
function FuncDimension(dimension) {}
function FuncDimensionPoint(dimension, point) {}
function FuncXYWidthHeight(x, y, width, height) { }

function Func() {
  Util.Redirect(arguments, FuncPoint, Point);
  Util.Redirect(arguments, FuncDimension, Dimension);
  Util.Redirect(arguments, FuncDimensionPoint, Dimension, Point);
  Util.Redirect(arguments, FuncXYWidthHeight, 0, 0, 0, 0);
}

Func(new Point());
Func(new Dimension());
Func(new Dimension(), new Point());
Func(0, 0, 0, 0);

জাভাস্ক্রিপ্ট overloading কাজ করার কোন উপায় নেই। তাই, আমি typeof() ওভারলোডিংয়ের জন্য একাধিক ফাংশনের পরিবর্তে typeof() পদ্ধতিতে নিম্নলিখিতগুলির মত সুপারিশ করি।

function multiTypeFunc(param)
{
    if(typeof param == 'string') {
        alert("I got a string type parameter!!");
     }else if(typeof param == 'number') {
        alert("I got a number type parameter!!");
     }else if(typeof param == 'boolean') {
        alert("I got a boolean type parameter!!");
     }else if(typeof param == 'object') {
        alert("I got a object type parameter!!");
     }else{
        alert("error : the parameter is undefined or null!!");
     }
}

গুড লাক!


জাভাস্ক্রিপ্ট ফাংশন ওভারলোড বিকল্প বস্তু পরিবর্তে ব্যবহার করা যেতে পারে, যেহেতু। যদি এক বা দুটি প্রয়োজনীয় আর্গুমেন্ট থাকে, তবে বিকল্প বস্তুর থেকে আলাদা রাখা ভাল। যদি বিকল্প বস্তুতে মান না দেওয়া হয় তবে ডিফল্ট মানের বিকল্প বিকল্প এবং জনবহুল মানগুলি কীভাবে ব্যবহার করবেন তা এখানে একটি উদাহরণ।

    function optionsObjectTest(x, y, opts) {
        opts = opts || {}; // default to an empty options object

        var stringValue = opts.stringValue || "string default value";
        var boolValue = !!opts.boolValue; // coerces value to boolean with a double negation pattern
        var numericValue = opts.numericValue === undefined ? 123 : opts.numericValue;

        return "{x:" + x + ", y:" + y + ", stringValue:'" + stringValue + "', boolValue:" + boolValue + ", numericValue:" + numericValue + "}";

}

here বিকল্প বস্তু ব্যবহার করার জন্য একটি উদাহরণ


পরামিতি সহ ফাংশন ওভারলোডিং করার সর্বোত্তম উপায় যুক্তি বা দৈর্ঘ্যের পরীক্ষা করা হয় না; ধরনগুলি পরীক্ষা করা আপনার কোডটিকে ধীর করে তুলবে এবং আপনার অ্যারে, নুলস, অবজেক্টস ইত্যাদির মজা থাকবে।

বেশিরভাগ বিকাশকারীরা কীভাবে তাদের বস্তুর শেষ যুক্তি হিসাবে বস্তুর উপর কাজ করে। এই বস্তু কিছু ধারণ করতে পারেন।

function foo(a, b, opts) {
  // ...
  if (opts['test']) { } //if test param exists, do something.. 
}


foo(1, 2, {"method":"add"});
foo(3, 4, {"test":"equals", "bar":"tree"});

তারপর আপনি আপনার পদ্ধতিতে চান যাই হোক না কেন এটি পরিচালনা করতে পারেন। [সুইচ, যদি-অন্য, ইত্যাদি]


সঠিক উত্তর জাভাস্ক্রিপ্টে কোনও ডাউনলোড করা হয় না।

ফাংশন ভিতরে চেক / স্যুইচিং আপলোড করা হয় না।

ওভারলোডিং ধারণা: কিছু প্রোগ্রামিং ভাষাগুলিতে, ফাংশন ওভারলোডিং বা পদ্ধতি ওভারলোডিং বিভিন্ন প্রয়োগগুলির সাথে একই নামের একাধিক পদ্ধতি তৈরি করার ক্ষমতা। একটি ওভারলোড হওয়া ফাংশনগুলিতে কলগুলি কলটির প্রেক্ষাপটে উপযুক্ত ফাংশনের একটি নির্দিষ্ট বাস্তবায়ন চালাবে, যা একটি ফাংশন কলটিকে প্রসঙ্গের ভিত্তিতে বিভিন্ন কাজ সম্পাদন করার অনুমতি দেয়।

উদাহরণস্বরূপ, doTask () এবং doTask (অবজেক্ট ও) ওভারলোড করা পদ্ধতি। পরেরটিকে কল করার জন্য, একটি বস্তুটি পরামিতি হিসাবে পাস করা উচিত, তবে পূর্বের একটি পরামিতি প্রয়োজন হয় না এবং একটি খালি প্যারামিটার ক্ষেত্রের সাথে বলা হয়। একটি সাধারণ ত্রুটি দ্বিতীয় পদ্ধতিতে বস্তুর একটি ডিফল্ট মান বরাদ্দ করা হবে, যা একটি দ্বিধান্বিত কল ত্রুটি হতে পারে, কারণ কম্পাইলারটি কোন দুটি পদ্ধতি ব্যবহার করতে পারে তা জানাবেন না।

https://en.wikipedia.org/wiki/Function_overloading

সমস্ত প্রস্তাবিত বাস্তবায়ন দুর্দান্ত, কিন্তু সত্য বলা যেতে পারে, জাভাস্ক্রিপ্টের জন্য কোনও স্থানীয় বাস্তবায়ন নেই।


সূচনা

এতদূর উত্তর দিয়ে পড়ার ফলে কেউ মাথা ব্যাথা দেবে। যে কেউ এই ধারণাটি জানতে চেষ্টা করবে সেটি নিম্নলিখিত পূর্বের প্রয়োজনীয়তাগুলি জানতে হবে।

Function overloading Definition , Function Length property , Function argument property

Function overloading এর সর্বাধিক ফর্ম মানে একটি ফাংশন এটি পাস করা হয় যে আর্গুমেন্ট সংখ্যা ভিত্তিতে বিভিন্ন কাজ সঞ্চালিত হয়। উল্লেখযোগ্যভাবে TASK1, TASK2 এবং TASK3 নীচের হাইলাইট করা হয় এবং একই ফাংশনে fooYo arguments সংখ্যা অনুসারে সঞ্চালিত হচ্ছে।

// if we have a function defined below
function fooYo(){
     // do something here
}
// on invoking fooYo with different number of arguments it should be capable to do different things

fooYo();  // does TASK1
fooYo('sagar'); // does TASK2
fooYo('sagar','munjal'); // does TAKS3

উল্লেখ্য - JS ফাংশন overloading অন্তর্নিহিত ক্ষমতা প্রদান করে না।

বিকল্প

জন ই রেজিগ (জেএসের নির্মাতা) ফাংশন ওভারলোডিং বাস্তবায়নের ক্ষমতা অর্জনের জন্য উপরের বিকল্পগুলি ব্যবহার করে এমন একটি বিকল্প নির্দেশ করেছেন।

নীচের কোডটি if-else বা switch বিবৃতি ব্যবহার করে একটি সরল কিন্তু সরল পদ্ধতির ব্যবহার করে।

  • argument-length সম্পত্তি মূল্যায়ন।
  • বিভিন্ন মান বিভিন্ন ফাংশন আহ্বান ফলাফল।

var ninja = {
  whatever: function() {
       switch (arguments.length) {
         case 0:
           /* do something */
           break;
         case 1:
           /* do something else */
           break;
         case 2:
           /* do yet something else */
           break;
       //and so on ...
    } 
  }
}

আরেকটি কৌশল আরও পরিষ্কার এবং গতিশীল। এই কৌশলটির হাইলাইট addMethod জেনেরিক ফাংশন।

  • আমরা একটি ফাংশন addMethod সংজ্ঞায়িত addMethod যা একই নামের সাথে একটি বস্তুর বিভিন্ন ফাংশন যুক্ত করতে ব্যবহৃত হয় তবে বিভিন্ন কার্যকারিতা

  • addMethod ফাংশন নীচের তিনটি addMethod বস্তু নাম object , ফাংশন নাম name এবং আমরা যে ফাংশন আহ্বান করতে চান ফাংশন গ্রহণ।

  • addMethod সংজ্ঞা var old function পূর্ববর্তী function বন্ধ করার সাহায্যে সংরক্ষণ করা হচ্ছে - একটি প্রতিরক্ষামূলক বুদ্বুদ।

function addMethod(object, name, fn) {
  var old = object[name];
  object[name] = function(){
    if (fn.length == arguments.length)
      return fn.apply(this, arguments)
    else if (typeof old == 'function')
      return old.apply(this, arguments);
  };
};

  • কোড প্রবাহ বুঝতে ডিবাগার ব্যবহার করুন।
  • addMethod নিচে তিনটি ফাংশন যোগ করা হয়, যা যখন ninja.whatever(x) সাথে ninja.whatever(x) ব্যবহার করে আহ্বান করা হয়, তখন x যে কোনও কিছু হতে পারে অর্থাৎ কোনও ফাঁকা বা এক বা একাধিক addMethod ফাংশন ব্যবহার করার সময় সংজ্ঞায়িত হিসাবে বিভিন্ন ফাংশনকে আহ্বান করে।

var ninja = {};
debugger;


addMethod(ninja,'whatever',function(){ console.log("I am the one with ZERO arguments supplied") });
addMethod(ninja,'whatever',function(a){ console.log("I am the one with ONE arguments supplied") });
addMethod(ninja,'whatever',function(a,b){ console.log("I am the one with TWO arguments supplied") });


ninja.whatever();
ninja.whatever(1,2);
ninja.whatever(3);


আমি overloaded মত পদ্ধতির একটি দরকারী উদাহরণ শেয়ার করতে চাই।

function Clear(control)
{
  var o = typeof control !== "undefined" ? control : document.body;
  var children = o.childNodes;
  while (o.childNodes.length > 0)
    o.removeChild(o.firstChild);
}

ব্যবহার: পরিষ্কার (); // সব নথি মুছে ফেলা

সাফ (myDiv); // myDiv দ্বারা রেফারেন্স প্যানেল মুছে ফেলা হবে


আমি বছর ধরে আমার overloads prettify করার জন্য এই ফাংশন ব্যবহার করা হয়েছে:

function overload(){
  const fs = arguments, fallback = fs[fs.length - 1];
  return function(){
    const f = fs[arguments.length] || (arguments.length >= fs.length ? fallback : null);
    return f.apply(this, arguments);
  }
}

Demostrated:

function curry1(f){
  return curry2(f, f.length);
}

function curry2(f, minimum){
  return function(...applied){
    if (applied.length >= minimum) {
      return f.apply(this, applied);
    } else {
      return curry2(function(...args){
        return f.apply(this, applied.concat(args));
      }, minimum - applied.length);
    }
  }
}

export const curry = overload(null, curry1, curry2);

JQuery এর offপদ্ধতির উপর নজর রাখুন :

  function off( types, selector, fn ) {
    var handleObj, type;
    if ( types && types.preventDefault && types.handleObj ) {

        // ( event )  dispatched jQuery.Event
        handleObj = types.handleObj;
        jQuery( types.delegateTarget ).off(
            handleObj.namespace ?
                handleObj.origType + "." + handleObj.namespace :
                handleObj.origType,
            handleObj.selector,
            handleObj.handler
        );
        return this;
    }
    if ( typeof types === "object" ) {

        // ( types-object [, selector] )
        for ( type in types ) {
            this.off( type, selector, types[ type ] );
        }
        return this;
    }
    if ( selector === false || typeof selector === "function" ) {

        // ( types [, fn] )
        fn = selector;
        selector = undefined;
    }
    if ( fn === false ) {
        fn = returnFalse;
    }
    return this.each( function() {
        jQuery.event.remove( this, types, fn, selector );
    } );
  }

কর্মক্ষমতা জন্য অপ্টিমাইজ যখন অপ্রয়োজনীয় অনেক overloaded ফাংশন। আপনি ফাংশন প্রধান decipher আছে। এটি এমন একটি overloadফাংশন ব্যবহার করার চেয়ে সম্ভবত দ্রুততর যা আমি প্রদান করি; তবে, কোন ওভারলোড বলা হয় তা সনাক্ত করার জন্য এটি একটি মানব দৃষ্টিকোণ থেকে ধীর।


তাই আমি সত্যিই জাভাস্ক্রিপ্ট নিঞ্জা গোপন পাওয়া যে কাজ করার এই উপায় পছন্দ

function addMethod(object,name,fn){
  var old = object[name];
  object[name] = function(){
    if (fn.length == arguments.length){
      return fn.apply(this,arguments);
    } else if(typeof old == 'function'){
        return old.apply(this,arguments);
    }
  }
}

আপনি তারপর কোনো বস্তুর overloaded ফাংশন যোগ করার জন্য addMethod ব্যবহার করুন। আমার জন্য এই কোডের মূল বিভ্রান্তি fn.length == arguments.length এর ব্যবহার ছিল - এটি কাজ করে কারণ fn.length প্রত্যাশিত প্যারামিটারগুলির সংখ্যা, যখন arguments.length হল প্রকৃতপক্ষে যেগুলির সাথে বলা হয় সেগুলির সংখ্যা ফাংশন। বেনামী ফাংশনটির কোনো যুক্তি নেই কারণ আপনি জাভাস্ক্রিপ্টে যেকোনো সংখ্যক আর্গুমেন্ট পাস করতে পারেন এবং ভাষাটি ক্ষমাশীল।

আমি এটি পছন্দ করেছি কারণ আপনি সর্বত্র এটি ব্যবহার করতে পারেন - শুধু এই ফাংশনটি তৈরি করুন এবং যেকোনো কোড বেস যা আপনি চান তা পদ্ধতিটি ব্যবহার করুন।

এটি একটি হাস্যকরভাবে বড় / সুইচ স্টেটমেন্ট থাকা এড়িয়ে চলতে থাকে, যা জটিল কোড লেখা শুরু করলে পড়ার পক্ষে কঠিন হয়ে পড়ে (গ্রহণযোগ্য উত্তরটি এর ফলস্বরূপ হবে)।

বিপরীতে, আমি মনে করি কোডটি প্রাথমিকভাবে কিছুটা অস্পষ্ট ... তবে আমি নিশ্চিত নই?


আমরা এই সমস্যা সমাধানের over.js তৈরি একটি খুব মার্জিত উপায়। আপনি করতে পারেন:

var obj = {

  /**
   * Says something in the console.
   *
   * say(msg) - Says something once.
   * say(msg, times) - Says something many times.
   */
  say: Over(
    function(msg$string){
      console.info(msg$string);
    },
    function(msg$string, times$number){
      for (var i = 0; i < times$number; i++) this.say(msg$string);
    }
  )

};

আমি @ আন্তুয়ানকে এর মতামত পছন্দ করি। আমি প্রায়ই বিভিন্ন পরিমাপ ও পরামিতি বিভিন্ন সংখ্যা সঙ্গে একটি ফাংশন প্রস্তাব। কখনও কখনও তারা একটি আদেশ অনুসরণ করবেন না। আমি পরামিতি ধরনের খুঁজছেন মানচিত্র ব্যবহার করুন:

findUDPServers: function(socketProperties, success, error) {
    var fqnMap = [];

    fqnMap['undefined'] = fqnMap['function'] = function(success, error) {
        var socketProperties = {name:'HELLO_SERVER'};

        this.searchServers(socketProperties, success, error);
    };

    fqnMap['object'] = function(socketProperties, success, error) {
        var _socketProperties = _.merge({name:'HELLO_SERVER'}, socketProperties || {});

        this.searchServers(_socketProperties, success, error);
    };

    fqnMap[typeof arguments[0]].apply(this, arguments);
}

জাভাস্ক্রিপ্ট untyped ভাষা, এবং আমি শুধুমাত্র প্যারামের সংখ্যা সম্পর্কিত একটি পদ্ধতি / ফাংশন overload করার ধারনা করে তোলে। তাই, আমি পরামিতি সংজ্ঞায়িত করা হয়েছে কিনা তা পরীক্ষা করার সুপারিশ করব:

myFunction = function(a, b, c) {
     if (b === undefined && c === undefined ){
          // do x...
     }
     else {
          // do y...
     }
};

জুলাই 2017 অনুযায়ী, নিম্নলিখিত সাধারণ কৌশল হয়েছে। মনে রাখবেন যে আমরা ফাংশনের মধ্যে টাইপ চেক করতে পারব।

function f(...rest){   // rest is an array
   console.log(rest.length);
   for (v of rest) if (typeof(v)=="number")console.log(v);
}
f(1,2,3);  // 3 1 2 3





overloading