Как найти default php

#!/usr/bin/php
<?php
function sum($array,$max){   //For Reference, use:  "&$array"
    $sum=0;
    for ($i=0; $i<2; $i++){
        #$array[$i]++;        //Uncomment this line to modify the array within the function.
        $sum += $array[$i]; 
    }
    return ($sum);
}$max = 1E7                  //10 M data points.
$data = range(0,$max,1);$start = microtime(true);
for ($x = 0 ; $x < 100; $x++){
    $sum = sum($data, $max);
}
$end =  microtime(true);
echo "Time: ".($end - $start)." sn";/* Run times:
#    PASS BY    MODIFIED?   Time
-    -------    ---------   ----
1    value      no          56 us
2    reference  no          58 us

3    valuue     yes         129 s
4    reference  yes         66 us

Conclusions:

1. PHP is already smart about zero-copy / copy-on-write. A function call does NOT copy the data unless it needs to; the data is
   only copied on write. That's why  #1 and #2 take similar times, whereas #3 takes 2 million times longer than #4.
   [You never need to use &$array to ask the compiler to do a zero-copy optimisation; it can work that out for itself.]

2. You do use &$array  to tell the compiler "it is OK for the function to over-write my argument in place, I don't need the original
   any more." This can make a huge difference to performance when we have large amounts of memory to copy.
   (This is the only way it is done in C, arrays are always passed as pointers)

3. The other use of & is as a way to specify where data should be *returned*. (e.g. as used by exec() ).
   (This is a C-like way of passing pointers for outputs, whereas PHP functions normally return complex types, or multiple answers
   in an array)

4. It's  unhelpful that only the function definition has &. The caller should have it, at least as syntactic sugar. Otherwise
   it leads to unreadable code: because the person reading the function call doesn't expect it to pass by reference. At the moment,
   it's necessary to write a by-reference function call with a comment, thus:
    $sum = sum($data,$max);  //warning, $data passed by reference, and may be modified.

5. Sometimes, pass by reference could be at the choice of the caller, NOT the function definitition. PHP doesn't allow it, but it
   would be meaningful for the caller to decide to pass data in as a reference. i.e. "I'm done with the variable, it's OK to stomp
   on it in memory".
*/

?>

my_fonction(['foo' => 'ko', 'bar' => 'not', 'goodValue' => 'Oh Yeah']['goodValue']);

// return 'Oh Yeah'

// This may sound strange, anyway it's very useful in a foreach (or other conditional structure).

$expectedStatusCodes = [404, 403];

function getValueFromArray(string $value): string
{
    return $value . PHP_EOL;
}

foreach ($expectedStatusCodes as $code) {
    echo $currentUserReference = getValueFromArray(
        [
            404 => "Doesn't exist",
            403 => 'Forbidden',
            200 => "you're welcome"
        ][$code]
    );
}

<?php
function run($op, $a, $b) {
  return $op($a, $b);
}$add = function($a, $b) {
  return $a + $b;
};$mul = function($a, $b) {
  return $a * $b;
};

echo

run($add, 1, 2), "n";
echo run($mul, 1, 2);
?>

Output:
3
2

<?php
$x = new stdClass();
$x->prop = 1;

function

f ( $o ) // Notice the absence of &
{
  $o->prop ++;
}f($x);

echo

$x->prop; // shows: 2
?>

This is different for arrays:

<?php
$y = [ 'prop' => 1 ];

function

g( $a )
{
  $a['prop'] ++;
  echo $a['prop'];  // shows: 2
}g($y);

echo

$y['prop'];  // shows: 1
?>

<?php

$array1

= [[1],[2],[3]];
$array2 = [4];
$array3 = [[5],[6],[7]];$result = array_merge(...$array1); // Legal, of course: $result == [1,2,3];
$result = array_merge($array2, ...$array1); // $result == [4,1,2,3]
$result = array_merge(...$array1, $array2); // Fatal error: Cannot use positional argument after argument unpacking.
$result = array_merge(...$array1, ...$array3); // Legal! $result == [1,2,3,5,6,7]
?>

The Right Thing for the error case above would be for $result==[1,2,3,4], but this isn't yet (v7.1.8) supported.

"The declaration can be made to accept NULL values if the default value of the parameter is set to NULL."

But you can do this (PHP 7.1+):

<?php
function foo(?string $bar) {
    //...
}foo(); // Fatal error
foo(null); // Okay
foo('Hello world'); // Okay
?>

<?php
function f( $x = 4 ) { echo $x . "\n"; }
f(); // prints 4
f( null ); // prints blank line
f( $y ); // $y undefined, prints blank line
?>

The utility of the optional argument feature is thus somewhat diminished.  Suppose you want to call the function f many times from function g, allowing the caller of g to specify if f should be called with a specific value or with its default value:

<?php
function f( $x = 4 ) {echo $x . "\n"; }// option 1: cut and paste the default value from f's interface into g's
function g( $x = 4 ) { f( $x ); f( $x ); }// option 2: branch based on input to g
function g( $x = null ) { if ( !isset( $x ) ) { f(); f() } else { f( $x ); f( $x ); } }
?>

Both options suck.

The best approach, it seems to me, is to always use a sentinel like null as the default value of an optional argument.  This way, callers like g and g's clients have many options, and furthermore, callers always know how to omit arguments so they can omit one in the middle of the parameter list.

<?php
function f( $x = null ) { if ( !isset( $x ) ) $x = 4; echo $x . "\n"; }

function

g( $x = null ) { f( $x ); f( $x ); }f(); // prints 4
f( null ); // prints 4
f( $y ); // $y undefined, prints 4
g(); // prints 4 twice
g( null ); // prints 4 twice
g( 5 ); // prints 5 twice?>

