PHP: Funksjonsparametere og argumenter. Funksjonsargumenter Liste over argumenter med variabel lengde

I min webutviklingspraksis kom jeg veldig ofte over situasjoner der kunder satte seg et spesifikt mål, nemlig å skille deler av adminpanelet angående tilgjengelighet for enkelte brukere. Samtidig ble utviklingen av denne modulen utført i sammenheng med et utvidbart system, det vil si med et ikke-fast antall moduler som det er organisert tilgang til, og følgelig et ubegrenset antall systembrukere.

Vel, i seg selv er dette emnet ganske tungt, og krever litt tid å analysere og sette oppgaven.

I sammenheng med denne artikkelen vil vi utvikle i sammenheng med et abstrakt informasjonssystem, med sin egen infrastruktur og arkitektur, mens dette systemet gir brukeren muligheten til å utvide funksjonaliteten, det vil si installere nye moduler, og deretter sette tilgangsrettigheter til dem for en bestemt bruker registrert som systemadministrator.

La oss først diskutere arkitekturen til det modulære systemet på pseudosystemet vi velger.

Alle moduler presenteres som innstikk knyttet til hoveddokumentet (indeksfil). Modulforespørselen kommer fra QUERY_STRING-spørringsstrengen, og plugin-navnet sendes som handlingsargument. På et tidspunkt i filindeksen blir denne parameteren hentet og behandlet. Etter det, hvis brukeren har tilstrekkelige rettigheter til å få tilgang til modulen i lesekonteksten, kontrolleres eksistensen av modulen spesifisert i spørringsstrengen, og hvis den eksisterer, kobles den til indeksfilen.

Jeg nevnte ikke bare «lesekonteksten», siden vårt system forutsetter eksistensen av to kontekster for å jobbe med systemet, nemlig lesing og skriving. Samtidig innebærer lesing direkte tilgang til modulen og til de delene av den som ikke krever endringer i datastrukturen i databasen. Under posten er det ment å gjøre endringer direkte i informasjonen som er lagret i databasen.

For å implementere denne mekanismen vil vi sjekke verdien av "do" spørrestrengvariabelen, som behandles i selve modulen og inneholder informasjon om hvilken del av modulen du trenger for å gi tilgang til brukeren.

Verdien av do vil være fast, denne variabelen vil ha følgende verdier:

• main - hoveddelen av modulen (tilgjengelig i lesesammenheng)
• config - modulkonfigurasjonsseksjon (tilgjengelig i forbindelse med oppføringen)
• opprette - utfør noen handlinger for å legge til informasjon til databasen (tilgjengelig i sammenheng med posten)
• slett - tilgang til en seksjon som gir mulighet til å slette noe informasjon, i sammenheng med denne modulen (tilgjengelig i sammenheng med posten)
• rediger - tilgang til redigeringsinformasjon i konteksten av modulen (tilgjengelig i sammenheng med posten)

Generelt kan denne listen økes, mens alt bare avhenger av prosjektets omfang og dets behov for funksjonalitet.

Nå direkte om modulene. I tillegg til den fysiske eksistensen av en bestemt modul i sammenheng med prosjektets filsystem, må modulen også legges til en spesiell databasetabell som vil inneholde informasjon om alle eksisterende moduler i systemet. Å legge til og endre dataene i denne tabellen gjøres vanligvis direkte i sammenheng med moduler, det vil si under installasjonen i systemet. Dette er imidlertid allerede en fordypning i prinsippene for visning av utvidbare systemer, som vi vil snakke om en annen gang, og derfor vil vi begrense oss til å manuelt oppdatere og legge til data om moduler.

Dermed vil en post om en systemmodul inneholde følgende informasjon: den engelske identifikatoren til modulnavnet, som vil være identisk med verdien av GET-miljøvariabelen - handle (modulen vil bli bedt direkte mot den), den russiske modulen identifikator, som vil bli brukt i listen over moduler.

I tillegg til modulene vil vi ha ytterligere to tabeller, nemlig en tabell som skal lagre data vedrørende tilgangsrettighetsprofiler og en tabell med informasjon om brukere direkte.

