Be concise.
Be useful.
All contributions dictatorially edited by webmasters to match personal tastes.
Please do not paste any copyright violating material.
Please try to avoid dependencies to third-party libraries and frameworks.
- Clojure
- Clojure
- C++
- C++
- C#
- Dart
- Fortran
- Go
- JS
- Java
- Java
- Java
- Lua
- PHP
- Pascal
- Perl
- Python
- Ruby
- Rust
- VB
(defn f [& [x]]
(if (integer? x)
(println "Present" x)
(println "Not present")))Optional argument with positional parameters
(defn f
([] (println "Not present"))
([x] (println "Present" x)))Optional argument with pattern matching
void f(std::optional<int> x = {}) {
std::cout << (x ? "Present" + std::to_string(x.value()) : "Not Present");
}c++ 17
void f(std::optional<int> x = {}) {
if (x) {
std::cout << "Present" << x.value();
} else {
std::cout << "Not present";
}
}c++ 17
void f(int? x = null)
{
Console.WriteLine(x.HasValue ? $"Present {x}" : "Not Present");
}Optional arguments in the CLR are honoured by the calling language by substituting the specified default value in place of an omitted argument. The callee thus cannot distinguish between an omitted argument and a passed argument with the same value as the specified default. Nullable<int> is used here because int is a value type.
void f({int? x}) => print(x == null ? "Not present" : "Present");subroutine f(x)
integer, optional :: x
if (present(x)) then
print *,"Present", x
else
print *,"Not present"
end if
end subroutine f
func f(x ...int) {
if len(x) > 0 {
println("Present", x[0])
} else {
println("Not present")
}
}Go does not have optional arguments, but to some extend, they can be mimicked with a variadic parameter.
x is a variadic parameter, which must be the last parameter for the function f.
Strictly speaking, x is a list of integers, which might have more than one element. These additional elements are ignored.
x is a variadic parameter, which must be the last parameter for the function f.
Strictly speaking, x is a list of integers, which might have more than one element. These additional elements are ignored.
function f(x) {
console.log(x ? `Present: ${x}` : 'Not present');
}void f() { set(null); }
void f(int x) { set(x); }
private void set(Integer t) {
if (t != null) out.println("Present");
else out.println("Not present");
}In Java, "overloading" a method is the typical way to create an optional parameter.
void f(int ... x) {
if (x.length != 0) out.println("Present");
else out.println("Not present");
}"... The method can then be called with any number of that parameter, including none."
private void f(Integer x) {
if (x != null) {
System.out.println("Present " + x);
} else {
System.out.println("Not present");
}
}The caller always needs to provide a first argument, which may be null.
function f( x )
if x then
print("Present", x)
else
print("Not present")
end
endfunction f(?int $x = null) {
echo $x ? 'Present' . $x : 'Not present';
}procedure f; overload;
begin
writeln('not present');
end;
procedure f(x: integer); overload;
begin
writeln('present');
end;Not exactly what tkoenig meant, but can be resolved using overloading (same procedure name with different parameter list) quite easily.
def f(x=None):
if x is None:
print("Not present")
else:
print("Present", x)def f( x=nil )
puts x ? "present" : "not present"
end
fn f(x: Option<()>) {
match x {
Some(x) => println!("Present {}", x),
None => println!("Not present"),
}
}