Funktionsargument

Funktionsargument

Information kan skickas till funktioner via argumentlistan, som är en kommaseparerad lista med uttryck. Argumenten utvärderas från vänster till höger, innan funktionen faktiskt anropas (ivrig utvärdering).

PHP stöder att skicka argument via värde (standard), att skicka via referens och standardargumentvärden. Variabla argumentlistor och namngivna argument stöds också.

Exempel #1 Skicka arrayer till funktioner

<?php
function takes_array($input)
{
    echo "$input[0] + $input[1] = ", $input[0]+$input[1];
}
?>

Från och med PHP 8.0.0 kan listan över funktionsargument inkludera ett avslutande kommatecken, vilket kommer att ignoreras. Detta är särskilt användbart i fall där argumentlistan är lång eller innehåller långa variabelnamn, vilket gör det bekvämt att lista argument vertikalt.

Exempel #2 Funktionsargumentlista med avslutande komma

<?php
function takes_many_args(
    $first_arg,
    $second_arg,
    $a_very_long_argument_name,
    $arg_with_default = 5,
    $again = 'a default string', // Detta avslutande komma var inte tillåtet före 8.0.0.
)
{
    // ...
}
?>

Skicka argument via referens

Som standard skickas funktionsargument via värde (så att om värdet av argumentet ändras inom funktionen, ändras det inte utanför funktionen). För att tillåta en funktion att ändra sina argument måste de skickas via referens.

För att ett argument alltid ska skickas via referens, lägg till ett ampersand (&) framför argumentets namn i funktionsdefinitionen:

Exempel #3 Skicka funktionsparametrar via referens

<?php
function add_some_extra(&$string)
{
    $string .= 'and something extra.';
}
$str = 'This is a string, ';
add_some_extra($str);
echo $str;    // skriver ut 'This is a string, and something extra.'
?>

Det är ett fel att skicka ett värde som argument som förväntas skickas via referens.

Standardargumentvärden

En funktion kan definiera standardvärden för argument med syntax som liknar tilldelning av en variabel. Standardvärdet används endast när parametern inte är specificerad; särskilt bör noteras att om null skickas tilldelas inte standardvärdet.

Exempel #4 Användning av standardparametrar i funktioner

<?php
function makecoffee($type = "cappuccino")
{
    return "Making a cup of $type.\n";
}
echo makecoffee();
echo makecoffee(null);
echo makecoffee("espresso");
?>

Ovanstående exempel ger följande utmatning:

Making a cup of cappuccino.
Making a cup of .
Making a cup of espresso.

Standardparametervärden kan vara skalära värden, arrayer, den speciella typen null, och från och med PHP 8.1.0 även objekt med hjälp av new ClassName() syntax.

Exempel #5 Användning av icke-skalära typer som standardvärden

<?php
function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
{
    $device = is_null($coffeeMaker) ? "hands" : $coffeeMaker;
    return "Making a cup of ".join(", ", $types)." with $device.\n";
}
echo makecoffee();
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
?>

Ovanstående exempel ger följande utmatning:

Making a cup of cappuccino with hands.
Making a cup of cappuccino, lavazza with teapot.

Exempel #6 Användning av objekt som standardvärden (från PHP 8.1.0)

<?php
class DefaultCoffeeMaker {
    public function brew() {
        return "Making coffee.\n";
    }
}
class FancyCoffeeMaker {
    public function brew() {
        return "Crafting a beautiful coffee just for you.\n";
    }
}
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
{
    return $coffeeMaker->brew();
}
echo makecoffee();
echo makecoffee(new FancyCoffeeMaker);
?>

Ovanstående exempel ger följande utmatning:

Making coffee.
Crafting a beautiful coffee just for you.

Standardvärdet måste vara ett konstant uttryck, inte till exempel en variabel, en klassmedlem eller ett funktionsanrop.

Observera att alla valfria argument bör specificeras efter alla obligatoriska argument, annars kan de inte hoppas över vid anrop. Överväg följande exempel:

Exempel #7 Felaktig användning av standardfunktionsargument

<?php
function makeyogurt($container = "bowl", $flavour)
{
    return "Making a $container of $flavour yogurt.\n";
}
 
echo makeyogurt("raspberry"); // "raspberry" är $container, inte $flavour
?>

Ovanstående exempel ger följande utmatning:

Fatal error: Uncaught ArgumentCountError: Too few arguments
 to function makeyogurt(), 1 passed in example.php on line 42

Nu, jämför ovanstående med detta:

Exempel #8 Korrekt användning av standardfunktionsargument

<?php
function makeyogurt($flavour, $container = "bowl")
{
    return "Making a $container of $flavour yogurt.\n";
}
 
echo makeyogurt("raspberry"); // "raspberry" är $flavour
?>

Ovanstående exempel ger följande utmatning:

Making a bowl of raspberry yogurt.

Från och med PHP 8.0.0 kan namngivna argument användas för att hoppa över flera valfria parametrar.

Exempel #9 Korrekt användning av namngivna argument

<?php
function makeyogurt($container = "bowl", $flavour = "raspberry", $style = "Greek")
{
    return "Making a $container of $flavour $style yogurt.\n";
}

echo makeyogurt(style: "natural");
?>

Ovanstående exempel ger följande utmatning:

Making a bowl of raspberry natural yogurt.

Från och med PHP 8.0.0 är det föråldrat att deklarera obligatoriska argument efter valfria argument. Detta kan vanligtvis lösas genom att ta bort standardvärdet, eftersom det aldrig kommer att användas. Ett undantag från denna regel är argument av formen Type $param = null, där null som standard gör typen implicit nullable. Denna användning är fortfarande tillåten, även om det rekommenderas att använda en explicit nullable typ istället.

