PHP: Функционални параметри и аргументи. Php грешка - Невалиден аргумент за върната стойност на функцията foreach().

Вашето съобщение е правилно.

За съжаление, ако трябва да използвате незадължителен параметър в самия край на списъка с параметри, трябва да посочите всеки последен параметър. Обикновено, ако искате да смесвате и съпоставяте, вие им давате стойности по подразбиране "" или null и не ги използвайте във функцията, ако са стойността по подразбиране.

Няма начин да "предадете" аргумент, освен като посочите стойността по подразбиране като false или null.

Тъй като на PHP липсва синтактична захар, когато става въпрос за това, често ще видите нещо подобно:

Checkbox_field(array("name" => "някакво име", ....));

Който, както красноречиво се казва в коментарите, използва масиви за емулиране на именувани аргументи.

Това дава максимална гъвкавост, но може да не е необходимо в някои случаи. Най-малкото можете да преместите всичко, което смятате, че не се очаква в повечето случаи в края на списъка с аргументи.

Не, не е възможно да се пропускат аргументи по този начин. Можете да пропуснете преминаващите аргументи само чев случай, че са в края на списъка с параметри.

Имаше официално предложение за това: https://wiki.php.net/rfc/skipparams, което беше отхвърлено. Страницата с предложения е свързана с други SO въпроси по тази тема.

Нищо не се е променило по отношение на възможността за пропускане на незадължителни аргументи, но в името на правилния синтаксис и за определяне на NULL за аргументите, които искам да пропусна, ето как бих го направил:

Define("DEFAULT_DATA_LIMIT", "50"); define("DEFAULT_DATA_PAGE", "1"); /** * getData * получаване на страница с данни * * Параметри: * име - (задължително) името на данните за получаване * лимит - (по избор) изпратете NULL, за да получите лимита по подразбиране: 50 * страница - (по избор) изпратете NULL за получаване на страницата по подразбиране: 1 * Връща: * страница с данни като масив */ функция getData($name, $limit = NULL, $page = NULL) ( $limit = ($limit==NULL) ? DEFAULT_DATA_LIMIT: $limit; $page = ($page==NULL) ? DEFAULT_DATA_PAGE: $page; ... )

Може да се извика така: getData("някое име",NULL,"23"); и всеки, който извика функцията в бъдеще, не трябва да помни стойностите по подразбиране всеки път или константата, декларирана за тях.

Прост отговор: Не. Но защо да пропускате, когато нулирането на аргументите постига това?

Ваш – “ Неправилно използване на аргументите на функцията по подразбиране“ и няма да работи както очаквате.

Странична бележка от документацията на PHP:

Когато използвате аргументи по подразбиране, всички стойности по подразбиране трябва да са от дясната страна на всички аргументи, които не са по подразбиране; в противен случай нещата няма да работят както се очаква.

Помислете за следното:

Функция getData($name, $limit = "50", $page = "1") ( return "Select * FROM books WHERE name = $name AND page = $page limit $limit"; ) echo getData("some name" , "", "23"); // няма да работи според очакванията

Резултатът ще бъде:

„Изберете * FROM books WHERE име = някакво име И страница = ограничение от 23“

Правилното използване на аргументите на функцията по подразбиране трябва да бъде както следва:

Функция getData($name, $page = "1", $limit = "50") ( return "Select * FROM books WHERE name = $name AND page = $page limit $limit"; ) echo getData("some name" , "23"); //работи според очакванията

Резултатът ще бъде:

„Изберете * FROM books WHERE име = някакво име И страница = 23 ограничение 50“

По подразбиране, след стойности, които не са по подразбиране, тя винаги ще замества стойността по подразбиране за тази променлива, освен ако такава не е дефинирана/посочена. Ето връзка за справка и откъде идват тези примери.

Редактиране: Задаването на това на null като null други може да работи и е друга алтернатива, но може да не е това, което искате. Той винаги задава стойността по подразбиране на нула, ако не е дефинирана.

Както бе споменато по-горе, няма да можете да пропускате опции. Написах този отговор, за да осигуря някакво допълнение, което беше твърде голямо, за да го публикувам в коментар.

