named-parameters

Let's say I want to select records where Id = 30 . Prepared statements allow two ways of binding parameters: question marks $id = 30; $q = $conn->prepare("SELECT * FROM pdo_db WHERE id > ?"); $q->execute(array($id)); // Here above ID will be passed named parameters $sth = $conn->prepare("SELECT `id`, `title` FROM `pdo_db` WHERE `id` > :id"); $sth->execute(array( ':id' => 30 )); Both are working fine and give accurate results but I am not able to get the exact differences between these two nor when I should use one or another? Question mark parameters are called positional parameters.

What's the best/canonical way to define a function with optional named arguments? To make it concrete, let's create a function foo with named arguments a , b , and c , which default to 1, 2, and 3, respectively. For comparison, here's a version of foo with positional arguments: foo[a_:1, b_:2, c_:3] := bar[a,b,c] Here is sample input and output for the named-arguments version of foo : foo[] --> bar[1,2,3] foo[b->7] --> bar[1,7,3] foo[a->6, b->7, c->8] --> bar[6,7,8] It should of course also be easy to have positional arguments before the named arguments. dreeves I found the standard way to do

When we create interface methods, can't we do something like in java : void interface_method(Integer,String, /* other parameter */); Instead I noticed that we also need to give the parameter names lile: void interface_method(Integer i, String s); Also the interface implementor don't need to have the same parameter name as in interface method. I found a similar question about c# over here . They mention one scenario of named parameter but I don't find any other relevent reason specifically in java. From a technical standpoint it wouldn't be necessary. I've always taken it as a syntax

Compile this simple program: class Program { static void Foo( Action bar ) { bar(); } static void Main( string[] args ) { Foo( () => Console.WriteLine( "42" ) ); } } Nothing strange there. If we make an error in the lambda function body: Foo( () => Console.LineWrite( "42" ) ); the compiler returns an error message: error CS0117: 'System.Console' does not contain a definition for 'LineWrite' So far so good. Now, let's use a named parameter in the call to Foo : Foo( bar: () => Console.LineWrite( "42" ) ); This time, the compiler messages are somewhat confusing: error CS1502: The best overloaded

I’m currently working on a classic ASP project talking to an Oracle database. I’m trying to find a way to safely call an Oracle PL/SQL script and passing parameters with ADO. The currently solution builds the SQL script by hand with embedded variables like this: strSQL = "SELECT field1, etc FROM my_table WHERE (field = '" & filter_value & "')" This, of course, is ugly and insecure, and open to abuse. The code that I have so far (purloined from various non classic asp based web sites) looks like this: dim strSQL, oConn, oCommand, oParam set oConn = server.createobject("ADODB.Connection") oConn

Ruby 2.0.0 supports keyword arguments (KA) and I wonder what the benefits/use-cases are of this feature in context of pure Ruby, especially when seen in light of the performance penalty due to the keyword matching that needs to be done every time a method with keyword arguments is called. require 'benchmark' def foo(a:1,b:2,c:3) [a,b,c] end def bar(a,b,c) [a,b,c] end number = 1000000 Benchmark.bm(4) do |bm| bm.report("foo") { number.times { foo(a:7,b:8,c:9) } } bm.report("bar") { number.times { bar(7,8,9) } } end # user system total real # foo 2.797000 0.032000 2.829000 ( 2.906362) # bar 0