Sikkerhetsprofiltabellen vil kun bestå av tre felt - profilidentifikatoren (den numeriske verdien av postidentifikatoren), modultekstidentifikatoren (beregnet for brukere), og en spesiallaget tekstetikett som inneholder informasjon om brukerens rettigheter i forbindelse med hver av modulene.

Vel, la oss se på denne spesielle strukturen. Det vil være: [ module_indefier: + \: + \;] *

Det vil si at det er en liste over par: modulnavn ":" lesetillatelser "," skrivetillatelser ";". I dette tilfellet oppdateres denne etiketten på tidspunktet for endringer i brukerens tilgangsrettigheter til systemet. Hvis det vises informasjon i systemet om en modul som ikke er inkludert i denne etiketten, trenger du bare å utføre redigeringsprosedyren, og dataene lagres automatisk.

Nå gjenstår det for oss å vurdere strukturen til bare én databasetabell, og vi kan begynne å implementere den algoritmiske delen, nemlig tabellen med informasjon om systembrukere, fordi å tildele tilgangsrettigheter til dem er vår hovedoppgave.

Jeg vil ikke legge til noe ekstra til det, men bare det som skal brukes i sammenheng med emnet for denne artikkelen. Brukertabellen vil inneholde følgende felt: bruker-ID (numerisk teller), pålogging, passord (hash av det opprinnelige passordet), brukersikkerhetsprofil (brukergruppe-ID, i forhold til rettigheter i systemet), og det er det. Det virker for meg som om denne informasjonen er ganske nok for oss til å implementere oppgaven, og jeg gir allerede muligheten til å gjøre alle de andre tilleggene selv.

Så vi diskuterte strukturen, og jeg håper alle har allerede en ide om hvordan vi skal implementere oppgaven som er satt i emnet for artikkelen. Nå vil jeg gi den ekstra SQL-koden til tabellene beskrevet ovenfor, hvoretter jeg umiddelbart vil gå videre til implementeringen av algoritmen for å sjekke brukertilgangsrettigheter, samt opprette og endre tilgangsprofiler. Etter hver enkelt modul vil vi diskutere i detalj alle spørsmål leserne måtte ha.

'moduler'-tabell:

CREATE TABLE `modules` (`id` bigint(20) NOT NULL auto_increment, `indefier` text collate utf8_unicode_ci NOT NULL, `title` text collate utf8_unicode_ci NOT NULL, PRIMARY KEY (`id`)) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

`sikre_grupper`-tabell:

LAG TABELL `secure_groups` (`id` bigint(20) NOT NULL auto_increment, `title` text collate utf8_unicode_ci NOT NULL, `perms` text collate utf8_unicode_ci NOT NULL, PRIMARY KEY (`id`)) ENGINE=MyISAM AUTO_INCREMENT CHARSET=utf8 COLLATE=utf8_unicode_ci ;

Tabell `brukere`

CREATE TABLE `users` (`id` bigint(20) NOT NULL auto_increment, `login` text collate utf8_unicode_ci NOT NULL, `passwd` text collate utf8_unicode_ci NOT NULL, `groupId` int(1) NOT NULL standard "0", PRIMARY NØKKEL (`id`)) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci ;

temp=array(); $this->temp["_result"]=0; $this->temp["_uid"]=explode("::",$_COOKIE["site_hash"]); $this->temp["_uid"]=$this->temp["_uid"]; $this->temp["_gid"]=$this->getUserSecurityAccess($this->temp["_uid"]); $this->temp["_conn_id"]=mysql_connect("vert","bruker","passwd"); mysql_select_db("database"); $this->temp["_q1"]=mysql_query("SELECT perms" ."FRA `secure_groups`" ."WHERE id=".$this->temp["_gid"]); $this->temp["_access_stamp"]=mysql_fetch_assoc($this->temp["_q1"]); $this->temp["_access_stamp"]=$this->temp["_access_stamp"]["perms"]; $this->temp["_access_stamp"]=explode(";",$this->temp["_access_stamp"]); $this->temp["_access_stamp"]=array_slice($this->temp["_access_stamp")],0,-1); foreach($this->temp["_access_stamp"] as $this->temp["v"])( $this->temp["_mod_access"]=explode(":",$this->temp["v "]); $this->temp["_mod_indefier"]=$this->temp["_mod_access"]; if($this->temp["_mod_indefier"]==$modul)( $this->temp[ "_perms"]=explode(",",$this->temp["_mod_access"]); switch($act)( case "r": $this->temp["_result"]=($this-> temp["_perms"]==1)?1:0; pause; case "w": $this->temp["_result"]=($this->temp["_perms"]==1)?1 :0; break; ) break; ) ) mysql_close($conn_id); returner $this->temp["_result"]; ) ) ?>