Exempel #10 Deklarera valfria argument efter obligatoriska argument

<?php
 function foo($a = [], $b) {} // Standardvärde används inte; föråldrat från PHP 8.0.0
 function foo($a, $b) {}      // Funktionellt ekvivalent, ingen föråldringsvarning

 function bar(A $a = null, $b) {} // Fortfarande tillåtet; $a är obligatoriskt men nullable
 function bar(?A $a, $b) {}       // Rekommenderat
 ?>

Notera: Från och med PHP 7.1.0, utelämnas en parameter som inte specificerar ett standardvärde och en ArgumentCountError kastas; i tidigare versioner gav det en varning.

Notera: Argument som skickas via referens kan ha ett standardvärde.

Variabla argumentlistor

PHP har stöd för variabla argumentlistor i användardefinierade funktioner genom att använda ... token.

Argumentlistor kan innehålla ... token för att ange att funktionen accepterar ett variabelt antal argument. Argumenten skickas in i den angivna variabeln som en array:

Exempel #11 Använda ... för att komma åt variabla argument

<?php
function sum(...$numbers) {
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}

echo sum(1, 2, 3, 4);
?>

Ovanstående exempel ger följande utmatning:

10

... kan också användas när du anropar funktioner för att packa upp en array eller Traversable variabel eller literal i argumentlistan:

Exempel #12 Använda ... för att tillhandahålla argument

<?php
function add($a, $b) {
    return $a + $b;
}

echo add(...[1, 2])."\n";

$a = [1, 2];
echo add(...$a);
?>

Ovanstående exempel ger följande utmatning:

3
3

Du kan specificera normala positionella argument före ... token. I detta fall kommer endast de efterföljande argumenten som inte matchar ett positionellt argument att läggas till i arrayen som genereras av ....

Det är också möjligt att lägga till en typdeklaration före ... token. Om detta finns måste alla argument som fångas av ... matcha den parametertypen.

Exempel #13 Typdeklarerade variabla argument

<?php
function total_intervals($unit, DateInterval ...$intervals) {
    $time = 0;
    foreach ($intervals as $interval) {
        $time += $interval->$unit;
    }
    return $time;
}

$a = new DateInterval('P1D');
$b = new DateInterval('P2D');
echo total_intervals('d', $a, $b).' days';

// Detta kommer att misslyckas, eftersom null inte är ett DateInterval-objekt.
echo total_intervals('d', null);
?>

Ovanstående exempel ger följande utmatning:

3 days

Catchable fatal error: Argument 2 passed to total_intervals() must be an instance of DateInterval, null given, called in - on line 14 and defined in - on line 2

Slutligen kan variabla argument också skickas via referens genom att prefixa ... med ett ampersand (&).

Namngivna argument

PHP 8.0.0 introducerade namngivna argument som en utvidgning av de befintliga positionella parametrarna. Namngivna argument tillåter att argument skickas till en funktion baserat på parameternamnet, snarare än parameterpositionen. Detta gör att argumentets betydelse blir självdokumenterande, gör att argumentens ordning blir oberoende och möjliggör att hoppa över standardvärden godtyckligt.

Namngivna argument skickas genom att prefixa värdet med parameternamnet följt av ett kolon. Användning av reserverade nyckelord som parameternamn är tillåtet. Parameternamnet måste vara en identifierare, det är inte tillåtet att specificera dynamiskt.

Exempel #14 Syntax för namngivet argument

<?php
myFunction(paramName: $value);
array_foobar(array: $value);

// INTE stöds.
function_name($variableStoringParamName: $value);
?>

Exempel #15 Positionella argument kontra namngivna argument

<?php
// Använda positionella argument:
array_fill(0, 100, 50);

// Använda namngivna argument:
array_fill(start_index: 0, count: 100, value: 50);
?>

Ordningen i vilken de namngivna argumenten skickas spelar ingen roll.

Exempel #16 Samma exempel som ovan med en annan ordning på parametrarna

<?php
array_fill(value: 50, count: 100, start_index: 0);
?>

Namngivna argument kan kombineras med positionella argument. I detta fall måste de namngivna argumenten komma efter de positionella argumenten. Det är också möjligt att endast specificera några av de valfria argumenten i en funktion, oavsett deras ordning.

Exempel #17 Kombinera namngivna argument med positionella argument

<?php
htmlspecialchars($string, double_encode: false);
// Samma som
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', false);
?>

Att skicka samma parameter flera gånger resulterar i ett Error-undantag.

Exempel #18 Fel som kastas när samma parameter skickas flera gånger

<?php
function foo($param) { ... }

foo(param: 1, param: 2);
// Fel: Namngiven parameter $param skriver över tidigare argument
foo(1, param: 2);
// Fel: Namngiven parameter $param skriver över tidigare argument
?>

Från och med PHP 8.1.0 är det möjligt att använda namngivna argument efter att ha packat upp argumenten. Ett namngivet argument får inte skriva över ett redan uppackat argument.

Exempel #19 Använd namngivna argument efter uppackning

<?php
function foo($a, $b, $c = 3, $d = 4) {
  return $a + $b + $c + $d;
}

var_dump(foo(...[1, 2], d: 40)); // 46
var_dump(foo(...['b' => 2, 'a' => 1], d: 40)); // 46

var_dump(foo(...[1, 2], b: 20)); // Fatal error. Namngiven parameter $b skriver över tidigare argument
?>

Sidslut

Orginalhemsidan på Engelska :
PHP
Språkreferens
Språkreferens#Funktioner