@Frank Nocke предлага извикване на функцията с нейните параметри по подразбиране, например като

Функция a($b=0, $c=NULL, $d="")( //...

трябва да използвате

$var = a(0, NULL, "ddd");

което ще функционира по същия начин като пропускането на първите два параметъра ($b и $c).

Не е ясно кои от тези са стойностите по подразбиране (настроено ли е на 0, за да посочи стойността по подразбиране, или това е важно?).

Съществува и опасност проблемът със стойностите по подразбиране да е свързан с външна (или вградена) функция, където стойностите по подразбиране могат да бъдат променени от автора на функцията (или метода). Така че, ако не промените обаждането си в програмата, може по невнимание да промените поведението му.

Някакво заобиколно решение може да бъде да се дефинират някои глобални константи като DEFAULT_A_B, които ще бъдат „стойността по подразбиране за параметър B на функция A“ и „пропускане“ по този начин:

$var = a(DEFAULT_A_B, DEFAULT_A_C, "ddd");

За класовете е по-просто и по-елегантно, ако дефинирате класови константи, защото те са част от глобалния обхват, например.

Клас MyObjectClass ( const DEFAULT_A_B = 0; функция a($b = self::DEFAULT_A_B)( // тяло на метода)) $obj = нов MyObjectClass(); $var = $obj->a(MyObjectClass::DEFAULT_A_B); // и т.н.

Имайте предвид, че тази константа по подразбиране е дефинирана точно веднъж в целия код (няма стойност дори в декларацията на метода), така че в случай на неочаквани промени винаги ще предоставяте на функцията/метода правилната стойност по подразбиране.

Яснотата на това решение със сигурност е по-добра от предоставянето на необработени стойности по подразбиране (като NULL, 0 и т.н.), които не казват нищо на читателя.

(Съгласен съм, че извикването като $var = a(,"ddd"); би било по-добър вариант)

За всеки липсващ параметър (трябва) отидете с параметъра по подразбиране, за да сте на сигурно място.

(Задоволяването на нула, където настройката по подразбиране е "" или подобна или обратното, ще ви навлече проблеми...)

Не можете да предавате аргументи, но можете да използвате параметри на масив и трябва да дефинирате само един параметър, който е масив от параметри.

Функция myfunction($array_param) ( echo $array_param["name"]; echo $array_param["age"]; ............. )

И можете да добавите толкова параметри, колкото имате нужда, не е нужно да ги дефинирате. Когато извиквате функция, задавате параметрите си по следния начин:

Myfunction(array("name" => "Bob","age" => "18", .........));

Е, както всички вече казаха, това, което искате, няма да бъде възможно в PHP без добавяне на няколко реда код към функциите.

Но можете да поставите тази част от кода в горната част на функцията, за да получите вашите функции:

Foreach((new ReflectionFunction(debug_backtrace()["function"]))->getParameters() като $param) ( if(empty($($param->getName())) && $param->isOptional()) $($param->getName()) = $param->getDefaultValue(); )

Така че основно с debug_backtrace() получавам името на функцията, в която е поставен този код, за да създам нов обект ReflectionFunction и да завъртя всички аргументи на функцията.

В цикъла просто проверявам дали аргументът на функцията е празен() И аргументът е „незадължителен“ (което означава, че има стойност по подразбиране). Ако е така, просто присвоявам стойност по подразбиране на аргумента.

демонстрация

Задайте ограничението на нула

Функция getData($name, $limit = null, $page = "1") ( ... )

и извикайте тази функция

GetData("някакво име", null, "23");

ако искате да зададете ограничение, можете да подадете като аргумент

GetData("някакво име", 50, "23");

Както беше посочено по-рано, нищо не се е променило. Пазете се обаче от твърде много параметри (особено разширени) - силен индикатор за миризма на код.

Може би вашата функция е твърде голяма:

// първи контекст за изграждане $dataFetcher->setPage(1); // $dataFetcher->setPageSize(50); // не се използва тук // след това изпълнете работата $dataFetcher->getData("някое име");

Някои параметри могат да бъдат групирани логически:

$pagination = нова пагинация(1 /*, 50*/); getData("някакво име", $pagination); // Кодерите на Java вероятно ще са запознати с тази форма: getData("някое име", ново Pagination(1));

В последния случай винаги можете да въведете параметър ad-hoc обект:

$param = нов GetDataParameter(); $param->setPage(1); // $param->setPageSize(50); // не се използва тук getData($param);

(това е само прославена версия на по-малко формалния метод масив от параметри)

Понякога причината за създаване на параметъра не е необходима. В този пример $page наистина ли означава да бъде по избор? Наистина ли има значение запазването на няколко знака?

// съмнително // не е очевидно на пръв поглед, че извикване без параметри на "getData()" // връща само една страница с данни функция getData($page = 1); // това има повече смисъл function log($message, $timestamp = null /* текущо време по подразбиране */);

Този фрагмент:

Функция getData($name, $options) ($default = array("limit" => 50, "page" => 2,); $args = array_merge($default, $options); print_r($args); ) getData("foo", array()); getData("foo", array("limit" => 2)); getData("foo", array("limit" => 10, "page" => 10));

Масив ( => 50 [страница] => 2) масив ( => 2 [страница] => 2) масив ( => 10 [страница] => 10)

Ето какво бих направил:

Надявам се това да помогне на някого

Опитай.

Функция getData($name, $limit = NULL, $page = "1") ( if (!$limit)( $limit = 50; ) ) getData("някое име", "", "23");

Не можете да пропуснете средния параметър в извикване на функция. Но можете да заобиколите това:

Function_call("1", "2", "3"); // Предаване с параметър. function_call("1", null, "3"); // Предаване без параметър.

Функция function_call($a, $b="50", $c)( if(isset($b))( echo $b; ) else( echo "50"; ) )

Както отбеляза @IbrahimLawal. Най-добре е просто да им зададете нулеви стойности. Просто проверете дали стойността е null, в която използвате вашите зададени настройки по подразбиране.

Надявам се това да помогне.

GetData("някакво име");

просто не ги предавайте и стандартното ще бъде прието

Php функции

Php скриптове

func_get_arg

Описание

Връща аргумента arg_num -th от списъка с аргументи на потребителската функция. Номерирането на аргументите на функцията започва от нула. func_get_arg()генерира предупреждение, когато се извиква извън дефиниция на функция.

Ако arg_num е по-голям от броя на предадените аргументи, ще се генерира предупреждение и func_get_arg()Ще се върне НЕВЯРНО .

func_get_arg()може да се използва заедно с func_num_args()И func_get_args()за създаване на функции с променлив брой аргументи.

Бележки, предоставени от потребителя

Относно оператор "отлагане". за dvogel at ssc dot wisc dot edu, изберете отровата си:

func_get_arg() изглежда не е позволено да се използва като аргумент на самата функция в рамките класконструктори в PHP 5.0.2 (wonk-ay!!!):

Горният скрипт генерира:

Фатална грешка: func_get_arg(): Не може да се използва като функционален параметър в c:\Inetpub\wwwroot\phpwasrc\chapter10\xxx на ред 23

Няма обаче проблеми при предаването им като параметри на обикновени функции.
dvogel и ssc точка wisc точка edu
22-10-2004 01:54

Винаги съм искал оператор за отлагане или каскада, за да мога да използвам този израз:

$a = $b ## $c ## $d ;

И всичко отдясно на оператора за присвояване би изчислило най-лявата стойност, която не е нула. По същество това е свита версия на това:

ако($b) (
$a =$b ;
} друго {
ако($c) (
$a =$c ;
} друго {
ако($d) (
$a = $d;
} друго {
$a = нула;
}
}
}

В допълнение към това, опитвам се да направя функция, която приема променлив брой аргументи и връща първия, който не е нула. Не искам да използвам това в някои големи масиви, така че бих искал да предам тези по препратка. Обаче предаването на препратки по време на извикване е деактивирано (и трябва да бъде, imo) в по-новите версии на PHP. Бих искал предложения как да предам както препратки, така и стойности към този all.php?act=funct&argument =

Единственото решение, за което се сещам, е да задам променливи към референцията на масивпърви. напр.

$a = масив (...);
$b = 0;
$c =
first_not_null($a, $b);

Някой знае ли по-добро решение?
harald в triptop dot org
15-09-2004 02:09

func_get_argе полезно, акознаете точния ред на аргументите, или акоредът няма значение. Използвам тази функция (или func_get_args) запример за създаване на собствен sprintfопаковки.

акоискате да предадете променлив брой аргументи на функция, според мен е по-добре да го изпратите като ключ/стойност масивнапр.:

И "извличане" на масиввътре в all.php?act=funct&argument= не е нужно да правите трикове като проверка на типа заразпознаване на параметри, в този случай.
04-06-2004 05:16

Всъщност смятам, че има нужда затакива функции "прави абсолютно всичко". Използвам ги предимно като инструменти забързо прототипиране.
И има метод, с който можете да прехвърлите няколко низа на функция: ерег ();
Друга употреба затакива функции е да създават малки кодови фрагменти задруги хора там. Те вече няма да трябва да редактират функцията акоте не използват параметър. Те просто не го назовават, когато извикват all.php?act=funct&argument=
Това води до всеобхватни функции, които са много стабилни в употребата си. Обикновено имате само малък кодов фрагмент (напр. фрагменти за блокиране на ip). Чрез този тип програмиране имате цели функции.
26-05-2004 08:29

Много, освен ако не е умно, трябва да посочите поне два параметъра от един и същи тип - кой кой е? Очевидно можете да изберете някои настройки по подразбиране, но тогава всичко става грозно. Какво акоимате нужда САМО от низ акое предоставено и булево значение? Проверката на типа става основният фокус на вашата функция, мамка му. Зав името на чистия код трябва да посочите чист интерфейс към вашите функции и да решите какво и къде се предава като аргумент. Да, винаги можете да кодирате функция do_absolutely_everything(), но има ли смисъл?
anders at ingemann точка fakestuff точка de
30.04.2004 03:18 ч

Доста готино нещо запотребител дефиниранифункции е само да изпрати необходимите параметри. Акоизвиквате функция, която има три незадължителни параметъра, които трябва дефинирампървите две (дори акоте трябва да останат като дефиниранистандарт във функцията), преди да можете да кажете на функцията какъв е третият важен параметър. Вместо това можете просто да разберете по шаблона или типа на изпратения параметър към коя променлива трябва да бъде присвоен.
като този:

Няма значение акоправиш това:

Можете също да използвате ерег(). Чрез това можете да използвате повече от един параметър като низ.
хм вероятно ерег() е най-доброто решение...
Няма значение.
просто вижте ;-)
могъщи (в) могъщи (точка) org
12-03-2004 08:45

func_get_arg() връща * копие* на аргумента, доколкото ми е известно, няма начин да се извлекат препратки към променлив брой аргументи.

Имам модулна система в моята игра, където бих искал да мога да предавам променлив брой аргументи на функции в модул и да ги предавам по препратка акомодулът пита затова чрез препратка, но не можете да приемете незадължителни параметри като препратки, нито можете да извлечете препратката на променлив брой аргументи. Изглежда, че моите модули ще трябва да се справят с възможността да приемат параметри на своите функции чрез препратка.
martin at classaxe точка com
07-06-2002 09:55

Тази функция, макар и елегантна, сама по себе си не избягва проблема с генерирането на предупредителни съобщения, когато променливите не са зададени, освен ако разбира се не сте изключили предупрежденията:
съобщаване на грешка(E_ERROR);

Отговорът затези, които обичат да виждат необходимите предупреждения?
Наречете го така:
@allSet($w, $x, $y, $z)

Параметрите са посочени в дефиницията на функцията, в скоби, и са нейните локални променливи, т.е. те се виждат само в тялото й, ако има няколко параметъра, те се посочват разделени със запетаи. При извикване функцията може да получи аргументи, които се използват за инициализиране на параметри.

Разгледахме какви са параметрите, сега ще научим с какви стойности се инициализират. Стойностите, които ще бъдат присвоени на параметрите, се наричат ​​аргументи - това може да бъде например низ или цяло число, променлива или някакъв по-сложен израз, състоящ се от променливи и оператори, но който може да бъде оценен от PHP интерпретатора за да се получи стойността, с която ще се инициализира параметърът. Просто казано, аргументът е стойността, предадена на функция:

Предаване на аргументи

PHP поддържа два начина за предаване на аргументи на функцията. Първият е предаване на аргументи по стойност (работи по подразбиране), вторият е предаване на аргументи по референция. PHP също поддържа стойности по подразбиране. Нека сега разгледаме и трите варианта по-подробно.

По подразбиране аргументите се предават на функция по стойност (това означава, че ако промените стойността на параметър вътре във функцията, стойността, предадена извън нея, ще остане същата):

$color color"; // Стойността на променливата не се е променила?>

Ако трябва да разрешите на функция да променя предадените аргументи извън функцията, трябва да ги предадете по препратка. За да бъде подаден аргумент по препратка, трябва да посочите & (амперсанд) преди името на параметъра в дефиницията на функцията:

Функциите могат да дефинират стойности на аргументи по подразбиране. За да зададете стойност по подразбиране, в дефиницията на функцията трябва само да присвоите параметъра на желаната стойност:

\n"; ) echo tea(); // ще отпечата стойността по подразбиране echo tea("black"); ?>

Забележка: Всички параметри, които имат стойности на аргументи по подразбиране, трябва да бъдат разположени отдясно на аргументи, които нямат стойности по подразбиране, в противен случай вашият код може да не работи според очакванията:

Върната стойност на функцията

Когато една функция завърши, тя може да върне някаква стойност (резултат от функцията) на програмата, която я е извикала. Операторът return във функциите се използва за определяне на стойността, върната от функцията. Връщаната стойност може да бъде всякакъв тип. Има следния синтаксис:

Израз за връщане;

Операторът return може да се намира навсякъде във функцията. Когато контролът го достигне, функцията връща стойност (ако е зададена) и завършва изпълнението си. Ако оператор за връщане не е посочен или не е посочена върната стойност, тогава функцията ще върне NULL. За да използвате върнатата стойност, резултатът от изпълнението на функцията може да бъде присвоен на променлива, например:

"; // => 16. функция foo($num) ( if($num === 10) return "$num е 10"; else return "$num не е 10"; echo "hello"; // this ред от код никога няма да бъде изпълнен) echo foo(6); ?>

Възможно ли е в PHP 4/5 да посочите наименуван незадължителен параметър при извикване, като пропуснете тези, които не искате да посочите (както в python)?

Функция foo($a,$b="", $c="") ( // каквото и да е ) foo("здравей", $c="bar"); // искаме $b по подразбиране, но посочете $c

Не, не е възможно: ако искате да предадете третия параметър, трябва да предадете втория. И именуваните параметри също не са възможни.

„Решение“ би било да използвате само един параметър, масив, и винаги да го предавате... Но не винаги дефинирайте всичко в него.

Функция foo($params) ( var_dump($params); )

И го наричам така:

Foo(масив("a" => "здравей",)); foo(array("a" => "hello", "c" => "glop",)); foo(array("a" => "hello", "test" => "other one",));

Ще получите този резултат:

Масив "a" => низ "hello" (length=5) array "a" => низ "hello" (length=5) "c" => низ "glop" (length=4) масив "a" => низ "здравей" (дължина=5) "тест" => низ "още един" (дължина=11)

Но не ми харесва това решение:

• Ще загубите phpdoc
• Вашето IDE вече няма да може да дава никакви подсказки... Което е лошо

Така че бих използвал това само в много специфични случаи - за функции с много незадължителни параметри, например...

Не, PHP не може да предава аргументи по име.

Ако имате функция, която приема много аргументи и всички те имат стойности по подразбиране, можете да обмислите вместо това функцията да приема масив от аргументи:

Функционален тест (масив $args) ( $defaults = array("a" => "", "b" => "", "c" => ""); $args = array_merge($defaults, array_intersect_key($args , $defaults)); list($a, $b, $c) = array_values($args); // алтернатива на list(): extract($args); // вече можете да използвате $a, $b , $c )

Единственият начин, по който можете донякъде да направите това, е като използвате масиви с именувани ключове и какво ли още не.

При PHP редът на аргументите е това, което има значение. Не можете да посочите определен аргумент не на място, но вместо това можете да пропуснете аргументи, като подадете NULL, стига да нямате нищо против стойността във вашата функция да има NULL стойност.

Foo("здравей", NULL, "бар");

Считано от PHP 5.4имате съкратен синтаксис на масива (не е необходимо да указвате масиви с тромавия „масив“ и вместо това да използвате „“).

Можеш мимическиименувани параметри по много начини, един добър и прост начин може да бъде:

Bar("one", ["a1" => "two", "bar" => "three", "foo" => "four"]); // изход: twothreefour функционална лента ($a1, $kwargs = ["bar" => null, "foo" => null]) ( extract($kwargs); echo $a1; echo $bar; echo $foo; )

Не е точно красиво, но върши работа, биха казали някои.

Клас NamedArguments ( статична функция init($args) ( $assoc = reset($args); if (is_array($assoc)) ( $diff = array_diff(array_keys($assoc), array_keys($args)); if (празен ($diff)) return $assoc; trigger_error("Невалидни параметри: ".join(",",$diff), E_USER_ERROR); ) return array(); ) ) class Test (публична статична функция foobar($required, $ optional1 = "", $optional2 = "") ( extract(NamedArguments::init(get_defined_vars())); printf("required: %s, optional1: %s, optional2: %s\n", $required, $ optional1, $optional2); ) ) Тест::foobar("required", "optional1", "optional2"); Test::foobar(array("required" => "required", "optional1" => "optional1", "optional2" => "optional2"));

Можете да запазите phpdoc и възможността да задавате настройки по подразбиране, като подадете обект вместо масив, напр.

Клас FooOptions ( $opt1 = "x"; $opt2 = "y"; /* и т.н. */);

Това също ви позволява да извършвате стриктна проверка на типа във вашето извикване на функция, ако искате да:

Функция foo(FooOptions $opts) ( ... )

Разбира се, може да платите за това с допълнителна подробност, настройвайки обекта FooOptions. За съжаление няма напълно безплатно пътуване.

Обикновено не можете, но мисля, че има много начини за предаване на именувани аргументи на PHP функция. Лично аз разчитам на дефиницията, използвайки масиви и просто извиквам това, което трябва да предам:

Class Test( public $a = false; private $b = false; public $c = false; public $d = false; public $e = false; public function _factory())( $args = func_get_args(); $args = $ args; $this->a = array_key_exists("a",$args)? $args["a"] : 0; $this->b = array_key_exists("b",$args)? $args["b" " ] : 0; $this->c = array_key_exists("c",$args) ? $args["c"] : 0; $this->d = array_key_exists("d",$args) ? $args[ " d"] : 0; $this->e = array_key_exists("e",$args) ? $args["e"] : 0; ) публична функция show() ( var_dump($this); ) ) $test = нов тест (); $args["c"]=999; $test->_factory($args); $test->show();

Ако трябва да предам 10 аргумента и 3 от тях са данните, от които наистина се нуждая, ДОРИ НЕ Е УМНО да предам във функцията нещо като

Връща myfunction(false,false,10,false,false,"date",false,false,false,"desc");

С подхода, който давам, можете да настроите всеки от 10-те аргумента в масив:

$arr["count"]=10; $arr["тип"]="дата"; $arr["order"]="desc"; връщане на моята функция ($ arr);

Имам публикация в моя блог, обясняваща този процес по-подробно.

Ето какво съм използвал. Дефиницията на функция приема един незадължителен аргумент от масив, който определя незадължителните именувани аргументи:

Функция func($arg, $options = Array()) ( $defaults = Array("foo" => 1.0, "bar" => FALSE); $options = array_merge($default, $options); // Нормална функция тяло тук. Използвайте $options["foo"] и // $options["bar"], за да извлечете наименувани стойности на параметри. ... )

Обикновено можете да извикате без наименувани аргументи:

Func("xyzzy")

За да зададете незадължителен именуван аргумент, предайте го в незадължителния масив:

Func("xyzzy", Array("foo" => 5.7))

Не наистина. Има няколко алтернативи, които можете да използвате.

Тест(null,null,"здравей")

Или предайте масив:

Тест(масив("c" => "здравей"));

Тогава функцията може да бъде:

Функционален тест($масив) ( $c = isset($масив[c])? $масив[c] : ""; )

Или добавете функция между тях, но не бих предложил това:

Функция ctest($c) ( test("","",$c); )

Опитайте функционален тест ($a="",$b="",&$c="")()

Поставяне на & пред $c

Не мисля така…
Ако трябва да извикате например функцията substr, която има 3 параметъра, и искате комплектдължината на $ беззадайте $start, ще бъдете принудени да го направите.

Substr($str,0,10);

хубав начин да отмените това е да използвате винаги масивиза параметри

Прост отговор. Не, не можеш.
Можете да опитате да го заобиколите, като подадете обект/масив или използвате някои други модели на инжектиране на зависимости.

Също така, опитайте се да използвате нули, а не празни низове, тъй като е по-определено да тествате за тяхното съществуване с помощта на is_null()

Функционален тест ($a=null,$b=null,$c=null)( if (is_null($a) ( //направи нещо относно $a ) if (is_null($b) ( //направи нещо относно $b ) if (is_null($c) ( //направи нещо за $c ) )

Тест(null,null,"Здравей");

Накратко, понякога да, чрез използване на отражение и въведени променливи. Мисля обаче, че това вероятно не е това, което търсите.

По-добро решение на вашия проблем вероятно е да подадете 3-те аргумента, тъй като функциите сами обработват липсващия във вашата функция

Не можете да го направите по начина на питона. Както и да е, можете да подадете асоциативен масив и след това да използвате записите в масива по техните имена:

Функционален тест ($args=array("a"=>"","b"=>"","c"=>"")) ( // направете нещо ) test(array("c"=>"Hello "));

Това не намалява въвеждането, но поне е по-описателно, като имената на аргументите са видими и четливи в извикването.

Ето една работа около:

Функция set_param_defaults($params) ( foreach($params["default_values"] as $arg_name => $arg_value) ( ​​​​if (!isset($params[$arg_name])) ( $params[$arg_name] = $arg_value ; ) ) return $params; ) function foo($z, $x = null, $y = null) ( $default_values ​​​​= ["x" => "стойност по подразбиране за x", "y" => "default стойност за y" ]; $params = set_param_defaults(get_defined_vars()); print "$z\n"; print $params["x"] . "\n"; print $params["y"] . "\n "; ) foo ("задайте z стойност", нула, "задайте y стойност"); печат "\n"; foo("задайте z стойност", "задайте x стойност");

АЛТЕРНАТИВА:
Лично аз бих избрал този метод.

Функция foo($z, $x_y) ( $x_y += ["x" => "стойност по подразбиране за x", "y" => "стойност по подразбиране за y"]; print "$z\n"; print $ x_y["x"] . "\n"; отпечатайте $x_y["y"] . "\n"; ) foo("задаване на z стойност", ["y" => "задаване на y стойност"]); печат "\n"; foo("set z value", ["x" => "set x value"]);

Разпечатки за двата примера.

• задайте z стойност
• стойност по подразбиране за x
• задайте стойност на y

• задайте z стойност
• задайте стойност x
• стойност по подразбиране за y

Просто използвайте модела на асоциативен масив, който Drupal използва. За незадължителни аргументи по подразбиране просто приемете аргумент $options, който е асоциативен масив. След това използвайте оператора array +, за да зададете всички липсващи ключове в масива.

Функция foo ($a_required_parameter, $options = array()) ( $options += array("b" => "", "c" => "",); // каквото и да е) foo("a", array( "c" => "стойност на c")); // Няма нужда да се предава b, когато се указва c.