Php substituce proměnných do řetězce. Použití šablon v PHP

(PHP 4, PHP 5, PHP 7)

str_replace - Nahradí všechny výskyty hledaného řetězce náhradním řetězcem

Popis

Tato funkce vrátí řetězec nebo pole se všemi výskyty hledání v předmětu nahrazené nahrazením.

Pokud nepotřebujete složitá pravidla pro vyhledávání / nahrazování (např. regulární výrazy), je tato funkce preferována. preg_replace ().

Seznam parametrů

Pokud jsou hledání a nahrazování pole, pak str_replace () používá každou hodnotu z odpovídajícího pole pro vyhledávání a nahrazování v předmětu. Pokud má nahrazující pole méně prvků než hledání, jako náhradní řetězec pro zbývající hodnoty bude použit prázdný řetězec. Pokud je hledání pole a nahrazení je řetězec, bude tento náhradní řetězec použit pro každý prvek ve vyhledávacím poli. Opačný případ nedává smysl.

Pokud jsou pole hledat nebo nahrazovat, jejich prvky budou zpracovány od prvního do posledního.

Hodnota, kterou je třeba hledat, známá také jako jehla(jehla). Pro sadu požadovaných hodnot můžete použít pole.

Nahradit

Hodnota nahrazení bude použita k nahrazení hledání hodnot hledání. Pro více hodnot můžete použít pole.

Předmět

Řetězec nebo pole, které se má vyhledat a nahradit, známé také jako kupka sena(kupka sena).

Pokud je předmět pole, pak se nad každým předmětem předmětu provede hledání náhrady a funkce také vrátí pole.

Pokud projde, bude nastaven na počet provedených výměn.

Návratové hodnoty

Tato funkce vrací řetězec nebo pole s nahrazenými hodnotami.

Příklady

Příklad č. 1 Příklady použití str_replace ()

// přiřadí
$ bodytag = str_replace ("% body%", "black", " " );

