What specification supports optional parameters?

How do I use optional parameters in Java?

&lt;sup&gt;**Note:** This question was asked at a time when C# did not yet support optional parameters (i.e. before C# 4).&lt;/sup&gt;

We&#39;re building a web API that&#39;s programmatically generated from a C# class. The class has method `GetFooBar(int a, int b)` and the API has a method `GetFooBar` taking query params like `&amp;a=foo &amp;b=bar`. 

The classes needs to support optional parameters, which isn&#39;t supported in C# the language. What&#39;s the best approach?

How can you use optional parameters in C#?

Is it possible in Swift? If not then is there a workaround to do it?

How to define optional methods in Swift protocol?

I noticed that with the optional parameters in C# 4 if you specify an  optional parameter on an interface you ***don,t*** have to make that parameter optional on any implementing class:

    public interface MyInterface
    {
    	void TestMethod(bool flag = false);
    }
    
    public class MyClass : MyInterface
    {
    	public void TestMethod(bool flag)
    	{
    	    Console.WriteLine(flag);
    	}
    }

and therefore:

    var obj = new MyClass();    	
    obj.TestMethod(); // compiler error

    var obj2 = new MyClass() as MyInterface;
    obj2.TestMethod(); // prints false

Does anyone know why optional parameters are designed to work this way?

On one hand I suppose the ability to override any default values specified on the interfaces is useful though to be honest I&#39;m not sure if you should even be able to specify default values on the interface as that should be an implementation decision.

On the other hand, this disconnect means you can&#39;t always use the concrete class and the interface interchangeably. This of course, wouldn&#39;t be a problem if the default value is specified on the implementation, but then if you&#39;re exposing your concrete class as the interface (using some IOC framework to inject the concrete class for instance) then really there&#39;s no point having the default value as the caller will have to always provide it anyway.

Why are C# 4 optional parameters defined on interface not enforced on implementing class?

I find the named parameters feature in C# quite useful in some cases.

    calculateBMI(70, height: 175);

What can I use if I want this in JavaScript? 

---

What I don’t want is this:

    myFunction({ param1: 70, param2: 175 });

    function myFunction(params){
      // Check if params is an object
      // Check if the parameters I need are non-null
      // Blah blah
    }

That approach I’ve already used. Is there another way?

I’m okay using any library to do this.

Is there a way to provide named parameters in a function call in JavaScript?

How are &quot;keyword arguments&quot; different from regular arguments? Can&#39;t all arguments be passed as `name=value` instead of using positional syntax?

Normal arguments vs. keyword arguments

I am debugging some JavaScript and can&#39;t explain what this `||` does:

    function (title, msg) {
      var title = title || &#39;Error&#39;;
      var msg   = msg || &#39;Error on Request&#39;;
    }

Why is this guy using `var title = title || &#39;ERROR&#39;`? I sometimes see it without a `var` declaration as well.



What does the construct x = x || y mean?

Does C# 4.0 allow optional `out` or `ref` arguments?

C# 4.0 optional out/ref arguments

Is it possible to point to a specific settings file in order to override the default settings.xml being used by maven for a single command?
Example:

    mvn clean install -Dparam # -&gt; pass specific settings file path as param to override default &quot;home/.m2/settings.xml&quot;

maven command line how to point to a specific settings.xml for a single command?

I wish to say:
 

    public void Problem(Guid optional = Guid.Empty)
    {
    }


But the compiler complains that Guid.Empty is not a compile time constant.

As I don’t wish to change the API I can’t use:

     Nullable&lt;Guid&gt;

How can I default a parameter to Guid.Empty in C#?

I am creating a stored procedure to do a search through a table.  I have many different search fields, all of which are optional.  Is there a way to create a stored procedure that will handle this?  Let&#39;s say I have a table with four fields:  ID, FirstName, LastName and Title.  I could do something like this:

    CREATE PROCEDURE spDoSearch
        @FirstName varchar(25) = null,
        @LastName varchar(25) = null,
        @Title varchar(25) = null
    AS
        BEGIN
            SELECT ID, FirstName, LastName, Title
            FROM tblUsers
            WHERE
                FirstName = ISNULL(@FirstName, FirstName) AND
                LastName = ISNULL(@LastName, LastName) AND
                Title = ISNULL(@Title, Title)
        END

This sort of works.  However it ignores records where FirstName, LastName or Title are NULL.  If Title is not specified in the search parameters I want to include records where Title is NULL - same for FirstName and LastName.  I know I could probably do this with dynamic SQL but I would like to avoid that.

How can I use optional parameters in a T-SQL stored procedure?

I put a dict as the default value for an optional argument to a Python function, and pylint (using Sublime package) told me it was dangerous. Can someone explain why this is the case? And is a better alternative to use `None` instead?

