Php променливи във фигурни скоби. Концепцията за операторни скоби

Коментирайте: В PHP 7.0.0 на 64-битови платформи няма постижими ограничения за дължина на реда на 32-битови системи, а в по-ранните версии на PHP редовете не могат да бъдат по-големи от 2 GB (2147483647 байта).

Синтаксис

Един низ може да бъде дефиниран по четири различни начина:

• единични кавички
• двойни кавички
• синтаксис на nowdoc (от PHP 5.3.0)

Единични кавички

Най-лесният начин да дефинирате низ е да го поставите в единични кавички (символът " ).

За да използвате единична кавичка в низ, екранирайте я с обратна наклонена черта ( \ ). Ако трябва да напишете самата обратна наклонена черта, дублирайте я ( \\ ). Всички други употреби на обратната наклонена черта ще се интерпретират като нормални знаци: това означава, че ако се опитате да използвате други екраниращи последователности, като напр. \rили \n, те ще бъдат изведени такива, каквито са, вместо някакво специално поведение.

ехо "това е прост низ";

ехо „Можете също да вмъкнете в редове
знак за нов ред като този,
това е добре";

// Резултати: Арнолд веднъж каза: „Ще се върна“
ехо „Един ден Арнолд каза: „Ще се върна“.;

Ехо „Изтрихте ли C:\\*.*?“;

// Изходи: Изтрихте ли C:\*.*?
echo "Изтрихте ли C:\*.*?" ;

// Изходи: Това няма да бъде разширено: \n нов ред
ехо "Това няма да бъде разширено: \n нов ред";

// Резултати: променливите $expand и $either не се разширяват
ехо "Променливите $expand и $either не се разширяват";
?>

Двойни кавички

Ако низът е ограден в двойни кавички ("), PHP разпознава следните екраниращи последователности със специални знаци:

Ескейп последователности

Последователност	Значение
\n	нов ред (LF или 0x0A (10) в ASCII)
\r	връщане на каретка (CR или 0x0D (13) в ASCII)
\t	хоризонтален раздел (HT или 0x09 (9) в ASCII)
\v	вертикален раздел (VT или 0x0B (11) в ASCII) (от PHP 5.2.5)
\e	екраниращ знак (ESC или 0x1B (27) в ASCII) (от PHP 5.4.4)
\f	страница емисия (FF или 0x0C(12) в ASCII) (от PHP 5.2.5)
\\	обратна наклонена черта
\$	знак за долар
\"	двойни кавички
\{1,3}	поредица от знаци, съответстваща на регулярен израз на осмичен знак, който безшумно препълва, за да се побере в байт (т.е. "\400" === "\000")
\x(1,2)	последователност от знаци, съответстваща на регулярния израз на знак в шестнадесетичен запис
\u(+)	поредица от знаци, съответстваща на регулярен израз на Unicode знак, който се преобразува в низ в UTF-8 представяне (добавено в PHP 7.0.0)

Както при низ, затворен в единични кавички, екранирането на който и да е знак също ще изведе самия символ за екраниране. Преди PHP 5.1.1, обратна наклонена черта \($var)не беше публикувано.

Heredoc

Третият начин за дефиниране на низове е да използвате синтаксиса на heredoc: <<< . След този оператор трябва да зададете идентификатор, след това подаване на ред. След това идва самият ред и след това същият идентификатор, затваряйки вмъкването.

Линия трябвазапочнете със затварящ идентификатор, т.е. трябва да се появи в първата колона на реда. Освен това идентификаторът трябва да следва същите правила за именуване като всички други тагове в PHP: да съдържа само буквено-цифрови знаци и долна черта и не трябва да започва с число (долната черта е разрешена).

внимание

Много е важно да се отбележи, че затварящият идентификаторен ред не трябва да съдържа други знаци освен точка и запетая ( ; ). Това означава, че ид не трябва да има отстъпи че не може да има интервали или раздели преди или след точка и запетая. Също така е важно да разберете, че първият знак преди затварящия идентификатор трябва да бъде знак за нов ред, както е дефинирано от вашата операционна система. Например, на UNIX системи, включително macOS, това е \n. Нов ред също трябва да започва веднага след затварящия идентификатор.

Ако това правило е нарушено и затварящият идентификатор не е "чист", затварящият идентификатор се счита за липсващ и PHP ще продължи да го търси допълнително. Ако в този случай правилният затварящ идентификатор никога не бъде намерен, това ще доведе до грешка при анализиране с номера на реда в края на скрипта.

Пример #1 Пример за неправилен синтаксис

клас foo(
публичен $bar =<<бар
EOT;
// отстъпът преди затварящия идентификатор не е разрешен
}
?>

Пример #2 Пример за правилен синтаксис

клас foo(
публичен $bar =<<бар
EOT;
}
?>

Heredoc не може да се използва за инициализиране на полета на клас.

Текстът на Heredoc се държи по същия начин като низ в двойни кавички, без да ги има.

Това означава, че не е нужно да избягвате кавички в heredoc, но все пак можете да използвате екраниращите последователности по-горе.

Променливите се обработват, но трябва да сте толкова внимателни, когато използвате сложни променливи в heredoc, както когато работите с низове.<<Пример #3 Пример за дефиниране на низ в Heredoc
$str =
Примерен ред,
обхващащ няколко реда,

използвайки синтаксиса на heredoc.
{
EOD;
Клас foo

var $foo;
{
var $bar;
Функция__construct()
}
}

$this -> foo = "Foo" ;
$това ->

$foo = нов foo();<<$name = "Име" ; .
ехоКазвам се "$name". Пиша $foo -> foo .
Сега правя изводи
EOT;
?>

($foo -> лента [1])

Това трябва да изведе главната буква "A": \x41

Казвам се "Име". Пиша Фу. Сега извеждам Bar2. Това трябва да изведе главна буква "A": A

Също така е възможно да се използва синтаксис на heredoc за предаване на данни през аргументи на функцията:

От версия 5.3.0 стана възможно да се инициализират статични променливи и свойства/константи на класове с помощта на синтаксиса на heredoc:
Пример #5 Използване на heredoc за инициализиране на статични променливи
{
// Статични променливи<<функция foo()
статичен $bar =
}

Тук няма нищо...
ЕТИКЕТ;
{
// Константи/свойства на клас<<клас foo
const BAR =

Пример за използване на константа<<FOOBAR;
const BAR =
}
?>

Обществен $baz =

Пример за използване на поле

От PHP 5.3.0 можете също да оградите идентификатора на Heredoc с двойни кавички: Nowdoc Nowdoc е същото за низове в единични кавички, както heredoc е за низове в двойни кавички. Nowdoc е подобен на heredoc, но вътре в него не се правят замени

. Този дизайн е идеален за вграждане на PHP код или други големи текстови блокове, без да се налага да го екранирате. В това той е малко подобен на конструкцията SGML <<< чрез деклариране на блок от текст, който не е предназначен да бъде обработен. <<<"EOT" Nowdoc се обозначава със същата последователност

, който се използва в heredoc, но следният идентификатор е ограден в единични кавички, например,

$foo = нов foo();<<<"EOD"
.
Всички условия, които се прилагат за идентификаторите на heredoc, се отнасят и за nowdoc, особено тези, които се прилагат за затварящия идентификатор.
Пример #7 Пример за използване на nowdoc
Примерен текст,
обхващащ няколко реда

използвайки синтаксиса на nowdoc. Обратно наклонените черти винаги се третират буквално,

Пример за текст, обхващащ няколко реда, използващ синтаксис на nowdoc. Обратните наклонени черти винаги се третират буквално, като \\ и \".

Пример #8 Пример за цитиране на низ в Nowdoc с променливи

/* По-сложен пример с променливи. */
ЕТИКЕТ;
{
публичен $foo;
публичен $bar;

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

$this -> foo = "Foo" ;
$това ->

$foo = нов foo();<<<"EOT"
Казвам се "$name". Отпечатвам $foo->foo.
Сега отпечатвам ($foo->bar).
Това не трябва да извежда главно "А": \x41
EOT;
?>

използвайки синтаксиса на nowdoc. Обратно наклонените черти винаги се третират буквално,

Казвам се "$name". Отпечатвам $foo->foo. Сега отпечатвам ($foo->bar). Това не трябва да извежда главно "А": \x41

Пример #9 Пример за използване на статични данни

клас foo(
публичен $bar =<<<"EOT"
бар
EOT;
}
?>

Коментирайте:

Поддръжката на nowdoc беше добавена в PHP 5.3.0.

Обработка на променливи

Ако даден низ е посочен в двойни кавички или използвайки heredoc, променливите в него се обработват.

Има два вида синтаксис: прост и сложен. Простият синтаксис е по-лесен и удобен. Това прави възможно обработката на променлива, стойност на масив (масив ) или свойства на обект (обект

) с минимални усилия.

Сложният синтаксис може да бъде идентифициран от фигурните скоби около израза.

Прост синтаксис $ Ако преводачът срещне знак за долар (

), той улавя възможно най-много знаци, за да формира валидно име на променлива. Ако искате да укажете края на име, оградете името на променливата във фигурни скоби.

$juice = "ябълка";

echo "Той изпи малко $juice сок." . PHP_EOL ;
// Неправилно. "s" е валиден знак за име на променлива, но променливата се казва $juice.

echo "Той изпи малко сок, направен от $сокове." ;
// Правилно. Краят на името на променливата е строго посочен с помощта на скоби:
?>

използвайки синтаксиса на nowdoc. Обратно наклонените черти винаги се третират буквално,

echo "Той изпи малко сок, направен от $(сок) s." ;

Той изпи малко ябълков сок. Той изпи малко сок от. Той изпи сок от ябълки. Простият синтаксис е по-лесен и удобен. Това прави възможно обработката на променлива, стойност на масив (Елемент от масив ( ) или свойства на обект () или свойство на обект ( ] ). В индексите на масива има затваряща квадратна скоба (

) маркира края на дефиницията на индекса. За свойствата на обекта важат същите правила, както и за простите променливи.

Пример #10 Пример за прост синтаксис
дефинирай ("KOOLAID", "koolaid1");

$juices = array("apple" , "orange" , "koolaid1" => "purple" );
echo "Той изпи малко $juices [ 0 ] сок." . PHP_EOL ;
echo "Той изпи малко $juices [ 1 ] сок." . PHP_EOL ;

echo "Той изпи малко $juices [ koolaid1 ] сок." . PHP_EOL ;
класни хора (
public $john = "Джон Смит";
public $jane = "Джейн Смит";

public $robert = "Робърт Полсън";
}

Public $smith = "Смит" ;

echo "$people -> john изпи малко $juices [ 0 ] сок." . PHP_EOL ;
echo " $people -> john тогава каза здравей на $people -> jane." . PHP_EOL ;
echo "$people -> съпругата на Джон "поздрави $people -> Робърт." . PHP_EOL;
echo " $people -> robert поздрави двамата $people -> smiths." ; // Няма да работи
?>

използвайки синтаксиса на nowdoc. Обратно наклонените черти винаги се третират буквално,

Той изпи малко ябълков сок. Той изпи малко портокалов сок. Той изпи малко лилав сок. Джон Смит изпи малко ябълков сок. Тогава Джон Смит поздрави Джейн Смит. Съпругата на Джон Смит поздрави Робърт Полсен.

PHP 7.1.0 добави поддръжка отрицателенчислови индекси.

Пример #11 Отрицателни числови индекси

$string = "низ";
ехо „Символът при индекс -2 е равен на$низ [- 2]." , PHP_EOL;
$низ [- 3] = "o";
ехо „Промяната на знака в позиция -3 на „o“ води до следния ред:$низ." , PHP_EOL;
?>

използвайки синтаксиса на nowdoc. Обратно наклонените черти винаги се третират буквално,

Символът с индекс -2 е равен на n. Промяната на знака в позиция -3 на "o" дава следния ред: силен

За нещо по-сложно използвайте сложен синтаксис.

Сложен (къдрав) синтаксис

Нарича се сложен не защото е труден за разбиране, а защото позволява използването на сложни изрази.

Всяка скаларна променлива, елемент на масив или свойство на обект, съпоставено към низ, може да бъде представено в низ с помощта на този синтаксис. Просто напишете израза по същия начин, както бихте го направили извън реда, и след това го обвийте { И } . защото { не може да бъде екраниран, този синтаксис ще бъде разпознат само когато $ следва директно { . Използвайте {\$ за печат {$ .

Няколко илюстративни примера:
// Показване на всички грешки

съобщаване на грешка (E_ALL);

$great = "страхотно";
// Не работи, извежда: Това е (страхотно)

echo "Това е ($велико)" ;
// Работи, извежда: Това е страхотно

echo "Това е ($велико) ";
ехо // Работи„Този ​​площад е широк

($square -> width) 00 сантиметра." ;
// Работи, цитираните ключови думи работят само със синтаксиса на фигурни скоби

echo "Това е ($велико) ";
echo "Това работи: ( $arr [ "ключ" ]) " ;

echo "Това работи: ( $arr [ 4 ][ 3 ]) " ;
// Това е невалидно по същата причина като $foo извън
// линии. С други думи, все още ще работи,
// но тъй като PHP първо търси константата foo, това ще причини
ехо // ниво на грешка E_NOTICE (недефинирана константа).„Това е грешно:

( $arr [ foo ][ 3 ]) " ;
// Работи. Когато използвате вътрешно многомерни масиви
// редовете винаги използват фигурни скоби

echo "Това работи: ( $arr [ "foo" ][ 3 ]) " ;
// Работи.

ехо echo "Това работи: ". $arr [ "foo" ][ 3 ];($obj -> values ​​[3]-> име) ";

ехо „Това е стойността на променливата с име$name : ($( $name )) " ;

ехо „Това е стойността на променливата, наречена така, както е върната от функцията getName():($( getName ())) " ;

ехо „Това е стойността на променливата по име, която \$object->getName() връща:($( $object -> getName ())) " ;

// Не работи, извежда: Ето какво връща getName(): (getName())
ехо „Ето какво връща getName(): (getName())“;
?>

Също така е възможно да се осъществи достъп до свойства на обекти в низове, като се използва този синтаксис.

клас foo(
var $bar = "Аз съм бар." ;
}

$this -> foo = "Foo" ;
$bar = "бар";
$baz = array("foo" , "bar" , "baz" , "quux" );
ехо "( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>

използвайки синтаксиса на nowdoc. Обратно наклонените черти винаги се третират буквално,

Аз съм бар. Аз съм бар.

Коментирайте:

Функциите, извикванията на методи, статичните променливи на класа и константите на класа работят вътрешно {$} , започвайки с PHP 5. Предоставената стойност обаче ще се третира като име на променлива в същия контекст като реда, в който е дефинирана. Използване на единични къдрави скоби ( {} ) няма да работи за достъп до стойностите на функции, методи, константи на клас или статични променливи на клас.

Няколко илюстративни примера:
// Показване на всички грешки

класни бири (
const softdrink = "rootbeer" ;
public static $ale = "ipa";
}

$rootbeer = "A & W" ;
$ipa = "Александър Кийт" ;

// Това работи, извежда: Бих искал A & W
echo "Бих искал ($( бири :: безалкохолни напитки )) \n" ;

// Това също работи, извежда: Бих искал Александър Кийт
echo "Бих искал ($( бира :: $ейл)) \n" ;
?>

Достъп и промяна на знак в низ

Символите в низовете могат да се използват и модифицират чрез указване на отместването им от началото на низа, започвайки от нула, в квадратни скоби след низа, например $str. Мислете за низ за тази цел като масив от знаци.И Ако трябва да получите или замените повече от 1 символ, можете да използвате функциите.

Коментирайте: substr() substr_replace()От PHP 7.1.0 се поддържат отрицателни стойности на отместване. Те определят отместването от края на реда. Преди това отрицателните отмествания причиняваха грешка в нивото E_NOTICE

Коментирайте: при четене (връщане на празен низ) или

внимание

E_ПРЕДУПРЕЖДЕНИЕ Те определят отместването от края на реда. Преди това отрицателните отмествания причиняваха грешка в нивото.

внимание

Използва се само първият знак от присвоения низ.

Коментирайте: От PHP 7.1.0 присвояването на празен низ ще доведе до фатална грешка. Преди това в този случай беше присвоен нулев байт (NULL).

Низовете в PHP са вътрешни масиви от байтове. В резултат на това достъпът или модифицирането на низ с отместване не е безопасно за многобайтово кодиране и трябва да се извършва само с низове в еднобайтово кодиране, като ISO-8859-1.

От PHP 7.1.0 използването на празен индекс причинява фатална грешка, преди в този случай низът беше преобразуван в масив без предупреждение.
Пример #12 Някои примерни низове
// Получаване на първия знак от низа

$str = "Това е тест." ;
$first = $str [0];

// Получаване на третия знак от низа
$трето = $str [ 2 ];
// Получаване на последния знак от низа

$str = "Това все още е тест." ;
$последен = $str [ strlen ($str ) - 1];
// Промяна на последния знак от реда

?>

$str = "Поглед към морето" ; $str [ strlen ($str )- 1 ] = "e";От PHP 5.4 отместването в низ трябва да бъде посочено като цяло число или низ, съдържащ цифри, в противен случай ще бъде издадено предупреждение. Предишно отместване, дадено от низ като 0 .

"фу"

, без предупреждение се трансформира в

Пример #13 Разлики между PHP 5.3 и 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" ]));

Резултатът от изпълнението на този пример в PHP 5.3:

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

Коментирайте:

Резултатът от изпълнението на този пример в PHP 5.4: string(1) "b" bool(true) Предупреждение: Незаконно отместване на низ "1.0" в /tmp/t.php на ред 7 string(1) "b" bool(false) Предупреждение: Незаконно отместване на низ "x" в / tmp/t.php на ред 9 string(1) "a" bool(false) string(1) "b" bool(false) {} Опит за достъп до променливи от други типове (с изключение на масиви или обекти, които имплементират определени интерфейси), използвайки или.

Коментирайте:

мълчаливо ще се върне NULL {} .

PHP 5.5 добави поддръжка за достъп до символи в низови литерали с помощта на синтаксиса

или

Има много полезни функции за модифициране на низове.

Основните функции са описани в раздела за низови функции, а за разширено търсене и замяна, Perl-съвместими функции за регулярен израз. Преобразуване в низСтойност може да бъде преобразувана в низ чрез преобразуване strval(). ехо string(1) "b" bool(true) Предупреждение: Незаконно отместване на низ "1.0" в /tmp/t.php на ред 7 string(1) "b" bool(false) Предупреждение: Незаконно отместване на низ "x" в / tmp/t.php на ред 9 string(1) "a" bool(false) string(1) "b" bool(false) В изрази, където се изисква низ, преобразуването става автоматично.Това се случва, когато използвате функции печат.

, или когато стойността на променлива се сравнява с низ. Четенето на разделите Типове и Манипулиране на типове в ръководството ще направи следното по-ясно. Вижте също settype()Масивите винаги се преобразуват в низ Простият синтаксис е по-лесен и удобен. Това прави възможно обработката на променлива, стойност на масив ("Масив" ехо NULL В изрази, където се изисква низ, преобразуването става автоматично., така че не можете да покажете съдържанието на масива ( ), използвайкиза да видите какво съдържа. За да видите един елемент, използвайте нещо като

ехо $arr["foo"] . Вижте по-долу за съвети как да показвате/преглеждате цялото съдържание.За да конвертирате променлива тип "обект"във вид

низ илиИзползва се магическият метод __toString.

Значение винаги се преобразува в празен низ.И Както можете да видите по-горе, директното конвертиране на масиви, обекти или ресурси в низ не предоставя полезна информация за самите стойности, освен техните типове..

По-добър начин за извеждане на стойности за отстраняване на грешки е използването на функции print_r().

var_dump()

Повечето стойности в PHP могат да бъдат преобразувани в низ за постоянно съхранение. Този метод се нарича сериализация и може да се направи с помощта на функцията

сериализирам () Преобразуване на низове в числаАко низът е разпознат като числова стойност, получената стойност и тип се определят, както следва. Ако низът не съдържа нито един от знаците ".", "e" или "E" и стойността на числото попада в границите на цели числа (дефинирани PHP_INT_MAX ), низът ще бъде разпознат като цяло число ().

цяло число

). Във всички останали случаи се счита за число с плаваща запетая (
плавам Стойността се определя от началото на низа. Ако редът започва с валидна числова стойност, тази стойност ще бъде използвана. В противен случай стойността ще бъде 0 (нула). Валидната цифрова стойност е една или повече цифри (които могат да съдържат десетична запетая), незадължително предшествани от знак, последван от незадължителна експонента. Показателят е "e" или "E", последвано от една или повече цифри.
$foo = 1 + "10,5" ;
// $foo е float (11.5)
$foo = 1 + "-1.3e3" ; // $foo е float (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo е цяло число (1) $foo = 1 + "bob3" ; // $foo е цяло число (1)
$foo = 1 + "10 малки прасета" ;
// $foo е цяло число (11)
?>

За повече информация относно това преобразуване вижте раздела за strtod(3) в документацията на Unix.

Ако искате да тествате някой от примерите в този раздел, копирайте и поставете него и следния ред, за да видите какво ще се случи:

echo "\$foo== $foo ; тип: " . gettype ($foo) . "
\n" ;
?>

Не очаквайте да получите кода на знак, като го преобразувате в цяло число (както се прави например в C). За да конвертирате знаци в техните ASCII кодове и обратно, използвайте функциите ord()И chr().

Подробности за внедряването на тип низ

преди 7 години

В документацията не се споменава, но затварящата точка и запетая в края на heredoc всъщност се интерпретира като истинска точка и запетая и като такава понякога води до синтактични грешки.

$foo =<<abcd
КРАЙ;
?>

Това не:

Фу(<<abcd
КРАЙ;
);
// синтактична грешка, неочаквано ";"
?>

Без точка и запетая работи добре:

Фу(<<abcd
КРАЙ
);
?>

преди 3 години

Можете да използвате низ като масив от char (като C)

$a = "Тест за масив от низове";

var_dump($a);
// Върнете низ (17) "Тест за масив от низове"

var_dump($a);
// Върнете низ (1) "S"

// -- С преобразуване на масив --
var_dump((масив) $a);
// Върнете array(1) ( => string(17) "Тест за масив от низове")

var_dump((масив) $a);
// Върнете низ (17) "S"

Норихиори

преди 1 година

Всеки отделен израз, колкото и сложен да е, който започва с $ (т.е. променлива), може да бъде ()-вграден в низ в двойни кавички:

Echo "Изразът ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 )) анализира се също толкова добре, колкото ". $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42) . "прави". ;

?>

преди 2 години

И двете трябва да работят :(

Тестване на класа (
public static $VAR = "статичен";
public const VAR = "const" ;

Публична функция sayHelloStatic() (
echo "здравей: ( $this :: $VAR ) " ;
}

Публична функция sayHelloConst() (
echo "здравей: ( $this ::VAR) " ; //Грешка при анализиране: синтактична грешка, неочаквано ")", очаква се "["
}
}

$obj = ново тестване();
$obj -> sayHelloStatic();
$obj -> sayHelloConst ();

преди 14 години

Можете да използвате сложния синтаксис, за да поставите стойността както на свойствата на обекта, така и на методите на обекта в низ. например...
класТест{
публичен$едно= 1 ;
обществена функциядве() {
връщане2 ;
}
}
$тест= новоТест();
ехо"фу{ $тест-> един} бар{ $тест-> две()} " ;
?>
Ще изведе "foo 1 bar 2".

Не можете обаче да направите това за всички стойности във вашето пространство от имена. Константите на класа и статичните свойства/методи няма да работят, защото сложният синтаксис търси "$".
класТест{
констЕДНО= 1 ;
}
ехо"foo (Test::ONE) бар";
?>
Това ще изведе "foo (Test::one) bar". Константите и статичните свойства изискват да разделите низа.

преди 6 години

Водещите нули в низове (най-малко изненада) не се третират като осмични.
Помислете за:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x е $x, y е $y"; //отпечатва "x е 123, y е 83"
с други думи:
* водещите нули в цифровите литерали в изходния код се интерпретират като "осмични", вж. strtol().
* водещи нули в низове (напр. подадени от потребителя данни), когато се преобразуват (имплицитно или изрично) в цяло число, се игнорират и се считат за десетични, c.f. strtod().

преди 3 години

Внимавайте, че е в съответствие с „Преобразуване на низове в числа“:

ако ("123abc"== 123 ) ехо"(intstr == int) неправилно тества като вярно.";

// Тъй като едната страна е число, низът се преобразува неправилно от intstr в int, което след това съвпада с тестовото число.

// Вярно за всички условни изрази като изрази if и switch (вероятно също цикли while)!

// Това може да бъде огромен риск за сигурността при тестване/използване/записване на въведени от потребителя данни, докато се очаква и тества само цяло число.

// Изглежда, че единствената корекция е 123 да бъде низ като "123", така че да не се извършва преобразуване.

?>

преди 10 години

Ето един лесен хак, за да позволите на низове в двойни кавички и heredocs да съдържат произволни изрази в синтаксиса на фигурни скоби, включително константи и други извиквания на функции:

// Декларация за хакване
функция_израз($v) (връщане$v; }
$_expr= "_expr";

// Нашата детска площадка
дефинирам("qwe", "asd");
дефинирам("zxc", 5 );

$a= 3 ;
$b= 4 ;

функция c($a, $b) (връщане$a+ $b; }

//Използване
ехо„пред{ $_expr(1 + 2 )} публикация\n"; // извежда "pre 3 post"
ехо„пред{ $_expr(qwe)} публикация\n"; // извежда "pre asd post"
ехо„пред{ $_expr(c($a, $b)+ zxc* 2 )} публикация\n"; // извежда "преди 17 пост"

// Общият синтаксис е ($_expr(...))
?>

преди 11 години

За да си запазите ума, не четете предишни коментари за дати ;)

Когато и двата низа могат да бъдат преобразувани в числа (в ("$a" > "$b") тест), тогава се използват получените числа, в противен случай ПЪЛНИТЕ низове се сравняват символ по знак:

var_dump("1.22" > "01.23" ); // bool(false)
var_dump("1.22.00" > "01.23.00" ); //bool(вярно)
var_dump("1-22-00" > "01-23-00" ); //bool(вярно)
var_dump((плаващ)"1.22.00" > (плаващ)"01.23.00" ); // bool(false)
?>

преди 2 години

Реших, че би било полезно да добавя този коментар, така че информацията да се показва поне на правилната страница на сайта на PHP.

Имайте предвид, че ако възнамерявате да използвате низ в двойни кавички с асоциативен ключ, може да попаднете на грешката T_ENCAPSED_AND_WHITESPACE. Някои смятат това за едно от по-малко очевидните съобщения за грешка.

Израз като:

$плод=масив(
"а"=> "ябълка",
"б"=> "банан",
// и т.н
);

Печат „Това е а$плод[ "а"]"; // T_ENCAPSED_AND_WHITESPACE
?>

определено ще се разпадне на парчета.

Можете да го разрешите по следния начин:

В изрази, където се изисква низ, преобразуването става автоматично.„Това е а$плод[ а] " ; // премахване на кавички от ключа
В изрази, където се изисква низ, преобразуването става автоматично.„Това е а${ плодове[ "а"]} " ; // Сложен синтаксис
В изрази, където се изисква низ, преобразуването става автоматично.„Това е а{ $плод[ "а"]} " ; // Вариант на сложния синтаксис
?>

Имам лични предпочитания към последния вариант, тъй като е по-естествен и по-близък до това, което би бил изразът извън низа.

Не е ясно (поне за мен) защо PHP тълкува погрешно единичните кавички вътре в израза, но си представям, че това има нещо общо с факта, че кавичките не са част от низа със стойности - щом низът вече е анализиран, кавичките просто пречи...?

$GLOBALS променлива. Асоциативен масив, съдържащ препратки към всички променливи на глобалния обхват на скрипта, дефинирани в момента. Имената на променливите са ключове за масиви.

За да декларирате глобална променлива, просто я поставете в масива $GLOBALS

$GLOBALS["testkey2"]="testvalue2";

Можете да покажете всички стойности на променливите на масива $GLOBALS, като използвате print_r($GLOBALS); или така:

Foreach ($GLOBALS като $key=>$value) ехо "GLOBALS[".$key."] == ".$value."
";

Променлива $_SERVER.

Променлива $_REQUEST- асоциативен масив (масив), който по подразбиране съдържа данните от променливите $_GET, $_POST и $_COOKIE. Променливите в масива $_REQUEST се предават на скрипта с помощта на методите GET, POST или COOKIE, така че не може да им се вярва, защото може да са били променени от отдалечен потребител. Тяхното присъствие и редът, в който данните се добавят към съответните масиви, се определя от директивата variables_order (GPCS е зададена по подразбиране).

Променлива $_SESSION

Променлива $_ENV. Попълва се, ако скриптът е стартиран от командния ред. Масивът $_SERVER ще съдържа всички променливи от масива $_ENV.

$http_response_header променлива

Прост синтаксис

Ако интерпретаторът срещне знак за долар ($), той хваща възможно най-много знаци, за да формира валидно име на променлива. Ако искате да укажете края на име, оградете името на променливата във фигурни скоби.

$beer = "Heineken" ;
echo "Вкусът на $бирата е страхотен" ; // работи, """ е невалиден знак за име на променлива
echo "Той изпи няколко бири" ; // не работи, "s" е валиден знак за име на променлива
echo "Той изпи малко $(бира)" ; // работи
echo "Той изпи малко ($бира)" ; // работи
?>

Елемент от масив ( Простият синтаксис е по-лесен и удобен. Това прави възможно обработката на променлива, стойност на масив () или свойство на обект ( ) или свойства на обект (). В индексите на масива има затваряща квадратна скоба ( ] ) маркира края на дефиницията на индекса. За свойствата на обекта важат същите правила, както за простите променливи, въпреки че те не могат да бъдат измамени, както е с променливите.

// Тези примери са специално за вътрешно използване на масиви
// линии. Извън низовете винаги ограждайте ключовете за низове на вашия
// масив в кавички и не използвайте външни низове (скоби).

// Да покажем всички грешки
// Показване на всички грешки

$fruits = array("strawberry" => "red" , "banana" => "yellow" );

// Работи, но имайте предвид, че извън цитирания низ работи по различен начин
ехо "Бананът е $плодове.";

//Работи
ехо "Бананът е ($fruits["banana"]).";

// Работи, но PHP, както е описано по-долу, търси първо
// постоянен банан.
ехо „Бананът е ($плодове).“;

// Не работи, използвайте фигурни скоби. Това ще доведе до грешка при обработката.
ехо "Бананът е $fruits ["банан"].";

echo "Това е ($велико) ";
echo "Бананът е " . $fruits [ "банан" ] . "." ;

echo "Това е ($велико) ";
ехо „Този ​​квадрат е $square->width метра широк.“;

// Не работи. Вижте сложен синтаксис за решение.
ехо „Този ​​квадрат е $square->width00 сантиметра широк.“;
?>

За по-сложни задачи можете да използвате сложен синтаксис.

Сложен (къдрав) синтаксис

Този синтаксис се нарича сложен не защото е труден за разбиране, а защото позволява използването на сложни изрази.

Всъщност можете да включите всяка стойност, която е в пространството от имена в ред с този синтаксис. Просто пишете израза по същия начин, както бихте го направили извън реда, и след това го ограждате в ( и ). Тъй като не можете да екранирате "(", този синтаксис ще бъде разпознат само когато $ следва непосредствено (. (Използвайте "(\$" или "\($", за да екранирате "($")). Някои илюстративни примери:

// Да покажем всички грешки
// Показване на всички грешки

$велико = "фантастично";

// Не работи, ще изведе: Това е (фантастично)
echo "Това е ($страхотно)" ;

// Работи, отпечатва: Това е фантастично
echo "Това е ($страхотно)" ;
echo "Това е $(страхотно)" ;

echo "Това е ($велико) ";
ехо „Този ​​квадрат е ($square->width)00 сантиметра широк.“;

echo "Това е ($велико) ";
ехо „Работи: ($arr)“;

// Това е невалидно по същата причина, поради която $foo е невалиден извън
// линии. С други думи, все още ще работи,
// но тъй като PHP първо търси константата foo, това ще причини
// ниво на грешка E_NOTICE (недефинирана константа).
ехо „Това е грешно: ($arr)“;

// Работи. При използване на многомерни масиви, вътре
// редовете винаги използват фигурни скоби
ехо "Това работи: ($arr["foo"])";

echo "Това работи: ( $arr [ "foo" ][ 3 ]) " ;
// Работи.

Ехо "Можете дори да пишете ($obj->values->name)";

Ехо "Това е стойността на променливата с име $name: ($($name))";
?>

Символите в низовете могат да се използват и модифицират чрез указване на отместването им от началото на низа, започвайки от нула, във фигурни скоби след низа. Ето няколко примера:

От PHP 7.1.0 използването на празен индекс причинява фатална грешка, преди в този случай низът беше преобразуван в масив без предупреждение.
$str = "Това е тест." ;
$first = $str (0);

$str = "Това е тест." ;
$трето = $str (2);

// Получаване на третия знак от низа
$str = — Все още е тест.;
$последен = $str ( strlen ($str ) - 1);

$str = "Това все още е тест." ;
$str = "Погледни към морето";
$str ( strlen ($str ) - 1 ) = "самостоятелно";

?>

Стрингови функции и оператори

Стрингови оператори

Различните езици за програмиране използват различни оператори за конкатенация (съединяване) на низове. Например Pascal използва оператора "+". Използването на оператора "+" за свързване на низове в PHP е неправилно: ако низовете съдържат числа, тогава вместо свързване на низовете ще бъде извършена операцията за добавяне на две числа.

PHP има два оператора, които извършват конкатенация.

Първият е операторът за конкатенация ("."), който връща конкатенацията на левия и десния аргумент.

Вторият е оператор за присвояване с конкатенация, който добавя десния аргумент към левия.

Да дадем конкретен пример:

$a = "Здравей" ;
$b = $a. "Свят!" ; // $b съдържа низа "Hello World!" - Това е конкатенация

$a = "Здравей" ;
$a .= "Свят!" ; // $a съдържа низа "Hello World!" - Това е задание с конкатенация
?>

Оператори за сравнение на низове

Не се препоръчва използването на операторите за сравнение == и != за сравняване на низове, защото те изискват преобразуване на типа. Пример:

$x = 0;
$y=1;
if ($x == "" ) ехо "

x - празен низ

" ;
if ($y == "" ) ехо "

y - празен низ

" ;
// Изходи:
// x е празен низ
?>

Този скрипт ни казва, че $x е празен низ. Това се дължи на факта, че празният низ ("") се третира първо като 0 и едва след това като "празен". В PHP операндите се сравняват като низове само ако и двата са низове. Иначе се сравняват като числа. В този случай всеки низ, който PHP не може да преобразува в число (включително празен низ), ще се третира като 0.

Примери за сравнение на низове:

$x = "Низ" ;
$y = "Низ" ;
$ z = "Линия" ;
if ($x == $z) ехо "

Низ X е равен на низ Z

" ;
if ($x == $y) ехо "

Низ X е равен на низ Y

" ;
if ($x != $z) ехо "

Низ X НЕ е равен на низ Z

" ;
// Изходи:
// Низ X е равен на низ Y

?>

За да избегнете объркване и преобразуване на типа, се препоръчва да използвате оператора за еквивалентност, когато сравнявате низове. Операторът за еквивалентност винаги ви позволява да сравнявате правилно низовете, тъй като сравнява стойностите както по стойност, така и по тип:

$x = "Низ" ;
$y = "Низ" ;
$ z = "Линия" ;
if ($x == = $z) ехо "

Низ X е равен на низ Z

" ;
if ($x === $y) ехо "

Низ X е равен на низ Y

" ;
if ($ x !== $ z ) ехо "

Низ X НЕ е равен на низ Z

" ;
// Изходи:
// Низ X е равен на низ Y
// Низ X НЕ е равен на низ Z
?>

За интерполация на низове. От ръководството:

Сложен (къдрав) синтаксис

Не се нарича сложен, защото синтаксисът е сложен и следователно позволява сложни изрази.

Всяка скаларна променлива, елемент от масив или свойство на обект с низово представяне може да бъде включена чрез този синтаксис. Просто напишете израза, както бихте направили извън низа, и след това го обвийте в ( и ). Тъй като ( не може да бъде екраниран, този синтаксис ще бъде разпознат само когато $ следва ( . използвайте (\$, за да получите литерала ($ . Някои примери, за да стане ясно:

ширина)00 сантиметра ширина."; // Работи, ключовете в кавички работят само с помощта на синтаксиса на фигурни скоби echo "Това работи: ($arr["key"])"; // Работи echo "Това работи: ($arr)" ; // Това е погрешно по същата причина, както $foo е погрешно извън низа // ще работи, но само защото PHP първо търси константа с име foo; undefined constant) ще бъде /. / thrown. echo "Това не е наред: ($arr)"; arr["foo"])"; // Работи. $arr["foo"]; echo "Това също работи: ( $obj->values->name)"; echo "Това е стойността на променливата с име $name: ($($name))"; echo "Това е стойността на променливата, наименувана от върнатата стойност на getName( ): ($(getName()))"; echo "Това е стойността на променливата, наречена от върнатата стойност на \$object->getName(): ($($object->getName()))"; // Няма да работи, извежда: Това е върнатата стойност на getName(): (getName()) echo "Това е върнатата стойност на getName(): (getName())"; ?>

Често този синтаксис не е необходим. Например това:

$a = "abcd"; $out = "$a $a"; // "abcd abcd";

се държи точно така:

$out = "($a) ($a)"; // същото

Следователно фигурните скоби не са необходими. Но това:

$out = "$aefgh";

в зависимост от вашето ниво на грешка, или няма да работи, или ще създаде грешка, защото няма променлива с име $aefgh, така че трябва да направите:

$out = "$(a)efgh"; // или $out = "($a)efgh";