PHP-syntax och semantik

Syntaxen och semantiken för PHP , ett programmeringsspråk , bildar en uppsättning regler som definierar hur ett PHP-program kan skrivas och tolkas .

Översikt

Historiskt sett har utvecklingen av PHP varit något slumpartad. För att motverka detta har PHP Framework Interop Group (FIG) skapat The PHP Standards Recommendation (PSR) dokument som har hjälpt till att skapa mer standardisering av språket sedan 2009. De moderna kodningsstandarderna finns i PSR-1 (Basic Coding Standard) och PSR-2 (Coding Style Guide).

Nyckelord

Vissa nyckelord representerar saker som ser ut som funktioner, vissa ser ut som konstanter, men de är faktiskt språkkonstruktioner. Det är förbjudet att använda några nyckelord som konstanter, klassnamn, funktioner eller metoder. Det är tillåtet att använda dem som variabelnamn, men det kan vara förvirrande.

__halt_compiler()
abstrakt
och
array()
som
ha sönder
anropsbar (från och med PHP 5.4)
fall
fånga
klass
klona
konst
Fortsätta
deklarera
standard
dö()
do
eko
annan
elseif
tömma()
slutdeklarera
endfor
endforeach
endif
ändbrytare
under tiden
eval()
utgång()
sträcker sig
slutlig
slutligen (från och med PHP 5.5)
fn (från och med PHP 7.4)
för
för varje
fungera
global
goto (från och med PHP 5.3)
om
redskap
omfatta
inkludera_en gång
instans av
istället för (från och med PHP 5.4)
gränssnitt
isset()
lista()
matcha (från och med PHP 8.0)
namnutrymme (från och med PHP 5.3)
ny
eller
skriva ut
privat
skyddad
offentlig
behöva
kräver_en gång
lämna tillbaka
statisk
växla
kasta
egenskap (från och med PHP 5.4)
Prova
unset()
använda sig av
var
medan
xor
avkastning (från och med PHP 5.5)
avkastning från (från och med PHP 7.0)

Grundläggande språkkonstruktioner

PHP följer i allmänhet C-syntaxen , med undantag och förbättringar för dess huvudsakliga användning i webbutveckling , som använder strängmanipulation i hög grad . PHP-variabler måste ha prefixet " $ ". Detta gör att PHP kan utföra stränginterpolation i strängar med dubbla citattecken , där omvänt snedstreck stöds som ett escape-tecken . Ingen escape eller interpolation görs på strängar avgränsade av enkla citattecken . PHP stöder också en C-liknande sprintf -funktion. Koden kan modulariseras till funktioner definierade med nyckelordsfunktion . PHP stöder en valfri objektorienterad kodningsstil, med klasser betecknade med nyckelordet klass . Funktioner som definieras i klasser kallas ibland metoder . Kontrollstrukturer inkluderar: if , while , do/while , for , foreach och switch . Påståenden avslutas med semikolon, inte radslut.

Avgränsare

PHP-processorn analyserar bara kod inom dess avgränsare . Allt utanför dess avgränsare skickas direkt till utgången och tolkas inte av PHP. De enda öppna/stängda avgränsare som tillåts av PSR-1 är " <?php " och " ?> " eller <? = och ?> .

Syftet med de avgränsande taggarna är att separera PHP-kod från icke-PHP-data (främst HTML). Även om det är sällsynt i praktiken kommer PHP att exekvera kod inbäddad i alla filer som skickas till dess tolk, inklusive binära filer som PDF- eller JPEG-filer, eller i serverloggfiler. Allt utanför avgränsarna ignoreras av PHP-parsern och skickas igenom som utdata.

Dessa rekommenderade avgränsare skapar korrekt utformade XHTML- och andra XML- dokument. Detta kan vara till hjälp om källkodsdokumenten någonsin behöver bearbetas på andra sätt under programvarans livstid.

Om korrekt XML-validering inte är ett problem, och en fil endast innehåller PHP-kod, är det bättre att utelämna PHP-avslutningstaggen (?> ) i slutet av filen.

Ej rekommenderade taggar

Andra avgränsare kan användas på vissa servrar, även om de flesta inte längre stöds. Exempel är:

