Ang bawat programming language ay may mga subroutine. Sa C sila ay tinatawag na mga function, sa assembly language sila ay tinatawag na mga subroutine, at sa Pascal mayroong kahit dalawang uri ng mga subroutine: mga pamamaraan at mga pag-andar.

Ang subroutine ay isang espesyal na idinisenyong fragment ng isang programa na maaaring ma-access mula sa kahit saan sa loob ng programa. Ang mga subroutine ay lubos na pinasimple ang buhay ng mga programmer sa pamamagitan ng pagpapabuti ng pagiging madaling mabasa ng source code, pati na rin ang pagpapaikli nito, dahil ang mga indibidwal na mga fragment ng code ay hindi kailangang isulat nang maraming beses

Sa PHP, ang mga gawaing ito ay mga function na tinukoy ng gumagamit.

Bilang karagdagan sa mga built-in na function ng PHP, madalas na kailangang lumikha ng mga custom na function na gumaganap ng mga partikular na gawain.

Paglikha ng Mga Custom na Function

Ang isang function na tinukoy ng gumagamit ay maaaring ideklara sa anumang bahagi ng programa (script), hanggang sa punto ng unang paggamit nito. At hindi na kailangan ng anumang paunang deklarasyon, tulad ng sa iba pang mga programming language, sa partikular, sa C. Ang mga bentahe ng diskarte na ginamit sa PHP ay ang mga sumusunod.

Nang maabot ang kahulugan ng isang function na tinukoy ng gumagamit, susuriin ng tagasalin ang kawastuhan ng kahulugan at isasalin ang kahulugan ng function sa isang panloob na representasyon, ngunit hindi nito isasalin ang mismong code. At tama nga - bakit nag-broadcast ng code na maaaring hindi magamit. Ang syntax para sa pagdedeklara ng mga function ay ang mga sumusunod:

Pangalan ng function (argument1[=value1],...,argument1[=value1])
{
body_function
}

Ang deklarasyon ng function ay nagsisimula sa isang function na salita function, pagkatapos ay sumusunod ang pangalan ng function, pagkatapos ng pangalan ng function ay mayroong isang listahan ng mga argumento sa panaklong. Ang katawan ng function ay nakapaloob sa mga kulot na brace at maaaring maglaman ng anumang bilang ng mga pahayag.

Mga kinakailangan para sa mga pangalan ng function:

• Maaaring maglaman ng mga letrang Ruso ang mga pangalan ng function, ngunit hindi inirerekomenda ang pagbibigay ng mga pangalan ng function na binubuo ng mga letrang Ruso;
• Ang mga pangalan ng function ay hindi dapat maglaman ng mga puwang;
• Ang pangalan ng bawat function na tinukoy ng gumagamit ay dapat na natatangi. Kasabay nito, kinakailangang tandaan na ang kaso ay hindi isinasaalang-alang kapag nagdedeklara ng mga pag-andar at na-access ang mga ito. Iyon ay, halimbawa, ang mga function funct() at FUNCT() ay may parehong mga pangalan;
• Ang mga function ay maaaring bigyan ng parehong mga pangalan tulad ng mga variable, ngunit walang $ sign sa simula ng mga pangalan.

Ang mga uri ng halaga na ibinalik ng mga function na tinukoy ng user ay maaaring maging anumang uri. Upang ilipat ang resulta ng mga function ng user sa pangunahing programa (script), ginagamit ang konstruksiyon bumalik. Kung ang function ay hindi nagbabalik ng anuman, ang konstruksiyon bumalik huwag magpahiwatig. Disenyo bumalik maaaring ibalik ang anumang bagay, kabilang ang mga array.

Narito ang mga halimbawa ng paggamit ng mga custom na function.

Gaano man tayo gumamit ng PHP, lumalabas pa rin ang ilang function na hindi pa natin narinig. Ang ilan sa mga ito ay magiging lubhang kapaki-pakinabang sa atin. Gumawa ako ng maliit na listahan ng mga kapaki-pakinabang na function na dapat nasa arsenal ng bawat PHP programmer.

1. Paglikha ng mga function na may variable na bilang ng mga argumento

Malamang, alam mo na na pinapayagan kami ng PHP na lumikha ng mga function na may mga opsyonal na argumento. Ngayon ay magpapakita ako ng isang function kung saan ang bilang ng mga argumento ay maaaring mag-iba mula sa bawat kaso.

Ngunit una, tandaan natin kung paano tayo gumagawa ng mga function sa karaniwang paraan:

// function na may dalawang opsyonal na parameter function foo($arg1 = "", $arg2 = "") ( echo "arg1: $arg1\n"; echo "arg2: $arg2\n"; ) foo("hello", "mundo"); /* will output: arg1: hello arg2: world */ foo(); /* ay maglalabas: arg1: arg2: */

Ngayon tingnan natin kung paano ka makakasulat ng isang function na may walang limitasyong bilang ng mga argumento. Upang gawin ito, ang func_get_args() na pamamaraan ay gagamitin:

