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

Syntax

Řetězec může být definová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 (znak " ).

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é, duplikujte ho ( \\ ). Všechna ostatní použití zpětného lomítka budou interpretována jako normální znaky: to znamená, že pokud se pokusíte použít jiné únikové sekvence, jako např. \r nebo \n, budou vystupovat 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,
Tohle je fajn";

// Výstupy: Arnold jednou řekl: "Vrátím se"
echo "Jednoho dne Arnold řekl: 'Vrátím se''.";

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

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

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

// Výstupy: $expand a $either proměnné nejsou expandovány
echo "$expand a $either proměnné nejsou rozbaleny";
?>

Dvojité uvozovky

Pokud je řetězec uzavřen v uvozovkách ("), PHP rozpozná následující speciální sekvence escape znaků:

Únikové sekvence

Subsekvence	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)
\proti	vertikální karta (VT nebo 0x0B (11) v ASCII) (od PHP 5.2.5)
\E	znak escape (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í regulárnímu výrazu osmičkového znaku, která tiše přeteče, aby se vešla do bajtu (tj. "\400" === "\000")
\x(1,2)	posloupnost znaků odpovídající regulárnímu výrazu znaku 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 reprezentaci 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ý znak escape. Před PHP 5.1.1 zpětné lomítko \($var) nebyl zveřejněn.

Heredoc

Třetí způsob, jak definovat řetězce, je použít syntaxi 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á vkládání.

Čára musí začít uzavíracím identifikátorem, tzn. musí se objevit 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 závěrečný řádek identifikátoru nesmí obsahovat žádné jiné znaky kromě středníku ( ; ). To znamená, že id by nemělo být odsazeno a že před ani za středníkem nemohou 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 definovaný vaším operačním systémem. Například na systémech UNIX, včetně macOS, je tomu tak \n. Za koncovým identifikátorem musí také okamžitě začít 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ě není nikdy 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. Počínaje PHP 5.3 se toto omezení vztahuje pouze na heredocs obsahující proměnné.

Text Heredoc se chová stejně jako řetězec ve dvojitých uvozovkách, aniž by je měl. To znamená, že v heredoc nemusíte uvozovky escapovat, ale stále můžete použít sekvence escape výše. Proměnné se zpracovávají, ale při používání 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 definice řetězce Heredoc

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

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

Function__construct()
{
$this -> foo = "Foo" ;
$this ->
}
}

$foo = new foo();
$jméno = "Jméno" ;

echo<<Mé jméno je "$name". Píšu $foo -> foo .
Teď dedukuji( $foo -> bar [ 1 ]) .
Výsledkem by mělo být velké písmeno "A": \x41
EOT;
?>

Jmenuji se "Jméno". Píšu Foo. Nyní vypíšu 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:

Od verze 5.3.0 je 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Í;
}

// Vlastnosti konstant/třídy
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 podobný jako heredoc, ale uvnitř nejsou prováděny žádné náhrady. Tento design je ideální pro vkládání kódu PHP nebo jiných velkých bloků textu, aniž byste jej museli opustit. V tomto je trochu podobný konstruktu SGML deklarováním bloku textu, který není určen 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é se vztahují na identifikátory heredoc, se vztahují také na nowdoc, zejména ty, které se vztahují na uzavírací identifikátor.

Příklad #7 Příklad použití nowdoc

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

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

Příklad textu zahrnujícího více řádků pomocí syntaxe nowdoc. Zpětná lomítka jsou vždy zpracována doslovně, 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 ;

Function__construct()
{
$this -> foo = "Foo" ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$foo = new foo();
$jméno = "Jméno" ;

echo<<<"EOT"
Mé jméno je "$name". Tisknu $foo->foo.
Nyní tisknu ($foo->bar).
To by nemělo vypsat velké "A": \x41
EOT;
?>

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

Mé jméno je "$name". Tisknu $foo->foo. Nyní tisknu ($foo->bar). To by nemělo vypsat 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.

Manipulace s proměnnými

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 zadat konec názvu, uzavřete název proměnné do složených závorek.

$džus = "jablko" ;

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

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

// Správně. Konec názvu proměnné je striktně označen pomocí hranatých závorek:
echo "Vypil nějaký džus vyrobený z $( džusu ) s." ;
?>

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

Vypil trochu jablečného džusu. Vypil trochu šťávy z . Vypil trochu jablečného džusu.

Prvek 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" );
$juices = array("jablko" , "oranžová" , "koolaid1" => "fialová" );

echo "Vypil nějaké $džusy [ 0 ] džusu." . 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 = "Jan Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Veřejné $kovář = "Kovář" ;
}