Why is the empty dictionary a dangerous default value in Python?

I&#39;m writing some stored procs in SQL Server 2008, and wondered if the concept of optional input parameters is possible here?  

I suppose I could always pass in NULL for parameters I don&#39;t want to use, check the value in the stored proc, then take things from there, but I was interested if the concept is available here.  Thanks!  

optional parameters in SQL Server stored proc?

**1.**

    int Add (int a, int b = 3);
    int Add (int a, int b)
    {
    
    }

**2.**

    int Add (int a, int b);
    int Add (int a, int b = 3)
    {
    
    }

Both work; which is the standard way and **why**?

Default value of function parameter

Both of these generate an error saying they must be a compile-time constant:

    void Foo(TimeSpan span = TimeSpan.FromSeconds(2.0))
    void Foo(TimeSpan span = new TimeSpan(2000))

First of all, can someone explain why these values can&#39;t be determined at compile time? And is there a way to specify a default value for an optional TimeSpan object?

C# 4.0: Can I use a TimeSpan as an optional parameter with a default value?

I come with this:

&lt;pre&gt;
(defn string-&gt;integer [str &amp; [base]]
  (Integer/parseInt str (if (nil? base) 10 base)))

(string-&gt;integer &quot;10&quot;)
(string-&gt;integer &quot;FF&quot; 16)
&lt;/pre&gt;
But it must be a better way to do this.

How to create default value for function argument in Clojure

which one is better? at a glance optional parameter seems better (less code, less XML documentation, etc), but why do most MSDN library classes use overloading instead of optional parameters?

Is there any special thing you have to take note when you choose to use optional parameter (or overloading)?

method overloading vs optional parameter in C# 4.0

If I define a Ruby functions like this:

    def ldap_get ( base_dn, filter, scope=LDAP::LDAP_SCOPE_SUBTREE, attrs=nil )

How can I call it supplying only the first 2 and the last args? Why isn&#39;t something like

    ldap_get( base_dn, filter, , X)

possible or if it is possible, how can it be done?

Ruby optional parameters

OK I totally forgot how to skip arguments in PHP.

Lets say I have:

    function getData($name, $limit = &#39;50&#39;, $page = &#39;1&#39;) {
        ...
    }