// do not specify arguments function foo() ( // nagbabalik ng array ng mga pumasa na argumento $args = func_get_args(); foreach ($args as $k => $v) ( echo "arg".($k+1) ." : $v\n"; ) ) foo(); /* ay hindi maglalabas ng anuman */ foo("hello"); /* will print arg1: hello */ foo("hello", "world", "muli"); /* ay magpi-print ng arg1: hello arg2: world arg3: muli */

2. Gamitin ang Glob() upang maghanap ng mga file

Kadalasan ang mga pangalan ng mga function ay nagsasalita para sa kanilang sarili. Ang parehong ay hindi maaaring sabihin para sa glob() function.

Nang walang masyadong maraming detalye, ang functionality nito ay katulad ng scandir() method. Pinapayagan ka nitong mahanap ang kinakailangang file gamit ang isang template:

// hanapin ang lahat ng php file $files = glob("*.php"); print_r($mga file); /* ay maglalabas ng: Array ( => phptest.php => pi.php => post_output.php => test.php) */

Upang makahanap ng mga file ng ilang uri kailangan mong sumulat ng ganito:

// hanapin ang lahat ng php at txt file $files = glob("*.(php,txt)", GLOB_BRACE); print_r($mga file); /* output: Array ( => phptest.php => pi.php => post_output.php => test.php => log.txt => test.txt) */

Maaari mo ring tukuyin ang landas sa template:

$files = glob("../images/a*.jpg"); print_r($mga file); /* output: Array ( => ../images/apple.jpg => ../images/art.jpg) */

Upang makuha ang buong landas sa isang dokumento, gamitin ang realpath() na pamamaraan:

$files = glob("../images/a*.jpg"); // Ilapat ang function na "realpath" sa bawat elemento ng array $files = array_map("realpath",$files); print_r($mga file); /* ay maglalabas ng: Array ( => C:\wamp\www\images\apple.jpg => C:\wamp\www\images\art.jpg) */

3. Impormasyon tungkol sa memorya na ginamit

Kung sinusubaybayan mo ang dami ng memory na natupok ng iyong mga script, malamang na mas madalas mong i-optimize ang mga ito.

Ang PHP ay may malakas na tool sa pagsubaybay sa memorya. Maaaring iba ang mga pag-load sa iba't ibang bahagi ng script. Upang makuha ang kasalukuyang ginagamit na halaga ng memorya, dapat nating gamitin ang paraan ng memory_get_usage(). Upang ayusin ang maximum na dami ng memory na ginamit, gamitin ang memory_get_peak_usage()

Echo "Initial: ".memory_get_usage()." bytes \n"; /* Initial: 361400 bytes */ // magbigay ng maliit na load para sa ($i = 0; $i< 100000; $i++) { $array = md5($i); } // и ещё for ($i = 0; $i < 100000; $i++) { unset($array[$i]); } echo "Final: ".memory_get_usage()." bytes \n"; /* Final: 885912 bytes */ echo "Peak: ".memory_get_peak_usage()." bytes \n"; /* Peak: 13687072 bytes */

4. Impormasyon ng processor

Para magawa ito, kailangan mong gamitin ang getrusage() method. Ngunit tandaan na ang tampok na ito ay hindi gagana sa Windows.

Print_r(getrusage()); /* prints Array ( => 0 => 0 => 2 => 3 => 12692 => 764 => 3864 => 94 => 0 => 1 => 67 => 4 => 0 => 0 => 0 => 6269 => 0) */

Ang larawang nakabalangkas sa itaas ay magiging malinaw sa mga may karanasan sa pangangasiwa ng system. Para sa iba pa, nag-aalok kami ng transcript:

• ru_oublock: bilang ng block write operations
• ru_inblock: bilang ng block read operations
• ru_msgsnd: bilang ng mga mensaheng ipinadala
• ru_msgrcv: bilang ng mga natanggap na mensahe
• ru_maxrss: maximum na laki ng isang hindi paged na set
• ru_ixrss: kabuuang halaga ng nakabahaging memorya
• ru_idrss: kabuuang dami ng hindi nakabahaging data
• ru_minflt: bilang ng mga memory page na ginamit
• ru_majflt: bilang ng mga nawawalang error sa pahina
• ru_nsignals: bilang ng mga natanggap na signal
• ru_nvcsw: bilang ng mga paglipat ng konteksto ayon sa proseso
• ru_nivcsw: bilang ng sapilitang paglipat ng konteksto
• ru_nswap: bilang ng disk accesses kapag paging
• ru_utime.tv_usec: oras ng pagpapatakbo sa user mode (microseconds)
• ru_utime.tv_sec: oras ng pagpapatakbo sa user mode (segundo)
• ru_stime.tv_usec: oras ng pagpapatakbo sa privileged mode (microseconds)
• ru_stime.tv_sec: oras ng pagpapatakbo sa privileged mode (segundo)

Upang malaman kung anong mga mapagkukunan ng iyong processor ang ginagamit ng script, kailangan mo ang halaga ng 'oras ng gumagamit' (oras ng gumagamit) at 'oras ng system' (oras ng privileged mode). Makukuha mo ang resulta sa parehong segundo at microsecond. Upang i-convert ang kabuuang bilang ng mga segundo sa isang decimal na numero, kailangan mong hatiin ang halaga ng microsecond sa 1 milyon at idagdag ang halaga ng mga segundo sa halaga.