$people = noví lidé();

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

Výsledek spuštění 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.

PHP 7.1.0 přidána podpora negativníčíselné indexy.

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

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

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

Znak s indexem -2 je roven 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

Nazývá se složitým 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 v řetězci pomocí této syntaxe. Stačí napsat výraz stejným způsobem jako mimo řádek a poté jej zabalit { A } . Protože { nelze escapovat, tato syntaxe bude rozpoznána pouze tehdy $ následuje přímo { . Použití {\$ vytisknout {$ . Několik názorných příkladů:

// Zobrazit všechny chyby
error_reporting(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ý ) " ;

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

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

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

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

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

// Funguje.
echo "Funguje to: ". $arr [ "foo" ][ 3 ];

echo "Tohle taky funguje:( $obj -> hodnoty ​​[ 3 ]-> jméno ) ";

echo "Toto je hodnota pojmenované proměnné$jméno : ($( $jméno)) ";

echo "Toto je hodnota proměnné pojmenované tak, jak je vrácena funkcí getName():($( getName ())) ";

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

// Nefunguje, výstupy: GetName() vrací toto: (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 = new foo();
$bar = "bar" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>

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

Jsem bar. Jsem bar.

Komentář:

Funkce, volání metod, statické proměnné třídy a konstanty třídy fungují interně {$} , počínaje PHP 5. Zadaná hodnota však bude považována za název proměnné ve stejném kontextu jako řádek, 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
error_reporting(E_ALL);

třídní piva (
const softdrink = "kořenové pivo" ;
public static $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" ;

// I to funguje, výstupy: Chtěl bych Alexandra Keitha
echo "Chtěl bych ($( piva :: $ale )) \n" ;
?>

Přístup a změna znaku v řetězci

Znaky v řetězcích lze použít a upravit zadáním jejich posunutí od začátku řetězce, počínaje nulou, v hranatých závorkách za řetězcem, například $str . Představte si řetězec pro tento účel 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. Určují odsazení od konce řádku. Dříve záporné offsety způsobovaly chybu úrovně E_NOTICE při čtení (vrácení prázdného řetězce) nebo E_VAROVÁNÍ při psaní (ponechání řádku beze změny).

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

Pozornost

Pokus o zápis do posunu za hranicemi řádku vyplní řetězec mezerami až do tohoto posunu. Neceločíselné typy budou převedeny na celočíselné typy. 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 nulový bajt (NULL).

Pozornost

Řetězce v PHP jsou interně pole bajtů. V důsledku toho není přístup nebo úprava řetězce s posunem bezpečné pro vícebajtové kódování a mělo by být prováděno pouze s řetězci v jednobajtových kódováních, jako je ISO-8859-1.

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

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

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

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

// Získání posledního znaku řetězce
$str = "Toto je stále test." ;
$poslední = $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 jako celé číslo nebo řetězec obsahující číslice, jinak bude vydáno varování. Dříve offset daný řetězcem jako "foo", bez varování byl přeměněn 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:

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

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

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

Komentář:

Pokus o přístup k proměnným jiných typů (kromě polí nebo objektů, které implementují určitá rozhraní) pomocí nebo {} se tiše vrátí 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í funkcí regulárních výrazů kompatibilních s Perl.

Převést 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 vyžadován řetězec, proběhne převod automaticky. K tomu dochází, když používáte funkce echo nebo tisk, nebo když je hodnota proměnné porovnána s řetězcem. Přečtením sekcí Typy a Manipulace s typy v příručce 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 jeden prvek, 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 typu "Objekt" v typu tětiva Používá se magická metoda __toString.

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

Jak můžete vidět výše, přímý převod polí, objektů nebo zdrojů na řetězec 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é úložiště. 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čí následovně.

Pokud řetězec neobsahuje žádný ze znaků ".", "e" nebo "E" a hodnota čísla spadá do 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 řádek 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 je plovoucí (11.5)
$foo = 1 + "-1,3e3" ; // $foo je plovoucí (-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 je plovoucí (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 najdete v části o 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 ; napište: " . 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 zpět, použijte funkce ord() A chr().

Podrobnosti implementace typu řetězce

před 7 lety

Dokumentace to nezmiňuje, ale závěrečný 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ávrat string(17) "Test pole řetězců"

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

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

var_dump((pole) $a);
// Návrat string(17) "S"

Norihiori

před 15 lety

Pomocí složité syntaxe můžete do řetězce vložit hodnotu obou vlastností objektu A metod objektu. Například...
třídní test(
veřejné $jedna = 1 ;
veřejná funkce dvě() (
návrat 2;
}
}
$test = new 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::ONE) 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 by mohlo být obrovské 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"; //vytiskne "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) ( return $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žívání
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=array(
"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 hodnot - 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 $comment:

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

Pomocí tohoto zobrazíte všechny stejné barvy:

$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 k datům ;)

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(true)
var_dump("1-22-00" > "01-23-00" ); //bool(true)
var_dump((plovák)"1.22.00" > (plovoucí)"01.23.00" ); //bool(false)
?>

Řetězce v PHP jsou obklopeny jednoduchými nebo dvojitými uvozovkami. Hlavní rozdíl je v tom, že proměnnou můžete vložit do dvojitých uvozovek:

Nyní můžeme přijít s dalším řešením problému z lekce Proměnné v PHP:

$title"; echo"

"; ?>

Jak PHP najde proměnnou v řetězci?

Je to jednoduché. Pamatujete si, jaké znaky lze použít v názvu proměnné? Jsou to čísla, písmena a podtržítka _.

PHP tedy bere jako název vše, co je mezi symbolem $ a prvním zakázaným znakem.

V následujícím kódu PHP nesprávně určí název proměnné a vyvolá chybu:

Výsledek v prohlížeči:

Upozornění: Nedefinovaná proměnná: pricerub v D:\OpenServer\domains\site\index.php na řádku 3

Aby PHP správně určilo název proměnné v řetězci, musíte ji umístit do složených závorek () :

Výsledek v prohlížeči:

1499 rublů.

Neexistuje jasný konsensus o tom, které uvozovky by se měly používat pro běžné řetězce, ve kterých není třeba nic nahrazovat. Mnoho programátorů však dává přednost používání jednoduchých uvozovek.

Faktem je, že u mnoha lidí dvojité uvozovky evokují asociaci „do tohoto řádku se musí něco vložit“. Proto doporučuji používat jednoduché uvozovky pro běžný text a dvojité pouze v případě, že potřebujete do textu dosadit proměnnou. Příklad:

Únikové uvozovky

Pokud potřebujete vložit uvozovky do řetězce, existují 2 způsoby, jak to udělat:

Ve druhém příkladu zpětné lomítko \ uniká z následující uvozovky, takže s ním PHP zachází jako s řetězcem.

Co je podle vás potřeba udělat, aby se na obrazovce zobrazovala pouze zpětná lomítka? Koneckonců to unikne závěrečné citaci. Je to legrační, ale musíte napsat druhé lomítko, abyste unikli prvnímu:

Tabulky a zalomení řádků v uvozovkách

Zpětné lomítko ve dvojitých uvozovkách umožňuje uniknout nejen uvozovkám a sobě, ale také některým dalším znakům. Nejoblíbenější z nich jsou tabulátor (dlouhá mezera, kterou získáte, když stisknete klávesu TAB) a zalomení řádku. Vypadají takto:

Napište skript, který:
1. Vytvoří proměnnou $type s hodnotou Game.
2. Vytvoří proměnnou $name s hodnotou "World of Warcraft" (s uvozovkami).
3. Zobrazí obě proměnné uvnitř tagu

. Mezi proměnnými musí být mezera.

Jsem zastáncem krásného a optimalizovaného kódu, i když ne vždy dokážu při programování dodržovat všechna pravidla „dobré formy“.

Nyní si povíme něco o správném používání dvojitých a jednoduchých uvozovek v PHP. Než jsem začal psát příspěvek, rychle jsem prohledal knihy, které jsem měl na php, a kupodivu jsem v žádné z nich neviděl správné použití uvozovek. Proč je mi záhadou. Není nejmenší možnost obvinit autory z amatérismu, knihy zdaleka nejsou pro figuríny. Možná na to jen nechtěli soustředit pozornost, říkají, kdo to potřebuje, přijde na to sám.

Uvozovky, což je logické, mohou být jednoduché nebo dvojité. Rozdíl v jejich použití v PHP je následující. Interpret php vypíše řetězec uzavřený v jednoduchých uvozovkách tak, jak je, ale analyzuje řetězec uzavřený v uvozovkách na přítomnost proměnných v něm a poté, co je najde, nahradí jejich hodnoty.

Pokud tedy potřebujeme zobrazit text „tak, jak je“, používáme jednoduché uvozovky. Pokud potřebujete místo proměnné dosadit její hodnotu, použijte dvojité jedničky (pokud je proměnná pouze jedna, můžete uvozovky úplně vynechat). Často můžete vidět kód takto:

Zobrazí se pouze text. Ale v kódu je z nějakého neznámého důvodu uzavřen do dvojitých uvozovek, což nutí interpreta, aby jej analyzoval na přítomnost proměnných. Je správné uzavřít text do jednoduchých uvozovek.

Uvažujme o triviálním úkolu zobrazení proměnné jako součásti textu, včetně použití html kódu.

$datum"; ?>

Vše je zobrazeno dobře, text a datum jsou zvýrazněny tučně, které je nahrazeno místo proměnné. Musíte si ale pamatovat dvě věci. Za prvé, toto je vlastnost interpretru: zřetězení řetězců je mnohem rychlejší a vyžaduje méně prostředků než analýza řetězců. A za druhé, nezapomeňte na programovací paradigma „rozděl a panuj“. Není potřeba míchat vše do jednoho, mnohem správnější by bylo rozdělit text na dvě části – ty, které vyžadují a ty, které nevyžadují analýzu interpretem. Takže výše uvedený příklad by měl být napsán takto:

".$date.""; ?>

Toto pravidlo samozřejmě musíte dodržovat (vše, co nevyžaduje analýzu, uzavřít do jednoduchých uvozovek) nejen při zobrazování textu, ale také při přiřazování hodnot řetězcovým proměnným:

Nebo například při použití řetězců při předávání argumentů funkce:

A i když na moderních počítačích bude zisk v čase pro interpretaci kódu v závislosti na použití jednoduchých nebo dvojitých uvozovek prakticky nepozorovatelný, zejména v malých skriptech, stále stojí za to, abyste si od začátku zvykli psát kompetentní kód, je to mnohem jednodušší než znovu se to naučit později.

Hodnoty typu string jsou textové řetězce (zkráceně řetězce). Řetězec je posloupnost nula nebo více znaků. Znaky zahrnují písmena, čísla, interpunkci, speciální znaky a mezery.

Řetězec lze definovat čtyřmi různými způsoby:

• dvojité uvozovky
• jednoduché uvozovky
• syntaxe heredocu
• syntaxe nowdoc

Řetězec ve dvojitých uvozovkách

Řetězec ve dvojitých uvozovkách:

V řetězcích s dvojitými uvozovkami můžete použít sekvence escape. Kontrolní sekvence— jedná se o speciální znaky určené k formátování textového výstupu. V PHP jsou k dispozici následující sekvence escape:

Hlavní vlastností řetězců s dvojitými uvozovkami je schopnost zpracovávat proměnné v řetězcích.

Znak dolaru: \$";

Řetězce uzavřené ve dvojitých uvozovkách mohou obsahovat jednoduché uvozovky:

Echo "Jedna citace: "";

Řetězec v jednoduchých uvozovkách (apostrofy)

Řetězec v jednoduchých uvozovkách:

$str = "Řetězec"; echo "Jeden velký řádek lze rozdělit na několik malých řádků, aby se lépe četl.";

Na rozdíl od řetězců s dvojitými uvozovkami a syntaxe heredoc se proměnné a řídicí sekvence (s jednou výjimkou) uzavřené v jednoduchých uvozovkách nezpracovávají. To znamená, že budou interpretovány jako normální řetězcové znaky:

$num = 10; echo "Číslo: $num
Znak dolaru: \$";

Abyste mohli používat jednoduché uvozovky v řetězci uzavřeném do jednoduchých uvozovek, musíte je ukončit pomocí zpětného lomítka (\“). Pokud potřebujete napsat zpětné lomítko samotné, musíte ho duplikovat (\\):

Echo "Uvnitř použijte \"jednoduché\" uvozovky"; echo "Zpětné lomítko: \\";

Řetězce uzavřené v jednoduchých uvozovkách mohou obsahovat znaky dvojitých uvozovek:

Echo "Dvojitá citace: "";

Syntaxe heredoc

Syntaxe Heredoc je alternativní způsob zápisu řetězců.

Řetězec definovaný pomocí syntaxe Heredoc funguje stejně jako řetězec uzavřený v uvozovkách. Rozdíl mezi Heredocem a řetězcem s dvojitými uvozovkami je v tom, že u Heredocu není potřeba dvojité uvozovky uvozovat.

Syntaxe Heredoc začíná třemi znaky<<< , после которых должен быть указан произвольный идентификатор (назовём его открывающим). Идентификатор может быть указан как в двойных кавычках, так и без них. Okamžitě za identifikátorem musí následovat nový řádek, za identifikátorem by neměly být jiné znaky než nový řádek, jinak dojde k chybě. Následuje samotný obsah řetězce. Po obsahu řetězce musí být na samostatném řádku uveden koncový identifikátor (stejný jako po<<<). Перед ним и после него не должно быть никаких пробелов или других символов, за исключением точки с запятой. Если это правило нарушено, то считается, что закрывающий идентификатор отсутствует и будет вызвана ошибка:

<<

Syntaxe Nowdoc

Syntaxe Nowdoc, stejně jako Heredoc, je alternativní způsob zápisu řetězců.

Řetězec definovaný pomocí syntaxe Nowdoc funguje stejně jako řetězec uzavřený v jednoduchých uvozovkách. Rozdíl mezi Nowdoc a řetězcem v jednoduchých uvozovkách je v tom, že u Nowdoc není nutné uvozovat jednoduché uvozovky.

Syntaxe Nowdoc je podobná jako u Heredoc, pouze s tím rozdílem, že počáteční identifikátor musí být uzavřen v jednoduchých uvozovkách:

$num = 10; echo<<<"some_id" Число: $num some_id;

Manipulace s proměnnými v řetězcích

Existují dva typy syntaxe pro práci s proměnnými v řetězcích: jednoduchý A obtížný.

Jednoduchá syntaxe- tehdy je název proměnné uveden v řádku tak, jak je.

Když interpret narazí na znak dolaru, začne postupně kontrolovat, zda jsou všechny následující znaky platnými znaky v názvu proměnné. Aby tedy vytvořil platný název proměnné, zachytí co nejvíce znaků:

$str = "Svět!"; echo "Ahoj $str";

Složitá syntaxe- v tomto případě je název proměnné uzavřen ve složených závorkách.

Vzhledem k tomu, že pro zpracování proměnné v řádku interpret zachytí co nejvíce znaků, existují situace, kdy interpret není schopen nezávisle určit, kde končí název proměnné:

$sport1 = "vůle"; $sport2 = "noha"; echo "Mám rád $sport1ball a $sport2ball";

V tomto případě nebude dosaženo požadovaného výsledku, protože interpret bude považovat $sport1 za součást proměnné s názvem $sport1bol, která neexistuje.

Chcete-li interpretu explicitně sdělit, kde končí název proměnné, musíte název proměnné uzavřít do složených závorek:

$sport1 = "vůle"; $sport2 = "noha"; echo "Mám rád ($sport1)bol a ($sport2)bol.";

Znak dolaru lze umístit před nebo za složenou závorku:

$sport1 = "vůle"; $sport2 = "noha"; echo "Líbí se mi $(sport1)bol a ($sport2)bol.";

Zřetězení

Zřetězení je spojení dvou nebo více řetězců do jednoho většího řetězce. Ke zřetězení dochází pomocí operátoru zřetězení - . (tečka). Při zřetězení se každý následující řádek přidá na konec předchozího:

Hodnota libovolného typu, která je zřetězena s řetězcem, bude implicitně převedena na řetězec a poté zřetězena:

"; echo "Číslo: " . 1; ?>

Tento krátký článek ukazuje, jak a kde používat uvozovky v PHP.

Jednoduché uvozovky (apostrofy) v PHP

Řetězce uzavřené v jednoduchých uvozovkách PHP žádným způsobem nezpracovává. To znamená, že jednoduché uvozovky představují text uzavřený mezi nimi tak, jak je.

// Správné echo "Jak jde život?"; echo "Jak jde život? $jméno"; echo "Jak jde život?".$name; // Nesprávné echo "Jak se máš? $name";

Speciální znaky v jednoduchých a dvojitých uvozovkách

Chcete-li zajistit, že například znak tabulátoru (\t) bude interpretován jako znak tabulátoru a nikoli jako lomítko a písmeno t, musíte řádek textu obsahující znak tabulátoru uzavřít do dvojitých uvozovek. \' a \\ můžete použít pouze v jednoduchých uvozovkách. Všechny ostatní sekvence escape (\n, \r, \$ atd.) nejsou v jednoduchých uvozovkách povoleny.

// Nesprávné echo "Jak se máš?\n"; // Správné echo "Jak jde život?\n";

Chcete-li v řetězci ukončit dvojité uvozovky, umístěte je před zpětné lomítko \" .

// Nesprávná ozvěna "

Co se děje?

"; // Správná ozvěna"

Co se děje?

"; echo"

Co se děje?

";

Dvojité uvozovky v PHP

S textem uzavřeným v uvozovkách se zachází velmi odlišně. Například proměnné uzavřené v uvozovkách jsou nahrazeny svými hodnotami. To usnadňuje psaní SQL dotazů pomocí dvojitých uvozovek.

$dotaz = "INSERT INTO tabulky (příspěvek,autor,text,datum) VALUES ("$id","$autor","$text","$datum"");