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 de beståtte parameterne, siden de er nødvendige. I PHP kan brukerdefinerte funksjoner ha valgfrie parametere eller standardparametere, men mer om det senere.
I følge etablerte tradisjoner er det i alle programmeringsspråk to typer funksjonsargumenter:
- verdi parametere;
- variable parametere.
Funksjoner kan ikke endre en verdiparameter, det vil si at den er skrivebeskyttet - 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 (dette betyr at hvis du endrer verdien til et argument inne i funksjonen, vil verdien fortsatt være den samme utenfor den). La oss gi et eksempel:
funksjon funksjon ($ streng)
{
ekko "Parameter = $ streng
"
;
}
$ str = 777;
funksjon (777);
funksjon ( $ str);
// "Funct"-funksjonen vil skrive 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 viktig å sende en variabel. PHP bruker en variabel-for-referanse-mekanisme for å deklarere variable parametere.
Hvis du vil tillate en funksjon å endre argumentene, må du sende dem ved referanse.
Hvis du vil at argumentet alltid skal sendes ved referanse, må du inkludere et og-tegnet (&) foran argumentnavnet i funksjonsbeskrivelsen:
funksjonsfunksjon (& $-streng)
{
$ string. = "og denne er inne." ;
}
$ str = "Denne linjen er utenfor funksjonen,";
funksjon ($ str);
ekko $ str; // Skriver ut "Denne linjen er utenfor funksjonen, og denne er inne."
?>
Standard parametere
Ved programmering er 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 skal 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 av typen $. \ N";
}
ekko makecup ();
ekko makecup ("Kaffe");
?>
Resultatet av skriptet ovenfor vil være som følger:
Lag en kopp te
Lag en kopp kaffe
PHP lar også arrays og den spesielle typen NULL brukes som standardverdier, for eksempel:
funksjon makecup ($ typer = array ("Kaffe"), $ Maker = NULL)
{
$ device = is_null ($ Maker)? "sugar": $ Maker;
komme tilbake "Lag en kopp"... join (",", $ typer). "med $ enhet. \ n";
}
ekko makecup ();
ekko makecup (array ("Kaffe", "Te"), "krem");
?>
Det vurderte skriptet vil sende ut følgende:
Lag en kopp sukkerkaffe. Lag en kopp kaffe, te med krem.
Standarden må være et konstant uttrykk.
Merk at alle argumenter som har standardverdier må være plassert 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;
}
Ekko makecup (varmt); // Fungerer ikke som vi kan forvente
?>
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.
Nå vil vi endre det vurderte skriptet, korrigere feil i det:
funksjon makecup ($ kond ,
$ type = "te")
{
komme tilbake"Lag en kopp av $ type $ cond. \ N";
}
Ekko makecup (varmt); // 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! Siden PHP 5, kan standarder 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-utviklerne 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 () .
La oss vurdere mulighetene for de betraktede standardfunksjonene:
Standard funksjon func_num_args () returnerer antall argumenter som er sendt til den brukerdefinerte funksjonen:
funksjon funksjon ()
{
$ numargums = func_num_args ();
ekko "Antall argumenter: $ numargums \ n";
}
Funksjon (1, 2, 3); // Skriptet vil skrive ut "Antall argumenter: 3"
?>
Standard funksjon func_get_arg () returnerer et element fra listen over argumenter som er sendt til den egendefinerte funksjonen:
funksjon funksjon ()
{
$ numargs = func_num_args ();
ekko "Antall argumenter: $ numargs
\ n ";
if ($ numargs> = 2) (
ekko "Andre argument:"... func_get_arg (1). "
\ n ";
}
}
Funksjon (1, 2, 3);
?>
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.
Alle uttrykk som sendes til funksjonen for behandling og kan evalueres kan brukes som argumentverdier. I dette tilfellet kan det hende at funksjonen ikke aksepterer noen argumenter i det hele tatt, men hvis argumentene er tilstede, beregnes de 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 eksterne variabelen konstant når verdien til argumentet endres inne i funksjonen. Hvis du vil at funksjonen skal kunne påvirke verdien til en ekstern variabel, må du sende argumenter til den ved referanse. Dette gjøres ved å bruke og-tegnet "&" foran argumentnavnet i funksjonsbeskrivelsen (se eksempel # 1).
Eksempel #1. Sende funksjonsargumenter etter verdi og referanse
Standard funksjonsargumentverdier
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 å angi standardverdien til argumentet, er det nødvendig å tilordne ønsket verdi til dette argumentet i funksjonsdefinisjonen (se eksempel # 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 argumenter som ikke har standardverdier. I tillegg kan bare konstante uttrykk, matriser og NULL brukes som standardverdier. Du kan for eksempel ikke bruke variabler eller funksjonskall.
Eksempel nr. 2. Bruker standard argumentverdier
Argumentliste med variabel lengde
Hvis det nøyaktige antallet argumenter som sendes til funksjonen ikke er kjent på forhånd, kan du bruke argumentliste med variabel lengde... En slik liste dannes 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 nr. 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 matrisen. 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 # 4).
"; // Vil gi ut 10, fordi verdien ble sendt til funksjonen // ved referanse og deretter endret av funksjonen til 10 echo $ a_1;?>
Eksempel nr. 4. Hensyn ved bruk av en argumentliste med variabel lengde
Det er tillatt å bruke ellipsen "..." for å utvide matrisen som sendes som et argument til funksjonen til funksjonsargumentene i form av dens elementer (se eksempel # 5).
"; // Tilordne arrayet til variabelen $ a_3 =; // Utvid arrayet som sendes til funksjonen // Output 3 echo m_sum_2 (... $ a_3);?>
Eksempel nr. 5. Utvide en rekke argumenter som sendes til en funksjon når den kalles
Funksjoner for å få tilgang til argumenter
- func_get_args ()- returnerer en matrise bestående av funksjonsargumenter;
- func_get_arg (n)- returnerer det angitte funksjonsargumentet, der n = 0,1,2, ... er 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 er sendt til funksjonen.
"; // Skriv ut verdien av det tredje argumentet sendt til funksjonen echo func_get_arg (2); // Returner summen av funksjonsargumentene return $ sum;) // Kall funksjonen. Utgang 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 nr. 6. Bruke spesialfunksjoner for å arbeide med argumenter
Merk at du også kan få tilgang til funksjonsargumenter 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.
I min praksis med webutvikling kom jeg veldig ofte over situasjoner der kunder satte seg et spesifikt mål, nemlig separasjon av deler av administrasjonspanelet med hensyn til tilgjengeligheten til enkelte brukere. Samtidig ble utviklingen av denne modulen utført i sammenheng med et utvidbart system, det vil si med et ufast antall moduler som det er organisert tilgang til, og følgelig et ubegrenset antall brukere av systemet.
Vel, i seg selv er dette emnet ganske tungt, og krever en viss tid for å analysere og stille problemet.
I sammenheng med denne artikkelen vil vi gjennomføre utvikling 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 angi tilgangsrettigheter til denne eller den brukeren som er registrert som systemadministrator.
La oss diskutere fra begynnelsen av arkitekturen til et modulært system på vårt valgte pseudosystem.
Alle moduler presenteres i form av vedlegg knyttet til hoveddokumentet (indeksfil). Modulforespørselen kommer fra QUERY_STRING spørrestrengen, og navnet på plugin-modulen sendes som handlingsargument. På et tidspunkt i filindeksen blir denne parameteren fjernet 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 «lesekonteksten» av en grunn, siden vårt system antar eksistensen av to kontekster for å jobbe med systemet, nemlig lesing og skriving. Samtidig innebærer lesing direkte tilgang til modulen og til de deler av den som ikke innebærer endringer i datastrukturen i databasen. Under journalen forutsettes det at endringer gjøres 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 som må gis tilgang til brukeren.
Do-verdien vil være fast, denne variabelen vil ta på seg følgende verdier:
- main - hoveddelen av modulen (tilgjengelig i lesesammenheng)
- config - modulkonfigurasjonsseksjon (tilgjengelig i skrivekontekst)
- opprette - utfør noen handlinger for å legge til informasjon til databasen (tilgjengelig i sammenheng med en post)
- slett - tilgang til delen som gir muligheten til å slette noe informasjon i sammenheng med denne modulen (tilgjengelig i forbindelse med en post)
- rediger - tilgang til å redigere informasjon i konteksten av modulen (tilgjengelig i forbindelse med innlegget)
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 prosjektfilsystemet, 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 modulene, det vil si under installasjonen i systemet. Dette er imidlertid allerede en fordypning i prinsippene for å se på 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.
Så, posten om systemmodulen vil inneholde følgende informasjon: den engelske identifikatoren til modulnavnet, som vil være identisk med verdien av miljøvariabelen GET - act (modulen vil bli bedt om direkte for det), den russiske identifikatoren av modulen, som vil bli brukt i listen over moduler.
I tillegg til modulene vil vi ha ytterligere to tabeller, nemlig en tabell der data vedrørende tilgangsrettighetsprofiler skal lagres og en tabell med informasjon om brukere direkte.
Tabellen over sikkerhetsprofiler vil kun bestå av tre felt - profilidentifikator (numerisk verdi av postidentifikator), tekstmodulidentifikator (beregnet for brukere), samt en spesiallaget tekstetikett som inneholder informasjon om brukerrettigheter i sammenheng med hver av modulene.
Vel, la oss ta en titt på denne spesielle strukturen. Det blir som følger: [module_indefier: + \: + \;] *
Det vil si at det er en liste over par: modulnavn ":" leserettigheter "," skriverettigheter ";". I dette tilfellet oppdateres denne etiketten på tidspunktet for endringer i brukerens tilgangsrettigheter til systemet. Hvis systemet viser informasjon 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 tabellene med informasjon om brukerne av systemet, 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: brukeridentifikator (numerisk teller), pålogging, passord (hash av det opprinnelige passordet), brukersikkerhetsprofil (identifikator for brukergruppen, i forhold til rettighetene i systemet), og det er det. Det ser ut til at denne informasjonen vil være nok for deg og meg til å implementere oppgaven, og jeg gir alle de andre tilleggene muligheten til å gjøre det 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 å implementere algoritmen for å sjekke brukertilgangsrettigheter, samt opprette og endre tilgangsprofiler. Etter hver enkelt modul vil vi diskutere i detalj alle spørsmålene leserne måtte ha.
Modultabellen:
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 DEFAULT = 1_INCREMENT CHARSET = utf8 COLLATE = utf8_unicode_ci;
Tabellen `sikre_grupper`:
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 1_INCREMENT CHARSET = utf8 COLLATE = utf8_unicode_ci;
Tabellen `brukere`
LAG TABELL `brukere` (` 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 default" 0 ", PRIMARY NØKKEL (`id`)) ENGINE = MyISAM AUTO_INCREMENT = 1 STANDARD CHARSET = utf8 COLLATE = utf8_unicode_ci;
temp = array (); $ this-> temp ["_ resultat"] = 0; $ this-> temp ["_ uid"] = eksplodere ("::", $ _ 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". "FROM` 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"] = eksplodere (";", $ 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"] = eksplodere (":", $ this-> temp [ "v "]); $ this-> temp [" _ mod_indefier "] = $ this-> temp [" _ mod_access "]; if ($ this-> temp [" _ mod_indefier "] == $ modul) ($ this-> temp [ "_perms"] = eksplodere (",", $ this-> temp ["_ mod_access"]); switch ($ act) (case "r": $ this-> temp ["_ result" ] = ($ this-> temp ["_ perms"] == 1)? 1: 0; break; case "w": $ this-> temp ["_ result"] = ($ this-> temp [" _ perms"] == 1)? 1 : 0; break;) break;)) mysql_close ($ conn_id); returner $ this-> temp ["_ resultat"]; ))?>
Denne klassen implementerer funksjoner designet for å implementere den algoritmiske oppgaven beskrevet ovenfor. Vi vil nå 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`, bestående av brukerens identifikator i systemet og en hash for å sjekke autentisiteten hans i systemet. Funksjonen fjerner ganske enkelt verdien av identifikatoren, og returnerer verdien ved utgang.
Secure :: getUserSecurityAccess ($ id) funksjon
Ved avslutning returnerer denne funksjonen ID-en til sikkerhetsprofilen til gjeldende bruker i systemet.
Secure :: checkUserPermission ($ modul, $ 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 å generere en variabel i $ _COOKIE-miljøet, og emnet for artikkelen kan betraktes som avdekket.
Autorisasjonsprosedyren vil se ut som å legge inn brukerens personlige data (pålogging og passord) i et spesielt skjema, hvoretter dataene som overføres av brukeren vil bli behandlet ved hjelp av funksjonsmetoden checkAuthData (), og hvis dataene er korrekte, brukeren data vil bli lagret som informasjonskapsler for perioden angitt av brukeren, eller i fravær av en spesifisert verdi for standardperioden.
For å sjekke ektheten til dataene som er lagret i miljøvariabelen $ _COOKIE, bruker vi funksjonen EatCookie (), som vil validere dataene ved å returnere et boolsk testresultat (true - usant).
Jeg gir ikke et skjema som skal sendes inn, da dette ikke er en del av programmeringsteorien, og spesifiserer kun feltidentifikatorer.
- `ulogin` - brukernavn
- `upasswd` - brukerpassord
- "stime" - økttid angitt av brukeren (fra 1 til 5 timer)
- `auth` er navnet på send-knappen
Her, generelt, er det alt. Det gjenstår bare å prøve, eksperimentere, gjøre feil og finne en løsning, som jeg helt overlater 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 Kirill Karpenko, leder for IT-avdelingen til INPP.
Parametre er spesifisert i funksjonsdefinisjonen, innenfor parentes, og er dens lokale variabler, dvs. de er bare synlige i kroppen hennes, hvis det er flere parametere, er de atskilt med kommaer. Når den kalles opp, kan funksjonen motta argumenter som brukes til å initialisere parameterne.
Hva er parametrene vi har vurdert, nå vil vi finne ut hvilke verdier de er initialisert med. Verdiene som vil bli tildelt parameterne 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 beregnes 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 argumenter til en funksjon 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 nærmere på alle tre alternativene.
Som standard sendes argumenter til funksjonen etter verdi (dette betyr at hvis du endrer verdien til en parameter inne i funksjonen, vil den beståtte verdien forbli den samme utenfor den):
$ farge farge "; // Verdien av variabelen er ikke endret?>
Hvis du må tillate en funksjon å endre beståtte argumenter utenfor den, må du sende dem ved referanse. For at argumentet skal sendes ved referanse, må du spesifisere & (ampersand)-tegnet foran parameternavnet i funksjonsdefinisjonen:
Funksjoner kan definere standard argumentverdier. For å angi standardverdien, i funksjonsdefinisjonen, trenger du bare å tildele parameteren ønsket verdi:
\ n ";) echo tea (); // skriver ut standard ekko-te (" svart ");?>
Merk: alle parametere som har standard argumentverdier må være til høyre for argumentene som ingen standardverdier er satt for, ellers kan det hende at koden din ikke fungerer som forventet:
Funksjons returverdi
Når utførelsen av en funksjon er fullført, kan den returnere en viss verdi (resultatet av funksjonens arbeid) til programmet som kalte den. Return-setningen i funksjoner brukes til å definere returverdien til funksjonen. Returverdien kan være hvilken som helst type. Den har følgende syntaks:
Returner uttrykk;
Retursetningen kan plasseres hvor som helst i funksjonen. Når kontrollen når den, returnerer funksjonen (hvis spesifisert) og avsluttes. Hvis retursetningen ikke er spesifisert eller returverdien ikke er spesifisert, vil funksjonen returnere NULL. For å bruke returverdien kan resultatet av funksjonsutførelsen tilordnes en variabel for eksempel:
"; // => 16.funksjon foo ($ num) (hvis ($ num === 10) return" $ num er 10 "; ellers returner" $ num er ikke 10 "; ekko" hei "; // dette kodelinje vil aldri kjøres) echo foo (6);?>