Medyo nakakalito. Narito ang isang halimbawa:

// pahinga ng 3 segundong pagtulog(3); $data = getrusage(); echo "Oras ng gumagamit: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "Oras ng system: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* prints User time: 0.011552 System time: 0 */

Bagama't tumagal ng humigit-kumulang 3 segundo upang makumpleto ang script, hindi masyadong na-load ang processor. Ang katotohanan ay kapag tinawag (tulog), ang script ay halos walang mapagkukunan ng processor. Sa pangkalahatan, maraming mga gawain na tumatagal ng isang malaking halaga ng oras, ngunit hindi ginagamit ang processor. Halimbawa, naghihintay para sa mga operasyong nauugnay sa disk. Kaya hindi mo palaging ginagamit ang oras ng CPU sa iyong mga script.

Narito ang isa pang halimbawa:

// maglakad ng 10 milyong beses para sa ($i=0;$i<10000000;$i++) { } $data = getrusage(); echo "User time: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "System time: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* выводит User time: 1.424592 System time: 0.004204 */

Ang script ay tumagal ng 1.4 segundo ng oras ng CPU. Sa kasong ito, ang mga oras ng system call ay karaniwang mababa.

Ang privileged mode time (System Time) ay ang oras na ginugugol ng processor sa pagsasagawa ng mga kahilingan ng system sa kernel sa ngalan ng programa. Halimbawa:

$start = microtime(true); // tumawag sa microtime tuwing 3 segundo habang(microtime(true) - $start< 3) { } $data = getrusage(); echo "User time: ". ($data["ru_utime.tv_sec"] + $data["ru_utime.tv_usec"] / 1000000); echo "System time: ". ($data["ru_stime.tv_sec"] + $data["ru_stime.tv_usec"] / 1000000); /* выводит User time: 1.088171 System time: 1.675315 */

Ngayon ang oras ng system ay ginugol nang higit pa kaysa sa nakaraang halimbawa. Lahat salamat sa microtime() na pamamaraan, na gumagamit ng mga mapagkukunan ng system.

Gayunpaman, dapat tandaan na ang ipinapakitang oras ay maaaring hindi tumpak. Sa isang partikular na oras, ang mga mapagkukunan ng processor ay ginagamit din ng iba pang mga programa, na maaaring magresulta sa isang bahagyang error.

5. Magic constants

Maraming magic constant sa PHP, gaya ng kasalukuyang line number (__LINE__), file path (__FILE__), directory path (__DIR__), function name (__FUNCTION__), class name (__CLASS__), method name (__METHOD__) at namespaces ( __NAMESPACE__).

Hindi namin isasaalang-alang silang lahat. Tingnan natin ang isang pares:

// ang script na ito ay depende sa kasalukuyang lokasyon ng file at // ay maaaring magdulot ng mga problema kung ginamit mula sa iba't ibang mga direktoryo require_once("config/database.php"); // ang script na ito ay hindi magdudulot ng mga problema require_once(dirname(__FILE__) . "/config/database.php");

Gamitin ang __LINE__ kapag nagde-debug ng mga script:

// code // ... my_debug("some debug message", __LINE__); /* ay magpapakita ng Linya 4: ilang mensahe sa pag-debug */ // higit pang code // ... my_debug("isa pang mensahe ng debug", __LINE__); /* ay magpi-print ng Linya 11: isa pang mensahe ng debug */ function my_debug($msg, $line) ( echo "Line $line: $msg\n"; )

6. Pagbuo ng mga natatanging ID

May mga pagkakataon na kailangan mong bumuo ng isang natatanging string. Nakita ko nang maraming beses na ang md5() function ay ginagamit upang malutas ang problemang ito:

// bumuo ng random string echo md5(time() . mt_rand(1.1000000));

Ngunit sa katunayan, ang PHP ay may espesyal na function na uniqid() para sa mga layuning ito

// bumuo ng random string echo uniqid(); /* ay magpi-print ng 4bd67c947233e */ // isa pang beses echo uniqid(); /* ay magpi-print ng 4bd67c9472340 */

Sa mata ay makikita mo na ang mga unang simbolo ay, sa madaling salita, magkatulad... Ito ay dahil sa ang katunayan na ang pamamaraang ito ay gumagamit ng oras ng server upang makabuo ng mga simbolo. Ito ay kahit na kapaki-pakinabang, dahil... Ang lahat ng nabuong mga halaga ay nakuha sa alpabetikong pagkakasunud-sunod, na ginagawang posible upang mabilis na pag-uri-uriin ang mga ito.

Upang mabawasan ang mga pagkakataong makakuha ng duplicate, maaari kaming magdagdag ng prefix o gumamit ng pangalawang parameter (tinataas ang bilang ng mga character):

