Escape enkele aanhalingstekens in php. Php-aanhalingstekens, enkele aanhalingstekens, dubbele aanhalingstekens, escape-tekens

Ik ben geen expert in PHP-programmeren, maar ik ben een beetje in de war waarom ik code in PHP zie met een string tussen enkele aanhalingstekens en soms tussen dubbele aanhalingstekens.

Ik weet gewoon dat in .NET- of C-taal als het tussen enkele aanhalingstekens staat, dit betekent dat het een teken is en geen string.

11 antwoorden

wat je hoort te weten

$a = "naam"; $b = "mijn $a"; == "mijn naam" $c = "mijn $a"; != "mijn naam"

in PHP gebruiken mensen enkele aanhalingstekens om een ​​constante string te definiëren zoals "a" , "my name" , "abc xyz" , terwijl het gebruik van dubbele aanhalingstekens om een ​​string te definiëren een identificatie bevat zoals "a $b $c $d" .

Echo "mijn naam";

sneller dan

Echo "mijn naam";

Echo "mijn". $a;

trager dan

Echo "mijn $a";

dit geldt voor de andere gebruikte strings.

voorbeeld van enkele, dubbele, heredoc en nowdoc aanhalingstekens

beide soorten geneste tekens zijn tekenreeksen. Het ene type offerte wordt handig gebruikt om een ​​ander type offerte in te sluiten. """ En """ . Het grootste verschil tussen de typen aanhalingstekens is dat geneste identificatiereferenties tussen dubbele aanhalingstekens worden vervangen, maar niet tussen enkele aanhalingstekens.

in PHP wordt tekst met enkele aanhalingstekens behandeld als een tekenreekswaarde, en tekst met dubbele aanhalingstekens parseert variabelen, waarbij hun waarde wordt vervangen en verwerkt.

$test = "variabele"; echo "Hallo meneer $test"; // de uitvoer zou zijn: Hallo meneer variabele echo "Hallo meneer $test"; // de uitvoer zou zijn: Hallo meneer $test

hier ontleedt het dubbele aanhalingsteken de waarde en wordt het enkele aanhalingsteken behandeld als een tekenreekswaarde (zonder de variabele $test te ontleden).

Misschien ben ik een beetje laat en een beetje off-topic, maar toch...

je hoeft niet te selecteren op basis van de inhoud van je string tussen:
alert("Het is "game"-tijd."); of alert("Het is "game"-tijd.");

in plaats daarvan kun je zo typen en dan dubbele of enkele aanhalingstekens gebruiken, omdat het er niet toe doet:
alert("Het is 'game'-tijd."); and alert("Het is 'game'-tijd.");

$naam = "test"; $singleQuote = "Dit is een voorbeeld van een enkel aanhalingsteken $name"; // hier evalueert $name variabele echo $singleQuote niet; // Uitvoer: Dit is een voorbeeld van een enkel aanhalingsteken $name $singleQuote = "Dit is een voorbeeld van een enkel aanhalingsteken $name"; // hier zal $name variabele de variabele waarde evalueren en vervangen echo $singleQuote; // Uitvoer: Dit is een voorbeeld voor een test met enkele aanhalingstekens. Ook binnen de expressie met enkele aanhalingstekens evalueert u sneller de vergelijking met dubbele aanhalingstekens

een:

Het is heel belangrijk op te merken dat de regel met de afsluitende identificatie help hierdoc mag geen andere tekens bevatten behalve puntkomma (;). Dit betekent dat de ID niet kan bestaan inspringen, en dat kan niet zo zijn terrein of tabbladen vóór of na de komma.

voorbeeld:

$str =<<

Tekenreeksen in PHP worden omgeven door enkele of dubbele aanhalingstekens. Het belangrijkste verschil is dat je een variabele tussen dubbele aanhalingstekens kunt plaatsen:

Nu kunnen we een andere oplossing voor het probleem bedenken uit de les Variabelen in PHP:

$titel"; echo"

Hoe vindt PHP een variabele in een string?

Het is makkelijk. Weet jij nog welke tekens je in een variabelenaam kunt gebruiken? Dit zijn cijfers, letters en onderstrepingstekens _.