" <script language="php"> " och " </script> " (borttaget i PHP7)
Korta öppningstaggar ( <? ) (konfigurerade med inställningen short_open_tag ini)
- En speciell form av <? taggen är <?= , vilket automatiskt ekar nästa påstående. Före PHP 5.4.0 styrdes även detta med short_open_tag , men finns alltid tillgängligt i senare versioner.
ASP- stiltaggar ( <% eller <%= ) (borttaget i PHP7)

Variabler och kommentarer

Variabler är prefixerade med en dollarsymbol och en typ behöver inte anges i förväg. Till skillnad från funktions- och klassnamn är variabelnamn skiftlägeskänsliga. Både dubbla citationstecken ( "" ) och heredoc -strängar tillåter möjligheten att bädda in en variabels värde i strängen. Som i C, kan variabler gjutas till en specifik typ genom att prefixet typen inom parentes. PHP behandlar nya rader som blanksteg , på samma sätt som ett språk i fritt format . Sammankopplingsoperatorn är . _ (punkt). Arrayelement nås och sätts med hakparenteser i både associativa arrayer och indexerade arrayer. Lockiga parenteser kan användas för att komma åt arrayelement, men inte för att tilldela.

PHP har tre typer av kommentarsyntax : /* */ som fungerar som blockkommentarer och // samt # som används för inline-kommentarer. Många exempel använder utskriftsfunktionen istället för ekofunktionen . Båda funktionerna är nästan identiska; Den stora skillnaden är att utskrift är långsammare än eko eftersom den förra kommer att returnera en status som indikerar om den var framgångsrik eller inte utöver text till utmatning, medan den senare inte returnerar en status och bara returnerar texten för utmatning.

Enklaste programmet

Det vanliga " Hello World "-kodexemplet för PHP är:


 
 <?php  echo  "Hej världen!  \n  "  ;  ?>

Exemplet ovan ger ut följande:

Hej världen!

Istället för att använda <?php och ekosatsen , är en valfri "genväg" användningen av <? = istället för <?php som implicit ekar data. Till exempel:



    
        
    
    
    
 <!DOCTYPE html>  <  html  >  <  head  >  <  title  >  PHP "Hej världen!" program   </  title  >  </  head  >  <  body  >          <  p  >  <?  =  "Hej världen!"  ?>  </  p  > 
 </  body  >  </  html  >

Ovanstående exempel illustrerar också att text som inte finns i omslutande PHP-taggar kommer att matas ut direkt.

Operatörer

PHP stöder: aritmetiska operatorer , tilldelningsoperatorer , bitvisa operatorer , jämförelseoperatorer , felkontrolloperatorer, exekveringsoperatorer, inkrement/minska operatorer , logiska operatorer , strängoperatorer , arrayoperatorer, villkorsstyrda tilldelningsoperatorer .

Kontrollstrukturer

Villkor

Om ... annat uttalande

