Nemrég viták PHP nyelv A habré sokkal inkább az összetett rendszerek tervezésének képességén múlik, ami jó hír. Miután azonban áttekintettem egy tucat legelismertebb webes keretrendszert (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ és mások), őszintén meglepődtem, hogy jelentős hiányosságokat tapasztaltam az alapvető optimalizálás terén.

Annak érdekében, hogy ez a téma technikailag jobban orientált legyen, az eredményeket szigorúbb formában mutatjuk be, ami némileg megnehezítheti a felfogást.

Szóval, menjünk... A feladat rendkívül egyszerű: kísérleteket kell végezni a karakterláncok alkotásának sebességével egy- és kettős idézőjelben lévő részkarakterláncokból. Elvileg ez a kérdés továbbra is aktuális lesz hosszú ideje a PHP-beli karakterlánc-feldolgozás sajátosságai miatt.

Számos cikk található az alapvető szkriptoptimalizálásról oroszul és más nyelveken is. Keveset beszélnek a karakterláncokról, de a változók és vezérlőkarakterek idézőjelbe tett karakterláncainak "elemzésének" tényét megjegyzik (a hivatalos dokumentáció szerint). Ez alapján logikus az a feltételezés, hogy a dupla idézőjeles karakterláncok használata valamivel lassabb lesz, mint ugyanazon műveletek egyszeres idézőjeles részkarakterláncokkal.

A változók karakterláncokká való helyettesítésén és a változók részkarakterláncokkal való összefűzésén kívül a PHP még legalább egy módszert valósít meg a karakterláncok képzésére: a sprintf függvényt. Logikus ezt feltételezni ez a módszer jelentősen gyengébb lesz, mint a "standard" egy extra függvényhívás és benne lévő karakterlánc-elemzés miatt.

Az egyetlen kiegészítés, mielőtt bemutatom a tesztszkript kódját: figyelembe kell vennie a 2 lehetséges opciók idézőjeles karakterláncokkal való munka: figyelembe véve az egyszerű és "fejlett" kódolási stílust. Az a tény, hogy a változók a sorok elején vannak, valószínűleg nem érdemes odafigyelni - ezek csak példák:
$string = "A $_SERVER["HTTP_HOST"] nem Uljanovszk régió közigazgatása. Szeretjük az orosz nyelvet, és nem szeretjük azokat, akik beszélik..."
és
$string = "($_SERVER["HTTP_HOST"]) nem Uljanovszk régió közigazgatása. Szeretjük az orosz nyelvet, és nem szeretjük azokat, akik beszélik..."

Első számú teszt.
Nos, úgy tűnik, minden fenntartás megtörtént – ideje megmutatni a munka eredményét. Forrás tesztelő található.

A képernyőképek azt mutatják, hogy a hipotézisem nem igazolódott be. A húrokkal való sprintf-en keresztüli munkavégzés feltételezése bizonyult az egyetlen helyesnek. A leggyorsabbak a működő funkciók voltak dupla idézőjelek.

A helyzet rövid elmélkedése után magától jött a magyarázat: a lényeg az, hogy a hivatkozási karakterlánc, amelybe a helyettesítéseket végrehajtották, túl rövid: az ilyen karakterláncon áthaladó elemző csekély dolog. Azonban még itt is világos, hogy a változók karakterláncba való natív helyettesítése előnyt jelent a "fejlett stílussal" szemben.
Ez egyben az összefűzési megközelítés gyengesége is: a beszúrt adatok mennyisége meghaladja az alsztringek mennyiségét. Hogy honnan jön a rezsi, az a már említett habratópiában olvasható.

Azonban még ezek a gondolatok is megerősítésre szorultak. Ehhez egy második tesztre volt szükség az ilyen (számomra) kiszámíthatatlan viselkedés lehetséges okainak megváltoztatásával. Úgy látszik, az ötödik verzióban sok mindent módosítottak (bevallom, a php ötödik verziójában csak 1 tesztet végeztem: a tömbelemek megkerülésére).

Kettes számú teszt.
A második hipotézis az, hogy a referenciakarakterlánc meghosszabbítása végül megnöveli a dupla idézőjelben lévő karakterláncok képzéséhez kapcsolódó tesztelői függvények százalékos arányát az 1-es számú teszt eredményeihez képest. Ugyanezt a helyzetet kell elméletileg megfigyelni a művelettel kapcsolatban is. a sprintf függvényből. Ez elsősorban a karakterlánc-elemzés szükségességéből és az arra fordított idő növekedéséből adódik. Abban a helyzetben, amikor a részkarakterláncok szimpla idézőjelekbe fűződnek, úgy gondolom, hogy az eredmény megközelítőleg ugyanaz lesz, mint az első tesztben, ami az idézőjelek_3() függvény végrehajtási idejének arányában enyhén csökkenni fog. a teljes forgatókönyvből (de nincs teljesítménynövekedés).

A következtetések valójában csak pozitívak és megerősítik a hipotézist. Ha a referenciakarakterláncot enyhén megnöveljük, nagy a terhelés, ami a dupla idézőjelek és a sprintf függvények teljesítményének csökkenéséhez vezet.

Az idézőjeles karakterláncokra vonatkozó feltételezés is helyesnek bizonyult: az első teszt 36,75%-a helyett a másodikban a quotes_3() függvény a szkript végrehajtási idejének 33,76%-át vette igénybe.

gyakorlati érték.
Egyszerűen fogalmazva, az adatokból elvonatkoztatva megállapíthatjuk: mi hosszabb húr, amelyben helyettesítést kell végrehajtani, annál valószínűbb, hogy az összefűzési művelet gyorsabban befejeződik, mint a kettős idézőjelben lévő változó keresése. Az önkéntesek megpróbálhatják úgy kiválasztani a szükséges beillesztési paramétereket (változók száma, hivatkozási karakterlánc hossza, karakterláncok hossza a változókban), hogy azok megfeleljenek a végrehajtási idők egyenlőségének.

Valójában ez minden. Csak annyit kell hozzátenni, hogy a programozásban nincsenek apróságok (ez azoknak szól, akik szeretik azt mondani, hogy „megtakarítás a meccseken” (c) Adelf). Az ilyen finomságok ismeretében és figyelembevételével olyan kódot írhat, amely minden szintjén optimalizálva lesz;)

PS:
A Zend Studio For Eclipse 6.0.0 (Debugger + Profiler) segítségével végrehajtott tesztek.
PHP 5.2.5 verzió
Debian Linux operációs rendszer

PPS:
Örülnék, ha valaki leírná ezeknek a teszteknek az eredményeit. Úgy gondolom, hogy ez lehetővé teszi annak objektívebb értékelését, hogy szükség van-e a karakterláncokba való behelyettesítés egyik vagy másik módszerére. Hálás lennék a prezentációs stílus és a dizájn egészséges kritikájáért is.

(PHP 4, PHP 5, PHP 7)

str_replace- A keresési karakterlánc minden előfordulását lecseréli a helyettesítő karakterláncra

Leírás

Ez a függvény egy karakterláncot vagy tömböt ad vissza, amelyben a tárgyban végzett keresés minden előfordulását helyettesíti a helyettesítővel.

Ha nincs szüksége összetett keresési/csereszabályokra (például reguláris kifejezésekre), ez a funkció előnyösebb. preg_replace().

Paraméterlista

Ha a keresés és a csere tömbök, akkor str_replace() a megfelelő tömb minden egyes értékét használja a tárgyban való kereséshez és cseréhez. Ha kevesebb elem van a helyettesítő tömbben, mint a keresésben, akkor az üres karakterlánc lesz a fennmaradó értékek helyettesítő karakterlánca. Ha a keresés egy tömb, a helyettesítés pedig egy karakterlánc, akkor ezt a helyettesítő karakterláncot használja a rendszer a keresési tömb minden eleméhez. A fordított esetnek nincs értelme.

Ha a keresés vagy a csere tömb, akkor az elemei az elsőtől az utolsóig kerülnek feldolgozásra.

A keresett érték, más néven tű(tű). Egy tömböt több keresési értékhez is használhat.

Cserélje ki

A csereérték a keresett keresési értékek lecserélésére szolgál. Egy tömböt több értékhez is használhat.

tantárgy

A keresendő és lecserélendő karakterlánc vagy tömb, más néven szénaboglya(egy rakás széna).

Ha a tárgy egy tömb, akkor a keresés és a csere a tárgy minden elemére kerül sor, és a függvény eredménye is egy tömb lesz.

Ha sikeres, akkor a végrehajtott cserék száma lesz beállítva.

Visszatérési értékek

Ez a függvény egy karakterláncot vagy tömböt ad vissza az értékekkel lecserélve.

Példák

1. példa Használati példák str_replace()

// hozzárendel
$bodytag = str_replace("%body%" , "black" , " " );

// hozzárendelés: Hll Wrld f PHP
$hangzók = array("a" , "e" , "i" , "o" , "u" , "A" , "E" , "I" , "O" , "U" );
$onlyconsonants = str_replace ($vowels , "" , "Hello World of PHP" );

// hozzárendeli: Minden nap egyél pizzát, sört és fagylaltot
$kifejezés = "Minden nap enni kell gyümölcsöt, zöldséget és rostot.";
$egészséges = array("gyümölcsök" , "zöldségek" , "rost" );
$fincsi = array("pizza" , "sör" , "fagylalt" );

$új kifejezés = str_replace ($egészséges , $fincsi , $kifejezés );

// hozzárendelés: 2
$str = str_replace ("ll" , "" , "jó kisasszony molly!" , $count );
echo $count ;
?>

2. példa Példák lehetséges trükkökre str_replace()

// Csererendelés
$str = "1. sor\n2. sor\r3. sor\r\n4. sor\n";
$order = array("\r\n" , "\n" , "\r" );
$csere = "
" ;

// Először kezeli a \r\n fájlt, hogy ne cserélje le őket.
echo $newstr = str_csere ($sorrend , $csere , $str );

// F kimenetet ad, mert A helyébe B, majd B helyett C, és így tovább...
// Ennek eredményeként az E helyébe F kerül, mivel a csere balról jobbra történik.
$search = array("A" , "B" , "C" , "D" , "E" );
$csere = array("B" , "C" , "D" , "E" , "F" );
$tárgy = "A" ;
echo str_replace ($keresés , $csere , $tárgy );

// Kimenetek: alma, dió, dió (a fenti ok miatt)
$betűk = array("I" , "o" );
$gyümölcs = array("alma" , "dió" );
$text = "Arról vagyok szó" ;
$kimenet = str_replace ($betűk , $gyümölcs , $szöveg );
echo $kimenet ;
?>

Megjegyzések

Megjegyzés: Ez a funkció biztonságosan kezeli az adatokat bináris formában.

Figyelem

Megjegyzés a csererendeléshez

Mert str_replace() balról jobbra cserél, majd többszörös csere használatakor egy korábban beszúrt értéket cserélhet másikra. Lásd még példákat ezen az oldalon.

Megjegyzés:

Ez a funkció megkülönbözteti a kis- és nagybetűket. Használat str_place() kis- és nagybetűket nem érző cseréhez.

Megjegyzés: A PHP 7.0.0-ban 64 bites platformokon nincs elérhető karakterlánchossz-korlátozás, a 32 bites rendszereken és a PHP korábbi verzióiban a karakterláncok nem lehetnek nagyobbak 2 GB-nál (2147483647 bájt).

Szintaxis

Egy karakterlánc négyel definiálható különböző utak:

• egyetlen idézőjel
• dupla idézőjelek
• nowdoc szintaxis (PHP 5.3.0 óta)

Egyetlen idézetek

A legegyszerűbb módja Egy karakterlánc definiálása azt jelenti, hogy idézőjelek közé zárjuk (szimbólum " ).

Ha egyetlen idézetet szeretne használni egy karakterláncon belül, akkor azt egy fordított perjellel ( \ ). Ha magát a fordított perjelet kell írnia, duplikáljon ( \\ ). Az összes többi fordított perjel szabályos karakterként lesz értelmezve, ami azt jelenti, hogy ha más escape szekvenciákat próbál használni, mint pl. \r vagy \n, akkor minden különleges viselkedés helyett olyan formában jelennek meg, ahogy vannak.

visszhang "ez egy egyszerű karakterlánc";

visszhang "Sorokba is beszúrhat
újsor karakter, mint ez,
ez normális";

// Kimenetek: Egy nap Arnold azt mondta: "Visszajövök"
visszhang "Egy nap Arnold azt mondta: "Visszajövök";

visszhang "Törölted a C:\\*.*-t?";

// Kimenetek: Törölted a C:\*.*-t?
echo "Törölted a C:\*.*-t?" ;

// Kimenet: Ez nem lesz kibontva: \n új sor
visszhang "Ez nem bővül: \n újsor";

// Nyomtat: az $expand változókat sem bővíti ki $sem
visszhang "A(z) $expand is $ether változók nincsenek kibontva";
?>

Dupla idézőjelek

Ha a karakterlánc dupla idézőjelbe (") van zárva, a PHP a következő speciális karaktersorozatokat ismeri fel:

Menekülési sorozatok

Utóbbi	Jelentése
\n	újsor (LF vagy 0x0A (10) ASCII-ben)
\r	kocsi vissza (CR vagy 0x0D (13) ASCII-ben)
\t	vízszintes lap (HT vagy 0x09 (9) ASCII-ben)
\v	függőleges lap (VT vagy 0x0B (11) ASCII-ben) (PHP 5.2.5 óta)
\e	escape karakter (ESC vagy 0x1B(27) ASCII-ben) (PHP 5.4.4 óta)
\f	oldal feed (FF vagy 0x0C (12) ASCII-ben) (PHP 5.2.5 óta)
\\	fordított perjel
\$	dollár jel
\"	kettős idézet
\{1,3}	karaktersorozat, amely megfelel egy karakter reguláris kifejezésének oktálisan, és csendben túlcsordul, hogy egy bájtba illeszkedjen (pl. "\400" === "\000")
\x(1,2)	karaktersorozat, amely egy karakteres reguláris kifejezésre hexadecimálisan illeszkedik
\u(+)	olyan karaktersorozat, amely megfelel egy Unicode karakteres reguláris kifejezésnek, amely UTF-8-as karakterláncra van leképezve (a PHP 7.0.0-ban hozzáadva)

Mint egy idézőjelbe zárt karakterlánc esetében, a karakterek kihagyása magát az escape karaktert is kiírja. A PHP 5.1.1 előtt a fordított perjel be \($var) nincs nyomtatva.

Heredoc

A karakterláncok meghatározásának harmadik módja a heredoc szintaxis használata: <<< . Az utasítás után meg kell adni egy azonosítót, majd egy új sort. Utána jön maga a sor, majd ugyanaz az azonosító, ami bezárja a betétet.

Vonal kell záró azonosítóval kezdjük, pl. a sor első oszlopában kell lennie. Ezenkívül az azonosítónak ugyanazt az elnevezési konvenciót kell követnie, mint az összes többi PHP címkének: csak alfanumerikus karaktereket és aláhúzásjeleket tartalmazhat, és nem kezdődhet számmal (aláhúzás megengedett).

Figyelem

Nagyon fontos megjegyezni, hogy a záró azonosítójú karakterlánc nem tartalmazhat más karaktereket, kivéve a pontosvesszőt ( ; ). Ez azt jelenti, hogy az azonosító nem szabad behúzniés hogy a pontosvessző előtt vagy után nem lehet szóköz vagy tabulátor. Azt is fontos megérteni, hogy a záró azonosító előtti első karakternek újsor karakternek kell lennie, az operációs rendszer által meghatározottak szerint. Például UNIX rendszereken, beleértve a macOS-t is, ez van \n. A záró azonosítót is azonnal újsornak kell követnie.

Ha ezt a szabályt megsértik, és a záró azonosító nem "tiszta", akkor a rendszer úgy tekinti, hogy nincs záró azonosító, és a PHP folytatja a keresést. Ha ebben az esetben a helyes záró azonosító soha nem található, akkor ez elemzési hibát okoz, a szkript végén sorszámmal.

Beispiel #1 Hibás szintaxis példa

osztály foo (
nyilvános $bar =<<rúd
EOT;
// a záró azonosító előtti kitöltés nem megengedett
}
?>

Beispiel #2 Helyes szintaktikai példa

osztály foo (
nyilvános $bar =<<rúd
EOT;
}
?>

A Heredoc nem használható osztálymezők inicializálására. A PHP 5.3-tól kezdve ez a korlátozás csak azokra a heredokumentumokra vonatkozik, amelyek változókat tartalmaznak.

A Heredoc szöveg ugyanúgy viselkedik, mint egy dupla idézőjeles karakterlánc, anélkül, hogy ezek meglennének. Ez azt jelenti, hogy nincs szükség idézőjelekre a heredoc-ban, de továbbra is használhatod a fenti escape szekvenciákat. A változókat a rendszer kezeli, de ugyanolyan óvatosnak kell lennie, ha bonyolult változókat használ egy heredoc-ban, mint a karakterláncokkal való munka során.

Beispiel #3 heredoc karakterlánc-definíciós példa

$str =<<Vonal példa,
több vonalat átívelő
a heredoc szintaxis használatával.
EOD;

Class foo
{
var $foo ;
var $bar ;

__construct() függvény
{
$this -> foo = "foo" ;
$ez ->
}
}

$foo = newfoo();
$name = "Név" ;

visszhang<<A nevem "$name". Beírom a $foo -> foo .
Most kiviszem($foo -> bár [1]) .
Ennek egy nagy "A"-t kell kiadnia: \x41
EOT;
?>

A nevem "Név". Foo-t írok. Most a Bar2-t adom ki. Ennek egy nagy "A" betűt kell kiírnia: A

A heredoc szintaxis használata is lehetséges az adatok függvényargumentumokon keresztül történő átadására:

Az 5.3.0-s verzió óta lehetővé vált a statikus változók és osztálytulajdonságok/konstansok inicializálása a heredoc szintaxis használatával:

Beispiel #5 A heredoc használata statikus változók inicializálására

// Statikus változók
functionfoo()
{
statikus $bar =<<Nincs itt semmi...
címke;
}

// Osztályállandók/tulajdonságok
osztályú foo
{
const BAR =<<Példa konstans használatára
FOOBAR;

Nyilvános $bázis =<<Terephasználati példa
FOOBAR;
}
?>

A PHP 5.3.0-tól kezdődően a Heredoc azonosítót dupla idézőjelekkel is körül lehet venni:

Mostdoc

A Nowdoc ugyanaz az egy idézőjeles karakterláncok esetében, mint a heredoc a dupla idézőjeles karakterláncoknál. A Nowdoc hasonló a heredoc-hoz, de azon belül nem történik csere. Ez a konstrukció ideális PHP kód vagy más nagyméretű szövegblokkok beágyazására anélkül, hogy ki kellene menekülni belőle. Ebben egy kicsit hasonlít az SGML konstrukcióra. feldolgozásra nem szánt szövegblokk deklarálásával.

A Nowdoc-t ugyanaz a sorrend jelzi <<< , amelyet a heredoc-ban használunk, de az utána következő azonosító idézőjelek közé van zárva, pl. <<<"EOT" . A heredoc azonosítókra vonatkozó összes feltétel vonatkozik a nowdoc-ra is, különösen azok, amelyek a záró azonosítóra vonatkoznak.

Beispiel #7 nowdoc példa

visszhang<<<"EOD"
szöveges példa,
több vonalat átívelő
nowdoc szintaxis használatával. A fordított perjeleket mindig szó szerint kezelik,
például \\ és \".
EOD;

A példa futtatásának eredménye:

Példa több sort átívelő szövegre a nowdoc szintaxis használatával. A fordított perjeleket mindig szó szerint kezeljük, például \\ és \".

8. példa Nowdoc karakterlánc idéző ​​példa változókkal

/* Bonyolultabb példa változókkal. */
osztályú foo
{
nyilvános $foo ;
nyilvános $bar ;

__construct() függvény
{
$this -> foo = "foo" ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$foo = newfoo();
$name = "Név" ;

visszhang<<<"EOT"
A nevem "$name". Beírom, hogy $foo->foo.
Most gépelek ($foo->bar).
Ennek nem szabad nagy „A”-t kiadnia: \x41
EOT;
?>

A példa futtatásának eredménye:

A nevem "$name". Beírom, hogy $foo->foo. Most gépelek ($foo->bar). Ennek nem szabad nagy „A”-t kiadnia: \x41

9. példa Statikus adatpélda

osztály foo (
nyilvános $bar =<<<"EOT"
rúd
EOT;
}
?>

Megjegyzés:

A nowdoc támogatás hozzáadásra került a PHP 5.3.0-ban.

Változók feldolgozása

Ha egy karakterláncot idézőjelben vagy heredoc-kal adunk meg, akkor a benne lévő változók feldolgozásra kerülnek.

Kétféle szintaxis létezik: egyszerű és összetett. Az egyszerű szintaxis könnyebb és kényelmesebb. Lehetővé teszi egy változó, egy tömbérték feldolgozását ( sor) vagy objektum tulajdonságait ( tárgy) minimális erőfeszítéssel.

Az összetett szintaxis a kifejezést körülvevő kapcsos zárójelek alapján azonosítható.

Egyszerű szintaxis

Ha a tolmács dollárjellel találkozik ( $ ), a lehető legtöbb karaktert rögzíti a megfelelő változónév kialakításához. Ha meg szeretné adni egy név végét, tegye a változó nevét kapcsos zárójelek közé.

$lé = "alma" ;

echo "Ivott egy kis $lé juice-t." . PHP_EOL ;

// Helytelen. Az "s" egy érvényes karakter egy változónévhez, de a változó neve $juice.
echo "Ivott egy kis levet, ami $levekből készült." ;

// Helyes. A változó nevének vége szigorúan zárójelben van megadva:
echo "Ivott egy kis levet, ami $( juice ) s-ből készült." ;
?>

A példa futtatásának eredménye:

Ivott egy kis almalevet. Ivott egy kis gyümölcslevet. Almából készült gyümölcslevet ivott.

Egy tömb eleme ( sor) vagy tárgytulajdonság ( tárgy). A tömbindexekben a záró szögletes zárójel ( ] ) jelzi az indexdefiníció végét. Az objektum tulajdonságaira ugyanazok a szabályok vonatkoznak, mint az egyszerű változókra.

10. példa Egyszerű szintaxis példa

define("KOOLAID" , "koolaid1" );
$levek = array("alma" , "narancs" , "koolaid1" => "lila" );

echo "Ivott néhány $juices [ 0 ] gyümölcslevet." . PHP_EOL ;
echo "Ivott néhány $levet [ 1 ]." . PHP_EOL ;
echo "Ivott néhány $juices [ koolaid1 ] gyümölcslevet." . PHP_EOL ;

osztályos emberek (
public $john = "Kovács János" ;
nyilvános $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Nyilvános $kovács = "Smith" ;
}

$emberek = új emberek();

echo " $emberek -> john ivott egy kis $juices [ 0 ] gyümölcslevet." . PHP_EOL ;
echo " $people -> john majd köszönt $people -> jane -nek." . PHP_EOL ;
echo " $people -> John "s felesége köszöntötte $people -> Robertet." . PHP_EOL ;
echo " $people -> Robert üdvözölte a két $embert -> kovács ." ; // Nem fog működni
?>

A példa futtatásának eredménye:

Ivott egy kis almalevet. Ivott egy kis narancslevet. Ivott egy kis lila levet. John Smith ivott egy kis almalevet. John Smith ezután köszönt Jane Smith-nek. John Smith felesége üdvözölte Robert Paulsent, Robert Paulsen pedig a kettőt.

PHP 7.1.0 támogatás hozzáadva negatív numerikus indexek.

11. példa Negatív numerikus indexek

$string = "karakterlánc" ;
visszhang "A -2 indexen lévő karakter az$karakterlánc [- 2 ]." , PHP_EOL ;
$string [- 3 ] = "o" ;
visszhang "Ha a -3 pozícióban lévő karaktert "o"-ra változtatja, a következő sort kapja:$string." , PHP_EOL ;
?>

A példa futtatásának eredménye:

A -2 indexű karakter n. Ha a -3 pozícióban lévő karaktert "o"-ra változtatjuk, a következő karakterlánc jön létre: erős

Minden bonyolultabb dologhoz használjon összetett szintaxist.

Összetett (göndör) szintaxis

Nem azért nevezik összetettnek, mert nehéz megérteni, hanem azért, mert lehetővé teszi összetett kifejezések használatát.

Ezzel a szintaxissal bármilyen skalárváltozó, tömbelem vagy objektumtulajdonság, amely egy karakterláncra van leképezve, megjeleníthető egy karakterláncban. Csak írja be a kifejezést ugyanúgy, mint a karakterláncon kívülre, majd zárja be { és } . Mert a { nem lehet kikerülni, ezt a szintaxist csak akkor ismeri fel a rendszer, ha $ közvetlenül utána következik { . Használat {\$ nyomtatni {$ . Néhány szemléltető példa:

// Az összes hiba megjelenítése
hibabejelentés(E_ALL);

$nagy = "nagyszerű" ;

// Nem működik, kimenetek: Ez (nagyszerű)
echo "Ez ( $nagyszerű )" ;

// Működik, kimenetek: Ez nagyszerű
echo "Ez ($nagyszerű)" ;

// Működik
visszhang „Ez a tér széles( $négyzet -> szélesség ) 00 centiméter." ;

// Működik, az idézőjeles billentyűk csak göndör zárójeles szintaxissal működnek
echo "Ez működik: ( $arr [ "kulcs" ]) " ;

// Működik
echo "Ez működik: ( $arr [ 4 ][ 3 ]) " ;

// Ez ugyanaz, amiért $foo kívül van
// sorok. Más szóval, továbbra is működni fog
// de mivel a PHP először a foo állandót keresi, ez meg fogja hívni
// E_NOTICE szintű hiba (meghatározatlan állandó).
visszhang "Nem helyes:( $arr [ foo ][ 3 ]) " ;

// Működik. Ha többdimenziós tömböket használunk belül
// a karakterláncok mindig göndör kapcsos zárójelet használnak
echo "Ez működik: ( $arr [ "foo" ][ 3 ]) " ;

// Működik.
echo "Ez működik: " . $arr [ "foo" ][ 3 ];

visszhang "Ez is működik:( $obj -> értékek [ 3 ]-> név ) " ;

visszhang "Ez a nevezett változó értéke$név : ($( $név )) " ;

visszhang "Ez a változó név szerinti értéke, amelyet a getName() függvény ad vissza:($( getName ())) ";

visszhang "Ez a \$object->getName() által visszaadott név szerinti változó értéke:($( $object -> getName ())) " ;

// Nem működik, kimenet: A getName() ezt adja vissza: (getName())
visszhang "Ez az, amit a getName() visszaad: (getName())";
?>

Ezzel a szintaxissal a karakterláncokon belüli objektumtulajdonságok is elérhetők.

osztály foo (
var $bar = "Bar vagyok." ;
}

$foo = newfoo();
$bar = "sáv" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>

A példa futtatásának eredménye:

bár vagyok. bár vagyok.

Megjegyzés:

A függvények, metódushívások, statikus osztályváltozók és osztálykonstansok belsőleg működnek {$} , a PHP 5-ös verziója óta. A megadott érték azonban változónévként lesz kezelve ugyanabban a kontextusban, mint a karakterlánc, amelyben meghatározásra került. Egyetlen göndör zárójel használata ( {} ) nem fog működni a függvények, metódusok, osztálykonstansok vagy statikus osztályváltozók értékeinek eléréséhez.

// Az összes hiba megjelenítése
hibabejelentés(E_ALL);

osztályú sörök (
const üdítő = "gyökérsör" ;
public static $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = "Alexander Keith\"s" ;

// Ez működik, kiírja: A & W-t szeretném
echo "Szeretnék ($( sörök :: üdítőital )) \n" ;

// Ez is működik, kimenet: Alexander Keith"-t szeretném
echo "Szeretnék ($( beers :: $ale )) \n" ;
?>

Egy karakterlánc elérése és megváltoztatása

A karakterláncokban lévő karakterek használhatók és módosíthatók, ha megadjuk az eltolásukat a karakterlánc elejétől, nullától kezdve, a karakterlánc után szögletes zárójelben, például $str . Az erre a célra szolgáló karakterláncot karakterek tömbjeként kell elképzelni. Ha 1-nél több karaktert kell beszereznie vagy lecserélnie, használhatja a függvényeket substr()és substr_replace().

Megjegyzés: a PHP 7.1.0 óta a negatív eltolási értékek támogatottak. Beállítják az eltolást a húr végétől. Korábban a negatív eltolások szinthibát okoztak E_NOTICE olvasáskor (üres karakterlánc visszaadása) ill E_WARNINGírásnál (a karakterláncot változatlanul hagyva).

Megjegyzés: A karakterláncban lévő karakterek kapcsos zárójelekkel is elérhetők, például $str(42) .

Figyelem

Ha a karakterláncon kívüli eltolást próbál meg írni, akkor a karakterlánc szóközökkel töltődik be az eltolásig. A nem egész típusú típusok egész számokká lesznek konvertálva. A rossz eltolási típus szinthibát okoz E_WARNING. Csak a hozzárendelt karakterlánc első karaktere kerül felhasználásra. A PHP 7.1.0-tól kezdve az üres karakterlánc hozzárendelése végzetes hibát okoz. Korábban ebben az esetben egy null byte (NULL) volt hozzárendelve.

Figyelem

A PHP karakterláncai belső bájttömbök. Ennek eredményeként egy karakterlánc eltolás útján történő elérése vagy módosítása nem biztonságos, és csak egybájtos kódolású karakterláncokkal szabad megtenni, mint például az ISO-8859-1.

Megjegyzés: A PHP 7.1.0 óta az üres index használata végzetes hibát okoz, korábban ilyen esetben a string figyelmeztetés nélkül tömbbé alakult.

12. példa Több példa karakterlánc

// A karakterlánc első karakterének lekérése
$str = "Ez egy teszt." ;
$első = $str [ 0 ];

// Szerezze be a karakterlánc harmadik karakterét
$harmadik = $str [ 2 ];

// A karakterlánc utolsó karakterének lekérése
$str = "Ez még egy teszt." ;
$last = $str [ strlen($str )- 1 ];

// A karakterlánc utolsó karakterének módosítása
$str = "Nézd a tengert" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

A PHP 5.4-től kezdve a karakterlánc eltolásának egész számnak vagy számokat tartalmazó karakterláncnak kell lennie, ellenkező esetben figyelmeztetés jelenik meg. Korábban egy karakterlánc által adott eltolás "foo", figyelmeztetés nélkül át lett alakítva 0 .

13. példa: A PHP 5.3 és a PHP 5.4 közötti különbségek

$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" ]));
?>

A példa PHP 5.3-ban való futtatásának eredménye:

string(1) "b" bool(igaz) string(1) "b" bool(igaz) string(1) "a" bool(igaz) string(1) "b" bool(igaz)

A példa PHP 5.4-ben való futtatásának eredménye:

string(1) "b" bool(true) Figyelmeztetés: Illegal string offset "1.0" in /tmp/t.php a 7. sorban string(1) "b" bool(false) Figyelmeztetés: Illegális string offset "x" in / tmp/t.php a 9. sorban string(1) "a" bool(false) string(1) "b" bool(false)

Megjegyzés:

Más típusú változókhoz való hozzáférés kísérlete (kivéve a tömböket vagy objektumokat, amelyek bizonyos interfészeket valósítanak meg) vagy {} csendben vissza NULLA.

Megjegyzés:

A PHP 5.5 támogatást nyújtott a karakterlánc-literálokban lévő karakterekhez a szintaxis használatával vagy {} .

Számos hasznos funkció létezik a karakterláncok módosítására.

A fő függvényeket a karakterlánc-függvények részben ismertetjük, a speciális keresés és csere esetén pedig a Perl-kompatibilis reguláris kifejezés függvényeket.

Konvertálás karakterláncra

Az érték cast segítségével karakterláncra konvertálható (húr), vagy funkciókat strval(). Azokban a kifejezésekben, ahol karakterláncra van szükség, az átalakítás automatikusan megtörténik. Ez akkor fordul elő, amikor funkciókat használ visszhang vagy nyomtatás, vagy amikor egy változó értékét egy karakterlánchoz hasonlítjuk. A kézikönyv Típusok és Típuskezelés részeinek elolvasása a következőket világosabbá teszi. Lásd még settype().

A tömbök mindig karakterláncokká alakulnak "sor", így nem tudja megjeleníteni a tömb tartalmát ( sor) segítségével visszhang vagy nyomtatás megnézni, mit tartalmaz. Egy adott elem megtekintéséhez használjon valami hasonlót echo $arr["foo"]. Az alábbiakban az összes tartalom megjelenítésére/megtekintésére vonatkozó tippeket talál.

Típusváltozó konvertálásához "Tárgy" típusonként húr a __toString mágikus metódust használjuk.

Jelentése NULLA mindig üres karakterláncra konvertálva.

Mint fentebb látható, a tömbök, objektumok vagy erőforrások közvetlen felsorolása nem ad hasznos információkat magukról az értékekről, kivéve azok típusát. A hibakereséshez szükséges értékek kiadásának megfelelőbb módja a függvények használata print_r()és var_dump().

A PHP-ben a legtöbb érték karaktersorozattá alakítható állandó tárolás céljából. Ezt a módszert szerializálásnak hívják, és a függvénnyel végezhető el szerializál().

Karakterláncok átalakítása számokká

Ha a karakterláncot numerikus értékként ismeri fel, az eredményül kapott érték és típus a következőképpen kerül meghatározásra.

Ha a karakterlánc nem tartalmazza a ".", "e" vagy "E" karaktereket, és a szám értéke belefér az egész számok tartományába (meghatározott PHP_INT_MAX), a karakterlánc egész számként lesz felismerve ( egész szám). Minden más esetben lebegőpontos számnak ( úszó).

Az értéket a karakterlánc kezdeti része határozza meg. Ha a karakterlánc érvényes numerikus értékkel kezdődik, akkor ez az érték kerül felhasználásra. Ellenkező esetben az érték 0 (nulla) lesz. Az érvényes numerikus érték egy vagy több számjegy (amely tizedesvesszőt is tartalmazhat), amelyet opcionálisan előz meg egy előjel, majd egy opcionális kitevő. A kitevő "e" vagy "E", amelyet egy vagy több számjegy követ.

$foo = 1 + "10,5" ; // A $foo egy úszó (11.5)
$foo = 1 + "-1.3e3" ; // A $foo egy úszó (-1299)
$foo = 1 + "bob-1.3e3" ; // A $foo egy egész szám (1)
$foo = 1 + "bob3" ; // A $foo egy egész szám (1)
$foo = 1 + "10 kismalac" ; // A $foo egy egész szám (11)
$foo = 4 + "10,2 kismalac" ; // A $foo egy float (14.2)
$foo = "10,0 disznó" + 1 ; // A $foo egy úszó (11)
$foo = "10,0 disznó" + 1,0 ; // A $foo egy úszó (11)
?>

Erről az átalakításról további információért lásd a Unix dokumentáció strtod(3) szakaszát.

Ha szeretné tesztelni az ebben a részben található példákat, másolja ki és illessze be azt, valamint a következő sort, hogy megtudja, mi történik:

echo "\$foo== $foo ; írja be: " . gettype ($foo ) . "
\n" ;
?>

Ne várja el, hogy a karakterkódot egész számmá alakítva kapja meg (ahogyan például C-ben történik). A karakterek ASCII-kódokká alakításához és fordítva használja a függvényeket ord()és chr().

Karakterlánctípus megvalósításának részletei

7 évvel ezelőtt

A dokumentáció nem említi, de a heredoc végén található záró pontosvessző valójában valódi pontosvesszőként értelmeződik, és mint ilyen, néha szintaktikai hibákhoz vezet.

$foo =<<abcd
VÉGE;
?>

Ez nem:

foo(<<abcd
VÉGE;
);
// szintaktikai hiba, váratlan ";"
?>

Pontosvessző nélkül jól működik:

foo(<<abcd
VÉGE
);
?>

3 évvel ezelőtt

Használhat karakterláncot, mint karaktertömböt (például C)

$a = "String tömb teszt";

var_dump($a);
// Return string(17) "String array test"

var_dump($a);
// Return string(1) "S"

// -- Tömböntéssel --
var_dump((tömb)$a);
// Return array(1) ( => string(17) "String array test")

var_dump((tömb)$a);
// Return string(17) "S"

Norihiori

15 évvel ezelőtt

Az összetett szintaxis segítségével mind az objektumtulajdonságok, mind az objektummetódusok értékét egy karakterláncba helyezheti. Például...
osztály teszt(
nyilvános $egy = 1 ;
nyilvános funkció kettes()(
visszatérés 2 ;
}
}
$teszt = new Teszt();
echo "foo ( $test -> one ) bar ( $test -> two ()) " ;
?>
A kimenet "foo 1 bar 2" lesz.

Ezt azonban nem teheti meg a névtér összes értékénél. Az osztálykonstansok és a statikus tulajdonságok/módszerek nem működnek, mert az összetett szintaxis a "$"-t keresi.
osztály teszt(
const EGY = 1 ;
}
echo "foo (Teszt::ONE) bar" ;
?>
Ez a "foo (Test::one) bar" szöveget fogja kiírni. A konstansok és a statikus tulajdonságok megkövetelik a karakterlánc feldarabolását.

3 évvel ezelőtt

Ügyeljen arra, hogy összhangban a „karakterlánc számokká konvertálásával”:

Ha ("123abc" == 123 ) visszhang "(intstr == int) helytelenül igazként teszteli.";

// Mivel az egyik oldal egy szám, a karakterlánc hibásan alakul át intstr-ből int-be, ami ezután megegyezik a tesztszámmal.

// Igaz minden feltételes feltételre, például if és switch utasításokra (valószínűleg a while ciklusokra is)!

// Ez óriási biztonsági kockázatot jelenthet a felhasználói bevitel tesztelésekor/használatakor/mentésekor, miközben csak egész számra várunk és tesztelünk.

// Úgy tűnik, az egyetlen javítás az, hogy a 123 egy karakterlánc "123", így nem történik konverzió.

?>

6 évvel ezelőtt

A karakterláncok bevezető nulláit (legkisebb meglepetés) nem kezeljük oktálisként.
Fontolgat:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x az $x, y az $y"; //kiírja, hogy "x 123, y 83"
más szavakkal:
* a numerikus literálokban a kezdő nullák a forráskódban "oktálisként" értelmezhetők, vö. strtol().
* a bevezető nullákat karakterláncokban (pl. a felhasználó által benyújtott adatok), amikor (implicit vagy explicit) egész számra öntjük, figyelmen kívül hagyjuk, és decimálisnak tekintjük, vö. strtod().

10éve

Íme egy egyszerű feltörés, amely lehetővé teszi, hogy a dupla idézőjeles karakterláncok és heredocs tetszőleges kifejezéseket tartalmazzon kapcsos zárójeles szintaxisban, beleértve a konstansokat és egyéb függvényhívásokat:

// Hack nyilatkozat
függvény_kifejezés ($v ) ($v visszaadása ; )
$_expr = "_expr" ;

// A játszóterünk
define("qwe" , "ASD");
meghatározni("zxc", 5 );

$a= 3 ;
$b= 4 ;

funkció c($a, $b) (Visszatérés$a+ $b; }

// Használat
visszhang"elő{ $_expr(1 + 2 )} bejegyzés\n"; // kiírja a "pre 3 post"
visszhang"elő{ $_expr(qwe)} bejegyzés\n"; // kiírja a "pre asd post" parancsot
visszhang"elő{ $_expr(c($a, $b)+ zxc* 2 )} bejegyzés\n"; // kiírja "pre 17 post"

// Az általános szintaxis ($_expr(...))
?>

2 évvel ezelőtt

Úgy gondoltam, hasznos lenne ezt a megjegyzést hozzáadni, hogy az információ legalább a PHP webhely megfelelő oldalán jelenjen meg.

Vegye figyelembe, hogy ha dupla idézőjeles karakterláncot kíván használni asszociatív kulccsal, akkor a T_ENCAPSED_AND_WHITESPACE hibába ütközhet. Egyesek ezt az egyik kevésbé nyilvánvaló hibaüzenetnek tekintik.

Egy kifejezés, mint például:

$gyümölcs=array(
"a"=> "alma",
"b"=> banán,
//stb
);

nyomtatás "Ez egy$gyümölcs[ "a"]"; // T_ENCAPSED_AND_WHITESPACE
?>

biztosan darabokra hullik.

A következőképpen oldhatja meg:

nyomtatás"Ez egy$gyümölcs[ a] " ; // a kulcs idézőjelének törlése
nyomtatás"Ez egy${ gyümölcsök[ "a"]} " ; // Összetett szintaxis
nyomtatás"Ez egy{ $gyümölcs[ "a"]} " ; // Összetett szintaxis variáció
?>

Személy szerint az utolsó variációt részesítem előnyben, mivel ez természetesebb és közelebb áll ahhoz, hogy milyen lenne a kifejezés a karakterláncon kívül.

Nem világos (legalábbis számomra), hogy a PHP miért értelmezi félre az egyetlen idézetet a kifejezésben, de úgy gondolom, hogy valami köze van ahhoz, hogy az idézőjelek nem részei az értékláncnak – ha a karakterláncot már elemzik, az idézőjelek csak útban van … ?

2 évvel ezelőtt

Mindkettőnek működnie kell :(

osztálytesztelés{
nyilvános statikus$var= "statikus";
public const VAR ="konst";

közéleti funkciót mondd Hello Static() {
visszhangSzia:{ $ezt:: $var} " ;
}

közéleti funkciót mondd HelloConst() {
visszhangSzia:{ $ezt::VAR)" ; //Elemzési hiba: szintaktikai hiba, váratlan ")", "["
}
}

$obj=újtesztelés();
$obj-> mondd Hello Static();
$obj-> mondd HelloConst();

3 évvel ezelőtt

Valami, amit megtapasztaltam, ami kétségtelenül segíteni fog valakinek. . .
A szerkesztőmben ez a szintaxis kiemeli a HTML-t és a $commentet:

$html =<<<"EOD"
$megjegyzés
EOD;

Ennek használata ugyanazokat a színeket mutatja:

$html =<<$megjegyzés
EOD;

ami sokkal könnyebbé teszi a munkát

11 évvel ezelőtt

Hogy megmentsd magad, ne olvasd el a korábbi dátumokkal kapcsolatos kommenteket ;)

Ha mindkét karakterlánc konvertálható numerikussá (a ("$a" > "$b") tesztben), akkor a kapott számokat használjuk, ellenkező esetben a TELJES karakterláncokat karakterenként hasonlítják össze:

var_dump("1.22" > "01.23" ); // bool(false)
var_dump("1.22.00" > "01.23.00" ); // bool(true)
var_dump("1-22-00" > "01-23-00" ); // bool(true)
var_dump((úszó)"1.22.00" > (úszó)"01.23.00" ); // bool(false)
?>

Táblázatok:

C_id | cég | elhelyezkedés
1 | OOO Keresés | Kudykino mező 15/3
2 | CJSC Elita | Szlunyiszvalinszk 133/7
3 | OJSC Pyshpyshch | Soldatodachestroyskoe 404

Javítás típusa (javítási_típusok)
r_id | javítási_típusok |
1 | Kalapács + szögek
2 | Szépségvezetés
3 | Nagyjavítás

Megrendelések listája (lista)
l_id | Kik | Mi kell | idő | operátor megjegyzése
1 | 1 | 2 | %timestamp% | %operator_text%
2 | 2 | 1 | | %szöveg%
3 | 3 | 2 | | %szöveg%

Az 1. táblázat az ügyfelek listáját tartalmazza.
A 2. táblázat a szolgáltatások listáját tartalmazza.
A 3. számú táblázat tartalmazza az operatív csoportok aktuális megrendeléseinek listáját. Ezt a táblázatot rendszeresen frissítjük, kitöltésére webes űrlapot használunk. Mivel elég sok megrendelés érkezik, a rekordok ügyfélazonosító és szolgáltatás formájában kerülnek be a táblázatba.

Valójában az a probléma, hogy a harmadik táblázatot a "rendeléskiválasztás" webes űrlapon kell megjeleníteni, és az azonosító helyett a megfelelő mezőket más oszlopokból kell helyettesíteni.

A kód:
$query = "SELECT * FROM list";
$eredmény = mysql_query($query);
while($row=mysql_fetch_array($result. // eredmények lekérése minden sorból
( echo "";// adatok megjelenítése
}

CREATE TABLE "tábla_neve" ("id" int(255) NOT NULL AUTO_INCREMENT, "lista" szöveg (80) NOT NULL, PRIMARY KEY("id".

INSERT INTO "tábla_neve" ("lista") ÉRTÉKEK ("bla-bla")

legjobb válasz $query =
"
válasszon cégeket.Cég, javítási_típusok.Javítási_típusok, lista.comment_l
listából
belső csatlakozási társaságok
listán.Ki = cégek.c_id
belső csatlakozás javítás_típusok
listán."Mire van szükség" = javítási_típusok.r_id
";

Természetesen a képek, hangfájlok, videoinformációk, animációs adatok és kisalkalmazások a világháló tartalmának fontos részét képezik, de a weben található adatok túlnyomó többsége továbbra is szöveg – karaktersorozatok formájában. mint ez a mondat. Az alapvető PHP adattípus a szöveg megjelenítéséhez egy karakterlánc.

A karakterláncok leírása PHP-ben

A karakterláncok olyan karaktersorozatok, amelyek egyetlen entitásként kezelhetők – változókhoz rendelhetők, függvényekhez bemenetként adhatók át, függvényekből visszaadhatók, vagy kimenetként küldhetők el, hogy megjelenjenek a felhasználó weboldalán. A PHP-kódban a karakterlánc megadásának legegyszerűbb módja, ha egy karaktersorozatot idézőjelbe teszünk, egyszeres ("") vagy dupla ("), például az alábbiak szerint:

$myString = "Egyszerű karakterlánc"; $anotherString = "Másik karakterlánc";

Az idézőjelek és a dupla idézőjelek közötti különbség abból adódik, hogy a PHP környezet milyen kiterjedten értelmezi az idézőjeleket, mielőtt létrehozná a tényleges karakterláncot. Ha a karakterlánc szimpla idézőjelek közé van zárva, akkor szinte semmilyen értelmezés nem történik, és ha a karakterlánc kettős idézőjelbe van zárva, akkor a PHP környezet elvégzi a karakterláncban megadott összes változó értékének helyettesítését, valamint lecserél néhány speciális karaktersorozatot, amelyek a fordított perjellel kezdődnek ().

Például a következő kód feldolgozása után, amely egy weboldal része:

$count = 13; $string1 = "A \"Hello, world!\" karakterlánc $count karaktert tartalmaz.
"; $string2 = "A \"Hello, world!\" karakterlánc $count karaktert tartalmaz.
"; echo $karakterlánc1; echo $string2;

a következő kimenetet kaphatja meg a böngészőablakban:

Értékhelyettesítés göndör zárójelekkel

A legtöbb esetben egyszerűen bezárhatja a változót egy dupla idézőjeles karakterláncba, és a változó értéke be lesz cserélve a karakterláncba, amikor az értelmező feldolgozza a karakterláncot. Az alább leírt két helyzetben azonban kiderülhet, hogy a karakterlánc-értelmező nem tud megalapozott döntést hozni, és további útmutatásra van szüksége a fejlesztőtől.

Az első helyzet az, hogy az értelmező nem tudja meghatározni, hol végződik a változó neve, a második pedig akkor fordul elő, amikor a kifejezés értékét kell behelyettesíteni a karakterláncba, nem pedig egy egyszerű változó értékét. Ezekben az esetekben a fejlesztő tisztázhatja a feldolgozandó nevet vagy kifejezést kapcsos zárójelek közé (()).

Például a PHP értelmezőnek nem okoz gondot a következő kód feldolgozása:

$sport = "röplabda"; $play = "Szeretek $sportot játszani.";

Ilyen esetekben az értelmező találkozik a $ karakterrel, majd elkezdi a karakterek alláncait, hogy felfedje a változó nevét, és ezt mindaddig teszi, amíg nem találkozik egy szóközzel vagy ponttal, amely a $sport változó nevét követi. A szóközök és pontok nem lehetnek a változónév részei, így világossá válik, hogy a szóban forgó változó neve $sport; a PHP interpreter ezután sikeresen talál egy értéket az adott változóhoz ("röplabda"), és behelyettesíti azt.

De néha nem lehet egy változónév végét szóközzel vagy ponttal megjelölni. Tekintsük a következő példát:

$sport1 = "akarat"; $sport2 = "láb"; $sport3 = "kosár"; // Helytelen konstrukciók $play1 = "Imádok $sport1ballt játszani."; $play2 = "Szeretek $sport2ballt játszani."; $play3 = "Szeretek $sport3ballt játszani.";

Ebben az esetben a kívánt hatást nem éri el, mert a PHP értelmező a $sport1 karakterláncot a $sport1ball változónév részének tekinti, amelyhez láthatóan semmilyen értéket nem rendeltek. Ehelyett a következő jelölést kell használnia:

// Érvényes konstrukció $play1 = "Szeretek ($sport1)labdázni."; $play2 = "Szeretek ($sport2)labdát játszani."; $play3 = "Szeretek ($sport3)labdát játszani.";

Ez a jelölés azt mondja a PHP értelmezőnek, hogy csak a kapcsos zárójelek közé zárt változónévvel rendelkező kifejezés értékét kell kiértékelni az értékhelyettesítés előtt.

Hasonló okokból a PHP értelmezőnek, ha nem használ kapcsos zárójeleket, nehézséget okoz az összetett kifejezések értékeinek változónevekkel való helyettesítése, például a többdimenziós tömbök és objektumváltozók elemeinek elérése. Az általános szabály az, hogy ha a nyitó kapcsos kapcsos zárójelet (() közvetlenül egy $ követi, akkor a PHP értelmező kiértékeli a változónévvel ellátott kifejezés értékét a záró kapcsos kapcsos zárójelig ()), majd behelyettesíti a kapott értéket. a húrba. (Ha azt szeretné, hogy egy literális érték ($) jelenjen meg a karakterláncban, ezt megteheti úgy, hogy minden egyes karaktert egy fordított perjellel (\) ír elő).

Karakterek és karakterindexek karakterláncokban

Más programozási nyelvekkel ellentétben a PHP-nek nincs külön karaktertípusa, amely nem egyezne meg a karakterlánc típusával. Általánosságban elmondható, hogy a karakterek tényleges paramétereit igénylő függvények más nyelveken úgy vannak kialakítva, hogy PHP-ben 1 hosszúságú karakterláncokat vegyenek fel.

Egy karakterláncból az egyes karakterek kiválasztása nulla alapú karaktersorszám megadásával történhet, amelyet közvetlenül a karakterlánc változó neve után kapcsos zárójelben kell megadni. Az ilyen karakterek valójában egykarakteres karakterláncok. Például a következő kód futtatása:

$myString = "Duplázva"; for ($index = 0; $index< strlen($myString); $index++) { $char = $myString{$index}; print("$char$char"); }

a következő kimenetet eredményezi a böngészőablakban:

Nyilvánvaló, hogy a karakterlánc minden karaktere kétszer kerül kinyomtatásra a hurkon való minden egyes áthaladáskor. Az strlen() függvény egy karakterlánc hosszát adja vissza.

String műveletek

A PHP két karakterlánc-műveletet biztosít: a pont operátort (.) vagy összefűzési operátort, valamint a pont és egyenlőségjel operátort (.=), vagyis az összefűzés és hozzárendelés operátort. Tekintsük a következő példát:

$string1 = "Ez egy rész"; $string2 = "karakterláncok"; // Karakterlánc-összefűzés echo $string1." simple ".$string2."
"; // "Ez egy egyszerű karakterlánc része" // Összefűzése és hozzárendelése $string1 .= " simple "; // Egyenértékű: $string1 = $string1." simple "; $string1 .= $string2; echo $string1; // "Ez egy egyszerű karakterlánc része"

Meg kell jegyezni, hogy a fenti példában az első echo utasítás nem ad át több karakterlánc tényleges paramétert; csak egy karakterlánc aktuális paraméter kerül átadásra, amely négy karakterlánc összefűzéséből adódik. Az első és a harmadik sor változók segítségével van beállítva, a második és negyedik sor pedig egy idézőjelbe zárt karakterlánc.

Aldokumentum szintaxis szerkezete (Heredoc)

Az egy- és dupla idézőjelben lévő karakterláncok szintaktikai struktúrája mellett a PHP egy másik módot is kínál egy karakterlánc megadására, ún. a beágyazott dokumentum szintaktikai szerkezete (Heredoc). Mint kiderült, egy ilyen szintaktikai struktúra nagyon kényelmes eszköz a változókkal helyettesített nagy szövegtöredékek megadására, mivel kiküszöböli a felhasználónak a belső idézőjeleket speciális karakterekkel jelölnie. Ez a módszer különösen hasznos HTML-űrlapokat tartalmazó oldalak létrehozásakor.

Az aldokumentum szintaktikai szerkezetében használt operátorjel a (<<<). За этим знаком должна непосредственно следовать метка (не заключенная в кавычки), которая обозначает начало многострочного текста. Интерпретатор PHP продолжает включать в состав значения переменной следующие строки до тех пор, пока снова не появится эта же метка в начале строки. За заключительной меткой может следовать необязательная точка с запятой, а какие-либо другие символы после метки не допускаются.

Tekintsük a következő példát:

$karakterlánc =<<

EOT; echo $string;

Ne feledje, hogy a fent látható utolsó EOT szót egyáltalán nem szabad behúzni, ellenkező esetben a rendszer a kiegészítő szöveghez tartozóként kezeli. Nem szükséges az "EOT" szó használata címkeként, a címkének bármilyen neve lehet, követve a szokásos PHP változók elnevezési konvencióit.

A változók helyettesítése pontosan ugyanazzal a módszerrel történik, mint a dupla idézőjelbe zárt karakterláncok használatakor. A beágyazott dokumentum kényelmes tulajdonsága, hogy az így kijelölt szövegbe idézőjeleket lehet bevinni vezérlőkarakterek használata nélkül, és ez nem vezet a sorképzés idő előtti befejezéséhez. A fenti példa egy egyszerű HTML űrlapot ad ki:

String függvények

A PHP nyelv számos funkciót biztosít a karakterláncok feldolgozásához és konvertálásához. Ha valaha is szüksége van saját függvény létrehozására, amely karakterenként olvassa be és dolgozza fel a karakterláncokat, hogy új karakterláncot hozzon létre, először fontolja meg, hogy valaki másnak is szembe kellett-e néznie hasonló feladattal. És ha az intuíció azt sugallja, hogy létezik ilyen lehetőség, akkor talán van egy beépített funkció, amely megoldja a problémát. A karakterlánc-függvényekkel kapcsolatos további információkért lásd: https://php.net/manual/en/ref.strings.php.

Ez a rész a karakterláncok ellenőrzésének, összehasonlításának, módosításának és nyomtatásának alapvető funkcióit mutatja be. Ahhoz, hogy valóban elsajátíthassuk a PHP karakterlánc-manipulációs lehetőségeit, úgy tűnik, hogy az embernek legalább felületesen ismernie kell mindazt, amit ebben a részben tárgyalunk. A reguláris kifejezésekkel való együttműködésre tervezett függvények leírása a következő cikkben található.

Karakterlánc érvényesítése

Melyek a húrokkal kapcsolatos leggyakoribb kérdések, amelyekre választ kell adni? A kérdések listáján az első a kérdés, hogy milyen hosszú egy karakterlánc; a válaszhoz az strlen() függvényt használjuk, melynek neve a string long - a string hossza - rövidítése. Az alábbiakban látható egy példa egy ilyen funkció használatára:

$enStr = "Szia világ!"; $rusStr = "Egyszerű karakterlánc"; echo $enStr." - ".strlen($enStr)." karakterek
"; echo $rusStr." - ".strlen($rusStr)." karakterek";

Ennek a kódnak a futtatása a következő kétértelmű kimenetet eredményezi:

Mint látható, a "Hello world!" az eredmény helyes, de az "Egyszerű karakterlánc" karakterláncnál a 27 karakterből álló eredmény helytelen. mi a baj itt? A helyzet az, hogy az strlen() függvény bájtokat számol, nem karaktereket. Az első esetben a karakterlánc összes karaktere angol, azaz. ASCII kódolás képviseli és 1 bájtként kódolják. A második esetben a karakterlánc orosz karaktereket tartalmaz, amelyek 2 bájtban vannak kódolva (UTF-8). A későbbi problémák elkerülése érdekében, amikor karakterláncfüggvényekkel dolgozik, a PHP-nek olyan függvényeket kell használnia a többbyte-os kódolásokhoz, amelyek az mb_ előtaggal kezdődnek. Ez azt jelenti, hogy az előző példában az strlen() függvényt az mb_strlen()-re kell cserélni, és kifejezetten meg kell adni a kódolást:

Echo $rus_str." - ".mb_strlen($rus_str, "UTF8")." karakterek";

Karakterek és részkarakterláncok keresése

A következő kérdés a karakterláncokkal kapcsolatban az, hogy mit tartalmaznak. Például az strpos() függvény lehetővé teszi egy adott karakter pozíciószámának megtalálását egy karakterláncban, ha van ilyen:

$enStr = "Szia világ!"; echo ""l" szimbólum: ".strpos($enStr, "l"); 2

Az strpos() függvény használatával járó helyzetek olyan esetek, amikor a PHP típusérzéketlensége problémát jelenthet. Ha nem található egyezés, akkor a függvény hamis értéket ad vissza, és ha a keresőkarakter a karakterlánc legelső karakterével egyezik, akkor a függvény 0-t ad vissza (mivel a karakterláncban a karakterek pozíciói 0-tól kezdődnek, nem 1-től). Mindkét érték hamisnak felel meg, ha logikai feltétel tesztelésére használják. Ezen értékek megkülönböztetésének egyik módja az identitás-összehasonlító operátor (a PHP4 óta bevezetett === operátor), amely csak akkor ad vissza true értéket, ha az operandusai azonosak és azonos típusúak. Az identitás-összehasonlító operátor használható annak tesztelésére, hogy a visszatérési érték 0 (vagy hamis), anélkül, hogy fennállna annak a veszélye, hogy a visszatérési értéket összekeverik más értékekkel, amelyek az öntést követően azonosak lehetnek.

Az strpos() függvény egy karakterlánc helyett egy részkarakterlánc keresésére is használható. Ehhez elegendő egy többkarakteres karakterláncot megadni, nem pedig egykarakteres karakterláncot kívántként. Ezen túlmenően a függvény meghívásakor megadhat egy további egész paramétert, amely meghatározza a keresés kezdetének helyét.

Ellenkező irányban is lehet keresni, a karakterlánc végétől az elejéig. Erre a strrpos() függvény szolgál. (Ne feledje, hogy ennek a függvénynek a nevében van egy extra r, ami a fordított szó rövidítése.) Ez a függvény a keresendő karakterláncot és a keresendő egykarakteres karakterláncot veszi paraméterként, majd visszaadja a második paraméter utolsó pozíciós előfordulásait. az első paraméterben. (Eltérően az strpos() függvénytől, az strrpos() függvényben a keresett karakterláncnak csak egy karakterből kell állnia.) Miután ezt a függvényt ugyanazokkal a paraméterekkel alkalmaztuk, mint az előző példában, egy másik pozíciót találunk:

$enStr = "Szia világ!"; echo ""l" szimbólum: ".strrpos($enStr, "l"); // 9 mert a keresés a karakterlánc végétől indul

Összehasonlítás

Ez a vonal megegyezik ezzel a sorral? Úgy tűnik, a kódnak gyakran válaszolnia kell erre a kérdésre is, különösen, ha a végfelhasználótól érkező input kezeléséről van szó.

Arra a kérdésre, hogy a karakterláncok azonosak-e, a legegyszerűbb megoldás az egyszerű egyenlőség-összehasonlító operátor (==) használata, amely nemcsak a karakterláncok, hanem a számok egyenlőségét is ellenőrzi. Az == operátor használatakor két karakterlánc azonosnak tekinthető, ha pontosan ugyanazt a karaktersorozatot tartalmazzák. Ez nem ellenőrzi az azonos karakterláncok szigorúbb meghatározását, például azt a feltételt, hogy ezek a karakterláncok ugyanazon a címen legyenek tárolva a memóriában, de megkülönbözteti a kis- és nagybetűket (más szóval, hogy az összehasonlított betűk nagy- vagy kisbetűk-e).

Két karakterlánc összehasonlításának eredménye az == operátorral (vagy a megfelelő operátorokkal< и >) csak akkor megbízható, ha mindkét operandus karakterlánc, és ismert, hogy nem történt típuskonverzió. Az alábbiakban ismertetett strcmp() függvénnyel végzett ellenőrzés eredményei pedig mindig megbízhatóak.

A legfontosabb karakterlánc-összehasonlító függvény, amely a legtöbb munkát elvégzi, az strcmp(). Ez a függvény két karakterláncot vesz paraméterként, és bájtonként összehasonlítja, amíg különbséget nem talál. A függvény ezután negatív számot ad vissza, ha az első karakterlánc kisebb, mint a második, és pozitív számot, ha a második karakterlánc kisebb, mint az első. Ha a karakterláncok azonosak, az strcmp() függvény nullát ad vissza.

A strcasecmp() függvény ugyanígy működik, azzal a különbséggel, hogy az egyenlőség összehasonlítása nem tesz különbséget a kis- és nagybetűk között. Például a strcasecmp("hey!", "HEY!") hívásnak nullát kell visszaadnia.

Keresés

Az imént ismertetett összehasonlító függvények tudatják, ha egy karakterlánc egyenlő egy másik karakterlánccal. Annak meghatározásához, hogy egy karakterlánc egy másikban található-e, használja a fent leírt strpos() függvényt, vagy az strstr() függvényt és hasonló függvényeket.

Az strstr() függvény a keresendő karakterláncot és a keresendő karakterláncot veszi paraméterként (ebben a sorrendben). Ha sikeres, ez a függvény a karakterláncnak azt a részét adja vissza, amely a keresési karakterlánc első előfordulásával kezdődik (és tartalmazza a keresési karakterláncot). Ha nem található ilyen karakterlánc, a függvény false értéket ad vissza. A következő kódrészlet példákat mutat be a funkció használatára:

$str = "Szia világ!"; $findStr = "világ"; echo "Substring" $findStr" az eredeti karakterláncban: ".strstr($str, $findStr);

Az strcmp() függvényhez hasonlóan az strstr() függvénynek is van egy kis- és nagybetűket nem érzékeny változata, a stristr() (az i ebben a névben az érzéketlen rövidítése). Az stristr() függvény minden tekintetben megegyezik az strstr() függvénnyel, kivéve, hogy az összehasonlítás a kisbetűket nagybetűs megfelelőjeként kezeli.

Részkarakterlánc-mintavételezés

Számos PHP karakterlánc-függvény végez kivágási és beillesztési műveleteket a karakterláncokon. A vágás egy karakterlánc egy részének kijelölése, a beillesztés pedig egy karakterlánc szelektív módosítása. Ne feledje, hogy még az insert függvények sem módosítják (leggyakrabban) a bemeneti paraméterként megadott karakterláncot. Az ilyen függvények általában egy módosított másolatot adnak vissza, és az eredeti paramétert változatlanul hagyják.

A legegyszerűbb módja egy karakterlánc egy részének mintavételének a substr() függvény használata, amely egy új karakterláncot ad vissza, amely a régi karakterlánc egy részsorozatának egy részét tartalmazza. A substr() függvény paraméterként vesz egy karakterláncot (amelyből a részstring mintát kell venni), egy egész számot (az a hely, ahol a kívánt részkarakterlánc kezdődik) és egy opcionális egész harmadik paramétert, amely megadja a kívánt részkarakterlánc hosszát. Ha a harmadik paraméter nincs megadva, akkor azt feltételezzük, hogy az alkarakterlánc a karakterlánc végéig folytatódik. (Ne feledje, hogy ennek a függvénynek a használatakor a sor pozícióinak számozása nullától kezdődik, és nem egytől, mint minden PHP függvényparaméterben, amely numerikus pozíciókat jelöl a karakterláncokban.) Például:

$str = "Szia világ!"; echo mb_substr($str, 7, 3, "UTF8"); // "világ"

A kezdőpozíció paraméter és a hossz paraméter is lehet negatív, de mindkét esetben a negatív érték mást jelent. Ha a kezdőpozíció negatív, akkor a részkarakter kezdő karakterének helyzetét úgy határozzuk meg, hogy a sztring végétől visszafelé számolunk, nem pedig a karakterlánc elejétől előre. (A -1 kezdőpozíció azt jelzi, hogy a számlálás az utolsó karaktertől kezdődik, a -2 érték az utolsó előtti karaktert jelöli, és így tovább.)

Ez alapján feltételezhető, hogy a negatív hosszúságérték azt is jelenti, hogy a részstringet a kezdő karaktertől visszafelé számolva kell meghatározni, nem pedig előre számolva, de ez nem így van. Az az állítás, hogy a kiindulási pozícióban lévő karakter a visszaadott karakterlánc első karaktere (és nem az utolsó), mindig igaz. Ehelyett a negatív hosszparaméter azt jelenti, hogy a befejező karaktert a végétől visszafelé történő számolás határozza meg, nem pedig a kezdőponttól előre.

Íme néhány példa pozitív és negatív paraméterekkel:

$str = "Szia világ!"; echo mb_substr($str, 7, 3, "UTF8")."
"; // "világ" echo mb_substr($str, -4, 3, "UTF8")."
"; // "világ" echo mb_substr($str, 0, -5, "UTF8")."
"; // "Szia"

Szóközök és tabulátorok eltávolítása a karakterláncokból

Technikailag a chop(), ltrim() és trim() függvények részkarakterláncokkal való munkavégzésre szolgáló függvények (amelyek nagyon hasonlítanak más függvényekhez), de valójában ezek a függvények a nem kívánt karakterek eltávolítására szolgálnak a karakterláncokból. A chop(), ltrim() és trim() függvények eltávolítják az egyetlen karakterlánc-paraméterként megadott karakterlánc záró, kezdő, kezdő és záró szóköz karaktereit.

A szóközök mellett ezek a funkciók eltávolítják a többi szóköz karaktert is, például azokat, amelyeket a \n, \r, \t és \0 escape szekvenciák jeleznek (sorvégi karakterek, tabulátorok és a végét jelölő null karakterek egy sor C-programokban).

A PHP-ben általánosan elterjedt a karakterlánc végén lévő szóköz eltávolítására szolgáló függvény, a chop(), de egy azonos függvény, leíróbban rtrim() is meghívható. Végül meg kell jegyezni, hogy a chop() függvény annak ellenére, hogy a neve, ami azt jelenti, hogy "levágás" nagyon fenyegetően hangzik, nem károsítja az eredeti $original paramétert, amely megtartja a korábbi értéket.

Húrcsere

A fent tárgyalt összes karakterlánc-függvény a bemeneti paraméter egy részének kiválasztását biztosította, nem pedig egy teljesen új karakterlánc létrehozását. Ez a rész az str_replace() és substr_replace() függvényeket tárgyalja erre a célra.

Az str_replace() függvény lehetővé teszi, hogy egy adott részkarakterlánc minden előfordulását lecserélje egy másik karakterláncra. Ez a függvény három paramétert vesz igénybe: a keresendő karakterláncot, a megtalálása után lecserélendő karakterláncot és a cseréhez használandó karakterláncot. Tekintsük a következő példát:

$str = "Szia világ!"; echo str_replace("világ", "bolygó", $str); // "Hello bolygó!"

A csere a keresési karakterláncban található részkarakterlánc minden előfordulásakor megtörténik. Ha a fenti példával egy elavult enciklopédiában egy város nevét helyettesítettük, akkor az enciklopédia teljes szövegének egyetlen PHP sorba való konvertálása után a teljes szövegben egy lépésben végrehajtható lenne a csere.

Ahogy fentebb látható, az str_replace() függvény kiválasztja a forráskarakterláncnak azt a részét, amelyet le kell cserélni úgy, hogy megkeresi a kívánt részkarakterlánc előfordulásait a forráskarakterláncban; ezzel szemben a substr_replace() a lecserélendő részt az abszolút pozíciójával választja ki. Ez a függvény legfeljebb négy paramétert igényel: a cserélendő karakterláncot, a csereként használandó karakterláncot, a csere kezdőpozícióját és (opcionális paraméterként) a karakterlánc cserélendő részének hosszát. Tekintsük a következő példát:

echo substr_replace("ABCDEFG", "-", 2, 3); "AB-FG"

A karakterlánc CDE része egyetlen karakterre lett lecserélve. Vegye figyelembe, hogy ebben az esetben megengedett volt egy részkarakterlánc helyettesítése eltérő hosszúságú karakterlánccal. Ha a hossz paramétert kihagyjuk, akkor a karakterlánc teljes, a kezdőpozíció utáni részét kicseréljük.

A substr_replace() függvény negatív paramétereket is elfogad kiindulási pozícióként és hosszként, amelyeket pontosan úgy kezel, mint a fenti substr() függvényben. Fontos megjegyezni, hogy az str_replace és substr_replace függvényekkel végzett műveletek eredményeként az eredeti karakterlánc változatlan marad.

Végül számos kevésbé széles körben használt függvény van, amelyek új karakterláncokat képeznek a régiekből. Az strrev() függvény egyszerűen egy új karakterláncot ad vissza a bemeneti karakterláncban lévő karakterek megfordításával. Az str_repeat() függvény egy karakterláncot és egy integer paramétert vesz fel, és egy karakterláncot ad vissza, amely a karakterlánc paraméter meghatározott számú példányát tartalmazza:

echo str_repeat("ABC", 3); // ABCABCABC

Tokkonverziós funkciók

Ezek a funkciók lehetővé teszik a kisbetűk nagybetűssé alakítását és fordítva. A strtolower() függvény egy olyan karakterláncot ad vissza, amelyben minden betűt kisbetűssé alakítanak át. Nem számít, hogy az eredeti karakterlánc csak nagybetűket vagy nagy- és kisbetűket tartalmazott. Például:

$str = "Szia világ!"; echo mb_strtolower($str, "UTF8"); // "Helló Világ!"

Ha már tapasztalta, hogy sok űrlapellenőrzést kell elvégeznie, akkor észrevehette, hogy a strtolower() függvény rendkívül praktikus eszköz az olyan felhasználóktól kapott e-mail címek kezelésére, akik még mindig nem tudják, hogy az e-mail címek kis- és nagybetűk. -érzéketlen. Nem kevésbé hasznosak az ehhez a kategóriához kapcsolódó egyéb funkciók.

Az strtoupper() függvény olyan karakterláncot ad vissza, amelyben minden betűt nagybetűssé alakítanak át. Példa erre a következő kódrészlet:

$str = "Szia világ!"; echo mb_strtoupper($str, "UTF8"); // "HELLÓ VILÁG!"

Az ucfirst() függvény csak a karakterlánc első betűjét írja nagybetűvel, az ucwords() függvény a karakterlánc minden szavának első betűjét. Sem az ucwords() sem az ucfirst() függvénynek nincs hasonló funkciója a többbyte-os kódoláshoz, ezért nem kompatibilisek a cirill karakterláncokkal.

A vezérlőkarakterek bevezetésére szolgáló funkciók

A PHP nyelv egyik előnye, hogy szinte bármilyen rendszerrel adatcserére használható. Az ilyen típusú eszközöket általában egyfajta "szoftverragasztónak" tekintik. Ebben a szerepkörben a PHP nyelvet használják az adatbázis-kiszolgálókkal, LDAP-kiszolgálókkal való interakcióra, a socketeken keresztüli adatcserére és magán a HTTP-kapcsolaton keresztül. Ez az interakció gyakran úgy történik, hogy először létrehoznak egy üzenetkarakterláncot (például egy adatbázis-lekérdezést), majd ezt az üzenetet továbbítják a fogadó programnak. De a programok gyakran különleges jelentést adnak egyes karaktereknek, ezért ezeket vezérlőkarakterekké kell alakítani. Ez azt jelenti, hogy a fogadó program az ilyen karaktereket a karakterlánc szó szerinti részeként kezeli, ahelyett, hogy speciális kezelést alkalmazna.

Sok felhasználó ennek a problémának a megoldására engedélyezi az úgynevezett "varázsidéző ​​mód" használatát, amely biztosítja, hogy az idézőjelek vezérlőkarakterekké alakuljanak, mielőtt a karakterláncokat beszúrnák az adatbázisokba. De ha egy ilyen feldolgozási mód nem kivitelezhető vagy nem kívánatos, akkor a régi jó módszert kell használni: fordított perjel karaktereket kell beilleszteni, majd ezeket a karaktereket eltávolítani.

Az addslashes() függvény az egyszeres és dupla idézőjeleket, a fordított perjeleket és a null karaktereket escape szekvenciákká alakítja vissza perjelek használatával, mivel ezek azok a karakterek, amelyeket általában át kell alakítani escape szekvenciákká, amikor adatbázis-lekérdezéseket készítünk:

$escapedstring = addslashes("Karakterlánc "idézőjelekkel"."); $query = "INSERT INTO teszt (idézet) értékek ("$escapedstring")"; $eredmény = mysqli_query($link, $query) vagy die(mysql_error());

Ennek a kódnak a futtatása megakadályozza az SQL utasítás félreértelmezését, mintha a karakterlánc közvetlenül a "k" betű előtt végződne. Az adatok lekérése után pedig a stripslashes() függvényt kell használnia a fordított perjelek eltávolításához.

A quotemeta() függvény a karakterek szélesebb halmazát konvertálja escape szekvenciákká. Ezeknek a karaktereknek általában különleges jelentése van a Unix parancssorban: " . ", " " ", " + ", " * ", " ? ", " [ ", " ] ", " ^ ", " (", " $ " and ")". Például a következő kód futtatása:

$str = "Ezeket a karaktereket ($, *, ^) át kell alakítani."; echo quotemeta($str);

ezt a sort adja ki:

Kimeneti funkciók külső eszközre és vonalra

A kimenethez használt fő konstrukciók a print és a echo, amelyekről korábban részletesen volt szó. A változók értékeinek külső eszközre történő kiadásának szokásos módja az, hogy a változók nevét egy dupla idézőjeles karakterláncba foglalják (amelyet az értelmező dolgoz fel a változók értékeinek helyettesítésére), majd továbbítja ezt a karakterláncot a print vagy echo konstrukcióhoz.

Ha még pontosabban formázott kimenetre van szüksége, használhatja a PHP printf() és sprintf() függvényeit. Ez a két függvény ugyanazokat a paramétereket veszi fel: egy speciális formátumú karakterláncot, amelyet tetszőleges számú egyéb paraméter követ, amelyeket a formátum karakterlánc megfelelő helyein helyettesítenek az eredmény eléréséhez. Az egyetlen különbség a printf() és a sprintf() között, hogy a printf() közvetlenül a kimenethez használt külső eszközre küldi az eredmény karakterláncot, míg az sprintf() a végrehajtás eredményeként adja vissza az eredmény karakterláncot.

Néhány szó a tapasztalt C-programozóknak: A sprintf() ez a verziója kissé eltér a C verziótól abban, hogy a sprintf()-nek nem kell lefoglalt karakterláncot adnia az íráshoz, mivel a PHP értelmező memóriát foglal le a kapott karakterlánc számára a felhasználó.

A függvények használatának fő nehézsége a formátum karakterlánc helyes meghatározása. A formátumkarakterlánc minden karaktere közvetlenül megjelenik az eredményül kapott értékben, kivéve a % karaktereket és az ezeket közvetlenül követő karaktereket. A % szimbólum egy konverziós specifikáció kezdetét jelöli, amely meghatározza, hogyan kell a formátum karakterláncát követő paraméterek egyikét külső eszközre kiadni.

A % jel után öt elem alkotja a konverziós specifikációt, amelyeket alább ismertetünk, amelyek közül néhány nem kötelező: kitöltés, igazítás, minimális szélesség, pontosság és típus:

• Egy opcionális mínuszjel (-) jelzi, hogy egy szám negatív-e.
• Az egyetlen (nem kötelező) kitöltési karakter 0 vagy szóköz (). Ez a szimbólum minden olyan helyet kitölt, amely egyébként üresen maradna, de a felhasználó ragaszkodott a kiválasztásához (a minimális szélesség paraméter túl magasra állításával). Ha ez a kitöltési karakter nincs megadva, akkor alapértelmezés szerint szóközökkel kell kitölteni.
• Az opcionális igazoló karakter (-) határozza meg, hogy a kimeneti érték balra vagy jobbra igazított legyen. Ha ez a karakter meg van adva, akkor az érték balra igazításra kerül, ha pedig nincs meg, akkor jobbra igazítás kerül alkalmazásra.
• Opcionális minimális szélességű numerikus érték, amely megadja a kimeneti értéknek elfoglalt pozíciók minimális számát. (Ha a kimeneti értékek a megadottnál több karakterpozíciót igényelnek, akkor a kimeneti érték a tartományon kívül esik.)
• Egy opcionális precíziós megadó, pontként (.) és számmal formázott formában. A specifikátor jelzi, hogy a pont utáni tizedesjegyek számával mérve milyen pontossággal kell kiadni egy dupla pontosságú lebegőpontos számot. (E specifikáció alkalmazása nincs hatással a dupla pontosságú lebegőpontos számokon kívül más adatok kimenetére.)
• Egyetlen karakter, amely jelzi, hogyan kell értelmezni az értéktípust. Az f karakter azt jelzi, hogy az értéket dupla pontosságú lebegőpontos számként kell kinyomtatni, az s karakter azt, hogy az értéket karakterláncként kell kinyomtatni, és a többi lehetséges karakter (b, c, d, o, x, X ) azt jelzik, hogy az értéket egész számként kell értelmezni, és különféle formátumokban kell kiadni. Ezek a formátumok: b bináris formátumban, c a megfelelő ASCII-kóddal rendelkező karakterek, o oktális formátumban, x hexadecimális formátumban (a számjegyek kisbetűivel). ), X pedig a megjelenítéshez hexadecimális számok, amelyek nagybetűket használnak a számjegyek literális szimbólumaként.

A következő példa ugyanazt a kettős pontosságú lebegőpontos számot többféle módon is kiadja:

%10f 
%-10f 
%2.2f", $érték, $érték, $érték, $érték); ?>

A következő eredményeket produkálja:

A példában használt konstrukció

...

egy HTML-leíró, amely megmondja a böngészőnek, hogy az ebbe a leíróba zárt blokkot szó szerint kell formázni, anélkül, hogy több szóközt kellene tömöríteni egybe stb.

Funkciók a HTML kóddal való munkavégzéshez

A PHP számos funkciót biztosít a webspecifikus adatokat tartalmazó karakterláncok kezeléséhez. Az alábbi táblázat áttekintést nyújt ezekről a funkciókról:

HTML kóddal való együttműködésre tervezett karakterlánc-függvények

Funkció	Leírás
htmlspecialchars()	Egy karakterláncot vesz paraméterként, és egy olyan karakterláncot ad vissza, amelyben négy, a HTML nyelvben különleges jelentéssel bíró karaktert speciális karakterláncokra cseréltek. Ezen karakterek mindegyikét a megfelelő HTML komponens helyettesíti, amelyet ismét az eredeti karakter helyettesít, amikor az oldal szövegét kibontja a böngészőben. A & karaktert a & karakter " (idézőjel karakter) komponens helyettesíti - a " karakter< - < а символ > - >
htmlentities()	Teljesebb feldolgozást végez, mint a htmlspecialchars(), azaz. nem csak a speciális karaktereket cseréli le a HTML komponenssel, hanem az összes olyan karaktert is, amelynél a HTML komponens helyettesítése biztosított
get_html_translation_table()	Felveszi a két speciális állandó (HTML_SPECIAL_CHARS vagy HTML_ENTITIES) egyikét, és a htmlspecialchars() vagy htmlentities() függvények által használt konverziós táblázatot ad vissza. A keresőtábla egy tömb, amelynek kulcsai karakterláncok, és amelyeknek megfelelő értékei a helyettesítő karakterláncok.
nl2br()	Paraméterként egy karakterláncot vesz fel, és ugyanazt a karakterláncot adja vissza, de leírókkal , beszúrva az összes sorvégi karakter elé (\n, \r vagy \r\n). A funkció használatának szükségessége például akkor merül fel, ha a böngészőben megjelenő szövegnek ugyanazt a bekezdésezését szeretné megadni, mint a forrásszövegben
strip_tags()	Paraméterként egy karakterláncot vesz fel, és mindent megtesz annak érdekében, hogy az összes HTML-leírótól és PHP-leírótól megfosztott karakterláncot hozzon létre

Adatok kivonatolása az MD5 algoritmussal

Az MD5 algoritmus egy karakterlánc-feldolgozó algoritmus, amely úgynevezett kivonatot vagy digitális aláírást generál bármely paraméterként átadott karakterlánchoz. Az algoritmus a bemeneti karakterlánc alapján egy állandó hosszúságú karakterláncot generál, amely 32 hexadecimális számjegyből áll (0-9, a-f). Az MD5 algoritmus által generált eredmények nagyon hasznos tulajdonságokkal rendelkeznek, az alábbiak szerint:

• Az MD5 algoritmus mindig biztosítja, hogy a kimeneti karakterlánc ugyanaz legyen, ha ugyanazt a bemeneti karakterláncot kapja, így az MD5 titkosítás nem használható jelszavak tárolására.
• Az MD5 algoritmus alkalmazásának eredményei fix hosszúságúak, és nagyon egyenletesen oszlanak el a lehetséges értékek teljes tartományában.
• Az MD5 algoritmus egy adott kimeneti sztringjének megfelelő bemeneti karakterlánc generálható, vagy két bemeneti karakterlánc is létrehozható, amelyek feldolgozása ugyanahhoz a kimeneti sztringhez vezetne, de csak bizonyos feltételek mellett.

Az MD5 algoritmus PHP általi megvalósítása md5() függvényként érhető el, amely egy karakterláncot vesz be bemenetként, és az eredményeket 32 ​​karakteres kivonatként állítja elő. Például a következő kód futtatása:

$str = "Szia világ!"; echo "Hash kód a "$str" karakterlánchoz: ".md5($str)."
"; $str = "Szia, világ!"; echo "Hash kód a "$str" karakterlánchoz: ".md5($str)."
"; $str = "Hello world"; echo "Hash kód a "$str" karakterlánchoz: ".md5($str)."
";

a következő eredményeket jeleníti meg a böngészőablakban:

Természetesen ebben az esetben az összes bemeneti karakterlánc nagyon hasonlít egymásra, de a kimeneti karakterláncoknak nincs látható hasonlósága. Ezenkívül a lehetséges kimeneti értékek tartománya rendkívül nagy (1632), így rendkívül valószínűtlen annak az esélye, hogy két különböző karakterlánc kerül feldolgozásra (ami ugyanazt az MD5 értéket eredményezné).

Az MD5 algoritmus fenti jellemzőinek köszönhetően a segítségével kapott értékek sokféle probléma megoldására használhatók, beleértve az alábbiakban leírtakat is:
Üzenet vagy fájl ellenőrző összegének kiszámítása
Annak ellenőrzésére, hogy az üzenet megsérült-e az átvitel során, küldhet egy MD5 kivonatot az üzenettel együtt, és az üzenet fogadásakor újragenerálhatja az MD5 kivonatot. Ha a kivonat két verziója nem egyezik, akkor az átvitel során hiba történt.
Szabályozza, hogy a fájl tartalma változatlan maradjon-e
Ez a feladat hasonló az ellenőrző összeg kiszámításához. Az MD5 algoritmust gyakran használják ennek a műveletnek a végrehajtására a keresőmotorokban, ha rendszeresen ellenőrizni kell, hogy egy weboldal változott-e, és szükség esetén újra kell indexelni. A tény az, hogy a további ellenőrzéshez sokkal könnyebb megszervezni az MD5 kivonat tárolását, mint a teljes forrásfájlt.
Több karakterlánc vagy fájl felosztása részhalmazokra
A karakterláncok N véletlenszerűen kiválasztott részhalmazra való felosztásának problémájának megoldásához kiszámolhatja az egyes karakterláncok MD5-ös kivonatát, kiveszi az első néhány hexadecimális karaktert, átalakítja őket számmá, lekérheti a szám modulo modulo-ját, és felhasználhatja azt. maradék, mint a részhalmaz száma, amelybe ezt a sort kell írni.

Az md5() függvényen kívül a PHP biztosítja az md5_file() függvényt, amely egy fájlnevet vesz paraméterként, és a fájl tartalmának megfelelő kivonatolt MD5 értéket ad vissza.

A karakterláncok hasonlóságának értékelésére tervezett függvények

A gyakorlatban gyakran válik szükségessé annak meghatározása, hogy mennyire hasonló a két karakterlánc. Nyilvánvalóan a karakterlánc-hasonlóság becslésének eredménye attól függ, hogy mit értünk a karakterlánc-hasonlóság fogalmán.

Ha a helyesírási hasonlóságot tekintjük a hasonlóság értékelésének kritériumának, akkor alkalmazható Levenshtein metrika. A levenshtein() függvény két karakterláncot vesz fel paraméterként, és visszaadja az egyik karakterlánc másikká konvertálásához szükséges minimális számú karakter hozzáadását, törlését és cseréjét. Vegyünk egy példát:

echo levenshtein("Idő", "Idő"); // 1 echo levenshtein("fiú", "chefboyardee"); // 9 echo levenshtein("soha", "okos"); 2

Ha a fonetikai hasonlóságot hasonlósági kritériumnak tekintjük, akkor a soundex() és metaphone() függvények használhatók a hasonlóság értékelésére. Mindkét függvény bemenetként veszi a szóban forgó karakterláncot, és visszaad egy kulcssort, amely jelzi az adott szó kiejtési kategóriáját (amelyet angol szóként kezelünk). Ha egy bemeneti karakterlánc tartalmaként használt két szó pontosan ugyanannak a kimeneti értéknek felel meg, akkor valószínűleg ugyanúgy ejtik őket.

Elemző és tokenizáló függvények

Néha szükségessé válik, hogy egy program a karakterláncokat komponensekre bontsa, saját meghatározása alapján, hogy mit kell komponensnek tekinteni. A hosszú karakterlánc részekre bontásának folyamatát tokenizálásnak nevezzük. Egy ilyen folyamat különösen a bármely számítógépes program értelmezésére vagy fordítására vonatkozó általános eljárás része, beleértve a PHP-ben írt programokat is. A PHP nyelv egy speciális funkciót biztosít erre a célra - strtok ().

Az strtok() függvény két paramétert vesz igénybe: egy karakterláncot a tokenizáláshoz, és egy karakterláncot, amely tartalmazza az összes határolót (a tokenek közötti határként kezelt karaktereket). Az első meghívásakor mindkét paraméter felhasználásra kerül, és a függvény egy karakterlánc-értéket ad vissza, amely az első tokent reprezentálja. A következő tokenek kiválasztásához ugyanaz a hívás történik, de a forrás karakterlánc paraméter kimarad. A függvény megjegyzi az első paraméterben megadott karakterlánc címét, és aktuális karakterláncként használja. Ezenkívül ez a funkció megjegyzi, hogy a feldolgozás hol fejeződött be az előző hívás során. Tekintsük a következő példát:

$token = strtok("nyílt forráskódú HTML-beágyazott szerveroldali webszkriptek", " "); while($token) ( echo $token."
"; $token = strtok(" "); )

ami a következő kimenetet eredményezi a böngészőablakban:

Az eredeti karakterlánc azon a helyen van felosztva, ahol az egyes mezők találhatók.

Az strtok() függvény egyesével építi fel a tokeneket. Használhatja az explode() függvényt is, amely nagyjából ugyanezt hajtja végre, kivéve, hogy az összes tokent egyszerre, egy tömbben tárolja. A tömbként ábrázolt tokenek kézhezvétele után bármilyen műveletet végrehajthat velük, beleértve a rendezést is.

Az explode() függvény két paramétert igényel: egy határoló karakterláncot és egy karakterláncot, amelyet tokenekre kell felosztani. Ez a függvény egy tömböt ad vissza, amelynek minden eleme egy részkarakterlánc a felosztandó karakterláncban lévő határoló előfordulásai között. Tekintsük a következő példát:

$explodeResult = explode("ÉS", "egy ÉS egy kettő ÉS egy három");

ami egy $explode_result tömböt eredményez, amely három elemet tartalmaz, amelyek mindegyike egy karakterlánc: "egy", "a kettő" és "három". Ebben a konkrét példában a tömbben található karakterláncok egyikében sem fordul elő nagybetű, mivel az ÉS elválasztó nem szerepel az eredményben.

Az explode() függvényben használt határoló karakterlánc teljesen eltér az strtok() függvényben használt határoló karakterlánctól. A határoló egy teljes karakterlánc, ezért a karakterláncban szereplő összes karaktert a forrás karakterláncban kell megtalálni a határolóval megegyező sorrendben ahhoz, hogy a határolót megtaláltnak tekintsük.

Másrészt az strtok() függvényben egy elválasztott karakterlánc sok egyedi karaktert határoz meg, amelyek mindegyikét határolóként kezeli. Ez azt jelenti, hogy az explode() függvény szelektívebb, de hajlamosabb a törésre. Különösen, ha egy hosszú karakterlánc véletlenül kihagy egyetlen szóközt vagy egy sorvégi karaktert is, amely a határoló része, akkor ennek a függvénynek a teljes működése megszakadhat.

Az explode() függvénynek van egy inverz függvénye, az implode(), amely két paramétert vesz fel: egy összekötő karakterláncot (hasonló az explode() függvény elválasztó karakterláncához) és egy stringek tömbjét, amely hasonló ahhoz, amit az explode( ) funkciót. Az implode() függvény egy olyan karakterláncot ad vissza, amely úgy jött létre, hogy egy összekötő karakterláncot szúr be egy tömb összes egymást követő karakterlánceleme közé.