// prefixed with echo uniqid("foo_"); /* ay magpi-print ng foo_4bd67d6cd8b8f */ // na may pangalawang parameter na echo uniqid("",true); /* will print 4bd67d6cd8b926.12135106 */ // both echo uniqid("bar_",true); /* ay maglalabas ng bar_4bd67da367b650.43684647 */

Ang pamamaraang ito ay bumubuo ng mga string na mas maliit kaysa sa md5, sa gayon ay nakakatipid ng espasyo.

7. Serialization

Naranasan mo na bang mag-imbak ng kumplikadong data sa isang database o file? Upang ma-convert ang isang bagay sa isang string, ang PHP ay nagbibigay ng isang espesyal na function.

Sa pangkalahatan, mayroong 2 sa mga pamamaraang ito: serialize() at unserialize()

// complex array $myvar = array("hello", 42, array(1,"two"), "apple"); // convert sa string $string = serialize($myvar); echo $string; /* ay magpi-print ng:4:(i:0;s:5:"hello";i:1;i:42;i:2;a:2:(i:0;i:1;i:1; s :3:"dalawa";)i:3;s:5:"mansanas";) */ // makuha ang orihinal na halaga $newvar = unserialize($string); print_r($newvar); /* ay maglalabas ng Array ( => hello => 42 => Array ( => 1 => dalawa) => mansanas) */

Ganito gumagana ang mga function na ito. Gayunpaman, dahil sa mabilis na paglaki ng katanyagan ng JSON, 2 pamamaraan na json_encode() at json_decode() ang idinagdag sa PHP 5.2. Ang kanilang trabaho ay katulad ng serialize():

// complex array $myvar = array("hello", 42, array(1,"two"), "apple"); // convert sa string $string = json_encode($myvar); echo $string; /* ay magpi-print ng ["hello",42,,"apple"] */ // ibabalik ang orihinal na halaga $newvar = json_decode($string); print_r($newvar); /* prints Array ( => hello => 42 => Array ( => 1 => dalawa) => mansanas) */

Ang pagpipiliang ito ay mas compact at tugma sa iba pang mga wika tulad ng JavaScript. Gayunpaman, kapag nagtatrabaho sa napakakomplikadong mga bagay, maaaring mangyari ang pagkawala ng data.

8. Pag-compress ng string

Kapag pinag-uusapan natin ang tungkol sa compression, agad na naiisip ang mga archive na file sa ZIP format. Nagbibigay ang PHP ng kakayahang mag-compress ng mahabang string nang walang anumang mga file.

Ang sumusunod na halimbawa ay nagpapakita kung paano gumagana ang gzcompress() at gzuncompress() function:

$string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc ut elit id mi ultricies adipiscing. Nulla facilisi. Praesent pulvinar, sapien vel feugiat vestibulum, nulla dui pretium orci, non ultricies elit lacus quis ante. Lorem i amet , consectetur adipiscing elit. $compressed = gzcompress($string); echo "Orihinal na laki: ". strlen($string)."\n"; /* ay maglalabas ng Orihinal na laki: 800 */ echo "Naka-compress na laki: ". strlen($compressed)."\n"; /* ay maglalabas ng Compressed size: 418 */ // return $original = gzuncompress($compressed);

Maaari naming bawasan ang volume ng text ng 50%. Para sa parehong mga layunin, maaari mong gamitin ang gzencode() at gzdecode() na mga pamamaraan, na gumagamit ng ibang compression algorithm.

9. Ipatupad bago lumabas

Ang PHP ay may register_shutdown_function() function na magpapahintulot sa iyo na magsagawa ng ilang code bago isara ang script.

Sabihin nating gusto mong malaman ang ilang impormasyon... Oras ng pagtakbo ng script:

// makuha ang oras ng pagsisimula $start_time = microtime(true); // ilang mga operasyon // ... // ipakita ang running time echo na "execution took: ". (microtime(true) - $start_time). "segundo.";

Sa unang tingin, ito ay maaaring mukhang isang maliit na gawain. Para sa mga layuning ito, maaari mong ilagay ang code sa dulo ng file. Gayunpaman, kung ang exit() function ay gagana sa isang lugar bago ito, ang code na ito ay hindi kailanman gagana. Gayundin, hindi ito gagana kung mayroong isang error sa pahina o naantala ng gumagamit ang paglo-load ng pahina (sa pamamagitan ng pag-click sa kaukulang pindutan sa kanyang browser);

Kapag ginagamit ang register_shutdown_function() na pamamaraan, ang code ay isasagawa sa anumang kaso:

$start_time = microtime(true); register_shutdown_function("my_shutdown"); function my_shutdown() ( global $start_time; echo "naganap ang execution: ". (microtime(true) - $start_time). " seconds."; )

Konklusyon

Ang PHP ay isang buong planeta na hindi tumitigil sa paghanga sa amin sa nilalaman nito. Ano sa palagay mo ang tungkol sa mga function na ito?