How would I call this function so that the middle parameter takes the default value (ie. &#39;50&#39;)?

    getData(&#39;some name&#39;, &#39;&#39;, &#39;23&#39;);

Would the above be correct? I can&#39;t seem to get this to work.


How would I skip optional arguments in a function call?

Is there an easy way in Python to check whether the value of an optional parameter comes from its default value, or because the user has set it explicitly at the function call?

How to check whether optional function parameter is set

I&#39;m trying to declare an argument in Swift that takes an optional closure. The function I have declared looks like this:

    class Promise {
     
     func then(onFulfilled: ()-&gt;(), onReject: ()-&gt;()?){       
        if let callableRjector = onReject {
          // do stuff! 
        }
     }

    }
 
But Swift complains that &quot;Bound value in a conditional must be an Optional type&quot; where the &quot;if let&quot; is declared. 


How does one make an optional closure in swift?

How can I set default value for DateTime in optional parameter?

    public SomeClassInit(Guid docId, DateTime addedOn = DateTime.Now???)
    {
        //Init codes here
    }

Set default value for DateTime in optional parameter

How does one define a function that takes an optional array with an empty array as default?

    public void DoSomething(int index, ushort[] array = new ushort[] {},
     bool thirdParam = true)

results in:

Default parameter value for &#39;array&#39; must be a compile-time constant.




Passing an empty array as default value of an optional parameter

I was watching [Anders&#39; talk about C# 4.0 and sneak preview of C# 5.0][1], and it got me thinking about when optional parameters are available in C# what is going to be the recommended way to declare methods that do not need all parameters specified?

For example something like the `FileStream` class has about fifteen different constructors which can be divided into logical &#39;families&#39; e.g. the ones below from a string, the ones from an `IntPtr` and the ones from a `SafeFileHandle`.

    FileStream(string,FileMode);
    FileStream(string,FileMode,FileAccess);
    FileStream(string,FileMode,FileAccess,FileShare);
    FileStream(string,FileMode,FileAccess,FileShare,int);
    FileStream(string,FileMode,FileAccess,FileShare,int,bool);

It seems to me that this type of pattern could be simplified by having three constructors instead, and using optional parameters for the ones that can be defaulted, which would make the different families of constructors more distinct [note: I know this change will not be made in the BCL, I&#39;m talking hypothetically for this type of situation].

What do you think? From C# 4.0 will it make more sense to make closely related groups of constructors and methods a single method with optional parameters, or is there a good reason to stick with the traditional many-overload mechanism?

  [1]: http://channel9.msdn.com/pdc2008/TL16/

Should you declare methods using overloads or optional parameters in C# 4.0?

I am reading **Effective C#** by Bill Wagner. In *Item 14 - Minimize Duplicate Initialization Logic*, he shows the following example of using the new optional parameters feature in a constructor:

`public MyClass(int initialCount = 0, string name = &quot;&quot;)`


Notice that he used `&quot;&quot;` instead of `string.Empty`.   
He comments:
&gt; You&#39;ll note [in an example above] that the second constructor specified &quot;&quot; for the default value on the *name* parameter, rather than the more customary `string.Empty`. That&#39;s because `string.Empty` is not a compile-time constant. It is a static property defined in the string class. Because it is not a compile constant, you cannot use it for the default value for a parameter. 
&gt;

If we cannot use the `string.Empty` static in all situations, then doesn&#39;t that defeat the purpose of it? I thought that we would use it to be sure that we have a system-independent means of referring to the empty string. Is my understanding wrong? Thanks.

UPDATE  
Just a follow up comment. According to MSDN:
&gt;Each optional parameter has a default value as part of its definition. If no argument is sent for that parameter, the default value is used. **Default values must be constants.**
&gt;  

Then we aren&#39;t be able to use `System.Environment.NewLine` either, or use newly instantiated objects as default values. I haven&#39;t used VS2010 yet, and this is disappointing!

Cannot use String.Empty as a default value for an optional parameter

Seems like in .NET Framework there is an issue with optional parameters when you override the method. The output of the code below is:
&quot;bbb&quot;
&quot;aaa&quot;
. But the output I&#39;m expecting is:
&quot;bbb&quot;
&quot;bbb&quot;
.Is there a solution for this. I know it can be solved with method overloading but wondering the reason for this. Also the code works fine in Mono.

    class Program
    {
        class AAA
        {
            public virtual void MyMethod(string s = &quot;aaa&quot;)
            {
                Console.WriteLine(s);
            }

            public virtual void MyMethod2()
            {
                MyMethod();
            }
        }

        class BBB : AAA
        {
            public override void MyMethod(string s = &quot;bbb&quot;)
            {
                base.MyMethod(s);
            }

            public override void MyMethod2()
            {
                MyMethod();
            }
        }

        static void Main(string[] args)
        {
            BBB asd = new BBB();
            asd.MyMethod();
            asd.MyMethod2();
        }
    }

C# optional parameters on overridden methods

    // opt_options is optional
    function foo(a, b, opt_options) {
      // opt_c, opt_d, and opt_e are read from &#39;opt_options&#39;, only c and d have defaults
      var opt_c = &#39;default_for_c&#39;;
      var opt_d = &#39;default_for_d&#39;;
      var opt_e; // e has no default
    
      if (opt_options) {
        opt_c = opt_options.c || opt_c;
        opt_d = opt_options.d || opt_d;
        opt_e = opt_options.e;
      }
    }

The above seems awfully verbose. What&#39;s a better way to handle argument options with default parameters?

A javascript design pattern for options with default values?

Using c# 4.0 -- building an interface and a class that implements the interface. I want to declare an optional parameter in the interface and have it be reflected in the class. So, I have the following:

     public interface IFoo
     {
          void Bar(int i, int j=0);
     }

     public class Foo
     {
          void Bar(int i, int j=0) { // do stuff }
     }

This compiles, but it doesn&#39;t look right. The interface needs to have the optional parameters, because otherwise it doesn&#39;t reflect correctly in the interface method signature. 

Should I skip the optional parameter and just use a nullable type? Or will this work as intended with no side effects or consequences?

Optional parameters for interfaces

I&#39;m having trouble with this piece of code , after i took this class from the main.cpp file and splitted it in to .h and .cpp the compiler started complaining about the default parameters i was using in a void.

&lt;!-- language: cpp --&gt;

    /* PBASE.H */
        class pBase : public sf::Thread {
    private:
    	bool Running;
    
    public:
    	sf::Mutex Mutex;
    	WORD OriginalColor;
    	pBase(){
    		Launch();
    		Running = true;
    		OriginalColor = 0x7;
    	}
    	void progressBar(int , int);
    	bool key_pressed();
    	void setColor( int );
    	void setTitle( LPCWSTR );
    	bool test_connection(){
    		if(Running == false){
    			return 0;
    		}
    		else{
    			return 1;
    		}
    	return 0;
    	}
    	void Stop(){
    		Running = false;
    		if(Running == false) Wait();
    	}
    };

---

&lt;!-- language: cpp --&gt;

        /* PBASE.CPP */
        
        // ... other stuff above
        
        void pBase::setColor( int _color = -1){
        	if(_color == -1){
        		 SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),FOREGROUND_INTENSITY | OriginalColor);
        		 return;
        	}
        	SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),FOREGROUND_INTENSITY | _color);
    
    }


And the error , taken from VC2010


&gt; Error	4	error C2572: &#39;pBase::setColor&#39; : redefinition of default parameter : parameter 1


The compiler is complaining about my default parameters?

        public void log(String msg, Color c = Color.black)
        {
            loggerText.ForeColor = c;
            loggerText.AppendText(&quot;\n&quot; + msg);

        }

This results in an error that c must be a compile-time constant.  I&#39;ve read up on this a little and most examples are dealing with strings and ints.  I&#39;ve figured out I can use the colorconverter class but I&#39;m not sure it will be very efficient.  Is there a way to just pass a basic color as an optional parameter?

        public void log(String msg, String c = &quot;Black&quot;)
        {
            ColorConverter conv = new ColorConverter();
            Color color = (Color)conv.ConvertFromString(c);

            loggerText.ForeColor = color;
            loggerText.AppendText(&quot;\n&quot; + msg);
        }


C# 4.0: Can I use a Color as an optional parameter with a default value?

I would like to write a wrapper method for a webservice, the service accepts 2 mandatory and 3 optional parameters. 

To have a shorter example, I would like to get the following code working 

    def myMethod(pParm1=&#39;1&#39;, pParm2=&#39;2&#39;) {
        println &quot;${pParm1}${pParm2}&quot;
    }
    
    myMethod();
    myMethod(&#39;a&#39;)
    myMethod(pParm2:&#39;a&#39;) // doesn&#39;t work as expected
    myMethod(&#39;b&#39;,&#39;c&#39;)

The output is:

    12
    a2
    [pParm2:a]2
    a2
    bc

What I would like to achieve is to give one parameter and get `1a` as the result.
Is this possible (in the laziest way)?


Groovy method with optional parameters

How can i create a method that has optional parameters and params together? 


    static void Main(string[] args)
    {
    
        TestOptional(&quot;A&quot;,C: &quot;D&quot;, &quot;E&quot;);//this will not build
        TestOptional(&quot;A&quot;,C: &quot;D&quot;); //this does work , but i can only set 1 param
        Console.ReadLine();
    }
    
    public static void TestOptional(string A, int B = 0, params string[] C)
    {
        Console.WriteLine(A);
        Console.WriteLine(B);
        Console.WriteLine(C.Count());
    }   

C# 4.0, optional parameters and params do not work together

I&#39;ve used advanced parameter handling to support multiple parameter sets. Is there any pre-defined variable or way to determine which parameter set has been used to call the script?

e.g. something like

    if($parameterSet -eq &quot;set1&quot;) { ... } elseif ($parameterSet -eq &quot;set2&quot;) { ... }


?

Which parameter set has been used?

Is there a known reason why passing in `null` as a parameter in ES6 does not use the default parameter when one is provided?


    function sayHello(name = &quot;World&quot;) {
    	console.log(&quot;Hello, &quot; + name + &quot;!&quot;);
    }
    
    sayHello(&quot;Jim&quot;);     // Hello, Jim!
    sayHello(undefined); // Hello, World!
    sayHello(null);      // Hello, null!


Passing in NULL as a parameter in ES6 does not use the default parameter when one is provided

Example: 

    public int foo(int x, int optionalY = 1, int optionalZ = 2) { ... }

I&#39;d like to call it like this:

    int returnVal = foo(5,,8); 

In other words, I want to provide `x` and `z`, but I want to use the default for `Y`, `optionalY = 1.`

Visual Studio does not like the `,,`

Please help.



How to skip optional parameters in C#?

I&#39;m trying to implement a controller in AngularJS which is used across multiple pages. It makes use of some services. Some of them are loaded on all pages, some - not. I mean it is defined in different files, and these files are loaded independently. But if I do not load these services on all pages I got error:

    Error: Unknown provider: firstOtionalServiceProvider &lt;- firstOtionalService

So, I need to load scripts on all pages. Can I declare dependency as optional in Angular? E.g:

    myApp.controller(&#39;MyController&#39;, [&#39;$scope&#39;, &#39;firstRequiredService&#39;, &#39;secondRequiredService&#39;, &#39;optional:firstOptionalService&#39;, &#39;optional:secondOptionalService&#39;, function($scope, firstRequiredService, secondRequiredService, firstOptionalService, secondOptionalSerivce){

        // No need to check, as firstRequiredService must not be null
        firstRequiredService.alwaysDefined();

        // If the dependency is not resolved i want Angular to set null as argument and check
        if (firstOptionalService) {
            firstOptionalService.mayBeUndefinedSoCheckNull();
        }

    }]);



All Optional Parameters Solutions on Gang of Coders

Total of 36 Optional Parameters Solutions