Denne klassen implementerer funksjoner designet for å implementere den algoritmiske oppgaven beskrevet ovenfor. Nå skal vi diskutere hver funksjon separat.

secure::getUserId() funksjon

Ved å bruke denne funksjonen antar vi at under brukerautorisasjon i systemet, ble miljøvariabelen $_COOKIE satt til variabelen `site_hash`, som består av brukerens identifikator i systemet og en hash for å verifisere autentisiteten i systemet. Funksjonen fjerner ganske enkelt verdien til identifikatoren, og returnerer verdien som utdata.

function secure::getUserSecurityAccess($id)

Ved avslutning returnerer denne funksjonen sikkerhetsprofil-IDen til gjeldende bruker på systemet.

secure::checkUserPermission($module,$act)) funksjon

Det sendes en spørring til databasen angående brukerens rettigheter til å utføre lese-/skrivehandlinger i sammenheng med modulen som sendes som parameter.

Det gjenstår bare å beskrive prosedyren for å lage en variabel i $_COOKIE-miljøet, og emnet for artikkelen kan anses som løst.

Autorisasjonsprosedyren vil se ut som å legge inn brukerens personlige data (pålogging og passord) i et spesielt skjema, etter sending som dataene som overføres av brukeren vil bli behandlet i henhold til funksjonsmetoden checkAuthData (), og hvis dataene er korrekte, brukerdataene vil bli lagret i formen som registrerer informasjonskapsler for en periode angitt av brukeren, eller i fravær av en spesifisert verdi for en periode som standard.

For å sjekke ektheten til dataene som er lagret i miljøvariabelen $_COOKIE, bruker vi EatCookie()-funksjonen, som vil validere dataene og returnere et boolsk valideringsresultat (true - false).

Jeg gir ikke et skjema for å sende inn, siden det ikke er en del av programmeringsteorien, bare spesifiserer feltidentifikatorer.

• `ulogin` - brukerinnlogging
• `upasswd` - brukerpassord
• "stime" - økttid angitt av brukeren (fra 1 til 5 timer)
• `auth` - send inn knappennavn

Her, generelt, er det alt. Det gjenstår bare å prøve, eksperimentere, gjøre feil og finne en løsning, som jeg overlater helt til deg.

Jeg håper at vi snart møtes, og for de som har et spørsmål til meg angående artikkelen, og ikke bare - skriv til [e-postbeskyttet], på enten [e-postbeskyttet]

Med vennlig hilsen Karpenko Kirill, leder av IT-avdelingen ved Institutt for industriell og industriell produksjon.

Sende argumenter til egendefinerte funksjoner

Når du erklærer en funksjon, kan du spesifisere en liste over parametere som kan sendes til funksjonen, for eksempel:

funksjonsfunksjon ($a, $b, /* ..., */ $z) { ... };
?>

Når du kaller funksjonen funct() må du spesifisere alle parameterne som sendes inn, siden de er nødvendige. I PHP kan brukerdefinerte funksjoner ha valgfrie eller standardparametre, men mer om det senere.

I følge etablerte tradisjoner er det i alle programmeringsspråk to typer funksjonsargumenter:

• verdi parametere;
• parametere-variabler.

Funksjoner kan ikke endre verdiparameteren, det vil si at den er skrivebeskyttet tilgjengelig for funksjonen - den kan bruke den, men ikke mer. Det er ikke nødvendig å spesifisere en variabel som en verdiparameter, du kan spesifisere selve verdien, derav navnet - verdi parameteren.