Ang mga function na tinukoy ng gumagamit ay nilikha gamit ang keyword ng function, na sinusundan ng pangalan ng function, isang listahan ng mga argumento nito (na maaaring maging zero sa numero), at ang katawan ng mismong function. Ang layunin ng mga pag-andar ay napakalawak. Kung kailangan mong isagawa ang parehong code nang paulit-ulit, dapat mong ilagay ito sa iyong sariling function, at pagkatapos ay tawagan lamang ito kung saan mo ito kailangan. Ang pangalan ng function ay dapat magsimula sa isang Latin na character at maaaring naglalaman ng mga numero at isang maliit na character. Sa pamamagitan ng convention, ang mga function name sa PHP ay nagsisimula sa maliliit na titik, at kung ang pangalan ay gumagamit ng higit sa isang salita, ang bawat bago ay magsisimula sa malaking titik, kaagad man o pagkatapos ng underscore.

/** * Ipahayag ang isang simpleng user function */ function userFunction() ( )

Kung mayroong higit sa isang pagtuturo sa katawan ng isang function, ang lahat ng mga tagubilin ay dapat ilagay sa loob ng mga kulot na brace (). Kung ang isang function ay may isang pagtuturo lamang, ang mga kulot na brace ay opsyonal. Ngunit inirerekumenda ko na palagi mong gamitin ang mga ito.

Ang PHP ay may mga karaniwang function na ang mga pangalan ay hindi mo magagamit sa iyo. Kung susubukan mong gumawa ng function na tinatawag na date() o time() , makakakuha ka ng mensahe ng error tungkol sa pagsubok na i-override ang function. Sa PHP, isang beses lang maidedeklara ang mga function. Ipinagbabawal ang mga overriding function. Karaniwan, ang mga function ay tinukoy sa pinakadulo simula ng script (karaniwan ay sa hiwalay na mga file na kasama sa pangunahing script) bago ang simula ng pangunahing script. Gumawa tayo ng function para ipakita ang IP address ng user sa screen.

