Hallo beste beginnende programmeurs. Laten we doorgaan met het bestuderen van de elementen waaruit het bestaat.
In dit artikel zullen we leren wat php-operators zijn. In feite kennen we sommige ervan al bijna sinds onze kindertijd, maar we kennen ze alleen als tekens (+, -, =, !, ?).
In php worden ze allemaal operators genoemd, wat vrij logisch is, omdat ze een specifieke actie of bewerking uitvoeren.
Je zou zelfs kunnen zeggen dat alle afdrukbare tekens die geen letter of cijfer zijn, operatoren zijn in PHP. Maar dat is nog niet alles, want er zijn operatoren die uit letters bestaan.
Laten we op volgorde beginnen.
Rekenkundige operatoren
Rekenkundige operatoren worden gebruikt om bewerkingen op getallen uit te voeren.
+ is de opteloperator;
— — aftrekkingsoperator;
/ - divisie-operator;
* — vermenigvuldigingsoperator;
% is de operator voor het verkrijgen van de rest tijdens deling;
++ — operator voor het verhogen met één (increment);
— — — verlagen met één operator (verlaging)
Bij het schrijven wordt meestal een spatie voor en na de operator geplaatst. Dit wordt uitsluitend gedaan om de code gemakkelijker te kunnen lezen, hoewel deze ruimte nergens invloed op heeft en u desgewenst ook zonder kunt.
Complexe uitdrukkingen worden samengesteld volgens de regels die in de rekenkunde worden geaccepteerd, dat wil zeggen dat vermenigvuldigen en delen voorrang hebben op optellen en aftrekken, en wanneer beide in de uitdrukking voorkomen, staan deze tussen haakjes.
echo (6 + 7) * (7 + 8); // 195
?>
Wanneer u de actie uitvoert om een geheel getal door een geheel getal te delen, wordt het resultaat, in het geval van het verkrijgen van een rest, automatisch omgezet in een reëel getal (zwevende-kommagetal).
echo 8/3; //2.66666666666
?>
Het aantal cijfers dat voor een breukgetal wordt afgedrukt, hangt af van de waarde die is ingesteld in de precisierichtlijn in het php.ini-bestand. Meestal zijn dit 12 tekens, de punt niet meegerekend.
De %-operator wordt vaak gebruikt om te bepalen of een getal deelbaar is door een ander getal zonder rest of niet.
echo 53328% 4; //0
?>
Bewerkingen met rekenkundige operatoren, met uitzondering van verhogen en verlagen, worden aangeroepen binair, omdat er twee operanden bij betrokken zijn (term + term, deeltal / deler, enz.)
De acties van verhogen en verlagen worden genoemd unair, omdat er één operand bij betrokken is. Is er nog wat voorwaardelijke werking, waarbij drie operanden betrokken zijn.
De operatoren voor verhogen (++) en verlagen (- -) zijn alleen van toepassing op variabelen.
Variabel type geheel getal (hele getallen)
$volgende = 3;
echo +$volgende; // 4
?>
Tekenreeks van variabel type
$volgende = "abc";
echo $ volgende; // abd
?>
De letter "d" wordt afgedrukt in plaats van de letter "c" omdat deze de volgende in het alfabet is en we de waarde van de variabele met één hebben verhoogd.
De voorbeelden tonen acties met verhoging, en op dezelfde manier kunt u acties met verhoging uitvoeren.
Bitwise-operatoren
Bitwise-operatoren zijn ontworpen om met binaire gegevens te werken. Als iemand geen idee heeft wat het is, zal ik het uitleggen. Binaire getallen zijn getallen zoals 1001000011100000111000.
Omdat dergelijke gegevens vrijwel nooit worden gebruikt bij de ontwikkeling van websites, zullen we hier niet in detail op ingaan. Ik laat je alleen zien hoe ze eruit zien, zodat je, als je zulke symbolen tegenkomt, je kunt voorstellen waar je mee te maken hebt.
& - bitsgewijze verbinding AND (en);
~ — bitsgewijze negatie (niet);
| — bitsgewijze unie OF (of);
^ — bitsgewijze OF (xor);
<<
— сдвиг влево битового значения операнда;
>> — verschuif de bitwaarde van de operand naar rechts;
Het is zeer waarschijnlijk dat u deze operatoren tegenkomt, aangezien binaire gegevens veel worden gebruikt bij de ontwikkeling van grafische computerprogramma's. Maar om ze te bestuderen, als iemand het nodig heeft, zullen ze een aparte cursus over een andere bron moeten volgen.
Vergelijkingsoperatoren
Vergelijkingsoperatoren zijn logische operatoren en worden gebruikt om variabelen te vergelijken. Arrays en objecten kunnen niet met elkaar worden vergeleken.
> - exploitant groter dan;
=> - operator groter dan of gelijk;
<
— оператор меньше;
<=
— оператор меньше или равно;
== — gelijkheidsoperator;
!= — ongelijkheidsoperator;
=== — gelijkwaardigheidsoperator (de waarde en het type van de variabele zijn gelijk);
!== — niet-equivalentieoperator;
Als resultaat van de vergelijking wordt er één op het scherm weergegeven, wat overeenkomt met waar, of een lege string, die overeenkomt met onwaar.
echo 1 > 0; // 1
echo 1<
0
;
// пустая строка
echo 1 => 0; // 1
echo 1 == 1 ; // 1
?>
Op zichzelf worden vergelijkingsoperatoren dus bijna nooit gebruikt. Hun belangrijkste doel is om samen te werken met de if-instructie.
Voorwaardelijke uitspraken if, else, elseif.
Voorwaardelijke operatoren worden zo genoemd omdat ze zijn ontworpen om een bepaalde voorwaarde te testen, afhankelijk van welke actie wordt uitgevoerd.
De if-instructie neemt een Booleaanse variabele of expressie als argument. Als de voorwaarde waar is, wordt het resultaat weergegeven. Indien niet waar, wordt een lege regel weergegeven.
als ($volgende< $nexT)
{
echo "Kans op neerslag"; // Outputneerslag mogelijk
}
?>
$next = "Luchtvochtigheid 80%";
$nexT = "Luchtvochtigheid 90%";
als ($volgende > $volgendeT)
{
echo "Kans op neerslag"; // Druk een lege regel af
}
?>
Als het programma twee acties moet specificeren, waarvan er één wordt uitgevoerd als de waarde waar is, en de andere als de waarde onwaar is, dan wordt samen met de if-instructie de else-instructie gebruikt
$next = "Luchtvochtigheid 80%";
$nexT = "Luchtvochtigheid 90%";
als ($volgende > $volgendeT)
{
echo "Kans op neerslag";
}
anders
{
echo "Geen neerslag verwacht";
}
?>
In dit geval wordt "Neerslag wordt niet verwacht" weergegeven en als u in de uitdrukking het teken "Meer" in "Minder" wijzigt, wordt "Neerslag is mogelijk" weergegeven. Dit is hoe voorwaardelijke operators een voorwaarde controleren en het juiste resultaat op basis daarvan uitvoeren.
Heel vaak is het nodig om meer dan twee voorwaarden in te stellen, en om ze vervolgens opeenvolgend te controleren, wordt de elseif-operator gebruikt.
als ($volgende > $volgendeT)
{
echo "Ik zie";
}
elseif ($volgende<= $nexT)
{
echo "Sneeuw";
}
elseif ($volgende >= $volgendeT)
{
echo "Regen";
}
elseif ($volgende == $volgendeT)
{
echo "Droogte";
}
anders
{
echo "Kans op neerslag";
}
?>
Dit programma zal "Sneeuw" uitvoeren. Als geen van de voorwaarden overeenkomt, wordt 'Kans op neerslag' weergegeven.
Een if-instructie kan zoveel elseif-blokken bevatten als je wilt, maar slechts één else-instructie.
Een alternatieve opnamemogelijkheid is toegestaan - zonder accolades. In dit geval eindigen de regels van de if, else, elseif-instructies met een dubbele punt, en eindigt de hele constructie met het sleutelwoord (operator) endif.
$next = "Luchtvochtigheid 50%";
$nexT = "Luchtvochtigheid 60%";
als ($volgende<= $nexT):
echo "Sneeuw";
elseif ($next >= $nexT):
echo "Regen";
elseif ($volgende == $volgendeT):
echo "Droogte";
anders:
echo "Kans op neerslag";
stop als ;
?>
Logische operatoren
Logische operatoren zijn vergelijkbaar met bitsgewijze operatoren. Het verschil tussen beide is dat de eerste met logische variabelen werken, en de laatste met getallen.
Logische operatoren worden gebruikt in gevallen waarin u verschillende voorwaarden moet combineren, waardoor het aantal if-instructies wordt verminderd, wat op zijn beurt de kans op fouten in de code verkleint.
&& - verbindingsconjunctie AND;
en - ook EN, maar met lagere prioriteit;
|| - scheidingsconjunctie OR;
of - ook OR, maar met lagere prioriteit;
xor - exclusieve OF;
! - ontkenning;
Een lagere prioriteit betekent dat als beide operators aanwezig zijn, degene met de hogere prioriteit als eerste wordt uitgevoerd.
In de toekomst zullen we, aan de hand van voorbeelden van complexere scripts, dieper ingaan op logische operatoren.
Toewijzingsoperator
De toewijzingsoperator = wijst de waarde van de rechter operand toe aan de linker operand.
$volgende = "Hallo"
echo "Hallo" // Hallo
?>
Operator punt
De puntoperator scheidt het gehele deel van een getal van het breukdeel en combineert verschillende tekenreeksen en een getal tot één hele tekenreeks.
$volgende = 22;
echo "Vandaag daarna" .$next. "vorst wordt verwacht"; // Vandaag wordt na 22 uur vorst verwacht
?>
Operator voor haakjes
Net als in de wiskunde geeft de operator tussen haakjes voorrang aan de actie die ertussen zit.
De gegevens tussen haakjes worden eerst uitgevoerd en daarna de rest.
Accolades operator
Er zijn drie manieren, of zelfs stijlen, om accolades in PHP te plaatsen.
1. BSD-stijl - haakjes zijn links uitgelijnd.
als ($volgende)
{
}
2. GNU-stijl - haakjes zijn uitgelijnd, ingesprongen vanaf de linkerrand
als ($volgende)
{
echo “Hallo beste beginnende programmeurs”;
}
3. K&R-stijl - haakjes worden geopend op de operatorregel
als ($volgende)(
echo “Hallo beste beginnende programmeurs”;
}
Vanaf het allereerste begin moet u een van de stijlen kiezen en in de toekomst alleen deze gebruiken bij het schrijven van scripts. Bovendien maakt het helemaal niet uit welke stijl je voorkeur heeft. Het is belangrijk dat dit gedurende het hele programma uniform is.
Ik denk dat dat voor nu wel genoeg is. In principe kunnen niet alleen tekens, maar ook functies en andere elementen operatoren zijn, dus het is erg moeilijk om ze allemaal op te sommen, en het heeft geen zin.
Het is voldoende om een idee te hebben van de basisprincipes. En de rest analyseren we aan de hand van praktijkvoorbeelden.
Een Ier dwaalt in tranen rond op de luchthaven Sheremetyevo. Eén van de medewerkers besloot te sympathiseren:
– Mis je je thuisland?
- Helemaal niet. Ik ben zojuist al mijn bagage kwijtgeraakt
- Hoe kon dit gebeuren?
- Ik begrijp mezelf niet. Het lijkt erop dat ik de stekker goed heb aangesloten
variabele $GLOBALS. Een associatieve array met verwijzingen naar alle globale scopevariabelen van het script die momenteel zijn gedefinieerd. Variabelenamen zijn arraysleutels.
Om een globale variabele te declareren, plaatst u deze gewoon in de array $GLOBALS
$GLOBALS["testkey2"]="testwaarde2";
U kunt alle waarden van de arrayvariabelen $GLOBALS weergeven met print_r($GLOBALS); of zoals dit:
Foreach ($GLOBALS als $key=>$value) echo "GLOBALS[".$key."] == ".$value."
";
$_SERVER variabele.
$_REQUEST variabele- een associatieve array (array), die standaard de gegevens van de variabelen $_GET, $_POST en $_COOKIE bevat. Variabelen in de $_REQUEST-array worden aan het script doorgegeven met behulp van de GET-, POST- of COOKIE-methoden, dus ze kunnen niet worden vertrouwd omdat ze hadden door een externe gebruiker kunnen worden gewijzigd. Hun aanwezigheid en de volgorde waarin gegevens aan de overeenkomstige arrays worden toegevoegd, wordt bepaald door de variabelen_order-richtlijn (GPCS is standaard ingesteld).
$_SESSION variabele
$_ENV variabele. Ingevuld als het script vanaf de opdrachtregel is gestart. De array $_SERVER bevat alle variabelen uit de array $_ENV.
$http_response_header variabele
Opmerking: In PHP 7.0.0 op 64-bit platforms zijn er geen haalbare limieten voor de lijnlengte; op 32-bit systemen en in eerdere versies van PHP kunnen lijnen niet groter zijn dan 2 GB (2147483647 bytes).
Syntaxis
Een string kan op vier verschillende manieren worden gedefinieerd:
- enkele aanhalingstekens
- dubbele aanhalingstekens
- nowdoc-syntaxis (sinds PHP 5.3.0)
Enkele aanhalingstekens
De eenvoudigste manier om een string te definiëren is door deze tussen enkele aanhalingstekens te plaatsen (het symbool " ).
Om een enkel aanhalingsteken in een string te gebruiken, escapet u deze met een backslash ( \ ). Als u de backslash zelf moet schrijven, dupliceert u deze ( \\ ). Al het andere gebruik van de backslash wordt geïnterpreteerd als normale tekens: dit betekent dat als u andere escape-reeksen probeert te gebruiken, zoals \R of \N, worden ze uitgevoerd zoals ze zijn, in plaats van enig speciaal gedrag.
echo "Dit is een eenvoudige string";
echo "Je kunt ook in regels invoegen
newline-teken zoals dit,
Dit is goed";
// Uitgangen: Arnold zei ooit: "Ik kom terug"
echo "Op een dag zei Arnold: 'Ik kom terug.'';
Echo "Heb je C:\\*.* verwijderd?";
// Uitvoer: Heb je C:\*.* verwijderd?
echo "Heb je C:\*.* verwijderd?" ;
// Uitvoer: Dit wordt niet uitgebreid: \n nieuwe regel
echo "Dit wordt niet uitgebreid: \n nieuwe regel";
// Uitvoer: $expand en $ether variabelen worden niet uitgebreid
echo "$expand en $ether variabelen zijn niet uitgebreid";
?>
Dubbele aanhalingstekens
Als de string tussen dubbele aanhalingstekens (") staat, herkent PHP de volgende ontsnappingsreeksen voor speciale tekens:
| Vervolg | Betekenis |
|---|---|
| \N | nieuwe regel (LF of 0x0A (10) in ASCII) |
| \R | regelterugloop (CR of 0x0D (13) in ASCII) |
| \T | horizontaal tabblad (HT of 0x09 (9) in ASCII) |
| \v | verticaal tabblad (VT of 0x0B (11) in ASCII) (sinds PHP 5.2.5) |
| \ e | escape-teken (ESC of 0x1B (27) in ASCII) (sinds PHP 5.4.4) |
| \F | paginafeed (FF of 0x0C(12) in ASCII) (sinds PHP 5.2.5) |
| \\ | terugslag |
| \$ | dollarteken |
| \" | dubbele aanhalingstekens |
| \{1,3} | een reeks tekens die overeenkomen met een reguliere expressie van een octaal teken die stilletjes overloopt om in een byte te passen (dat wil zeggen "\400" === "\000") |
| \x(1,2) | reeks tekens die overeenkomen met de reguliere expressie van een teken in hexadecimale notatie |
| \u(+) | een reeks tekens die overeenkomen met een reguliere Unicode-tekenexpressie die is toegewezen aan een tekenreeks in UTF-8-weergave (toegevoegd in PHP 7.0.0) |
Net als bij een string tussen enkele aanhalingstekens, zal het escapen van een teken ook het escape-teken zelf uitvoeren. Vóór PHP 5.1.1, backslash naar binnen \($var) werd niet gepubliceerd.
Hierdoc
De derde manier om tekenreeksen te definiëren is door de heredoc-syntaxis te gebruiken: <<< . Na deze operator moet u een ID opgeven en vervolgens een regelinvoer. Hierna komt de regel zelf en vervolgens dezelfde identificatie, waarmee de invoeging wordt afgesloten.
Lijn moeten begin met een afsluitende identificatie, d.w.z. het moet in de eerste kolom van de rij verschijnen. Bovendien moet de ID dezelfde naamgevingsregels volgen als alle andere tags in PHP: mag alleen alfanumerieke tekens en een onderstrepingsteken bevatten, en mag niet beginnen met een cijfer (onderstrepingstekens zijn toegestaan).
Aandacht
Het is heel belangrijk op te merken dat de afsluitende identificatieregel geen andere tekens mag bevatten, behalve een puntkomma ( ; ). Dit betekent dat de id mag niet worden ingesprongen en dat er geen spaties of tabs voor of na de puntkomma mogen staan. Het is ook belangrijk om te begrijpen dat het eerste teken vóór de afsluitende ID het nieuweregelteken moet zijn dat door uw besturingssysteem is gedefinieerd. Op UNIX-systemen, inclusief macOS, is dit bijvoorbeeld het geval \N. Na de afsluitende identificatie moet ook onmiddellijk een nieuwe regel beginnen.
Als deze regel wordt overtreden en de afsluitende ID niet "schoon" is, wordt de afsluitende ID als ontbrekend beschouwd en zal PHP er verder naar blijven zoeken. Als in dit geval nooit de juiste afsluitende identificatie wordt gevonden, zal dit een parseerfout veroorzaken met het regelnummer aan het einde van het script.
Voorbeeld #1 Voorbeeld van onjuiste syntaxis
klasse foo (
openbaar $bar =<<
EOT;
// inspringen vóór de afsluitende identificatie is niet toegestaan
}
?>
Voorbeeld #2 Voorbeeld van correcte syntaxis
klasse foo (
openbaar $bar =<<
EOT;
}
?>
Heredoc kan niet worden gebruikt om klassenvelden te initialiseren. Vanaf PHP 5.3 is deze beperking alleen van toepassing op heredocs die variabelen bevatten.
Heredoc-tekst gedraagt zich op dezelfde manier als een tekenreeks tussen dubbele aanhalingstekens, zonder dat deze aanwezig zijn. Dit betekent dat u in heredoc geen aanhalingstekens hoeft te gebruiken, maar dat u nog steeds de bovenstaande ontsnappingsreeksen kunt gebruiken. Variabelen worden verwerkt, maar u moet net zo voorzichtig zijn bij het gebruik van complexe variabelen in heredoc als bij het werken met tekenreeksen.
Voorbeeld #3 Voorbeeld van Heredoc-tekenreeksdefinitie
$str =<<
verspreid over meerdere lijnen,
met behulp van de heredoc-syntaxis.
EOD;
Klasse foe
{
var $foo ;
var $balk;
Functie__construct()
{
$dit -> foo = "Foo";
$dit ->
}
}
$foo = nieuwe foo();
$naam = "Naam" ;
echo<<
Nu leid ik af($foo -> balk [ 1 ]) .
Dit zou de hoofdletter "A" moeten opleveren: \x41
EOT;
?>
Mijn naam is "Naam". Ik typ Foo. Nu voer ik Bar2 uit. Dit zou een hoofdletter "A" moeten opleveren: A
Het is ook mogelijk om de heredoc-syntaxis te gebruiken om gegevens door te geven via functieargumenten:
Sinds versie 5.3.0 is het mogelijk geworden om statische variabelen en klasse-eigenschappen/constanten te initialiseren met behulp van de heredoc-syntaxis:
Voorbeeld #5 Heredoc gebruiken om statische variabelen te initialiseren
// Statische variabelen
functie foo()
{
statisch $bar =<<
ETIKET;
}
// Constanten/klasse-eigenschappen
klasse fo
{
const BAR =<<
FOBAR;
Openbaar $baz =<<
FOBAR;
}
?>
Vanaf PHP 5.3.0 kun je de Heredoc-identifier ook omringen met dubbele aanhalingstekens:
Nudoc
Nowdoc is hetzelfde voor tekenreeksen met enkele aanhalingstekens als heredoc voor tekenreeksen met dubbele aanhalingstekens. Nowdoc lijkt op heredoc, maar dan binnenin er vinden geen vervangingen plaats. Dit ontwerp is ideaal voor het insluiten van PHP-code of andere grote tekstblokken zonder dat u eraan hoeft te ontsnappen. Hierin lijkt het een beetje op het SGML-construct door te declareren dat een tekstblok niet bedoeld is om te worden verwerkt.
Nowdoc wordt aangegeven met dezelfde reeks <<< , die wordt gebruikt in heredoc, maar de volgende identificatie staat tussen enkele aanhalingstekens, bijvoorbeeld: <<<"EOT" . Alle voorwaarden die van toepassing zijn op heredoc-identifiers zijn ook van toepassing op nowdoc, vooral de voorwaarden die van toepassing zijn op de afsluitende identifier.
Voorbeeld #7 Voorbeeld van het gebruik van nowdoc
echo<<<"EOD"
Voorbeeldtekst,
verspreid over meerdere lijnen
met behulp van nowdoc-syntaxis. Backslashes worden altijd letterlijk behandeld,
bijvoorbeeld \\ en \".
EOD;
Het resultaat van het uitvoeren van dit voorbeeld:
Voorbeeld van tekst die meerdere regels beslaat met behulp van de nowdoc-syntaxis. Backslashes worden altijd letterlijk behandeld, zoals \\ en \".
Voorbeeld #8 Nowdoc-tekenreekscitaat met variabelen
/* Complexer voorbeeld met variabelen. */
klasse fo
{
publiek $foo;
openbare $balk;
Functie__construct()
{
$dit -> foo = "Foo";
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}
$foo = nieuwe foo();
$naam = "Naam" ;
echo<<<"EOT"
Mijn naam is "$naam". Ik druk $foo->foo af.
Nu print ik ($foo->bar).
Dit zou geen hoofdletter "A" moeten opleveren: \x41
EOT;
?>
Het resultaat van het uitvoeren van dit voorbeeld:
Mijn naam is "$naam". Ik druk $foo->foo af. Nu print ik ($foo->bar). Dit zou geen hoofdletter "A" moeten opleveren: \x41
Voorbeeld #9 Voorbeeld van het gebruik van statische gegevens
klasse foo (
openbaar $bar =<<<"EOT"
bar
EOT;
}
?>
Opmerking:
nowdoc-ondersteuning is toegevoegd in PHP 5.3.0.
Variabelen verwerken
Als een string tussen dubbele aanhalingstekens wordt opgegeven, of als heredoc wordt gebruikt, worden de variabelen erin verwerkt.
Er zijn twee soorten syntaxis: eenvoudig en complex. Eenvoudige syntaxis is eenvoudiger en handiger. Het maakt het mogelijk om een variabele, een arraywaarde ( reeks) of objecteigenschappen ( voorwerp) met een minimum aan inspanning.
Complexe syntaxis kan worden geïdentificeerd door de accolades rond de uitdrukking.
Eenvoudige syntaxis
Als de tolk een dollarteken tegenkomt ( $ ), vangt het zoveel mogelijk tekens op om een geldige variabelenaam te vormen. Als u het einde van een naam wilt opgeven, plaatst u de naam van de variabele tussen accolades.
$sap = "appel";
echo "Hij dronk wat sap." . PHP_EOL;
// Niet correct. "s" is een geldig teken voor een variabelenaam, maar de variabele heet $juice.
echo "Hij dronk wat sap gemaakt van $sappen." ;
// Juist. Het einde van de variabelenaam wordt strikt aangegeven met haakjes:
echo "Hij dronk wat sap gemaakt van $( juice ) s." ;
?>
Het resultaat van het uitvoeren van dit voorbeeld:
Hij dronk wat appelsap. Hij dronk wat sap gemaakt van . Hij dronk wat sap gemaakt van appels.
Een array-element ( reeks) of objecteigenschap ( voorwerp). In array-indices staat er een afsluitend vierkant haakje ( ] ) markeert het einde van de indexdefinitie. Voor objecteigenschappen gelden dezelfde regels als voor eenvoudige variabelen.
Voorbeeld #10 Eenvoudig syntaxisvoorbeeld
definieer ("KOOLAID" , "koolaid1");
$juices = array("appel" , "oranje" , "koolaid1" => "paars" );
echo "Hij dronk wat $sappen [ 0 ] sap." . PHP_EOL;
echo "Hij dronk wat sap [ 1 ]." . PHP_EOL;
echo "Hij dronk wat $juices [koolaid1] sap." . PHP_EOL;
klasse mensen (
public $john = "Jan Smit" ;
public $jane = "Jane Smith";
publiek $robert = "Robert Paulsen" ;
Openbaar $smid = "Smid" ;
}
$mensen = nieuwe mensen();
echo "$people -> John dronk wat $juices [ 0 ] sap." . PHP_EOL;
echo " $people -> john zei toen hallo tegen $people -> jane ." . PHP_EOL;
echo "$people -> john "vrouw begroette $people -> robert." . PHP_EOL;
echo " $people -> robert begroette de twee $people -> smiths ." ; // Zal niet werken
?>
Het resultaat van het uitvoeren van dit voorbeeld:
Hij dronk wat appelsap. Hij dronk wat sinaasappelsap. Hij dronk wat paars sap. John Smith dronk wat appelsap. John Smith zei toen hallo tegen Jane Smith. De vrouw van John Smith begroette Robert Paulsen. Robert Paulsen begroette de twee.
PHP 7.1.0 ondersteuning toegevoegd negatief numerieke indexen.
Voorbeeld #11 Negatieve numerieke indexen
$string = "tekenreeks";
echo "Het teken op index -2 is gelijk aan$string [- 2 ]." , PHP_EOL ;
$string [- 3] = "o";
echo "Het veranderen van het karakter op positie -3 naar 'o' levert de volgende regel op:$string." , PHP_EOL;
?>
Het resultaat van het uitvoeren van dit voorbeeld:
Het karakter met index -2 is gelijk aan n. Het veranderen van het karakter op positie -3 naar "o" geeft de volgende regel: sterk
Gebruik voor iets complexer de complexe syntaxis.
Complexe (gekrulde) syntaxis
Het wordt niet complex genoemd omdat het moeilijk te begrijpen is, maar omdat het het gebruik van complexe uitdrukkingen mogelijk maakt.
Elke scalaire variabele, arrayelement of objecteigenschap die aan een string is toegewezen, kan met deze syntaxis in een string worden weergegeven. Schrijf de uitdrukking gewoon op dezelfde manier als u buiten de regel zou doen, en wikkel deze er vervolgens in { En } . Omdat de { kan niet worden ontsnapt, deze syntaxis wordt alleen herkend wanneer $ volgt direct { . Gebruik {\$ printen {$ . Een paar illustratieve voorbeelden:
// Toon alle fouten
error_reporting(E_ALL);
$geweldig = "geweldig";
// Werkt niet, output: Dit is (geweldig)
echo "Dit is($geweldig)";
// Werken, uitgangen: dit is geweldig
echo "Dit is ($geweldig)";
// Werkt
echo ‘Dit plein is breed($vierkant -> breedte ) 00 centimeter." ;
// Werkt, trefwoorden tussen aanhalingstekens werken alleen met accolade-syntaxis
echo "Dit werkt: ($arr ["sleutel"]) ";
// Werkt
echo "Dit werkt: ($arr [ 4 ][ 3 ]) ";
// Dit is ongeldig om dezelfde reden als $foo outside
// lijnen. Met andere woorden, het zal nog steeds werken,
// maar aangezien PHP eerst naar de constante foo zoekt, zal dit leiden tot
// niveaufout E_NOTICE (ongedefinieerde constante).
echo "Het is niet goed:($arr [ foo ][ 3 ]) " ;
// Werkt. Bij intern gebruik van multidimensionale arrays
// lijnen gebruiken altijd accolades
echo "Dit werkt: ($arr ["foo"][3]) ";
// Werkt.
echo "Dit werkt: " . $arr [ "foe" ][ 3 ];
echo ‘Dit werkt ook:( $obj -> waarden [ 3 ] -> naam ) " ;
echo "Dit is de waarde van de genoemde variabele$naam: ($($naam)) ";
echo "Dit is de waarde van de variabele met de naam zoals geretourneerd door de functie getName():($(getNaam ())) ";
echo "Dit is de waarde van de variabele op naam die \$object->getName() retourneert:($( $object -> getName ())) ";
// Werkt niet, geeft als resultaat: Dit is wat getName() retourneert: (getName())
echo "Dit is wat getName() retourneert: (getName())";
?>
Met deze syntaxis is het ook mogelijk om toegang te krijgen tot objecteigenschappen binnen tekenreeksen.
klasse foo (
var $bar = "Ik ben bar." ;
}
$foo = nieuwe foo();
$balk = "balk";
$baz = array("foo" , "bar" , "baz" , "quux" );
echo "($foo -> $bar) \n" ;
echo "( $foo ->( $baz [ 1 ])) \n" ;
?>
Het resultaat van het uitvoeren van dit voorbeeld:
Ik ben bar. Ik ben bar.
Opmerking:
Functies, methodeaanroepen, statische klassevariabelen en klasseconstanten werken intern {$} , te beginnen met PHP 5. De opgegeven waarde wordt echter behandeld als een variabelenaam in dezelfde context als de regel waarin deze is gedefinieerd. Gebruik enkele accolades ( {} ) werkt niet voor toegang tot de waarden van functies, methoden, klasseconstanten of statische klassevariabelen.
// Toon alle fouten
error_reporting(E_ALL);
klasse bieren (
const frisdrank = "wortelbier";
publieke statische $ale = "ipa";
}
$wortelbier = "A & W" ;
$ipa = "Alexander Keith" ;
// Dit werkt, geeft als resultaat: ik wil graag A & W
echo "Ik wil graag ($( bieren :: frisdrank )) \n" ;
// Dit werkt ook, geeft als resultaat: ik zou graag die van Alexander Keith willen hebben
echo "Ik wil graag ($( bieren :: $ale )) \n" ;
?>
Een teken in een string openen en wijzigen
Tekens in tekenreeksen kunnen worden gebruikt en gewijzigd door hun verschuiving vanaf het begin van de tekenreeks op te geven, beginnend bij nul, tussen vierkante haken na de tekenreeks, bijvoorbeeld $str . Beschouw een string voor dit doel als een array van karakters. Als u meer dan 1 teken nodig heeft of wilt vervangen, kunt u de functies gebruiken substr() En substr_replace().
Opmerking: Vanaf PHP 7.1.0 worden negatieve offsetwaarden ondersteund. Ze specificeren de afstand vanaf het einde van de lijn. Eerdere negatieve offsets veroorzaakten een niveaufout E_NOTICE bij lezen (retourneert een lege string) of E_WAARSCHUWING tijdens het schrijven (waarbij de regel ongewijzigd blijft).
Opmerking: Een teken in een string kan ook worden benaderd met behulp van accolades, bijvoorbeeld $str(42) .
Aandacht
Als u probeert naar een offset buiten de grenzen van de regel te schrijven, wordt de string opgevuld met spaties tot aan die offset. Niet-gehele typen worden geconverteerd naar typen met gehele getallen. Het verkeerde offsettype veroorzaakt een niveaufout E_WAARSCHUWING. Alleen het eerste teken van de toegewezen string wordt gebruikt. Vanaf PHP 7.1.0 zal het toewijzen van een lege string een fatale fout veroorzaken. Voorheen werd in dit geval een nulbyte (NULL) toegewezen.
Aandacht
Strings in PHP zijn intern arrays van bytes. Als gevolg hiervan is het benaderen of wijzigen van een string met een offset niet veilig voor multi-byte-codering, en mag dit alleen worden gedaan met strings in single-byte-coderingen, zoals ISO-8859-1.
Opmerking: Sinds PHP 7.1.0 veroorzaakte het gebruik van een lege index voorheen een fatale fout; in dit geval werd de string zonder waarschuwing naar een array geconverteerd.
Voorbeeld #12 Enkele voorbeeldreeksen
// Haal het eerste teken van de string op
$str = "Dit is een test." ;
$eerste = $str [ 0 ];
// Haal het derde teken van de string op
$derde = $str [ 2 ];
// Haal het laatste teken van de string op
$str = "Dit is nog een test." ;
$laatste = $str [ strlen ($str ) - 1 ];
// Wijzig het laatste teken van de regel
$str = "Kijk naar de zee" ;
$str [strlen ($str)- 1] = "e";
?>
Vanaf PHP 5.4 moet de offset in de string worden opgegeven als een geheel getal of als een string met cijfers, anders wordt er een waarschuwing gegeven. Eerder gecompenseerd door een string zoals "foe", zonder waarschuwing werd omgezet in 0 .
Voorbeeld #13 Verschillen tussen PHP 5.3 en PHP 5.4
$str = "abc";
Var_dump($str["1"]);
var_dump (isset($str [ "1" ]));
Var_dump($str["1.0"]);
var_dump (isset($str [ "1.0" ]));
Var_dump($str["x"]);
var_dump (isset($str [ "x" ]));
Var_dump($str["1x"]);
var_dump (isset($str [ "1x" ]));
?>
Het resultaat van het uitvoeren van dit voorbeeld in PHP 5.3:
string(1) "b" bool(waar) string(1) "b" bool(waar) string(1) "a" bool(waar) string(1) "b" bool(waar)
Het resultaat van het uitvoeren van dit voorbeeld in PHP 5.4:
string(1) "b" bool(true) Waarschuwing: illegale string-offset "1.0" in /tmp/t.php online 7 string(1) "b" bool(false) Waarschuwing: illegale string-offset "x" in / tmp/t.php online 9 string(1) "a" bool(false) string(1) "b" bool(false)
Opmerking:
Proberen toegang te krijgen tot variabelen van andere typen (met uitzondering van arrays of objecten die bepaalde interfaces implementeren) met behulp van of {} zal stilletjes terugkeren NUL.
Opmerking:
PHP 5.5 heeft ondersteuning toegevoegd voor toegang tot tekens in letterlijke tekenreeksen met behulp van de syntaxis of {} .
Er zijn veel handige functies voor het wijzigen van tekenreeksen.
Basisfuncties worden beschreven in de sectie over tekenreeksfuncties, en voor geavanceerd zoeken en vervangen, Perl-compatibele reguliere expressiefuncties.
Converteren naar tekenreeks
Een waarde kan met behulp van een cast naar een string worden geconverteerd (snaar) of functies strval(). In expressies waarbij een string vereist is, vindt de conversie automatisch plaats. Dit gebeurt wanneer u functies gebruikt echo of afdrukken, of wanneer de waarde van een variabele wordt vergeleken met een string. Als u de secties Typen en Typemanipulatie in de handleiding leest, wordt het volgende duidelijker. zie ook settype().
Arrays worden altijd geconverteerd naar string "Matrix", zodat u de inhoud van de array ( reeks), gebruik makend van echo of afdrukken om te zien wat erin zit. Om een enkel element te bekijken, gebruik je zoiets als echo $arr["foe"]. Zie hieronder voor tips over hoe u alle inhoud kunt weergeven/bekijken.
Om een typevariabele te converteren "Voorwerp" van soort snaar Er wordt gebruik gemaakt van de magische methode __toString.
Betekenis NUL wordt altijd geconverteerd naar de lege string.
Zoals je hierboven kunt zien, levert het rechtstreeks converteren van arrays, objecten of bronnen naar een string geen bruikbare informatie op over de waarden zelf, afgezien van hun typen. Een betere manier om waarden uit te voeren voor foutopsporing is door functies te gebruiken print_r() En var_dump().
De meeste waarden in PHP kunnen worden geconverteerd naar een string voor permanente opslag. Deze methode wordt serialisatie genoemd en kan worden uitgevoerd met behulp van de functie serialiseren().
Tekenreeksen omzetten in getallen
Als de string wordt herkend als een numerieke waarde, worden de resulterende waarde en het resulterende type als volgt bepaald.
Als de tekenreeks geen van de tekens ".", "e" of "E" bevat en de waarde van het getal binnen het bereik van gehele getallen valt (gedefinieerd PHP_INT_MAX), wordt de string herkend als een geheel getal ( geheel getal). In alle andere gevallen wordt het beschouwd als een getal met drijvende komma ( vlot).
De waarde wordt bepaald door het begin van de string. Als de regel begint met een geldige numerieke waarde, wordt die waarde gebruikt. Anders is de waarde 0 (nul). Een geldige numerieke waarde bestaat uit een of meer cijfers (die een decimaalpunt kunnen bevatten), eventueel voorafgegaan door een teken gevolgd door een optionele exponent. De exponent is "e" of "E", gevolgd door een of meer cijfers.
$foo = 1 + "10,5" ; // $foo is een float (11.5)
$foo = 1 + "-1.3e3" ; // $foo is een float (-1299)
$foo = 1 + "bob-1.3e3"; // $foo is een geheel getal (1)
$foo = 1 + "bob3"; // $foo is een geheel getal (1)
$foo = 1 + "10 kleine varkens" ; // $foo is een geheel getal (11)
$foo = 4 + "10,2 kleine biggetjes"; // $foo is een float (14.2)
$foo = "10,0 varkens" + 1; // $foo is zwevend (11)
$foo = "10,0 varkens" + 1,0; // $foo is zwevend (11)
?>
Voor meer informatie over deze conversie, zie de sectie over strtod(3) in de Unix-documentatie.
Als u een van de voorbeelden in deze sectie wilt testen, kopieert en plakt u deze samen met de volgende regel om te zien wat er gebeurt:
echo "\$foo== $foo ; typ: " . gettype ($foo) . "
\N" ;
?>
Verwacht niet dat je de code van een teken krijgt door het naar een geheel getal te converteren (zoals bijvoorbeeld in C gebeurt). Gebruik de functies om tekens naar hun ASCII-codes en omgekeerd te converteren orde() En chr().
Implementatiedetails van het tekenreekstype
7 jaar geleden
De documentatie vermeldt dit niet, maar een afsluitende puntkomma aan het einde van het heredoc wordt feitelijk geïnterpreteerd als een echte puntkomma, en leidt als zodanig soms tot syntaxisfouten.
$foe =<<
EINDE;
?>
Dit doet niet:
foo (<<
EINDE;
);
// syntaxisfout, onverwacht ";"
?>
Zonder puntkomma werkt het prima:
foo (<<
EINDE
);
?>
3 jaar geleden
Je kunt een string-achtige array van char gebruiken (zoals C)
$a = "Stringarraytest";
var_dump($a);
// Return string(17) "Stringarraytest"
var_dump($a);
// Retourtekenreeks(1) "S"
// -- Met arraycast --
var_dump((matrix) $a);
// Return array(1) ( => string(17) "Stringarraytest")
var_dump((matrix) $a);
// Retourtekenreeks(17) "S"
Norihiori
1 jaar geleden
Elke enkele expressie, hoe complex ook, die begint met $ (dat wil zeggen een variabele) kan () worden ingebed in een tekenreeks met dubbele aanhalingstekens:
Echo "De uitdrukking ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17: 42 )) wordt net zo goed geparseerd als ". $h -> q ()[ "x)" ]-> p (9 == 0? 17: 42) . "doet." ;
?>
2 jaar geleden
Beide zouden moeten werken:(
Klasse testen (
openbare statische $VAR = "statisch";
openbare const VAR = "const";
Publieke functie zegHelloStatic() (
echo "hallo: ($dit :: $VAR) ";
}
Openbare functie zegHelloConst() (
echo "hallo: ($dit ::VAR) "; //Parse-fout: syntaxisfout, onverwachte ")", verwacht "["
}
}
$obj = nieuwe testen();
$obj -> zegHelloStatic();
$obj -> zeg HalloConst ();
14 jaar geleden
U kunt de complexe syntaxis gebruiken om de waarde van zowel objecteigenschappen EN objectmethoden in een tekenreeks te plaatsen. Bijvoorbeeld...
klasTest{
openbaar$ één=
1
;
publieke functietwee() {
opbrengst2
;
}
}
$test= nieuwTest();
echo"foe{
$test->
een}
bar{
$test->
twee()}
"
;
?>
Zal "foo 1 bar 2" uitvoeren.
Je kunt dit echter niet voor alle waarden in je naamruimte doen. Klasseconstanten en statische eigenschappen/methoden zullen niet werken omdat de complexe syntaxis naar de "$" zoekt.
klasTest{
constEEN=
1
;
}
echo"foo (Test::ONE)-balk";
?>
Dit levert "foo (Test::one) bar" op. Constanten en statische eigenschappen vereisen dat u de string opsplitst.
6 jaar geleden
Voorloopnullen in tekenreeksen worden (minst verrassend) niet als octaal behandeld.
Overwegen:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x is $x, y is $y"; //print "x is 123, y is 83"
met andere woorden:
* voorloopnullen in numerieke letterlijke getallen in de broncode worden geïnterpreteerd als "octaal", vgl. strtol().
* voorloopnullen in tekenreeksen (bijvoorbeeld door de gebruiker ingediende gegevens), wanneer deze (impliciet of expliciet) naar een geheel getal worden omgezet, worden genegeerd en als decimaal beschouwd, c.f. strtod().
3 jaar geleden
Houd er rekening mee dat dit consistent is met "Stringconversie naar getallen":
als ("123abc"==
123
) echo"(intstr == int) test ten onrechte als waar.";
// Omdat één zijde een getal is, wordt de string verkeerd geconverteerd van intstr naar int, wat dan overeenkomt met het testnummer. // Geldt voor alle conditionals zoals if- en switch-instructies (waarschijnlijk ook while-lussen)! // Dit kan een enorm veiligheidsrisico vormen bij het testen/gebruiken/opslaan van gebruikersinvoer, terwijl er alleen op een geheel getal wordt verwacht en getest. // Het lijkt erop dat de enige oplossing is dat 123 een string is als "123", dus er vindt geen conversie plaats.
?>
10 jaar geleden Hier is een eenvoudige hack om tekenreeksen met dubbele aanhalingstekens en heredocs willekeurige uitdrukkingen in de syntaxis van accolades te laten bevatten, inclusief constanten en andere functieaanroepen:
// Hack-verklaring
// Onze speeltuin
$ een=
3
; functie C($ een,
$b) (opbrengst$ een+
$b; }
//Gebruik // Algemene syntaxis is ($_expr(...)) 11 jaar geleden Om je gedachten te redden, lees geen eerdere opmerkingen over datums;) Wanneer beide strings kunnen worden geconverteerd naar de numerieke waarden (in ("$a" > "$b") test), worden de resulterende numerieke waarden gebruikt, anders worden VOLLEDIGE strings teken voor teken vergeleken: var_dump("1.22"
>
"01.23"
);
// bool(onwaar) 2 jaar geleden Ik dacht dat het nuttig zou zijn om deze opmerking toe te voegen, zodat de informatie in ieder geval op de juiste pagina op de PHP-site verschijnt. Houd er rekening mee dat als u van plan bent een tekenreeks met dubbele aanhalingstekens te gebruiken met een associatieve sleutel, u mogelijk de fout T_ENCAPSED_AND_WHITESPACE tegenkomt. Sommigen beschouwen dit als een van de minder voor de hand liggende foutmeldingen. Een uitdrukking als: $fruit=array( Afdrukken "Dit is een$fruit[
"A"]";
// T_ENCAPSED_AND_WHITESPACE Je kunt het als volgt oplossen: afdrukken"Dit is een$fruit[
A]
"
;
// verwijder de sleutel Het is niet duidelijk (voor mij tenminste) waarom PHP het enkele aanhalingsteken in de uitdrukking verkeerd interpreteert, maar ik kan me voorstellen dat het iets te maken heeft met het feit dat aanhalingstekens geen deel uitmaken van de waardestring - zodra de string al wordt geparseerd, worden de aanhalingstekens gewoon in de weg zitten... ? In het laatste bericht hebben we gekeken naar de syntaxis van de voorwaardelijke instructie in PHP. In deze opmerking zullen we het hebben over operatorbeugels. Je zult ze voortdurend tegenkomen. Dit is een basisconcept van elke programmeertaal. Wikipedia zal ons helpen de vraag te beantwoorden wat operatorbeugels zijn: Operator-haakjes- haakjes of commando's die een blok commando's in een programmeertaal definiëren, gezien als één geheel, als één commando. Pascal gebruikt de volgende constructie om operatorbeugels aan te duiden: beginnen…. einde. In C-achtige talen (waaronder PHP), worden de bedieningsbeugels met symbolen beschreven {…}
. Die. met andere woorden, verschillende opdrachten tussen operatorhaakjes worden behandeld als 1 opdracht. In een artikel over termen in PHP er was een voorbeeld:
$b) ( echo "Variabele A is groter dan B"; ) else ( echo "Variabele B is groter dan A"; ) ?> In dit voorbeeld worden operatorbeugels 2 keer gebruikt. Ze framen de operators In dit voorbeeld staat er slechts één verklaring tussen haakjes, dus het komt neer op het schrijven van zoiets als dit:
$b) echo "Variabele A is groter dan B"; else echo "Variabele B is groter dan A"; ?> Syntaxis: Als (voorwaarde) expressie 1; anders expressie 2; Stel dat we een andere regel op het scherm willen weergeven als niet aan een voorwaarde wordt voldaan. Laten we ook de waarden van onze variabelen veranderen, zodat nu $ een was > $b. Laten we onze code aanpassen:
$b) echo "Variabele A is groter dan B."; else echo "Variabele B is groter dan A."; echo "Ja..ja A is eigenlijk kleiner dan B."; ?> Laten we het doen... Wat zien we op het scherm: Variabele A is groter dan B. Ja..ja A is eigenlijk kleiner dan B. Er zit hier ergens een fout. Zoals je misschien al geraden hebt, is het hele punt dat, aangezien onze voorwaarde waar is (a > b), de code wordt uitgevoerd: Echo "Variabele A is groter dan B."; In de draad anders We hebben maar 1 uitdrukking: Echo "Variabele B is groter dan A."; De volgende expressie wordt uitgevoerd, ongeacht de voorwaarde. Soortgelijk:
$b) echo "Variabele A is groter dan B."; else echo "Variabele B is groter dan A."; echo "Ja..ja A is eigenlijk kleiner dan B."; ?> Nu gebruiken we operatorhaakjes en combineren we twee uitdrukkingen in de vertakking anders:
$b) ( echo "Variabele A is groter dan B."; ) else ( echo "Variabele B is groter dan A."; echo "Ja..ja A is eigenlijk kleiner dan B."; ) ?> De code is veel duidelijker geworden. Nu PHP begrijpt dat als niet aan de voorwaarde ($a > $b) wordt voldaan, het twee regels moet afdrukken. En als de voorwaarde waar is: slechts één. Mijn grote voor jou advies– gebruik altijd aandrijvingsbeugels, ook als u niet meerdere aandrijvingen in 1 blok hoeft te combineren. Het feit is dat:
functie_expr($ v) (opbrengst$ v; }
$_expr=
"_expr";
definiëren("qwe",
"asd");
definiëren("zxc",
5
);
$b=
4
;
echo"pre{
$_expr(1
+
2
)}
bericht\n";
// geeft "pre 3 post" als resultaat
echo"pre{
$_expr(qwe)}
bericht\n";
// geeft "pre asd post" als uitvoer
echo"pre{
$_expr(C($ een,
$b)+
zxc*
2
)}
bericht\n";
// geeft "pre 17 post" als resultaat
?>
var_dump("1.22.00"
>
"01.23.00"
);
// bool (waar)
var_dump("1-22-00"
>
"01-23-00"
);
// bool (waar)
var_dump((vlot)"1.22.00"
> (zweven)"01.23.00"
);
// bool(onwaar)
?>
"A"=>
"appel",
"B"=>
"banaan",
//enz
);
?>
zal zeker in stukken vallen.
afdrukken"Dit is een${
fruit[
"A"]}
"
;
// Complexe syntaxis
afdrukken"Dit is een{
$fruit[
"A"]}
"
;
// Complexe syntaxisvariatie
?>
Ik heb een persoonlijke voorkeur voor de laatste variant, omdat deze natuurlijker is en dichter bij de uitdrukking buiten de string ligt.