you can call it
   myfunction($arg1, $arg2, $arg3);

provided you have defined your function as
   function myfuncion($a1, &$a2, &$a3) { // so &$a2 and &$a3 are
                                                             // declared to be refs.
    ... <function-code>
   }

However, what happens if you wanted to pass an undefined number of references, i.e., something like:
   myfunction(&$arg1, &$arg2, ..., &$arg-n);?
This doesn't work in PHP 5 anymore.

In the following code I tried to amend this by using the
array() language-construct as the actual argument in the
call to the function.

<?phpfunction aa ($A) {
    // This function increments each
    // "pseudo-argument" by 2s
    foreach ($A as &$x) {
      $x += 2;
    }
  }$x = 1; $y = 2; $z = 3;aa(array(&$x, &$y, &$z));
  echo "--$x--$y--$z--n";
  // This will output:
  // --3--4--5--
?>

I hope this is useful.

Sergio.

<?php
function foo(&...$args)
{
    $i = 0;
    foreach ($args as &$arg) {
        $arg = ++$i;
    }
}
foo($a, $b, $c);
echo 'a = ', $a, ', b = ', $b, ', c = ', $c;
?>
Gives
a = 1, b = 2, c = 3

<?phpclass A {
    const FOO = 'default';
    function bar( $val = self::FOO ) {
        echo $val;
    }
}$a = new A();
$a->bar(); // Will echo "default"

<?php
function variadic($first, ...$most, $last)
{/*etc.*/}variadic(1, 2, 3, 4, 5);
?>
results in a fatal error, even though it looks like the Thing To Do™ would be to set $first to 1, $most to [2, 3, 4], and $last to 5.

  func

($a, ...$b) ?>
The 3 dots, or elipsis, or "...", or dot dot dot is sometimes called the "spread operator" in other languages.

As this is only used in function arguments, it is probably not technically an true operator in PHP.  (As of 8.1 at least?).

(With having an difficult to search for name like "... token", I hope this note helps someone).

But it also works for class constructors as you can see below :

<?phpclass Courtesy {
    public string $firstname;
    public string $lastname;

        public function

__construct($firstname, $lastname) {
        $this->firstname = $firstname;
        $this->lastname = $lastname;
    }

        public function

hello() {
        return 'Hello ' . $this->firstname . ' ' . $this->lastname . '!';
    }
}$params = [ 'John', 'Doe' ];$courtesy = new Courtesy(...$params);

echo

$courtesy->hello();?>

"The default value must be a constant expression" is misleading (or even wrong).  PHP 5.4.4 fails to parse this function definition:

function htmlspecialchars_latin1($s, $flags = ENT_COMPAT | ENT_HTML401) {}

This yields a " PHP Parse error:  syntax error, unexpected '|', expecting ')' " although ENT_COMPAT|ENT_HTML401 is certainly what a compiler-affine person would call a "constant expression".

The obvious workaround is to use a single special value ($flags = NULL) as the default, and to set it to the desired value in the function's body (if ($flags === NULL) { $flags = ENT_COMPAT | ENT_HTML401; }).

Following code snippet will be executed w/o errors on PHP version 7. In this example, parent keyword is referencing on ParentClass instead of ClassTrait.
<?php
namespace TestTypeHints;

class

ParentClass
{
    public function someMethod()
    {
        echo 'Some method called' . PHP_EOL;
    }
}

trait

ClassTrait
{
    private $original;

    public function

__construct(parent $original)
    {
        $this->original = $original;
    }

    protected function

getOriginal(): parent
    {
        return $this->original;
    }
}

class

Implementation extends ParentClass
{
    use ClassTrait;

    public function

callSomeMethod()
    {
        $this->getOriginal()->someMethod();
    }
}$obj = new Implementation(new ParentClass());
$obj->callSomeMethod();
?>

Outputs:
Some method called

function my_function($arg1, &$arg2) {
  if ($arg1 == true) {
    $arg2 = true;
  }
}
my_function(true, $arg2 = false);
echo $arg2;

outputs 1 (true)

my_function(false, $arg2 = false);
echo $arg2;

outputs 0 (false)

You must explicitly set your default argument value to be null (as explained in this page) so your function can also receive nulls.

For instance, if you type an argument as "string", but pass a null variable into it, you might expect to receive an empty string, but actually, PHP will yell at you a TypeError.

<?php
function null_string_wrong(string $str) {
  var_dump($str);
}
function null_string_correct(string $str = null) {
  var_dump($str);
}
$null = null;
null_string_wrong('a');     //string(1) "a"
null_string_correct('a');   //string(1) "a"
null_string_correct();      //NULL
null_string_correct($null); //NULL
null_string_wrong($null);   //TypeError thrown
?>

<?php
function takes_many_args(
    $first_arg // some description
    , $second_arg // another comment
    , $a_very_long_argument_name = something($complicated) // IDK
    , $arg_with_default = 5
    , $again = 'a default string', // IMHO this trailing comma encourages illegible code and not being permitted seemed  a good idea lost with 8.0.0.
) {
    // ...
}
?>

This principle can be applied equally to complicated boolean expressions of an "if" statement (or the parts of a for statement).

<?phpfunction test1($a, $c, $b = 2)
{
    return $a + $b + $c;
}

function

test2($a, $b = 2, $c)
{
    return $a + $b + $c;
}

echo

test1(a: 1, c: 3)."n"; // Works
echo test2(a: 1, c: 3)."n"; // ArgumentCountError: Argument #2 ($b) not passed?>

I assume that this happens because internally PHP rewrites the calls to something like test1(1, 3) and test2(1, , 3). The first call is valid, but the second obviously isn't.