PHP neemt dus als naam alles wat tussen het $-symbool en het eerste verboden teken staat.

In de volgende code zal PHP de naam van de variabele verkeerd bepalen en een foutmelding genereren:

Resultaat in browser:

Opmerking: Ongedefinieerde variabele: pricerub in D:\OpenServer\domains\site\index.php op regel 3

Om PHP de naam van een variabele in een string correct te laten bepalen, moet je deze tussen accolades () plaatsen:

Resultaat in browser:

1499 wrijven.

Er bestaat geen duidelijke consensus over welke aanhalingstekens moeten worden gebruikt voor gewone tekenreeksen waarin niets hoeft te worden vervangen. Veel programmeurs gebruiken echter liever enkele aanhalingstekens.

Feit is dat dubbele aanhalingstekens bij veel mensen de associatie oproepen ‘er moet iets in deze regel worden ingevoegd’. Daarom raad ik aan om enkele aanhalingstekens te gebruiken voor gewone tekst, en alleen dubbele aanhalingstekens als je een variabele in de tekst moet vervangen. Voorbeeld:

Aanhalingstekens ontsnappen

Als u aanhalingstekens in een tekenreeks moet plaatsen, kunt u dit op twee manieren doen:

In het tweede voorbeeld ontsnapt de backslash \ aan het volgende citaat, zodat PHP het als een string behandelt.

Wat moet er volgens jou gebeuren om alleen backslashes op het scherm weer te geven? Het zal immers aan het slotcitaat ontsnappen. Het is grappig, maar je moet een tweede schuine streep schrijven om aan de eerste te ontsnappen:

Tabellering en regeleinden tussen dubbele aanhalingstekens

Met de backslash tussen dubbele aanhalingstekens kunt u niet alleen aan de aanhalingstekens en zichzelf ontsnappen, maar ook aan enkele andere tekens. De meest populaire zijn tab (de lange spatie die je krijgt als je op TAB drukt) en regeleinde. Ze zien er zo uit:

Schrijf een script dat:
1. Creëert een $type variabele met de waarde Game.
2. Creëert een variabele $name met de waarde "World of Warcraft" (tussen aanhalingstekens).
3. Toont beide variabelen binnen de tag

. Er moet een spatie tussen de variabelen zijn.

Zoals je in de vorige tutorial hebt gezien, is het echo-commando in php een manier om tekst uit te voeren. Gedurende je PHP-carrière zul je het echo-commando vaker gebruiken dan welk ander commando dan ook. Laten we het dus eens goed bekijken!

Lijnuitgang

Om een ​​string uit te voeren, zoals we in voorgaande lessen deden, wordt echo gebruikt. Met zijn hulp kunt u tekst tussen aanhalingstekens, variabele waarden, enz. weergeven. Laten we eens kijken naar een voorbeeld.

Ik gebruik graag PHP!"; ?>

Het uitvoeren van de zinsnede “Hallo!” We zijn al bekend, er is hier niets nieuws. Maar het volgende echo-commando bevat, zoals u kunt zien, een html-tag. Het is niet verboden om html-tags te gebruiken, omdat php ons dynamiek geeft, en de statische gegevens en het pagina-ontwerp nog steeds overgeleverd zijn aan reguliere html.

Let op, dubbele aanhalingstekens!

Het is erg cool dat je HTML in PHP kunt uitvoeren. U moet echter voorzichtig zijn bij het gebruik van HTML-code of een andere tekenreeks die aanhalingstekens bevat! Echo gebruikt aanhalingstekens om het begin en einde van een tekenreeks te definiëren, dus u moet een van de volgende opties gebruiken als u aanhalingstekens binnen echo wilt gebruiken:

• Gebruik geen aanhalingstekens binnen een string.
• Ontsnap aan interne aanhalingstekens met een schuine streep. Om te voorkomen dat de binnenste aanhalingstekens worden verwerkt, plaatst u er eenvoudigweg een backslash vlak voor, d.w.z. \".
• Gebruik enkele aanhalingstekens (apostrofs) binnen de tekenreeks.

Zie ons voorbeeld hieronder voor het juiste en onjuiste gebruik van het echo-commando:

Ik gebruik graag PHP!"; // OK omdat we aan de aanhalingstekens zijn ontsnapt! echo "