/** * Function na ipakita ang IP address ng user. * Ang IP address ay kinuha mula sa PHP superglobal array $_SERVER * na naglalaman ng mahalagang koneksyon at data ng server */ function userIP() ( print "

" . $_SERVER["REMOTE_ADDR"] . "

"; }

Ang function ay tinukoy. Upang matawag ito, sa script sa tamang lugar sapat na upang ipahiwatig ang pangalan ng pag-andar at ipasa ito ang mga kinakailangang parameter (kung kinakailangan).

UserIP(); // Ipinapakita ang IP address ng user tulad ng 127.0.0.1

Variable Saklaw

Kapag nagtatrabaho sa mga function, dapat mong matutunan ang konsepto ng variable na saklaw. Binubuo ito kung aling mga lugar sa script kung alin sa mga ipinahayag na variable ang maaaring gamitin. Ang mga variable na idineklara sa loob ng isang function ay mga lokal na variable. Maaari mong i-access ang mga ito sa loob ng function body, ngunit hindi mo ma-access ang mga ito sa labas ng function. Sa kabaligtaran, ang mga variable na idineklara sa labas ng katawan ng isang function ay hindi naa-access sa loob mismo ng function. Ngunit mayroong data na magagamit saanman sa script.

Mga superglobal na array

Ang $_SERVER, $_SESSION, $_COOKIE at iba pa ay mga superglobal na array. Available ang kanilang data kahit saan sa script. Narito ang ilan lamang sa kanila:

• $_SERVER["REMOTE_ADDR"] — IP address ng user;
• $_SERVER["SERVER_NAME"] — pangalan ng server;
• $_SERVER["DOCUMENT_ROOT"] - direktoryo ng ugat ng site;
• $_SERVER["REQUEST_URI"] - ang hiniling na address ng dokumento.

Mga Pangangatwiran ng Function

Kung ang isang function ay dapat magkaroon ng access sa data mula sa isang variable o pare-parehong ipinahayag sa labas ng katawan nito, ang data na ito ay maaaring ipasa dito bilang mga argumento. Ang bawat function ay maaaring tumagal ng anumang bilang ng mga argumento (parameter), kabilang ang zero. Sa halimbawa sa itaas, hindi kami nagpasa ng anumang mga argumento sa function. Tingnan natin ang isa pang halimbawa.

/** * Magdeklara ng custom na function upang magsama ng dalawang arbitrary value */ halaga ng function($value_1, $value_2) ( // Dapat tumagal ang function ng 2 kinakailangang argumento print $value_1 + $value_2; // At ipakita ang kabuuan ng ang mga argumentong ito ) $ green_apples = 10; // Mayroon kaming 10 berdeng mansanas $red_apples = 4; // At mayroon ding 4 na pulang mansanas // Malalaman natin ang kabuuang bilang ng mga mansanas sa pamamagitan ng pagtawag sa function na halaga () // Ang function na halaga () ay dapat tumagal ng dalawang argumento, na magiging bilang ng halaga ng mansanas ($ green_apples , $red_apples); // Ipinapakita ang 14

Mga opsyonal na parameter (default na parameter) ng function

Ang isang function ay maaaring magkaroon ng walang limitasyong bilang ng mga argumento (mga parameter), kung saan maaaring mayroong mga opsyonal (kabilang ang lahat). Upang gawing opsyonal ang argumento ng function, dapat itong bigyan ng default na halaga kapag idineklara ang function.

/** * Magdeklara ng function na may mga default na value */ halaga ng function($value_1, $value_2, $value_3 = 0) ( print $value_1 + $value_2 + $value_3; )

/** * Bilangin ang kabuuang bilang ng mga mansanas * Sa pagkakataong ito ang amount() function ay tumatagal ng tatlong argumento, * ngunit ang pangatlo ay opsyonal, dahil ang halaga nito * ay tinukoy noong ang function ay idineklara, kung hindi namin tinukoy ang pangatlo * argumento, mananatili itong katumbas ng zero * / $geen_apples = 11; $red_apples = 7; halaga($green_apples, $red_apples); // Displays 18 // Bigla kaming nakakita ng 10 pang dilaw na mansanas sa aming pantry $yellow_apples = 10; // At kailangan din nilang isaalang-alang ang halaga($green_apples, $red_apples, $yellow_apples); // Ipinapakita ang 28

Pansinin na tinawag namin ang parehong function nang dalawang beses sa loob ng parehong script. Magagawa ito nang maraming beses hangga't gusto mo. Kapag nagtatrabaho sa mga pag-andar, tandaan ang isang mahalagang detalye - kung kabilang sa mga argumento ng pag-andar ay may mga hindi ipinahayag na default at ipinahayag, ang mga hindi nadeklara (sapilitan) ay dapat na unang tukuyin.

Function userF($v1, $v2 = 100, $v3) ( // Hindi ito makakagawa ng anumang magandang print $v1 + $v2 + $v3; )

Pagbabalik ng halaga

Ang isa sa mga pangunahing tampok ng mga pag-andar ay ang kanilang kakayahang magbalik ng isang resulta. Hindi palaging kinakailangan sa isang script na gumawa ng isang bagay na may resulta ng isang function. Mas madalas kailangan lang itong i-save at gamitin sa ibang lugar sa script para sa ganap na magkakaibang mga layunin. [?] sa katunayan, ang mga function ay halos hindi ginagamit upang magpakita ng isang tiyak na halaga sa screen.. Upang maibalik ng isang function ang isang halaga sa lugar sa script kung saan ito tinawag, dapat mong gamitin ang return statement. Ang anumang code na sumusunod sa return statement ay hindi naisakatuparan (kung ang return statement ay gumana gaya ng inaasahan).

/** * Magdeklara ng custom na function para magdagdag ng mga mansanas * isa sa mga value ang default. * Ang function ay nagsusuma lamang ng mga halaga ng mga argumento, at ibinabalik * ang mga ito sa script nang hindi nai-print ang mga ito sa screen. */ halaga ng function ($value_1, $value_2, $value_3 = 0) ($resulta = $value_1 + $value_2 + $value_3; // Idagdag lang ang mga value ng function arguments return $result; // Ibalik ang resulta sa script. Ang $result variable ay lokal // at partikular na ang value nito ay hindi magiging available sa labas ng function body) $green_apples = 9; // mayroon kaming 9 berdeng mansanas $red_apples = 14; // At 14 pang pulang mansanas // Sa kabuuan mayroon kaming... $total_green_red = halaga($green_apples, $red_apples); // Ang return statement ng amount() function ay magbabalik ng value na 23, // na itatalaga sa variable na $total_green_red // Dinalhan nila kami ng 7 pang dilaw na mansanas $yellow_apples = 7; // At ngayon mayroon na tayong... $kabuuang_berde_pula_dilaw = halaga($berdeng_mansanas, $pulang_mansanas, $dilaw_mansanas); // Ibalik ang value 30 at isulat ito sa variable // $total_green_red_yellow $all = amount($total_green_red, $total_green_red_yellow); // Ibinabalik ang halaga na 53 // Nagpapakita ng mga Green at Red sa kabuuan - 23 print "

Berde at pula sa kabuuan - " . $total_green_red ."

"; // Magpapakita ng mga Greens, Reds at Yellows sa kabuuan - 30 print "

Berde, pula at dilaw sa kabuuan - " . $total_green_red_yellow ."

"; // Ipinapakita ang kabuuan ng mga halaga - 53 print "

Ang kabuuan ng mga halaga ay " . $all ."

";

Kaya, ano ang isang function?PHP?

Function - Ito ay isang mini-program na gumaganap ng ilang mga kapaki-pakinabang na aksyon at gumagawa ng isang tapos na resulta.
Tingnan natin ang diagram:

Subukan nating magsulat ng isang mini program gamit ang isang yari na template ng function.
Handa na ang template ng function:

Sabihin nating kailangan nating magsulat ng isang function na maaaring kalkulahin ang kabuuan ng mga numero 5 at 2. Tinitingnan namin ang template at sumulat:

Suriin natin ang code.
function suma() ay isang function na pinangalanang suma ;
echo 5 + 2; - sa katawan ng function na ipinahiwatig namin na ang mga numero 5 at 2 ay kailangang idagdag nang magkasama (5 + 2);
suma(); - tawagan ang function. Ang pagtawag sa isang function ay nangangahulugan ng pagpapatupad nito. Ibig sabihin, dapat kumpletuhin ang problema 5 + 2 at magbigay ng resulta ng 7.

Ngayon subukan nating tingnan ang mga pag-andar nang hakbang-hakbang.

Mga yugto ng paglikha ng isang function sa PHP

Yugtoako. Paglikha ng isang Function
Tandaan ang yari na template ng function:

Ito ay kung paano nilikha ang isang function sa PHP.
Isulat natin ang teksto" Natutuwa akong makita ka sa blog site».
Huwag lamang kalimutan: isinusulat namin ang teksto gamit ang .

"; } ?>

Ngayon ay kailangan mong tawagan ang function na "site()".

YugtoII. Naka-on ang pagtawag sa isang handa na functionPHP
Nalikha na ang function at dapat na ngayong isagawa. Upang magsagawa at magpakita ng isang function, tukuyin lamang ang “function name(); »

website();

Magiging ganito ang hitsura:

"; ) site(); ?>

Magagawa mo ito tulad nito:

"; ) ?> Ang daming text....Ang daming text....

Ilagay ang address sa iyong browser:

Resulta:

Mga function ng PHP na may mga argumento

Ang lahat ng mga halimbawa na may mga function sa itaas ay walang mga argumento. Ipapaliwanag ko sa iyo kung ano ang isang argumento sa code:

Kaya gumawa ako ng isang function na tinatawag na "site". Sa mga parameter (kung nasaan ang mga bracket), sumulat ako ng dalawang variable na $a at $b na pinaghihiwalay ng mga kuwit.

Function site ($a, $b)

$a at $b ang dalawang argumento.
echo "$a + $b = "; – dito ko ipinakita ang text sa monitor. Resulta: 5 + 5 =
echo $a + $b; – dito ko ipinahiwatig sa function na ang mga variable na $a at $b ay kailangang idagdag nang magkasama.
site (15, 5); – tinatawag na function. Pansin: sa mga panaklong nagpahiwatig ako ng dalawang argumento (15, 5) na hinihintay ng variable na $a at $b. Ang variable na $a ay makakatanggap ng unang argumento - 15 , $b - ang pangalawa 5 .

Para sa mga hindi nakakaunawa kung saan pinapalitan ang argumento at sa anong pagkakasunud-sunod, narito ang diagram:

Kaya, ang tapos na code:

I-save bilang "function.php" sa folder na "test-1" ng lokal na server (tingnan ang aralin 1).

Ilagay ang address sa iyong browser:

https://localhost/test-1/function.php

Resulta:

Hayaan akong gawing kumplikado ng kaunti ang function at gawin itong mas kawili-wili. Idaragdag ko ang address ng blog sa argumento at isusulat ko ang pangalan ng link.

Ang function na tinatawag na "site" ay makakatanggap ng argumento https://site/ sa $link variable, at ang $title variable ay makakatanggap ng link text - " Blog site – paggawa ng website!»

Ready code:

I-save bilang "function.php" sa folder na "test-1" ng lokal na server (tingnan ang aralin 1).

Ilagay ang address sa iyong browser:

https://localhost/test-1/function.php

Resulta:

Sa artikulong ito, ipinagpatuloy namin ang aming pag-aaral ng mga pangunahing kaalaman ng PHP at nagpapatuloy sa isang napakahalagang bahagi sa pag-aaral ng programming language na ito bilang mga function. Ang mga function ng PHP ay nasa lahat ng dako sa pagbuo ng website, kaya't ang pag-alam sa mga pangunahing kaalaman ay kinakailangan. Sa artikulong ito, titingnan natin ang mga pangunahing kaalaman ng mga function ng PHP, matutunan kung paano gamitin ang mga function sa pagsasanay, at titingnan ang mga function na may mga parameter at walang. Ang materyal na ito ay magiging sapat upang matutunan ang mga pangunahing kaalaman sa pagtatrabaho sa mga function ng PHP, pagkatapos nito ay maaari kang magsimula ng karagdagang pag-aaral ng programming language na ito.

Kaya, function ay isang hanay ng mga espesyal na utos na isinasagawa sa isang tiyak na paraan at gumagawa ng isang tiyak na resulta. Sa kasong ito, ang function ay may partikular na pangalan at maaaring gamitin saanman sa pahina. Upang gawin ito, tawagan lamang ang nais na function sa tamang lugar sa pahina. Ang syntax ng PHP function ay ang mga sumusunod.

Function function_name (mga parameter) ( Function body )

Para sa mas mahusay na pag-unawa, tingnan natin ang sumusunod na halimbawa. May building kami at alam ang taas nito. Kailangan nating kalkulahin ang libreng oras ng pagkahulog ng isang bagay na itinapon mula sa gusaling ito. Ipagpalagay natin na ang mga kondisyon ay perpekto. Upang malutas ang problemang ito ginagamit namin ang sumusunod na function.

Function mytime($h, $g) ($t = pow(2*$h/$g, 0.5); echo "Ang oras ng pagbagsak mula sa taas na ".$h." sa g = ".$g. " ay ". $t." segundo.";

Ngayon tingnan natin ang code sa itaas. Una, lumikha kami ng isang bagong function Aking oras. Upang gawin ito, isinusulat namin ang espesyal na function ng salita, pagkatapos ay ipinapahiwatig namin ang pangalan ng function na gagawin. Gayundin, sa mga panaklong, na pinaghihiwalay ng mga kuwit, huwag kalimutang ipahiwatig ang mga parameter para sa PHP function na nilikha. Kung walang ganoong mga parameter, maaari mong alisin ang mga ito at iwanang walang laman ang mga bracket. Susunod, buksan ang mga kulot na braces sa isang bagong linya at isulat ang katawan ng function sa kanila. Sa aming kaso, ito ang formula para sa pagkalkula ng libreng oras ng taglagas. Upang gawin ito, lumikha kami ng variable na $t, at bilang halaga nito ay itinatalaga namin ang formula para sa pagkalkula ng libreng oras ng taglagas dito.

Pagkatapos nito, ang resulta ay ipinapakita sa screen gamit ang . Ngayon, kung kailangan nating kalkulahin ang oras ng free fall, kailangan lang nating tawagan ang ating php function sa tamang lugar sa php file, at tukuyin ang halaga ng nais na taas at acceleration ng free fall bilang mga parameter (sa panaklong).

Gaya ng nakikita mo, ang mga function ay napakalaking praktikal na kahalagahan sa . Sa kanilang tulong, maaari mong flexible na palawakin ang handa na pag-andar ng mga site. Bilang halimbawa, isaalang-alang ang paglikha ng . Kung nabasa mo ang artikulong ito, maaaring napansin mo na ang page navigation ay ipinatupad gamit ang isang espesyal na function ng PHP na tinatawag sa tamang lugar sa template ng WordPress.

Ngayon, magpatuloy tayo upang isaalang-alang ang isa pang opsyon para sa paggamit ng mga function gamit ang mga link bilang isang halimbawa. Para sa kalinawan, tingnan natin ang dalawang halimbawa ng mga function - mayroon at walang mga parameter.

Ang PHP ay gumagana nang may at walang mga parameter

Sa nakaraang halimbawa tungkol sa libreng oras ng taglagas, tiningnan namin ang isang function na may mga parameter. Sa aming kaso, ito ang mga variable na $h at $g. Sa PHP, maaari mo ring gamitin ang mga function na walang mga parameter. Sa kasong ito, walang nakasulat sa panaklong pagkatapos ng pangalan ng function. Ang isang halimbawa ng naturang function ay isang function na nagpapakita ng ilang handa na solusyon, halimbawa, isang link o text.

Function mylink() ( echo "

Sa halimbawa sa itaas, lumikha kami ng walang parameter na function na tinatawag na mylink. Susunod, sa katawan ng function na tinukoy namin na kailangan naming magpakita ng isang regular na link. Ngayon, kapag tinawag mo ang function na ito saanman sa dokumento, ang teksto o link na nakasulat sa katawan ng mylink function ay ipapakita.

Ngayon gawin nating mas kumplikado ang mga bagay at gumawa ng PHP function na may mga parameter na magpapakita ng link sa screen. Sa halimbawang ito, ang link ay hindi na magiging static, ngunit dynamic at maaaring magbago depende sa kung anong halaga ang kinuha ng mga variable.

Function mylink ($link, $target, $title, $anchor) ( echo "$anchor"; ) $mylink = "https://archive.site"; $mytarget = "_blank"; $mytitle = "Paggawa at promosyon ng website"; $myanchor = "Создание и продвижение сайтов"; mylink($mylink, $mytarget, $mytitle, $myanchor);!}

Matapos matanggap ang mga halaga ng mga variable, tinatawag namin ang function mylink at ipasa ito sa mga parameter. Sa aming kaso, ito ang mga variable na nilikha namin dati. Ngayon, tulad ng nahulaan mo, ang halaga ng $mylink variable ay ipapasa sa $link variable, $mytarget sa $target, atbp. Bilang resulta, tatanggapin ng mylink function ang mga parameter na kailangan namin at ipapakita ang kaukulang resulta sa screen sa anyo ng isang link.

Sana maintindihan mo ang kakanyahan ng mga function ng PHP. Kung hindi, inirerekumenda kong basahin muli ang artikulo at suriin ang mga halimbawa. Ang materyal ay hindi kumplikado, ngunit napakahalaga, kaya kung seryoso kang magpasya na matuto ng PHP, inirerekumenda kong maingat na pag-aralan ang lahat ng materyal.

Ito ay nagtatapos sa artikulong ito. Kung hindi mo nais na makaligtaan ang pinakabagong mga balita mula sa site, inirerekumenda ko ang pag-subscribe sa newsletter sa anumang paraan na maginhawa para sa iyo sa seksyong "" o gamit ang form sa ibaba.

Iyon lang. Good luck at tagumpay sa pag-aaral ng mga pangunahing kaalaman ng PHP.