Som standard sendes argumenter til en funksjon av verdi (som betyr at hvis du endrer verdien til et argument inne i funksjonen, vil verdien utenfor fortsatt forbli den samme). Her er et eksempel:

funct($string)
{
ekko "

Parameter = $streng

$str = 777 ;
funksjon(777);
funksjon( $str);

// Funksjonen "funct" vil sende ut strengen "Parameter = 777" to ganger

?>

I motsetning til verdiparametere, kan variable parametere endres mens funksjonen kjører. Her er det ikke lenger mulig å sende en verdi, det er nødvendig å sende en variabel. PHP bruker variabel-for-referanse-mekanismen for å deklarere variable parametere.

Hvis du vil tillate funksjoner å endre argumentene deres, må du sende dem ved referanse.

Hvis du vil at argumentet alltid skal sendes ved referanse, må du inkludere et og-tegnet (&) før argumentnavnet i funksjonserklæringen:

funct (& $string)
{
$string .= "denne er inne." ;
}
$str = "Denne linjen er utenfor funksjonen,";
funct($str);
ekko $str ; // Skriver ut "Denne linjen er utenfor funksjonen, denne linjen er innenfor."
?>

Standardalternativer

Ved programmering blir det ofte nødvendig å lage en funksjon med et variabelt antall parametere. Det er to grunner til dette:

• Det er for mange parametere. I dette tilfellet gir det ingen mening å spesifisere alle parameterne hver gang;
• Funksjoner må returnere verdier av forskjellige typer avhengig av settet med parametere.

I PHP kan funksjoner returnere hvilken som helst verdi avhengig av parameterne som sendes til dem.

funksjon makecup ($type = "Te" )
{
komme tilbake "Lag en kopp $type.\n";
}
echo makecup();
echo makecup("Kaffe");
?>

Utdataene til dette skriptet vil se slik ut:

Lag en kopp te
Lag en kopp kaffe

PHP tillater også matriser og den spesielle typen NULL som standardverdier, slik som:

funksjon makecup ($types = array("Kaffe" ), $Maker = NULL )
{
$device = is_null ($Maker) ? "sukker" : $Maker ;
komme tilbake "Lag en kopp". bli med (", " , $typer ). " med $device.\n" ;
}
echo makecup();
echo makecup (array("Kaffe" , "Te" ), "krem" );
?>

Skriptet ovenfor vil sende ut følgende:

Lag en kopp kaffe med sukker. Lag en kopp kaffe, te med krem.

Standardverdien må være et konstant uttrykk.

Merk at alle argumenter som har standardverdier må være til høyre for argumenter som ikke har noen standardverdier, ellers kan det hende at koden din ikke fungerer som du forventer. Tenk på følgende eksempel:

funksjon makecup ($type = "te" , $cond )
{
komme tilbake;
}

Echo makecup("hot"); // Fungerer ikke som vi kanskje forventer
?>

Resultatet av skriptet ovenfor vil være noe sånt som dette:

Advarsel: Mangler argument 2 for makecup() i c:\inetpub\site\test.php på nett 2
Lag en varm kopp.

La oss nå endre det vurderte skriptet, korrigere feilene i det:

funksjon makecup($cond , $type = "te")
{
komme tilbake"Lag en kopp $type $cond.\n";
}

Echo makecup("hot"); // Nå fungerer skriptet vårt som det skal!
?>

Resultatet av det korrigerte skriptet vil se slik ut:

Lag en varm kopp te.

Merk følgende! Fra og med PHP 5 kan standardverdier sendes ved referanse!

Variabelt antall argumenter i funksjoner

Noen ganger vet vi ikke nøyaktig hvor mange parametere som vil bli sendt til funksjonen vår. Spesielt for dette tilfellet har PHP-utviklere gitt muligheten til å bruke et variabelt antall argumenter.

Implementeringen av denne funksjonen er ganske gjennomsiktig og består i å bruke funksjonene func_num_args() , func_get_arg() Og func_get_args() .

Vurder mulighetene for de betraktede standardfunksjonene:

Standard funksjon func_num_args() returnerer antall argumenter som er sendt til den egendefinerte funksjonen:

funksjon()
{
$numargums = func_num_args();
ekko "Antall argumenter: $numargums\n";
}

funct(1 , 2 , 3 ); // Skriptet vil gi ut "Antall argumenter: 3"
?>

Standard funksjon func_get_arg() returnerer et element fra listen over argumenter som er sendt til den egendefinerte funksjonen:

funksjon()
{
$numargs = func_num_args();
ekko "Antall argumenter: $numargs
\n";
if ($numargs >= 2 ) (
ekko "Andre argument: ". func_get_arg (1 ). "
\n" ;
}
}

funct(1 , 2 , 3 );
?>

Parametre er spesifisert i funksjonsdefinisjonen, innenfor parentes, og er dens lokale variabler, dvs. de er bare synlige i kroppen, hvis det er flere parametere, er de angitt atskilt med kommaer. Når den kalles opp, kan en funksjon motta argumenter som parametere initialiseres med.

Vi har vurdert hvilke parametere som er, nå vil vi lære om hvilke verdier de er initialisert med. Verdiene som vil bli tildelt parametrene kalles argumenter - dette kan for eksempel være en streng eller heltallsliteral, en variabel eller et mer komplekst uttrykk som består av variabler og operatorer, men som kan evalueres av PHP tolk for å få verdien som parameteren vil bli initialisert med. Enkelt sagt er et argument en verdi som sendes til en funksjon:

Beståtte argumenter

PHP støtter to måter å sende funksjonsargumenter på. Den første er å sende argumenter etter verdi (fungerer som standard), den andre er å sende argumenter ved referanse. PHP støtter også standardverdier. La oss nå se på alle tre alternativene mer detaljert.

Som standard sendes argumenter til en funksjon etter verdi (dette betyr at hvis du endrer verdien til en parameter inne i funksjonen, vil den beståtte verdien forbli den samme utenfor funksjonen):

$color color"; // Har verdien til variabelen endret seg?>

Hvis du vil tillate en funksjon å endre de beståtte argumentene utenfor den, må du sende dem ved referanse. For at et argument skal sendes ved referanse, må du spesifisere & (ampersand)-tegnet før parameternavnet i funksjonsdefinisjonen:

Funksjoner kan definere standard argumentverdier. For å angi en standardverdi, i funksjonsdefinisjonen, er alt du trenger å gjøre å sette parameteren til ønsket verdi:

\n"; ) echo tea(); // skriver ut standardverdien echo tea("black"); ?>

Merk: Alle parametere som har standard argumentverdier må være til høyre for argumenter som ikke har standardverdier, ellers kan det hende at koden din ikke fungerer som forventet:

Funksjons returverdi

Når en funksjon avsluttes, kan den returnere en verdi (resultatet av funksjonen) til programmet som kalte den. Return-setningen i funksjoner brukes til å bestemme verdien som returneres av funksjonen. Returverdien kan være hvilken som helst type. Den har følgende syntaks:

returnere uttrykk;

Retursetningen kan plasseres hvor som helst i en funksjon. Når kontrollen når den, returnerer funksjonen en verdi (hvis spesifisert) og avslutter kjøringen. Hvis ingen retursetning er spesifisert eller ingen returverdi er spesifisert, vil funksjonen returnere NULL . For å bruke returverdien kan resultatet av funksjonsutførelsen tilordnes en variabel, for eksempel:

"; // => 16. funksjon foo($num) (if($num === 10) returner "$num er lik 10"; ellers returnerer "$num er ikke lik 10"; ekko "hei" ; // denne kodelinjen vil aldri bli utført ) echo foo(6); ?>

Abonnenter

Funksjonsargumenter

Hva er funksjonsargumenter?

Funksjonsargumenter er oppført atskilt med komma i parentes etter navnet på funksjonen som defineres og er dens lokale variabler.

Argumentverdier kan være alle uttrykk som sendes til funksjonen for behandling og kan evalueres. I dette tilfellet kan det hende at funksjonen ikke tar noen argumenter i det hele tatt, men hvis argumentene er tilstede, blir de evaluert fra venstre til høyre.

Sende funksjonsargumenter etter verdi og referanse

Misligholde argumenter sendes til funksjonen etter verdi, men også støttet sende argumenter ved referanse og standardverdier.

Når du sender argumenter etter verdi, forblir den opprinnelige verdien til den ytre variabelen konstant når verdien til argumentet inne i funksjonen endres. Hvis det kreves at funksjonen kan påvirke verdien av en ekstern variabel, er det nødvendig å sende argumenter til den ved referanse. Dette gjøres ved å bruke og-tegnet "&" foran argumentnavnet i funksjonsbeskrivelsen (se eksempel nr. 1).

Eksempel #1. Sende funksjonsargumenter etter verdi og referanse

Funksjon Argument Standardverdier

Også i PHP er det mulig å bruke for standard funksjonsargumenter, som er verdiene som brukes hvis ingen verdi sendes til det gitte argumentet når funksjonen kalles. For å sette standardverdien til et argument, er det nødvendig å tilordne ønsket verdi til dette argumentet i funksjonsdefinisjonen (se eksempel nr. 2). I dette tilfellet kan standardverdier ha både argumenter sendt av verdi og argumenter sendt ved referanse. I alle fall må alle argumenter som er tildelt standardverdier vises i listen etter argumentene som ikke har standardverdier. I tillegg kan bare konstante uttrykk, så vel som matriser og NULL , brukes som standardverdier. Du kan ikke bruke for eksempel variabler eller funksjonskall.

Eksempel #2. Bruke standard argumentverdier

Liste over argumenter med variabel lengde

Hvis det nøyaktige antallet argumenter som sendes til en funksjon ikke er kjent på forhånd, kan du bruke argumentliste med variabel lengde. En slik liste er dannet ved å bruke en spesiell variabel foran med en ellipse "..." . Som et resultat vil argumentene sendes til den angitte variabelen som en matrise (se eksempel #3).

Eksempel #3. Bruke en argumentliste med variabel lengde

Før ellipsen kan du spesifisere vanlige argumenter, mens alle andre argumenter som sendes til funksjonen vil bli lagt inn i en matrise. I tillegg, før ellipsen, kan du spesifisere typen argumenter som kan legges inn i matrisen, samt og-tegnet "&" for å sende argumenter ved referanse (se eksempel nr. 4).

"; // Utganger 10 fordi verdien ble sendt til funksjonen //ved referanse og deretter endret av funksjonen til 10 echo $a_1; ?>

Eksempel nummer 4. Funksjoner ved å bruke en argumentliste med variabel lengde

Det er tillatt å bruke ellipsen "..." for å utvide en matrise som sendes som funksjonsargument til funksjonsargumentene i form av elementene (se eksempel #5).

"; //Tildel arrayen til variabelen $a_3=; //Utvid arrayen som er sendt til funksjonen //Outputs 3 echo m_sum_2(...$a_3); ?>

Eksempel nummer 5. Utvide en rekke argumenter som sendes til en funksjon når den kalles

Argumenttilgangsfunksjoner

• func_get_args()- returnerer en matrise bestående av funksjonsargumenter;
• func_get_arg(n)- returnerer det spesifiserte funksjonsargumentet, der n=0,1,2,... - nummeret på argumentet i listen, som starter fra null (husk at argumentene beregnes fra venstre mot høyre);
• func_num_args()- returnerer antallet argumenter som faktisk sendes til funksjonen.

"; //Vis verdien av det tredje argumentet sendt til funksjonen echo func_get_arg(2); //Retur summen av funksjonens argumenter returner $sum; ) //Kalte funksjonen. Viser 38, dvs. antall argumenter som er bestått er 3, //og verdien 3. argument er 8 (elementnummerering starter fra null) m_sum(1,2,8); ?>

Eksempel nummer 6. Bruke spesialfunksjoner for å arbeide med argumenter

Merk at funksjonsargumenter også kan nås ved hjelp av spesialfunksjoner, spesielt hvis funksjonen tar flere argumenter enn den forventer å motta (se eksempel #6):

Rask hopp til andre sider

http://nettsted Copyright © Petr Romanovsky, Minsk, 2016-2019.