Ik gebruik graag PHP!

Ik gebruik graag PHP!

Als u een tekenreeks met aanhalingstekens wilt uitvoeren, gebruikt u een apostrof (') of verwijdert u de aanhalingstekens door er een schuine streep (\") voor te plaatsen. De backslash vertelt PHP dat je wilt dat het teken erna niet door de tolk wordt geparseerd!

Variabele uitvoer

Het afleiden van variabelen is heel eenvoudig. In feite hoeft u niets speciaals te doen om variabelen in PHP weer te geven. Hij kan het zelf. Hier is een voorbeeld om u te helpen alles te begrijpen:

Resultaat:

Hallo Bob. Mijn naam is: 4a

Gelijktijdige uitvoer van variabelen en tekstreeksen

U kunt variabelen ook tussen dubbele aanhalingstekens uitvoeren (bijvoorbeeld "teksttekst $variabele"). Door een variabele tussen aanhalingstekens ("") te plaatsen, vertel je PHP dat je wilt dat deze de waarde overneemt, converteert naar een stringtype en uitvoert. Het onderstaande voorbeeld laat zien hoe je deze truc correct uitvoert :)

"; echo "Hallo, ik ben Bob. Wie ben jij? $my_string
"; echo "Hallo, ik ben Bob. Wie ben jij? $my_string Bobetta"; ?>

Resultaat:

Hallo Bob. Mijn naam is: Bobetta Hallo, ik ben Bob. Wie ben jij? Hallo Bob. Mijn naam is: Hallo, ik ben Bob. Wie ben je? Hallo Bob. Mijn naam is: Bobetta

Het plaatsen van variabelen binnen een regel kan tijd besparen en uw code gemakkelijker leesbaar maken, maar het is even wennen. Vergeet niet om aanhalingstekens te gebruiken; enkele aanhalingstekens zullen geen variabele waarden opleveren. Enkele aanhalingstekens zullen eenvoudigweg de naam van de variabele naar een string uitvoeren, d.w.z. $my_string, niet "Hallo Bob. Mijn naam is."

Echo is geen functie!

Echo is geen functie, maar een taalconstructie. Bij het gebruik van functies in PHP hebben ze een heel specifieke vorm, waar we later zeker naar zullen kijken. Weet voorlopig dat echo een speciaal hulpmiddel is waar u zeker dol op zult zijn! :D

Aaneenschakeling van PHP-tekenreeksen

Misschien wel de meest gebruikelijke bewerking met strings is het aaneenschakelen ervan, oftewel het verbinden van de ene string met de andere. Om tekenreeksen samen te voegen, is een speciale operator “.” geïntroduceerd. (punt).

Voorbeeld:


Bij de uitgang krijgen we de hele regel: "Mijn geboorteland is breed!"

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:

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 =<<bar
EOT;
// inspringen vóór de afsluitende identificatie is niet toegestaan
}
?>

Voorbeeld #2 Voorbeeld van correcte syntaxis

klasse foo (
openbaar $bar =<<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 string 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 een Heredoc-tekenreeksdefinitie

$str =<<Voorbeeldregel,
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<<Mijn naam is "$naam". Ik typ $foo -> foo .
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 =<<Er is hier niets...
ETIKET;
}