// přiřadí: Hll Wrld f PHP
$ samohlásky = pole ("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
$ onlyconsonants = str_replace ($ samohlásky, "", "Ahoj světe PHP");

// přiřadí: Měli byste jíst pizzu, pivo a zmrzlinu každý den
$ fráze = "Měli byste jíst ovoce, zeleninu a vlákninu každý den.";
$ zdravé = pole ("ovoce", "zelenina", "vláknina");
$ mňam = pole ("pizza", "pivo", "zmrzlina");

$ newphrase = str_replace ($ zdravé, $ mňam, $ fráze);

// přiřadí: 2
$ str = str_replace ("ll", "", "dobrá slečno Molly!", $ count);
echo $ počet;
?>

Příklad č. 2 Příklady možných triků s str_replace ()

// Objednávka výměny
$ str = "Řádek 1 \ n řádek 2 \ r řádek 3 \ r \ n řádek 4 \ n";
$ order = pole ("\ r \ n", "\ n", "\ r");
$ nahradit = "
" ;

// Zpracuje \ r \ n jako první, aby nedošlo k jejich opětovnému nahrazení.
echo $ newstr = str_replace ($ objednávka, $ nahradit, $ str);

// Vytiskne F, protože A je nahrazeno B, pak B C a tak dále...
// V důsledku toho bude E nahrazeno F, protože nahrazení je zleva doprava.
$ hledat = pole ("A", "B", "C", "D", "E");
$ nahradit = pole ("B", "C", "D", "E", "F");
$ předmět = "A";
echo str_replace ($ hledat, $ nahradit, $ předmět);

// Výstupy: jablko-ořech ořech (z výše uvedeného důvodu)
$ písmena = pole ("i", "o");
$ ovoce = pole ("jablko", "ořech");
$ text = "Chystám se";
$ output = str_replace ($ písmena, $ ovoce, $ text);
echo $ výstup;
?>

Poznámky (upravit)

Komentář: Tato funkce je bezpečná pro zpracování dat v binární podobě.

Varování

Poznámka k výměně

Protože str_replace () provede výměnu zleva doprava, při použití více záměn pak může nahradit dříve vloženou hodnotu jinou. Viz také příklady na této stránce.

Komentář:
Tato funkce rozlišuje malá a velká písmena. Použití str_ireplace () pro výměnu bez ohledu na velikost písmen.

Komentář: PHP 7.0.0 na 64bitových platformách nemá žádné limity dosažitelné délky řetězce, na 32bitových systémech a dřívějších verze PHP, řádky nemohou být větší než 2 GB (2147483647 bajtů).

Syntax

Řetězec může být specifikován čtyřmi různé způsoby:

jednoduché uvozovky
dvojité uvozovky
syntaxe nowdoc (od PHP 5.3.0)

Jednoduché uvozovky

Nejjednodušší způsob definovat řetězec znamená uzavřít jej do jednoduchých uvozovek ( " ).

Chcete-li v řetězci použít jednu uvozovku, uzavřete ji zpětným lomítkem ( \ ). Pokud potřebujete napsat zpětné lomítko samotné, zkopírujte jej ( \\ ). Všechna ostatní použití zpětného lomítka budou interpretována jako normální znaky, což znamená, že pokud se pokusíte použít jiné escape sekvence jako např. \ r nebo \ n, budou zobrazeny tak, jak jsou, namísto jakéhokoli zvláštního chování.

echo "toto je jednoduchý řetězec";

echo „Lze vkládat i do řádků
postava z nového řádku, jako je tato,
to je normální";

// Výstupy: Arnold jednou řekl: "Já se vrátím"
echo "Arnold jednou řekl," já \ "vrátím se";

Echo "Odstranili jste C: \\ *. *?";

// Výstupy: Odstranili jste C: \ *. *?
echo "Odstranili jste C: \ *. *?" ;

// Výstupy: Toto nebude rozbaleno: \ n nový řádek
echo "Toto nebude rozbaleno: \ n nový řádek";

// Výstupy: Proměnné $ expandují také $ buď nejsou expandovány
echo "Proměnné $ expandují také $ expandují";
?>

Dvojité uvozovky

Pokud je řetězec uzavřen do dvojitých uvozovek ("), PHP rozpozná následující sekvence escape pro speciální znaky:

Únikové sekvence

Sekvence	Význam
\ n	nový řádek (LF nebo 0x0A (10) v ASCII)
\ r	návrat vozíku (CR nebo 0x0D (13) v ASCII)
\ t	horizontální karta (HT nebo 0x09 (9) v ASCII)
\ v	vertikální karta (VT nebo 0x0B (11) v ASCII) (od PHP 5.2.5)
\ e	escape znak (ESC nebo 0x1B (27) v ASCII) (od PHP 5.4.4)
\ f	seznam stránek (FF nebo 0x0C (12) v ASCII) (od PHP 5.2.5)
\\	obrácené lomítko
\$	znak dolaru
\"	dvojitá citace
\{1,3}	posloupnost znaků odpovídajících znaku regulárního výrazu v osmičkové soustavě, která tiše přeteče, aby se vešla do bajtu (tj. "\ 400" === "\ 000")
\ x (1,2)	posloupnost znaků odpovídajících znaku regulárního výrazu v hexadecimálním zápisu
\ u (+)	sekvence znaků odpovídajících regulárnímu výrazu znaků Unicode, který se mapuje na řetězec v notaci UTF-8 (přidáno v PHP 7.0.0)

Stejně jako u řetězce uzavřeného v jednoduchých uvozovkách, escapování libovolného znaku také vypíše samotný escape znak. Před PHP 5.1.1 zpětné lomítko in \ ($ var) nebyl vytištěn.

Heredoc

Třetí způsob, jak definovat řetězce, je pomocí syntaxe heredoc: <<< ... Po tomto operátoru musíte zadat identifikátor a poté odřádkování. Poté následuje samotný řádek a poté stejný identifikátor, který uzavírá vložku.

Čára by měl začít uzavíracím identifikátorem, tzn. musí být v prvním sloupci řádku. Identifikátor se navíc musí řídit stejnými pravidly pro pojmenování jako všechny ostatní značky v PHP: obsahovat pouze alfanumerické znaky a podtržítko a nesmí začínat číslem (podtržítka jsou povolena).

Pozornost

Je velmi důležité si uvědomit, že řádek s koncovým identifikátorem nesmí obsahovat žádné další znaky, s výjimkou středníku ( ; ). To znamená, že identifikátor nesmí být odsazené a že před ani za středníkem nesmí být žádné mezery ani tabulátory. Je také důležité pochopit, že první znak před koncovým identifikátorem musí být znak nového řádku, jak je definováno vaším operačním systémem. Například na systémech UNIX, včetně macOS, je tomu tak \ n... Bezprostředně za koncovým identifikátorem musí také začínat nový řádek.

Pokud je toto pravidlo porušeno a koncový identifikátor není „čistý“, považuje se koncový identifikátor za chybějící a PHP jej bude dále hledat. Pokud v tomto případě stále není nalezen správný uzavírací identifikátor, způsobí to chybu analýzy s číslem řádku na konci skriptu.

Příklad č. 1 Příklad nesprávné syntaxe

třída foo (
veřejný $ bar =<<bar
EOT;
// odsazení před koncovým identifikátorem není povoleno
}
?>

Příklad # 2 Příklad správné syntaxe

třída foo (
veřejný $ bar =<<bar
EOT;
}
?>

Heredoc nelze použít k inicializaci polí třídy. Od PHP 5.3 se toto omezení vztahuje pouze na heredocs obsahující proměnné.

Text Heredoc se chová stejně jako řetězec s dvojitými uvozovkami, aniž by je měl. To znamená, že v heredoc nemusíte uvozovky escapovat, ale stále můžete použít výše uvedené sekvence escapování. Proměnné se zpracovávají, ale při použití složitých proměnných uvnitř heredocu musíte být stejně opatrní jako při práci s řetězci.

Příklad č. 3 Příklad definování řetězce heredoc

$ str =<<Příklad řádku,
přes několik řádků,
pomocí syntaxe heredoc.
EOD;

Třída foo
{
var $ foo;
var $ bar;

Funkce __construct ()
{
$ this -> foo = "Foo";
$ toto ->
}
}

$ foo = nový foo ();
$ name = "Jméno";

echo<<Jmenuji se "$ name". Píšu $ foo -> foo .
Teď vytáhnu($ foo -> bar [1]) .
Výsledkem by mělo být velké "A": \ x41
EOT;
?>

Jmenuji se "Imarek". Píšu Foo. Nyní zobrazujem Bar2. Výsledkem by mělo být velké písmeno "A": A

Je také možné použít syntaxi heredoc k předání dat prostřednictvím argumentů funkce:

Počínaje verzí 5.3.0 bylo možné inicializovat statické proměnné a vlastnosti / konstanty třídy pomocí syntaxe heredoc:

Příklad č. 5 Použití heredoc k inicializaci statických proměnných

// Statické proměnné
funkce foo ()
{
statický $ bar =<<Nic tu není...
OZNAČENÍ;
}

// Konstanty třídy / vlastnosti
třída foo
{
const BAR =<<Příklad použití konstanty
FOOBAR;

Veřejné $ baz =<<Příklad použití pole
FOOBAR;
}
?>

Od PHP 5.3.0 můžete také umístit identifikátor Heredoc do dvojitých uvozovek:

Nowdoc

Nowdoc je stejný pro řetězce v jednoduchých uvozovkách jako heredoc pro řetězce s dvojitými uvozovkami. Nowdoc je jako heredoc, ale uvnitř nejsou prováděny žádné substituce... Tato konstrukce je ideální pro vkládání kódu PHP nebo jiných velkých bloků textu bez nutnosti escapování. V tomto je to trochu jako konstrukt SGML. prohlášením bloku textu ke zpracování.

Nowdoc je označen stejnou sekvencí <<< , který se používá v heredoc, ale následující identifikátor je uzavřen v jednoduchých uvozovkách, např. <<<"EOT" ... Všechny podmínky, které platí pro identifikátory heredoc, platí také pro nowdoc, zejména ty, které se týkají uzavíracího identifikátoru.

Příklad č. 7 Příklad použití nowdoc

echo<<<"EOD"
Ukázkový text,
přes několik řádků,
pomocí syntaxe nowdoc. S zpětnými lomítky se vždy zachází doslova,
například \\ a \ ".
EOD;

Výsledek tohoto příkladu:

Ukázkový text zahrnující více řádků pomocí syntaxe nowdoc. Zpětná lomítka jsou vždy zpracována doslova, například \\ a \ ".

Příklad č. 8 Příklad citování řetězce Nowdoc s proměnnými

/ * Složitější příklad s proměnnými. * /
třída foo
{
veřejné $ foo;
veřejný $ bar;

Funkce __construct ()
{
$ this -> foo = "Foo";
$ this -> bar = pole ("Bar1", "Bar2", "Bar3");
}
}

$ foo = nový foo ();
$ name = "Jméno";

echo<<<"EOT"
Jmenuji se "$ name". Píšu $ foo-> foo.
Teď píšu ($ foo-> bar).
To by nemělo vytisknout velké "A": \ x41
EOT;
?>

Výsledek tohoto příkladu:

Jmenuji se "$ name". Píšu $ foo-> foo. Teď píšu ($ foo-> bar). To by nemělo vytisknout velké "A": \ x41

Příklad č. 9 Příklad použití statických dat

třída foo (
veřejný $ bar =<<<"EOT"
bar
EOT;
}
?>

Komentář:
Podpora Nowdoc byla přidána do PHP 5.3.0.

Variabilní manipulace

Pokud je řetězec zadán v uvozovkách nebo pomocí heredoc, jsou zpracovány proměnné v něm obsažené.

Existují dva typy syntaxe: jednoduchá a složitá. Jednoduchá syntaxe je jednodušší a pohodlnější. Umožňuje zpracovat proměnnou, hodnotu pole ( pole) nebo vlastnosti objektu ( objekt) s minimálním úsilím.

Složitou syntaxi lze identifikovat podle složených závorek obklopujících výraz.

Jednoduchá syntaxe

Pokud tlumočník narazí na znak dolaru ( $ ), zachytí co nejvíce znaků, aby vytvořil správný název proměnné. Pokud chcete přesně definovat konec názvu, uzavřete název proměnné do složených závorek.

$ šťáva = "jablko";

echo "Vypil nějaký $ džus." ... PHP_EOL;

// Špatně. "s" je platný znak pro název proměnné, ale proměnná se jmenuje $ juice.
echo "Vypil nějaký džus vyrobený z $ džusů." ;

// Správně. Konec názvu proměnné je přesně specifikován pomocí závorek:
echo "Vypil nějaký džus vyrobený z $ (džusu) s." ;
?>

Výsledek tohoto příkladu:

Vypil trochu jablečného džusu. Vypil trochu připravené šťávy. Vypil trochu jablečného džusu.

Element pole ( pole) nebo vlastnost objektu ( objekt). V indexech pole je uzavírací hranatá závorka ( ] ) označuje konec definice indexu. Pro vlastnosti objektu platí stejná pravidla jako pro jednoduché proměnné.

Příklad č. 10 Jednoduchý příklad syntaxe

definovat ("KOOLAID", "koolaid1");
$ šťávy = pole ("jablko", "pomeranč", "koolaid1" => "fialová");

echo "Vypil nějaké $ džusy [0] džus." ... PHP_EOL;
echo "Vypil nějaké $ džusy [1] džus." ... PHP_EOL;
echo "Vypil nějaké $ džusy [koolaid1] džus." ... PHP_EOL;

třídní lidé (
public $ john = "John Smith";
public $ jane = "Jane Smith";
public $ robert = "Robert Paulsen";

Veřejné $ smith = "Smith";
}

$ lidé = noví lidé ();

echo "$ lidí -> John vypil $ džusy [0] džus." ... PHP_EOL;
echo "$ people -> john pak pozdravil $ people -> jane." ... PHP_EOL;
echo "$ people -> john" manželka pozdravila $ people -> robert. ". PHP_EOL;
echo "$ lidi -> robert pozdravil dva $ lidi -> kováři." ; // To nebude fungovat
?>

Výsledek tohoto příkladu:

Vypil trochu jablečného džusu. Vypil trochu pomerančového džusu. Vypil trochu fialového džusu. John Smith vypil trochu jablečného džusu. John Smith pak řekl ahoj Jane Smith. Manželka Johna Smithe pozdravila Roberta Paulsena. Robert Paulsen ty dva pozdravil.

PHP 7.1.0 přidává podporu pro zápornýčíselné indexy.

Příklad č. 11 Záporné číselné indexy

$ řetězec = "řetězec";
echo "Znak s indexem -2 je$ řetězec [- 2].", PHP_EOL;
$ string [- 3] = "o";
echo "Změnou znaku na pozici -3 na" o "se zobrazí následující řádek:$ string. ", PHP_EOL;
?>

Výsledek tohoto příkladu:

Znak s indexem -2 je n. Změnou znaku na pozici -3 na "o" vznikne následující řádek: silný

Pro cokoliv složitějšího použijte komplexní syntaxi.

Složitá (složená) syntaxe

Říká se tomu obtížné ne proto, že je obtížné mu porozumět, ale proto, že umožňuje použití složitých výrazů.

Jakákoli skalární proměnná, prvek pole nebo vlastnost objektu namapovaná na řetězec mohou být reprezentovány na řetězci s touto syntaxí. Stačí napsat výraz stejným způsobem jako mimo řádek a poté jej uzavřít { a } ... Pokud { nelze escapovat, tato syntaxe bude rozpoznána pouze tehdy $ následuje bezprostředně poté { ... Použití {\$ vytisknout {$ ... Několik názorných příkladů:

// Zobrazit všechny chyby
chybové hlášení (E_ALL);

$ skvělý = "skvělý";

// Nefunguje, výstupy: To je (skvělé)
echo "To je ($ skvělé)";

// Práce, výstupy: To je skvělé
echo "To je ($ skvělé)";

// Pracovní
echo „Tohle náměstí je široké($ čtverec -> šířka) 00 centimetrů. ";

// Funguje, klíče v uvozovkách fungují pouze se syntaxí složených závorek
echo "Toto funguje: ($ arr [" klíč "])";

// Pracovní
echo "Funguje to: ($ arr [4] [3])";

// Toto je nesprávné ze stejného důvodu jako $ foo venku
// řetězce. Jinými slovy, bude to stále fungovat.
// ale protože PHP nejprve hledá konstantní foo, toto zavolá
// Chyba úrovně E_NOTICE (nedefinovaná konstanta).
echo "Není to správné:($ arr [foo] [3]) ";

// Pracovní. Při použití vícerozměrných polí interně
// řetězce vždy používají složené závorky
echo "Funguje to: ($ arr [" foo "] [3])";

// Pracovní.
echo "To funguje:". $ arr ["foo"] [3];

echo "Tohle taky funguje:($ obj -> hodnoty [3] -> název) ";

echo "Toto je hodnota proměnné podle názvu$ name: ($ ($ name)) ";

echo "Toto je hodnota proměnné podle názvu, kterou vrací funkce getName ():($ (getName ())) ";

echo "Toto je hodnota proměnné podle názvu, kterou \ $ object-> getName () vrací:($ ($ objekt -> getName ())) ";

// Nefunguje, výstupy: Toto je to, co getName () vrací: (getName ())
echo "Toto vrací getName (): (getName ())";
?>

Pomocí této syntaxe je také možné přistupovat k vlastnostem objektů v řetězcích.

třída foo (
var $ bar = "Jsem bar." ;
}

$ foo = nový foo ();
$ bar = "bar";
$ baz = pole ("foo", "bar", "baz", "quux");
echo "($ foo -> $ bar) \ n";
echo "($ foo -> ($ baz [1])) \ n";
?>

Výsledek tohoto příkladu:

jsem bar. jsem bar.

Komentář:
Funkce, volání metod, statické proměnné třídy a konstanty třídy fungují interně {$} od PHP 5. Zadaná hodnota však bude považována za název proměnné ve stejném kontextu jako řetězec, ve kterém je definována. Použití jednoduchých složených závorek ( {} ) nebude fungovat pro přístup k hodnotám funkcí, metod, konstant třídy nebo statických proměnných třídy.

// Zobrazit všechny chyby
chybové hlášení (E_ALL);

třídní piva (
const softdrink = "kořenové pivo";
veřejné statické $ ale = "ipa";
}

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

// Funguje to, výstupy: Chtěl bych A & W
echo "Rád bych ($ (piva :: nealkoholický nápoj)) \ n";

// Toto také funguje, výstupy: Chtěl bych Alexander Keith "s
echo "Chtěl bych ($ (piva :: $ ale)) \ n";
?>

Přístup a úprava znaku v řetězci

Znaky v řetězcích lze používat a upravovat definováním jejich posunu od začátku řetězce, počínaje nulou, v hranatých závorkách za řetězcem, například $ str. Pro tento účel si řetězec představte jako pole znaků. Pokud potřebujete získat nebo nahradit více než 1 znak, můžete použít funkce substr () a substr_replace ().

Komentář: od PHP 7.1.0 jsou podporovány záporné hodnoty offsetu. Nastaví posun od konce řádku. Dříve záporné offsety způsobovaly chybu úrovně E_NOTICE buď při čtení (vracení prázdného řetězce). E_VAROVÁNÍ při psaní (řádek ponechán beze změny).

Komentář: Na znak v řetězci lze také odkazovat pomocí složených závorek, například $ str (42).

Pozornost

Pokus o zápis do off-line offsetu vyplní řádek mezerami až do tohoto offsetu. Neceločíselné typy budou převedeny na celá čísla. Nesprávný typ offsetu způsobí chybu úrovně E_VAROVÁNÍ... Použije se pouze první znak přiřazeného řetězce. Od PHP 7.1.0 způsobí přiřazení prázdného řetězce fatální chybu. Dříve byl v tomto případě přiřazen bajt NULL.

Pozornost

Řetězce v PHP jsou interně pole bajtů. Výsledkem je, že přístup nebo úprava řetězce na offsetu není z hlediska vícebajtového kódování bezpečná a měla by být prováděna pouze s řetězci v jednobajtových kódováních, jako je ISO-8859-1.

Komentář: Počínaje PHP 7.1.0 způsobuje použití prázdného indexu fatální chybu, dříve v podobném případě byl řetězec bez varování převeden na pole.

Příklad č. 12 Několik příkladů řetězců

// Získá první znak řetězce
$ str = "Toto je test." ;
$ první = $ str [0];

// Získá třetí znak řetězce
$ třetí = $ str [2];

// Získání posledního znaku řetězce
$ str = "Toto je stále test." ;
$ last = $ str [strlen ($ str) - 1];

// Změna posledního znaku řádku
$ str = "Podívejte se na moře";
$ str [strlen ($ str) - 1] = "e";

Od PHP 5.4 musí být offset v řetězci specifikován buď jako celé číslo nebo jako řetězec obsahující čísla, jinak bude vydáno varování. Dříve offset určený řádkem formuláře "foo", bez varování převedeny na 0 .

Příklad č. 13 Rozdíly mezi PHP 5.3 a 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"]));
?>

Výsledek spuštění tohoto příkladu v PHP 5.3:

řetězec (1) "b" bool (true) řetězec (1) "b" bool (true) řetězec (1) "a" bool (true) řetězec (1) "b" bool (true)

Výsledek spuštění tohoto příkladu v PHP 5.4:

řetězec (1) "b" bool (true) Varování: Neplatný posun řetězce "1.0" v /tmp/t.php na řádku 7 řetězec (1) "b" bool (false) Varování: Neplatný posun řetězce "x" v / tmp / t.php na řádku 9 řetězec (1) "a" bool (false) řetězec (1) "b" bool (false)

Komentář:
Pokus o přístup k proměnným jiných typů (s výjimkou polí nebo objektů, které implementují určitá rozhraní) pomocí nebo {} tiše vrátit NULA.

Komentář:
PHP 5.5 přidalo podporu pro přístup ke znakům v řetězcových literálech pomocí syntaxe nebo {} .

Existuje mnoho užitečných funkcí pro úpravu řetězců.

Základní funkce jsou popsány v části o řetězcových funkcích a pro pokročilé vyhledávání a nahrazování funkce regulárních výrazů kompatibilních s Perl.

Převod na řetězec

Hodnotu lze převést na řetězec pomocí přetypování (tětiva), nebo funkce strval ()... Ve výrazech, kde je potřeba řetězec, proběhne převod automaticky. K tomu dochází při použití funkcí echo nebo tisk, nebo když je hodnota proměnné porovnána s řetězcem. Přečtením částí příručky Typy a Manipulace s typy bude následující jasnější. viz také settype ().

Pole jsou vždy převedeny na řetězec "Pole" takže nemůžete zobrazit obsah pole ( pole) použitím echo nebo tisk abyste viděli, co obsahuje. Chcete-li zobrazit jednotlivou položku, použijte něco jako echo $ arr ["foo"]... Níže naleznete tipy, jak zobrazit/zobrazit veškerý obsah.

Chcete-li převést proměnnou na typ "Objekt" v typu tětiva používá se magická metoda __toString.

Význam NULA vždy převede na prázdný řetězec.

Jak můžete vidět výše, přímý převod na řetězec polí, objektů nebo zdrojů neposkytuje žádné užitečné informace o hodnotách samotných, kromě jejich typů. Lepším způsobem výstupu hodnot pro ladění je použití funkcí print_r () a var_dump ().

Většinu hodnot v PHP lze převést na řetězec pro trvalé uložení. Tato metoda se nazývá serializace a lze ji provést pomocí funkce serializovat ().

Převod řetězců na čísla

Pokud je řetězec rozpoznán jako číselná hodnota, výsledná hodnota a typ se určí tak, jak je uvedeno níže.

Pokud řetězec neobsahuje žádný ze znaků ".", "E" nebo "E" a hodnota čísla je umístěna v rozsahu celých čísel (definováno PHP_INT_MAX), bude řetězec rozpoznán jako celé číslo ( celé číslo). Ve všech ostatních případech se považuje za číslo s pohyblivou řádovou čárkou ( plovák).

Hodnota je určena začátkem řetězce. Pokud řetězec začíná platnou číselnou hodnotou, použije se tato hodnota. Jinak bude hodnota 0 (nula). Platná číselná hodnota je jedna nebo více číslic (které mohou obsahovat desetinnou čárku), před kterými může být znaménko následované volitelným exponentem. Exponent je "e" nebo "E" následované jednou nebo více číslicemi.

$ foo = 1 + "10,5"; // $ foo is float (11.5)
$ foo = 1 + "-1,3e3"; // $ foo is float (-1299)
$ foo = 1 + "bob-1.3e3"; // $ foo je celé číslo (1)
$ foo = 1 + "bob3"; // $ foo je celé číslo (1)
$ foo = 1 + "10 malých prasat"; // $ foo je celé číslo (11)
$ foo = 4 + "10.2 malá prasátka"; // $ foo is float (14.2)
$ foo = "10,0 prasat" + 1; // $ foo is float (11)
$ foo = "10,0 prasat" + 1,0; // $ foo is float (11)
?>

Další informace o této konverzi naleznete v části strtod (3) v dokumentaci k Unixu.

Pokud chcete otestovat některý z příkladů v této části, zkopírujte jej a vložte jej a následující řádek, abyste viděli, co se stane:

echo "\ $ foo == $ foo; typ:". gettype ($ foo). "
\ n ";
?>

Nečekejte, že kód znaku získáte převodem na celé číslo (jak se to dělá například v C). Chcete-li převést znaky na jejich kódy ASCII a naopak, použijte funkce ord () a chr ().

Podrobnosti implementace typu řetězce

před 7 lety

Dokumentace to nezmiňuje, ale koncový středník na konci heredoc je ve skutečnosti interpretován jako skutečný středník a jako takový někdy vede k syntaktickým chybám.

$ foo =<<abeceda
KONEC;
?>

Toto neplatí:

foo (<<abeceda
KONEC;
);
// chyba syntaxe, neočekávané ";"
?>

Bez středníku to funguje dobře:

foo (<<abeceda
KONEC
);
?>

před 3 lety

Můžete použít řetězec jako pole znaků (jako C)

$ a = "Test pole řetězců";

var_dump ($ a);
// Návratový řetězec (17) "Test pole řetězců"

var_dump ($ a);
// Návratový řetězec (1) "S"

// - S přetypováním pole -
var_dump ((pole) $ a);
// Návrat pole (1) (=> řetězec (17) "Test pole řetězců")

var_dump ((pole) $ a);
// Návratový řetězec (17) "S"

Norihiori

před 15 lety

Pomocí složité syntaxe můžete vložit hodnotu obou vlastností objektu A metod objektu do řetězce. Například ...
třídní test (
veřejný $ jeden = 1;
veřejná funkce dvě () (
návrat 2;
}
}
$ test = nový test ();
echo "foo ($ test -> jeden) pruh ($ test -> dva ())";
?>
Bude vydávat „foo 1 bar 2“.

Nemůžete to však udělat pro všechny hodnoty ve vašem jmenném prostoru. Konstanty třídy a statické vlastnosti / metody nebudou fungovat, protože složitá syntaxe hledá "$".
třídní test (
const JEDNA = 1;
}
echo "foo (Test :: JEDEN) bar";
?>
Výsledkem bude „foo (Test :: one) bar“. Konstanty a statické vlastnosti vyžadují, abyste řetězec přerušili.

před 3 lety

Pozor, v souladu s „Převod řetězce na čísla“:

If ("123abc" == 123) echo "(intstr == int) nesprávně testuje jako pravdivé.";

// Protože jedna strana je číslo, řetězec je nesprávně převeden z intstr na int, který pak odpovídá testovacímu číslu.

// Platí pro všechny podmínky, jako jsou příkazy if a switch (pravděpodobně také cykly while)!

// To může být velké bezpečnostní riziko při testování / používání / ukládání uživatelského vstupu, zatímco očekáváte a testujete pouze celé číslo.

// Zdá se, že jedinou opravou je, aby 123 byl řetězec jako "123", takže nedojde k žádné konverzi.

před 6 lety

Počáteční nuly v řetězcích nejsou (nejmenší překvapení) považovány za osmičkové.
Zvážit:
$ x = "0123" + 0;
$ y = 0123 + 0;
echo "x je $ x, y je $ y"; // vypíše "x je 123, y je 83"
jinými slovy:
* úvodní nuly v číselných literálech ve zdrojovém kódu jsou interpretovány jako "osmičkové", srov. strtol ().
* úvodní nuly v řetězcích (např. data odeslaná uživatelem) jsou při přetypování (implicitně nebo explicitně) na celé číslo ignorovány a považovány za desítkové, srov. strtod ().

před 10ti lety

Zde je snadný hack, který umožní řetězcům a heredocům ve dvojitých uvozovkách obsahovat libovolné výrazy v syntaxi složených závorek, včetně konstant a dalších volání funkcí:

// Prohlášení o hacku
funkce _expr ($ v) (návrat $ v;)
$ _expr = "_expr";

// Naše hřiště
definovat ("qwe" , "asd");
definovat("zxc", 5 );

$ a= 3 ;
$ b= 4 ;

funkce C($ a, $ b) (vrátit se$ a+ $ b; }

// Použití
echo"před{ $ _expr(1 + 2 )} příspěvek \ n "; // výstupy "pre 3 post"
echo"před{ $ _expr(qwe)} příspěvek \ n "; // výstupy "pre asd post"
echo"před{ $ _expr(C($ a, $ b)+ zxc* 2 )} příspěvek \ n "; // výstupy "pre 17 post"

// Obecná syntaxe je ($ _expr (...))
?>

Před 2 roky

Myslel jsem, že by bylo užitečné přidat tento komentář, aby se informace objevily alespoň na správné stránce na webu PHP.

Všimněte si, že pokud máte v úmyslu použít řetězec ve dvojitých uvozovkách s asociativním klíčem, můžete narazit na chybu T_ENCAPSED_AND_WHITESPACE. Někteří to považují za jednu z méně zjevných chybových zpráv.

Výraz jako:

$ ovoce= pole (
"A"=> "jablko",
"b"=> "banán",
// atd
);

Tisk "Toto je a$ ovoce[ "a"] "; // T_ENCAPSED_AND_WHITESPACE
?>

se určitě rozpadne na kusy.

Můžete to vyřešit následovně:

tisk"Toto je a$ ovoce[ A] " ; // zrušte citaci klíče
tisk"Toto je a${ ovoce[ "A"]} " ; // Složitá syntaxe
tisk"Toto je a{ $ ovoce[ "A"]} " ; // Komplexní variace syntaxe
?>

Osobně preferuji poslední variantu, protože je přirozenější a blíže tomu, jaký by byl výraz mimo řetězec.

Není jasné (alespoň mně), proč PHP chybně interpretuje jedinou uvozovku uvnitř výrazu, ale myslím si, že to má něco společného s tím, že uvozovky nejsou součástí řetězce hodnoty - jakmile je řetězec již analyzován, uvozovky prostě překážet...?

Před 2 roky

Obojí by mělo fungovat :(

třídaTestování{
veřejná statika$ VAR= "statický";
public const VAR ="konst";

Veřejná funkce řekniHelloStatic() {
echo"Ahoj:{ $ toto:: $ VAR} " ;
}

Veřejná funkce řekniHelloConst() {
echo"Ahoj:{ $ toto:: VAR)" ; // Chyba analýzy: chyba syntaxe, neočekávané ")", očekává se "["
}
}

$ obj= novýTestování();
$ obj-> řekniHelloStatic();
$ obj-> řekniHelloConst();

před 3 lety

Něco, co jsem zažil, co bezpochyby někomu pomůže. ... ...
V mém editoru to zvýrazní syntaxi HTML a komentář $:

$ html =<<<"EOD"
$ komentář
EOD;

Pomocí tohoto zobrazíte všechny stejnou barvu:

$ html =<<$ komentář
EOD;

práce s ním je mnohem jednodušší

před 11 lety

Abyste si zachránili mysl, nečtěte předchozí komentáře o datech;)

Když lze oba řetězce převést na numerické (v testu ("$ a"> "$ b")), použijí se výsledná numerická čísla, jinak se porovnávají FULL řetězce char-by-char:

var_dump("1.22" > "01.23" ); // bool (false)
var_dump("1.22.00" > "01.23.00" ); // bool (pravda)
var_dump("1-22-00" > "01-23-00" ); // bool (pravda)
var_dump((plovák)"1.22.00" > (plovoucí)"01.23.00" ); // bool (false)
?>

smíšený preg_replace(smíšený vzor, smíšená náhrada, smíšený předmět [, int limit])

Vyhledá v předmětu shodu se vzorem a nahradí je náhradou. Pokud je zadán parametr limit, budou nahrazeny limitní výskyty šablony; pokud je limit vynechán nebo je roven -1, všechny výskyty vzoru budou nahrazeny.

Nahrazení může obsahovat odkazy ve tvaru \\ n nebo (od PHP 4.0.4) $ n, přičemž přednost se dává druhému. Každý takový odkaz bude nahrazen podřetězcem odpovídajícím podvzoru n „n“ uzavřenému v závorkách. N může nabývat hodnot od 0 do 99 a odkaz \\ 0 (nebo $ 0) odpovídá celému vzoru. Podvzory jsou číslováno zleva doprava, počínaje jedničkou...

Při použití zástupných znaků pomocí odkazů na podvzory může být možné, aby číslo bezprostředně následovalo masku. V tomto případě způsobí zápis \\ n chybu: odkaz na první podvzor následovaný číslem 1 bude zapsán jako \\ 11, což bude interpretováno jako odkaz na jedenáctý podvzor. Tento zmatek lze odstranit pomocí konstruktu \ $ (1) 1, který ukazuje na izolovaný odkaz na první podvzor, za kterým následuje číslice 1.

Výstupem tohoto příkladu bude:

1. dubna 2003

Pokud je během provádění funkce nalezena shoda vzoru, bude vrácena upravená hodnota předmětu, jinak bude vrácen původní předmět.

První tři parametry funkce preg_replace () mohou být jednorozměrná pole. Pokud pole používá klíče, budou při zpracování pole převzaty v pořadí, v jakém jsou umístěny v poli. Klíče pole pro vzor a výměnu jsou volitelné. Pokud se přesto rozhodnete použít indexy ke spárování vzorů a řetězců zahrnutých do nahrazení, použijte funkci ksort () pro každé z polí.

Příklad 2. Použití polí s číselnými indexy jako argumenty funkce preg_replace ()

$ řetězec = "Rychlá hnědá liška přeskočila líného psa."$ vzory [0] = "/ rychle /";
$ vzory [1] = "/ hnědá /";
$ vzory [2] = "/ liška /"; $ nahrazení [2] = "medvěd";
$ nahrazení [1] = "černá";
$ nahrazení [0] = "pomalé"; preg_replace ($ vzory, $ nahrazení, $ řetězec);
?>

Výsledek:

Pomalý černý medvěd přeskočil líného psa.

Pokud je parametrem předmětu pole, pro každý jeho prvek se provede vyhledávání a nahrazení zástupných znaků. Vráceným výsledkem bude také pole.

V případě, že parametry pattern a nahrazení jsou pole, preg_replace () střídavě načte pár prvků z obou polí a použije je pro operaci hledání a nahrazení. Pokud náhradní pole obsahuje více prvků než vzor, místo chybějících prvků budou nahrazeny prázdné řetězce. Pokud je vzor pole a nahrazení je řetězec, bude každý prvek pole vzorů vyhledán a nahrazen vzorem (vzorem budou střídavě všechny prvky pole, zatímco náhradní řetězec zůstane pevný). Varianta, kdy vzor je řetězec a nahrazení je pole, nedává smysl.

Modifikátor / e mění chování funkce preg_replace () a to tak, že parametr nahrazení je po provedení nezbytných substitucí interpretován jako PHP kód a teprve poté je použit k nahrazení. Při použití tohoto modifikátoru buďte opatrní: parametr nahrazení musí obsahovat správný PHP kód, jinak v řádku obsahujícím volání funkce preg_replace (), dojde k chybě syntaxe.

Příklad 3. Náhrada několika šablonami

$ vzory = pole ( "/ (19 | 20) (\ d (2)) - (\ d (1,2)) - (\ d (1,2)) /",
"/ ^ \ s * ((\ w +)) \ s * = /");
$ nahradit = pole ("\\ 3 / \\ 4 / \\ 1 \\ 2", "$ \\ 1 =");
echo preg_replace (vzory $, $ nahradit, "(počáteční datum) = 1999-5-27");
?>

Tento příklad vypíše:

Převede všechny značky HTML na velká písmena

Příklad 5. Převodník HTML na text

// $ dokument ve výstupu by měl obsahovat HTML dokument.
// Je nutné odstranit všechny HTML tagy, javascriptové sekce,
// mezery mezi znaky. Je také nutné některé vyměnit
// HTML entity na jejich ekvivalent.$ hledat = pole ( ""]*?>.*?"si", // Vystřihněte javaScript
""<[\/\!]*?[^<>] *?> "si", // Odstraní značky HTML
"" ([\ r \ n]) [\ s] + "", // Odstraní mezery
"" & (quot | # 34); "i", // Nahrazuje entity HTML
"" & (amp | # 38); "i",
"" & (lt | # 60); "i",
"" & (gt | # 62); "i",
"" & (nbsp | # 160); "i",
"" & (mimo | # 161); "i",
"" & (cent | # 162); "i",
"" & (libra | # 163); "i",
"" & (kopie | # 169); "i",
"" (\ d +); "e"); // interpretovat jako php kód$ nahradit = pole ("",
"" ,
"\\1" ,
"\"" ,
"&" ,
"<" ,
">" ,
" " ,
chr (161),
chr (162),
chr (163),
chr (169),
"chr (\\ 1)"); $ text = preg_replace ($ hledat, $ nahradit, $ dokument);
?>

Tabulky:

Seznam objednávek (seznam)
l_id | Kdo | Co je potřeba | Čas | Komentář operátora
1 | 1 | 2 | % časové razítko% | % operator_text%
2 | 2 | 1 | | % text%
3 | 3 | 2 | | % text%

Tabulka č. 1 obsahuje seznam klientů.
Tabulka 2 obsahuje seznam služeb.
Tabulka 3 obsahuje seznam aktuálních zakázek pro operační týmy. Tato tabulka je pravidelně aktualizována a k jejímu vyplnění slouží webový formulář. Vzhledem k tomu, že přichází poměrně málo objednávek, jsou do tabulky zapisovány záznamy ve formě ID klientů a služeb.

Skutečný problém je v tom, že třetí tabulka by se měla zobrazovat ve webovém formuláři "výběr objednávky" a místo ID je potřeba dosadit odpovídající pole z jiných sloupců.

Kód:
$ dotaz = "VYBRAT * ZE seznamu";
$ vysledek = mysql_query (dotaz $);
while ($ row = mysql_fetch_array ($ result. // vzít výsledky z každého řádku
(echo ""; // tisk dat
}

CREATE TABLE "název_tabulky" ("id" int (255) NOT NULL AUTO_INCREMENT, text "seznam" (80) NOT NULL, PRIMÁRNÍ KLÍČ ("id".

INSERT INTO "table_name" ("seznam") HODNOT ("bla-bla")

nejlepší odpověď $ dotaz =
"
vybrat společnosti.Společnost, typy_oprav.Typy_oprav, seznam.komentář_l
ze seznamu
vnitřní společnosti
na seznamu.Kdo = společnosti.c_id
typy oprav vnitřního spojení
na seznamu. "Co je potřeba" = repair_types.r_id
";

V poslední době se diskuze o jazyce PHP na Habré omezily na možnosti navrhování složitých systémů, které se nemohou než radovat. Když jsem se však podíval na tucet nejuznávanějších webových frameworků (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ a další), byl jsem upřímně překvapen, když jsem našel některé významné nedostatky z hlediska elementární optimalizace.

Aby bylo toto téma více technicky zaměřené, jsou výsledky prezentovány rigoróznější formou, což může vnímání poněkud zkomplikovat.

Takže, jdeme na to... Úkol je extrémně jednoduchý: provést experimenty s rychlostí vytváření řetězců z podřetězců v jednoduchých a dvojitých uvozovkách. V zásadě bude tato otázka vzhledem ke zvláštnostem zpracování řetězců v PHP aktuální ještě dlouho.

Existuje mnoho článků o základní optimalizaci skriptů jak v ruštině, tak v jiných jazycích. Říká málo o řetězcích, ale upozorňuje na skutečnost, že se řetězce „analyzují“ ve dvojitých uvozovkách pro proměnné a řídicí znaky (jako v oficiální dokumentaci). Na základě toho je logické předpokládat, že používání řetězců v uvozovkách při práci bude poněkud pomalejší než stejné operace s podřetězci v jednoduchých uvozovkách.

Kromě substituce proměnných do řetězců a zřetězení proměnných s podřetězci implementuje PHP ještě minimálně jeden způsob tvoření řetězců: práci s funkcí sprintf. Je logické předpokládat, že tato metoda bude výrazně horší než ta "standardní" kvůli zbytečnému volání funkce a parsování řetězce uvnitř.

Jediný dodatek, než vám představím kód testovacího skriptu: musíte zvážit 2 možné možnosti práce s řetězci v uvozovkách: s přihlédnutím k jednoduchému a „pokročilému“ stylu kódování. Neměli byste věnovat pozornost skutečnosti, že proměnné jsou pravděpodobně na samém začátku řádků - jsou to jen příklady:
$ string = "$ _SERVER [" HTTP_HOST "] - ne správa oblasti Uljanovsk. Milujeme ruský jazyk a nemáme rádi ty, kteří jej používají ... "
a
$ string = "($ _SERVER [" HTTP_HOST "]) - ne správa oblasti Uljanovsk. Milujeme ruský jazyk a nemáme rádi ty, kteří jej používají ... "

Test číslo jedna.
No, zdá se, že všechny výhrady byly učiněny – je čas ukázat výsledky práce. Zdrojový kód testeru lze nalézt.

Screenshoty ukazují, že moje hypotéza se nepotvrdila. Jediný správný předpoklad se ukázal být o práci s řetězci přes sprintf. Nejrychlejší jsou funkce, které pracují s dvojitými uvozovkami.

Po krátkém zvážení situace přišlo vysvětlení samo: celá podstata spočívá v tom, že referenční řetězec, do kterého byly substituce provedeny, je příliš krátký: předávání analyzátoru po takovém řetězci je maličkost. I zde však můžete vidět, že nativní substituce proměnné v řetězci dává výhodu oproti „pokročilému stylu“.
To je také slabina přístupu zřetězení: objemy vložených dat převyšují objemy podřetězců. Odkud se režijní náklady berou, se dočtete v již zmíněných habratopicích.

I tyto myšlenky však musely být potvrzeny. To vyžadovalo druhý test se změnami z možných důvodů uvedených pro takové nepředvídatelné (pro mě) chování. Zdá se, že v páté verzi bylo hodně vyladěno (přiznám se, že v páté verzi php jsem provedl pouze 1 test: procházet prvky pole).

Test číslo dvě.
Druhá hypotéza: prodloužení referenčního řetězce nakonec zvýší procento doby běhu testovacích funkcí spojených s vytvářením řetězců ve dvojitých uvozovkách vzhledem k výsledkům testu 1. Stejná situace by teoreticky měla být pozorována s ohledem na provoz funkce sprintf. To je způsobeno především potřebou analyzovat řetězce a zvýšením času stráveného na tomto procesu. V situaci se zřetězením podřetězců v jednoduchých uvozovkách si myslím, že bude pozorován přibližně stejný výsledek jako v prvním testu, což způsobí mírné snížení zlomku doby provádění funkce quotes_3 () časem celý skript běží (ale ne zvýšení výkonu).

Závěry jsou ve skutečnosti pouze pozitivní a potvrzující hypotézu. S mírným zvýšením referenčního řetězce se objeví velké zatížení, což vede ke snížení výkonu funkcí pro práci s dvojitými uvozovkami a sprintf.

Předpoklad týkající se řetězců v jednoduchých uvozovkách se také ukázal jako správný: místo 36,75 % času v prvním testu zabrala funkce quotes_3 () ve druhém 33,76 % času provádění skriptu.

Praktická hodnota.
Jednoduše řečeno, abstrahujeme od dat, můžeme dojít k závěru: čím delší je řetězec, ve kterém je třeba provést substituci, tím je pravděpodobnější, že operace zřetězení bude provedena rychleji než hledání proměnné v uvozovkách. Dobrovolníci se mohou pokusit zvolit potřebné parametry vkládání (počet proměnných, délka referenčního řetězce, délka řetězců v proměnných) tak, aby vyhovovaly rovnosti časů provádění.

To je ve skutečnosti vše. Zbývá jen dodat, že v programování nejsou žádné maličkosti (to říkám těm, kteří rádi říkají „úspora na zápasy“ (c) Adelf). Když znáte takové jemnosti a vezmete je v úvahu, můžete napsat kód, který bude optimalizován na všech úrovních;)

PS:
Testy provedené pomocí Zend Studio For Eclipse 6.0.0 (včetně Debuggeru a Profileru).
PHP verze 5.2.5
OS Debian Linux

PPS:
Byl bych rád, kdyby někdo zveřejnil výsledky těchto testů. Myslím, že nám to umožní objektivněji posoudit nutnost použití té či oné metody substituce v řetězcích. Byl bych také vděčný za zdravou kritiku stylu prezentace a designu.