Syntaxen för en PHP if ... else-sats är som följer:

  
    
   
    
  
    
 if  (  villkor  )  {  // uttalanden;  }  elseif  (  condition2  )  {  // uttalanden;  }  annat  {  // uttalanden;  }

För enstaka uttalanden kan parenteser utelämnas och om valfritt kondenseras till en enda rad:

  
  
  om  (  tillstånd  )  dosomething  ();  elseif  (  villkor2  )  dosomethingelse  ();  annat  doyetathirdthing  ();

Ternär villkorad operatör

    0    



   0 
      
  
      
 $abs  =  $värde  >=  ?  $värde  :  -  $värde  ;  /* Motsvarar */  if  (  $värde  >=  )  {  $abs  =  $värde  ;  }  annat  {  $abs  =  -  $värde  ;  }

Elvis operatör

Eftersom PHP 5.3 stöder Elvis-operator ( ?: ) där det är möjligt att utelämna den mellersta delen av den ternära operatorn.

     



       $c  =  $a  ?:  $b  ;  /* Motsvarar */  $c  =  $a  ?  $a  :  $b  ;

Noll sammansmältande operatör

Sedan version 7.0 stöder PHP också Null-koalescerande operatör ( ?? ).

    



       $a  =  $b  ??  $c  ;  /* Motsvarar */  $a  =  isset  (  $b  )  ?  $b  :  $c  ;

Sedan version 7.4 stöder PHP också Null-koalescerande operatör med syntaxen ??= .

  



     $a  ??=  $b  ;  /* Motsvarar */  $a  =  $a  ??  $b  ;

Säker navigationsoperatör

Sedan version 8.0 stöder PHP även Safe navigation operator ( ?-> ).

  



          $variabel  =  $objekt  ?->  metod  ();  /* Motsvarar */  $variabel  =  $objekt  !==  null  ?  $object  ->  metod  ()  :  null  ;

Byt uttalande

Ett exempel på syntaxen för en PHP switch-sats är följande:

  
     0
      
      
     
      
      
     
      
      
    
      
 switch  (  expr  )  {  case  :  // uttalanden;  bryta  ;  fall  1  :  // uttalanden;  bryta  ;  fall  2  :  // uttalanden;  bryta  ;  default  :  // uttalanden;  }

Observera att till skillnad från i C kan värden i case-satsen vara vilken typ som helst, inte bara heltal.

Matcha uttryck

PHP 8 introducerar matchningsuttrycket . Matchningsuttrycket liknar konceptuellt en switch- sats och är mer kompakt för vissa användningsfall.

   
    0  
      
      

 echo  match  (  1  )  {  =>  'Foo'  ,  1  =>  'Bar'  ,  2  =>  'Baz'  ,  };  //> Bar

Slingor

För loop

PHP-syntaxen för en for-loop är följande:

    
    
 for  (  initiering  ;  villkor  ;  eftertanke  )  {  // uttalanden;  }

Medan loop

Syntaxen för en PHP while loop är följande:

  
    
 while  (  villkor  )  {  // uttalanden;  }

Gör while loop

Syntaxen för en PHP do while loop är som följer:

 
    
   gör  {  // uttalanden;  }  while  (  villkor  );

För varje slinga

Syntaxen för en PHP för varje slinga är följande:

    
    
 foreach  (  $set  som  $värde  )  {  // uttalanden;  }

Alternativ syntax för kontrollstrukturer

PHP erbjuder en alternativ syntax som använder kolon snarare än standardsyntaxen med lockigt klammer (av " { ...} " ). Denna syntax påverkar följande kontrollstrukturer: if , while , for , foreach och switch . Syntaxen varierar endast något från syntaxen med lockigt klammer. ersätts öppningsstången ( { ) med ett kolon ( : ) och den täta klammern ersätts med endif; , under tiden; , endfor; , endforeach; , eller ändbrytare; , respektive. Att blanda syntaxstilar inom samma kontrollblock stöds inte. Ett exempel på syntaxen för en if / elseif -sats är följande:

 
     
 
     

     
 if  (  villkor  )  :  // code here  elseif  (  villkor  )  :  // code here  else  :  // code here  endif  ;

Denna stil kallas ibland mallsyntax, eftersom den ofta är lättare att läsa när man kombinerar PHP och HTML eller JavaScript för villkorlig utdata:


     
  
     
  
  
  
  
 <  html  >  <?php  if  (  $day  ==  'torsdag'  )  :  ?>  <  div  >  Imorgon är det fredag!  </  div  >  <?php  elseif  (  $day  ==  'fredag'  )  :  ?>  <  div  >  TGIF  </  div  >  <?php  else  :  ?>  <  div  >  ugh  </  div  >  <?php  endif  ;  ?>  </  html  >

Undantagshantering

Körtidsundantagshanteringsmetoden i PHP ärvs från C++.

 

       0 
          
    
       


 
      
     0 
      
    
       



   function  inv  (  $x  )  {  if  (  $x  ==  )  {  throw  new  Exception  (  'Division med noll' )  ;  }  returnera  1  /  $x  ;  }  prova  {  echo  inv  (  2  );  // skriver ut 0,5  echo  inv  (  );  // kasta ett undantag  echo  inv  (  5  );  // kommer inte att köra  }  catch  (  Undantag  $e  )  {  echo  $e  ->  getMessage  ();  // skriver ut Division med noll  }  // Fortsätt exekvering  echo  "Hej"  ;  // skriver ut Hej

Datatyper

Skalära typer

PHP stöder fyra skalärtyper: bool , int , float , string .

Boolean

PHP har en inbyggd boolesk typ, som heter " bool ", liknande de ursprungliga booleska typerna i Java och C++ . Med hjälp av reglerna för omvandling av boolesk typ tolkas värden som inte är noll som sant och noll som falskt , som i Perl . Både konstanterna sant och falskt är skiftlägesokänsliga.

Heltal

PHP lagrar heltal i ett plattformsberoende intervall. Detta intervall är vanligtvis det för 32-bitars eller 64-bitars tecken med heltal. Heltalsvariabler kan tilldelas med decimala (positiva och negativa), oktala och hexadecimala notationer.

   
   
   
  0 
    $a  =  1234  ;  // decimaltal  $b  =  0321  ;  // oktalt tal (motsvarande 209 decimaler)  $c  =  0x1B  ;  // hexadecimalt tal (motsvarande 27 decimaler)  $d  =  b11  ;  // binärt tal (motsvarande 3 decimaler)  $e  =  1  _234_567  ;  // decimaltal (från och med PHP 7.4.0)

Flyta

Reella tal lagras också i ett plattformsspecifikt intervall. De kan specificeras med flyttalsnotation eller två former av vetenskaplig notation .

  
       
        
    $a  =  1,234  ;  $b  =  1,2e3  ;  // 1200  $c  =  7E-5  ;  // 0,00007  $d  =  1  _234  .  567  ;  // från och med PHP 7.4.0

Sträng

PHP stöder strängar , som kan användas med enkla citattecken, dubbla citattecken, nowdoc eller heredoc -syntax.

Dubbla citattecken stöder variabel interpolation:

  

   $age  =  '23'  ;  echo  "John är  $age  years old"  ;  // John är 23 år gammal

Syntax för lockiga hängslen:

  
  

    
  
  

   $f  =  "sqrt"  ;  $x  =  25  ;  echo  "a  $xc\n  "  ;  // Varning: Odefinierad variabel $xc  echo  "a  {  $x  }  c  \n  "  ;  // skriver ut a25c  echo  "a  ${  x  }  c  \n  "  ;  // skriver också ut a25c  echo  "  $f  (  $x  ) is  {  $f  (  $x  )  }  \n  "  ;  // prints sqrt(25) är 5

Specialtyper

PHP stöder två specialtyper: null , resurs . Datatypen noll representerar en variabel som inte har något värde. Det enda värdet i datatypen null är NULL . NULL - konstanten är inte skiftlägeskänslig. Variabler av typen " resurs " representerar referenser till resurser från externa källor. Dessa skapas vanligtvis av funktioner från ett visst tillägg och kan endast bearbetas av funktioner från samma tillägg. Exempel inkluderar fil-, bild- och databasresurser.

Sammansatta typer

PHP stöder fyra sammansatta typer: array , object , callable , iterable .

Array

Arrayer kan innehålla blandade element av vilken typ som helst, inklusive resurser, objekt. Flerdimensionella arrayer skapas genom att tilldela arrayer som arrayelement. PHP har ingen sann array-typ. PHP-matriser är naturligt glesa och associativa . Indexerade arrayer är helt enkelt hash som använder heltal som nycklar.

Indexerad array:

       
   $season  =  [  "Höst"  ,  "Vinter"  ,  "Vår"  ,  "Sommar"  ];  echo  $säsong  [  2  ];  // Vår

Associativ array:

            
   $salary  =  [  "Alex"  =>  34000  ,  "Bill"  =>  43000  ,  "Jim"  =>  28000  ];  echo  $salary  [  "Bill"  ];  // 43000

Flerdimensionell array:

  
      
          
          
    
      
          
          
    


    $mark  =  [  "Alex"  =>  [  "biologi"  =>  73  ,  "historia"  =>  85  ],  "Jim"  =>  [  "biologi"  =>  86  ,  "historia"  =>  92  ]  ];  echo  $mark  [  "Jim"  ][  "historia"  ];  // 92

Objekt

Objektdatatypen är en kombination av variabler, funktioner och datastrukturer i det objektorienterade programmeringsparadigmet .

 

    


    class  Person  {  //...  }  $person  =  ny  person  ();

Ringbar

Sedan version 5.3 har PHP förstklassiga funktioner som kan användas t.ex. som argument till en annan funktion.

    

     


       

  

     


       
    
       function  runner  (  anropbar  $funktion  ,  blandad  ...  $args  )  {  return  $function  (  ...  $args  );  }  $f  =  fn  (  $x  ,  $y  )  =>  $x  **  $y  ;  funktion  summa  (  int  |  float  ...  $args  )  {  return  array_sum  (  $args  );  }  echo  runner  (  fn  (  $x  )  =>  $x  **  2  ,  2  );  // skriver ut 4  echo  runner  (  $f  ,  2  ,  3  );  // skriver ut 8  echo  runner  (  'summa'  ,  1  ,  2  ,  3  ,  4  );  // skriver ut 10

Iterable

Iterabel typ indikerar att variabel kan användas med varje slinga. Det kan vara vilken array eller generator eller objekt som helst som implementerar det speciella interna Traversable -gränssnittet.

  

        
             
    

     



           


     
            
          
    



            

         
   
  function  printSquares  (  iterable  $data  )  {  foreach  (  $data  as  $value  )  {  echo  (  $value  **  2  )  .  ""  ;  }  echo  "  \n  "  ;  }  // array  $array  =  [  1  ,  2  ,  3  ,  4  ,  5  ,  6  ,  7  ,  8  ,  9  ,  10  ];  // generator  $generator  =  function  ()  :  Generator  {  for  (  $i  =  1  ;  $i  <=  10  ;  $i  ++  )  {  yield  $i  ;  }  };  // objekt  $arrayIterator  =  ny  ArrayIterator  ([  1  ,  2  ,  3  ,  4  ,  5  ,  6  ,  7  ,  8  ,  9  ,  10  ]);  printSquares  (  $array  );  // 1 4 9 16 25 36 49 64 81 100  printSquares  (  $generator  ());  // 1 4 9 16 25 36 49 64 81 100  printSquares  (  $arrayIterator )  ;  // 1 4 9 16 25 36 49 64 81 100

Fackliga typer

Unionstyper introducerades i PHP 8.0

         function  foo  (  sträng  |  int  $foo  )  :  sträng  |  int  {}

Funktioner

PHP har hundratals basfunktioner och tusentals fler från tillägg. Före PHP version 5.3.0 är funktioner inte förstklassiga funktioner och kan endast refereras till med deras namn, medan PHP 5.3.0 introducerar stängningar. Användardefinierade funktioner kan skapas när som helst och utan prototyper. Funktioner kan definieras inuti kodblock, vilket tillåter ett körtidsbeslut om huruvida en funktion ska definieras eller inte. Det finns inget koncept för lokala funktioner. Funktionsanrop måste använda parenteser med undantag för noll-argumentklasskonstruktorfunktioner som anropas med PHP new operator, där parenteser är valfria.

Ett exempel på funktionsdefinition är följande:

 

     


 
  function  hello  (  $target  =  'World'  )  {  echo  "Hej  $target  !  \n  "  ;  }  hej  ();  // utmatar "Hello World!"  hej  (  'Wikipedia'  );  // utmatar "Hej Wikipedia!"

Funktionsanrop kan göras via variabler, där värdet på en variabel innehåller namnet på den funktion som ska anropas. Detta illustreras i följande exempel:

 

     


 

     


  
  

   function  hello  ()  {  return  'Hej'  ;  }  function  world  ()  {  return  "World!"  ;  }  $function1  =  'hej'  ;  $function2  =  'värld'  ;  echo  "  {  $funktion1  ()  }  {  $funktion2  ()  }  "  ;

Ett standardvärde för parametrar kan tilldelas i funktionsdefinitionen, men före PHP 8.0 stödde inte namngivna parametrar eller parameterhoppning. Vissa grundläggande PHP-utvecklare har offentligt uttryckt besvikelse över detta beslut. Andra har föreslagit lösningar för denna begränsning.

Namngivna argument

Namngivna argument introducerades i PHP 8.0

  

       



   


     
      function  power  (  $bas  ,  $exp  )  {  return  $base  **  $exp  ;  }  // Använda positionsargument:  echo  power  (  2  ,  3  );  // prints 8  // Använda namngivna argument:  echo  power  (  bas  :  2  ,  exp  :  3  );  // skriver ut 8  ekokraft  (  exp  :  3  ,  bas  :  2  )  ;  // skriver ut 8

Typdeklaration

Specificering av typer av funktionsparametrar och funktionsreturvärden har stöds sedan PHP 7.0.

Returtypdeklaration:

    

       


   funktion  summa  (  $a  ,  $b  )  :  float  {  return  $a  +  $b  ;  }  var_dump  (  summa  (  1  ,  2  ));  // skriver ut float(3)

Typ av parametrar:

    

       


      
   function  summa  (  int  $a  ,  int  $b  )  {  return  $a  +  $b  ;  }  var_dump  (  summa  (  1  ,  2  ));  // skriver ut int(3)  var_dump  (  summa  (  1.6  ,  2.3  ));  // skriver ut int(3)

Strikt skrivning

Utan strikt skrivning aktiverat:

         
          

  
    
  
     $f1  =  fn  (  $a  ,  $b  )  :  int  =>  $a  +  $b  ;  $f2  =  fn  (  int  $a  ,  int  $b  )  =>  $a  +  $b  ;  var_dump  (  $f1  (  1.3  ,  2.6  ));  // skriver ut int(3)  var_dump  (  $f1  (  1  ,  '2' ))  ;  // skriver ut int(3)  var_dump  (  $f2  (  1.3  ,  2.6  ));  // skriver ut int(3)  var_dump  (  $f2  (  1  ,  '2' )  );  // skriver ut int(3)

Med strikt skrivning aktiverat:


         
          

  
    
  
     deklarera  (  strikta_typer  =  1  ); 
 $f1  =  fn  (  $a  ,  $b  )  :  int  =>  $a  +  $b  ;  $f2  =  fn  (  int  $a  ,  int  $b  )  =>  $a  +  $b  ;  var_dump  (  $f1  (  1.3  ,  2.6  ));  // Fatalt fel: Returvärdet måste vara av typen int, float returnerade  var_dump  (  $f1  (  1  ,  '2' ))  ;  // skriver ut int(3)  var_dump  (  $f2  (  1.3  ,  2.6  ));  // Fatalt fel: Argument #1 ($a) måste vara av typen int, float givet  var_dump  (  $f2  (  1  ,  '2' ))  ;  // Fatalt fel: Argument #2 ($b) måste vara av typen int, sträng given

Anonyma funktioner

PHP stöder äkta anonyma funktioner från och med version 5.3. I tidigare versioner stödde PHP endast kvasi-anonyma funktioner genom funktionen create_function() .

  
        
   $x  =  3  ;  $func  =  funktion  (  $z  )  {  return  $z  *  2  ;  };  echo  $func  (  $x  );  // skriver ut 6

Eftersom version 7.4 PHP även stöder syntax för pilfunktioner ( => ) .

  
      
   $x  =  3  ;  $func  =  fn  (  $z  )  =>  $z  *  2  ;  echo  $func  (  $x  );  // skriver ut 6

Stängningar

Skapar stängningar

        



    
         
           
    
 $add  =  fn  (  $x  )  =>  fn  (  $y  )  =>  $y  +  $x  ;  /* Motsvarar */  $add  =  function  (  $x  )  {  return  function  (  $y  )  use  (  $x  )  {  return  $y  +  $x  ;  };  };

använder sig av

  

        
    $f  =  $add  (  5  );  eko  $f  (  3  );  // skriver ut 8  echo  $add  (  2  )(  4  );  // skriver ut 6

Generatorer

Med hjälp av generatorer kan vi skriva kod som använder foreach för att iterera över en datauppsättning utan att behöva skapa en array i minnet, vilket kan resultera i minneskostnader eller betydande bearbetningstid för generering.

Föremål

Grundläggande objektorienterad programmeringsfunktionalitet lades till i PHP 3. Objekthanteringen skrevs om helt för PHP 5, vilket utökade funktionsuppsättningen och förbättrade prestandan. I tidigare versioner av PHP hanterades objekt som primitiva typer . Nackdelen med denna metod var att hela objektet kopierades när en variabel tilldelades eller skickades som en parameter till en metod. I det nya tillvägagångssättet refereras objekt med handle och inte efter värde. PHP 5 introducerade privata och skyddade medlemsvariabler och metoder, tillsammans med abstrakta klasser och slutliga klasser samt abstrakta metoder och slutliga metoder . Den introducerade också ett standardsätt för att deklarera konstruktörer och destruktorer , liknande det för andra objektorienterade språk som C++ , och en standardmodell för undantagshantering . Dessutom lade PHP 5 till gränssnitt och möjliggör att flera gränssnitt kan implementeras. Det finns speciella gränssnitt som gör att objekt kan interagera med runtime-systemet. Objekt som implementerar ArrayAccess kan användas med arraysyntax och objekt som implementerar Iterator eller IteratorAggregate kan användas med foreach- språkkonstruktionen . Den statiska metoden och klassvariabelfunktionerna i Zend Engine 2 fungerar inte som vissa förväntar sig. Det finns ingen virtuell tabellfunktion i motorn, så statiska variabler är bundna med ett namn istället för en referens vid kompilering.

Det här exemplet visar hur man definierar en klass, Foo , som ärver från klassen Bar . Metoden myStaticMethod är en offentlig statisk metod som kan anropas med Foo::myStaticMethod(); .

   

     
    
          
    

       
    
          
    
 klass  Foo  utökar  Bar  {  function  __construct  ()  {  $doo  =  "wah dee dee"  ;  }  offentlig  statisk  funktion  myStaticMethod  ()  {  $dee  =  "dee dee dum"  ;  }  }

Om utvecklaren skapar en kopia av ett objekt med det reserverade ordet clone kommer Zend-motorn att kontrollera om en __clone()- metod har definierats eller inte. Om inte, anropar den en standard __clone() som kopierar objektets egenskaper. Om en __clone() -metod är definierad, kommer den att ansvara för att ställa in nödvändiga egenskaper i det skapade objektet. För enkelhetens skull kommer motorn att tillhandahålla en funktion som importerar egenskaperna för källobjektet, så att programmeraren kan börja med en replika av källobjektet med bivärde och bara åsidosätta egenskaper som behöver ändras.

Egenskaper

Det här exemplet använder en egenskap för att förbättra andra klasser:


 

        

        

       
    
            
               
        

         
    


 

     



   

     
 //  Mallegenskapen  TSingleton  {  private  static  $_instance  =  null  ;  privat  funktion  __construct  ()  {}  // Måste ha privat standardkonstruktor och vara medveten om att den inte öppnas i klassen  public  static  function  getInstance  ()  {  if  (  null  ===  self  ::  $_instance  )  {  self  ::  $_instance  =  nytt  jag  ();  }  returnera  själv  ::  $_instance  ;  }  }  klass  FrontController  {  använd  TSingleton  ;  }  // Kan även användas i redan utökade klasser  class  WebSite  extends  SomeClass  {  use  TSingleton  ;  }

Detta gör det möjligt att simulera aspekter av multipelt arv:

 

        


 

       
    
        
    


 

       
    
        
    


 

       

      
    
        
    
 egenskap  TBounding  {  public  $x  ,  $y  ,  $width  ,  $height  ;  }  trait  TMoveable  {  public  function  moveTo  (  $x  ,  $y  )  {  // …  }  }  trait  TResizeable  {  public  function  resize  (  $newWidth  ,  $newHeight  )  {  // …  }  }  class  Rectangle  {  use  TBounding  ,  TMoveable  ,  TResizeable  ;  public  function  fillColor  (  $color  )  {  // …  }  }

Se även

Hypertext Markup Language (HTML)
Mallmotor (webb)

PHP
människor	Andi Gutmans Rasmus Lerdorf Zeev Suraski
Resurser	Accelerator ( Lista ) Kompositör Redaktörer Bibliotek PÄRON
Genomföranden	HHVM HPHPc Papegoja PeachPie Phalanger Quercus Zend motor
Webbramverk	CakePHP CodeIgniter Drupal eZ Publish Fettfri BränslePHP Hord Joomla! Laminor Laravel Li3 (tidigare litium) Midgård MODx Nette Framework Phalcon Pop PHP PHP-Fusion PRADO Qcodo Silex SilverStripe Symfoni TYPO3 WordPress XOOPS Yii Zeta-komponenter
Testning	Behat PHPUnit
ORMs	Lära Driva fram
Idus	Aptana Codelobster Eclipse PDT NetBeans PHPEdit PhpStorm RadPHP Zend Studio
Widget verktygslåda	PHP-GTK wxPHP
Kategori Commons