// Constanten/klasse-eigenschappen
klasse fo
{
const BAR =<<Voorbeeld van het gebruik van een constante
FOBAR;

Openbaar $baz =<<Voorbeeld van het gebruik van een veld
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 heeft 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 variabelenaam die getName() retourneert:($(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 objecteigenschappen binnen tekenreeksen te benaderen.

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";
openbare 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 wilt verkrijgen of 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 lijngrenzen 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 openen 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 geconverteerd naar een array.

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 een 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 en 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 =<<abcd
EINDE;
?>

Dit doet niet:

foe(<<abcd
EINDE;
);
// syntaxisfout, onverwacht ";"
?>

Zonder puntkomma werkt het prima:

foe(<<abcd
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

15 jaar geleden

U kunt de complexe syntaxis gebruiken om de waarde van zowel objecteigenschappen EN objectmethoden in een tekenreeks te plaatsen. Bijvoorbeeld...
klasse Test(
publiek $één = 1;
publieke functie twee() (
retour 2;
}
}
$test = nieuwe test();
echo "foo ($test -> één) 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.
klasse Test(
const EEN = 1;
}
echo "foo (Test::EEN) bar" ;
?>
Dit zal "foo (Test::one) bar" opleveren. Constanten en statische eigenschappen vereisen dat u de string opsplitst.

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.

?>

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().

10 jaar geleden

Hier is een eenvoudige hack om tekenreeksen met dubbele aanhalingstekens en heredocs willekeurige expressies in de syntaxis van accolades te laten bevatten, inclusief constanten en andere functieaanroepen:

// Hack-verklaring
functie _expr ($v ) ( retourneert $v ; )
$_expr = "_expr" ;

// Onze speeltuin
definieer("qwe" , "asd");
definiëren("zxc", 5 );

$ een= 3 ;
$b= 4 ;

functie C($ een, $b) (opbrengst$ een+ $b; }

//Gebruik
echo"pre{ $_expr(1 + 2 )} post\n"; // geeft "pre 3 post" als resultaat
echo"pre{ $_expr(qwe)} post\n"; // geeft "pre asd post" als uitvoer
echo"pre{ $_expr(C($ een, $b)+ zxc* 2 )} post\n"; // geeft "pre 17 post" als uitvoer

// Algemene syntaxis is ($_expr(...))
?>

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(
"A"=> "appel",
"B"=> "banaan",
//enz
);

Afdrukken "Dit is een$fruit[ "A"]"; // T_ENCAPSED_AND_WHITESPACE
?>

zal zeker in stukken vallen.

Je kunt het als volgt oplossen:

afdrukken"Dit is een$fruit[ A] " ; // verwijder de sleutel
afdrukken"Dit is een${ fruit[ "A"]} " ; // Complexe syntaxis
afdrukken"Dit is een{ $fruit[ "A"]} " ; // Complexe syntaxisvariatie
?>

Ik heb een persoonlijke voorkeur voor de laatste variatie, omdat deze natuurlijker is en dichter bij hoe de uitdrukking eruit zou zien buiten de string.

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... ?

2 jaar geleden

Beide zouden moeten werken:(

klasTesten{
publiek statisch$VAR= "statisch";
openbare const VAR ="const";

Publieke functie zeg HalloStatisch() {
echo"Hallo:{ $ dit:: $VAR} " ;
}

Publieke functie zeg HalloConst() {
echo"Hallo:{ $ dit::VAR)" ; //Parse-fout: syntaxisfout, onverwacht ")", verwacht "["
}
}

$object= nieuwTesten();
$object-> zeg HalloStatisch();
$object-> zeg HalloConst();

3 jaar geleden

Iets wat ik heb meegemaakt en dat ongetwijfeld iemand zal helpen. . .
In mijn editor zal dit de syntaxis van HTML en de $comment markeren:

$html=<<<"EOD"
$commentaar
EOD;

Als u dit gebruikt, wordt alles dezelfde kleur weergegeven:

$html=<<$commentaar
EOD;

waardoor het een stuk gemakkelijker wordt om mee te werken

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)
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)
?>

Een string is een set karakters. In PHP is een karakter hetzelfde als een byte, wat betekent dat er precies 256 verschillende karakters mogelijk zijn. Dit betekent ook dat PHP geen native Unicode-ondersteuning heeft. Sommige Unicode-ondersteuning wordt geleverd door de functies utf8_encode() en utf8_decode().

Let op: Er is geen probleem als de string erg groot is. Er zijn vrijwel geen beperkingen op de grootte van strings opgelegd door PHP, dus er is absoluut geen reden om je zorgen te maken over hun lengte.

Syntaxis

Een string kan op drie verschillende manieren worden gedefinieerd.

Enkele aanhalingstekens

De eenvoudigste manier om een ​​tekenreeks te definiëren is door deze tussen enkele aanhalingstekens te plaatsen (het teken ").

Om een ​​enkel aanhalingsteken in een tekenreeks te gebruiken, zoals in veel andere talen, moet dit worden voorafgegaan door een backslash (\), dat wil zeggen een escape. Als de backslash vóór een enkel aanhalingsteken moet komen of aan het einde van de regel moet staan, moet u deze dupliceren. Houd er rekening mee dat als je aan een ander personage probeert te ontsnappen, de backslash ook wordt afgedrukt! Het is dus over het algemeen niet nodig om aan de backslash zelf te ontsnappen.

Opmerking: in PHP 3 wordt in dit geval een bericht op E_NOTICE-niveau uitgegeven.

Opmerking: In tegenstelling tot de andere twee syntaxis worden variabelen en escape-reeksen voor speciale tekens die voorkomen in tekenreeksen met enkele aanhalingstekens niet verwerkt.

Echo "dit is een eenvoudige string"; echo "Je kunt op deze manier ook een newline-teken in strings invoegen, zoals normaal is"; // Uitgangen: Arnold zei ooit: "Ik kom terug" echo "Arnold zei ooit: "Ik kom terug""; // Uitvoer: Heb je C:\*.* verwijderd? echo "Heb je C:\\*.* verwijderd?"; // Uitvoer: Heb je C:\*.* verwijderd? echo "Heb je C:\*.* verwijderd?"; // Uitvoer: Dit zal niet invoegen: \n een nieuwe regel echo "Dit zal niet invoegen: \n een nieuwe regel"; // Uitvoer: $expand en $either variabelen worden niet vervangen echo "$expand en $either variabelen worden niet vervangen";

Dubbele aanhalingstekens

Als de string tussen dubbele aanhalingstekens (") staat, herkent PHP meer escape-reeksen voor speciale tekens:

Tabel 11-1. Ontsnappingssequenties

We herhalen: als je een ander karakter wilt onthouden, wordt de backslash ook afgedrukt!

Maar de belangrijkste eigenschap van tekenreeksen tussen dubbele aanhalingstekens is de omgang met variabelen. Zie meer details: tekenreeksverwerking.

Hierdoc

Een andere manier om tekenreeksen te definiëren is door de heredoc-syntaxis ("

De afsluitende ID moet in de eerste kolom van de rij beginnen. Bovendien moet de ID dezelfde naamgevingsregels volgen als alle andere tags in PHP: mag alleen alfanumerieke tekens en een onderstrepingsteken bevatten, en moet beginnen met een niet-cijferig of onderstrepingsteken.

Aandacht

Het is heel belangrijk op te merken dat de afsluitende identificatieregel geen andere tekens bevat, behalve eventueel een puntkomma (;). Dit betekent dat de identifier niet ingesprongen mag zijn 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 een nieuweregelteken moet zijn, zoals gedefinieerd door uw besturingssysteem. Op Macintosh is dit bijvoorbeeld \r.

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 fout veroorzaken bij de verwerking met het regelnummer aan het einde van het script.

Heredoc-tekst gedraagt ​​zich op dezelfde manier als een string 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 11-2. Voorbeeld van een Heredoc-tekenreeksdefinitie

$str =<<foe = "foe"; $this->bar = array("Bar1", "Bar2", "Bar3"); ) ) $foo = nieuwe foo(); $naam = "MijnNaam"; echo<<foe. Nu voer ik ($foo->bar) uit. Dit zou een hoofdletter "A" moeten opleveren: \x41 EOT;

Opmerking: Heredoc-ondersteuning is toegevoegd in PHP 4.

Variabelen verwerken

Als een string tussen dubbele aanhalingstekens wordt gedefinieerd, of als heredoc wordt gebruikt, worden de variabelen erin verwerkt.

Er zijn twee soorten syntaxis: eenvoudig en complex. Eenvoudige syntaxis is eenvoudiger en handiger. Hiermee kunt u een variabele, een arraywaarde of een objecteigenschap verwerken.

De complexe syntaxis is geïntroduceerd in PHP 4 en is te herkennen aan de accolades rond de expressie.

Eenvoudige syntaxis

Als de tolk een dollarteken ($) tegenkomt, verzamelt hij zoveel mogelijk tekens om een ​​geldige variabelenaam te vormen. Als u het einde van een naam wilt opgeven, plaatst u de naam van de variabele tussen accolades.

$bier = "Heineken"; echo "$beer"s smaak is geweldig"; // werkt, """ is een ongeldig teken voor de naam van een variabele echo "Hij dronk wat $biertjes"; // werkt niet, "s" is een geldige variabelenaam echo "Hij dronk wat $(bier)s"; // werkt echo "Hij dronk wat ($bier) s"; // werkt

Op dezelfde manier kan een array-element (array) of een eigenschap van een object (object) worden verwerkt. In array-indexen markeert een afsluitend vierkant haakje (]) het einde van de indexdefinitie. Voor objecteigenschappen gelden dezelfde regels als voor eenvoudige variabelen, hoewel ze niet zoals bij variabelen voor de gek gehouden kunnen worden.

// Deze voorbeelden gaan specifiek over het gebruik van arrays binnen // strings. Buiten de strings moet u de stringsleutels van uw // array altijd tussen aanhalingstekens plaatsen en niet buiten de strings (haakjes) gebruiken. // Laten we alle fouten tonen error_reporting(E_ALL); $fruits = array("aardbei" => "rood", "banaan" => "geel"); // Werkt, maar houd er rekening mee dat het anders werkt buiten de aangehaalde string-echo "Een banaan is $fruits."; // Werkt echo "Een banaan is ($fruits["banaan"])."; // Werkt, maar PHP zoekt, zoals hieronder beschreven, eerst // naar de banaanconstante. echo "Een banaan is ($fruit)."; // Werkt niet, gebruik accolades. Dit zal een verwerkingsfout veroorzaken. echo "Een banaan is $fruit["banaan"]."; // Werkt echo "Een banaan is ". $fruit["banaan"] . "."; // Werkt echo "Dit vierkant is $square->meter breed."; // Werkt niet. Zie complexe syntaxis voor oplossing. echo "Dit vierkant is $square->width00 centimeter breed.";

Voor alles wat complexer is, moet u een complexe syntaxis gebruiken.

Complexe (gekrulde) syntaxis

Het wordt niet complex genoemd omdat het moeilijk te begrijpen is, maar omdat het het gebruik van complexe uitdrukkingen mogelijk maakt.

In feite kunt u met deze syntaxis elke waarde die zich in de naamruimte bevindt, in een regel opnemen. U schrijft de uitdrukking eenvoudigweg op dezelfde manier als u buiten de regel zou doen, en plaatst deze vervolgens tussen ( en ). Omdat je "(" niet kunt ontsnappen, wordt deze syntaxis alleen herkend als $ onmiddellijk volgt op (. (Gebruik "(\$" of "\($" om te ontsnappen aan "($")). Enkele illustratieve voorbeelden:

// Laten we alle fouten tonen error_reporting(E_ALL); $geweldig = "fantastisch"; // Werkt niet, geeft als resultaat: This is (fantastisch) echo "This is ($great)"; // Werkt, zal resulteren in: Dit is een fantastische echo "Dit is ($great)"; echo "Dit is $(geweldig)"; // Werkt echo "Dit vierkant is ($square->width)00 centimeter breed."; // Werkt echo "Dit werkt: ($arr)"; // Dit is ongeldig om dezelfde reden dat $foo ongeldig is buiten de // regel. Met andere woorden, dit zal nog steeds werken, // maar omdat PHP eerst naar de constante foo zoekt, zal het // een E_NOTICE-fout (ongedefinieerde constante) genereren. echo "Dit is fout: ($arr)"; // Werkt. Wanneer u multidimensionale arrays gebruikt, gebruik dan altijd accolades binnen // strings echo "Dit werkt: ($arr["foo"])"; // Werkt. echo "Dit werkt: " . $arr["foe"]; echo "Je kunt zelfs ($obj->waarden->naam) schrijven"; echo "Dit is de waarde van de variabele genaamd $name: ($($name))";

Een teken in een string openen en wijzigen

Tekens in tekenreeksen kunnen worden gebruikt en gewijzigd door hun afstand vanaf het begin van de tekenreeks op te geven, beginnend bij nul, tussen accolades na de tekenreeks.

Opmerking: voor achterwaartse compatibiliteit heeft u nog steeds de mogelijkheid om array-haakjes voor dezelfde doeleinden te gebruiken. Vanaf PHP 4 is deze syntaxis echter verouderd.

Voorbeeld 11-3. Enkele voorbeeldstrings

// Haal het eerste teken van de string op $str = "Dit is een test."; $eerste = $str(0); // Haal het derde teken op van de string $third = $str(2); // Haal het laatste teken van de string op $str = "Dit is nog een test."; $laatste = $str(strlen($str)-1); // Verander het laatste teken van de regel $str = "Kijk naar de zee"; $str(strlen($str)-1) = "Ik";

Handige functies en operators

Tekenreeksen kunnen worden samengevoegd met behulp van de operator "." (punt). Houd er rekening mee dat de opteloperator "+" hier niet werkt. Zie Tekenreeksoperatoren voor meer informatie.

Er zijn veel handige functies voor het wijzigen van tekenreeksen.

De belangrijkste functies worden beschreven in de sectie over tekenreeksfuncties, reguliere expressiefuncties voor geavanceerd zoeken en vervangen (in twee delen: Perl en POSIX geavanceerd).

Er zijn ook functies voor URL-tekenreeksen en functies voor het coderen/decoderen van tekenreeksen (mcrypt en mhash).

Tenslotte, als je nog steeds niet hebt gevonden wat je zoekt, zie dan ook karaktertypefuncties.

Converteren naar tekenreeks

U kunt een waarde naar een string converteren met behulp van een cast (string) of de strval() functie. In expressies waarbij een string vereist is, vindt de conversie automatisch plaats. Dit gebeurt wanneer u de functies echo() of print() gebruikt, of wanneer u de waarde van een variabele vergelijkt met een tekenreeks. Als u de secties Typen en Typemanipulatie in de handleiding leest, wordt het volgende duidelijker. Zie ook settype().

De Booleaanse waarde TRUE wordt geconverteerd naar de tekenreeks "1", en de waarde FALSE wordt weergegeven als "" (de lege tekenreeks). Op deze manier kunt u waarden in beide richtingen converteren: van Boolean naar string en omgekeerd.

Een geheel getal of float wordt omgezet in een string, weergegeven door een getal dat bestaat uit de cijfers ervan (inclusief de exponent voor getallen met drijvende komma).

Arrays worden altijd geconverteerd naar de string "Array", dus u kunt de inhoud van een array niet weergeven met echo() of print() om te zien wat deze bevat. Om een ​​enkel element te bekijken moet je iets doen als echo $arr["foo"]. Zie hieronder voor tips over hoe u alle inhoud kunt weergeven/bekijken.

Objecten worden altijd geconverteerd naar de string "Object". Als u de waarde van een objectlidvariabele wilt afdrukken voor foutopsporingsdoeleinden, lees dan de volgende paragrafen. Als u de klassenaam van het vereiste object wilt achterhalen, gebruikt u get_class() .

Resources worden altijd geconverteerd naar strings met de structuur "Resource id #1", waarbij 1 het unieke resourcenummer is dat PHP er tijdens runtime aan heeft toegewezen. Als u het resourcetype wilt ophalen, gebruikt u .

NULL wordt altijd geconverteerd naar de lege string.

Zoals u hierboven kunt zien, geeft het uitvoeren van arrays, objecten of bronnen u geen enkele nuttige informatie over de waarden zelf. Een betere manier om waarden af ​​te drukken voor foutopsporing is door de functies print_r() en var_dump() te gebruiken.

Je kunt PHP-waarden ook omzetten naar strings voor permanente opslag. Deze methode wordt serialisatie genoemd en kan worden uitgevoerd met de functie serialize(). Als uw PHP-installatie WDDX-ondersteuning heeft, kunt u bovendien PHP-waarden serialiseren in XML-structuren.

Tekenreeksen omzetten in getallen

Als de string wordt herkend als een numerieke waarde, worden de resulterende waarde en het resulterende type als volgt bepaald.

Een string wordt herkend als een float als deze een van de tekens ".", "e" of "E" bevat. Anders wordt het gedefinieerd als een geheel getal.

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 float (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, kunt u deze en de volgende regel kopiëren en plakken 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 je bijvoorbeeld in C zou kunnen doen). Om karakters naar hun codes en omgekeerd te converteren, gebruik je de ord() en