Форум PHP

Иногда в коде встречается $aaa = &$arr['f']['k'];

Что это за значок? Вернее, зачем он?

& - извлекает адрес переменой и идет уже присваенние адреса. Если изменить $aaa измениться и $arr['f']['k'];

Получение ссылки - вот есть допустим у вас массив из 1000 элементов - передаёте вы его в функцию, делаете с ним что-то и возвращаете. На тот момент пока вы находитесь в функции создаётся копия массива и в программе у вас хранится 2000 элементов вместо 1000. Хотя вам всё равно и вы бы с удовольствием скормили функции первую копию - вот для этого и предназначены ссылки - они позволяют передавать не копию, а сам объект.

PS Пример несколько утрирован, так как массивы всегда передаются по ссылке начиная с 4.какой-то версии PHP...

Ммм... а где это используется? Я вот пока смысла в этом не вижу.

Используется в функциях например очень часто

<? function set_1($var, $error) { // тут идут вычисления // в случае ошибки в $error описание ошибки } set_1($a, &$error); echo $error ?>

Если передача была не по ссылки глобальная переменная $error была бы пуста.

<?  function set_1($var)  {  // тут идут вычисления  // в случае ошибки в $error описание ошибки  $arr[]=$result; $arr[]=$error; return $arr; }  $a=set_1($var);  $error=$a[1]; $result=$a[0]; ?>

Чем плох вариант?

Всем =) А особенно тем что он возращает массив. И его уже никуда не "вставишь"

<? function is_my($var, $var2) { if($my > 100) $var2 = 'slishkom mnogo'; if($my > 0) return true; else return  false; } $v = 101; if ( is_my($v, &$var2) ) echo $var2; ?>

<?  function is_my($my)  {  if($my > 100){ return 'slishkom mnogo'; } if($my > 0 and $my <=100){ return true;}  else return  false;  }  $v = 101;  $a=is_my($v); if ($a==true){print "угу";}  if ($a=='slishkom mnogo'){print "не угу";}  if ($a==false){print "промолчу";}  ?>

Да более простой пример:

<?php function increment(&$a) {  $a += 110; } $a = 25; increment($a); echo $a; ?>

результат 135.

Используется так же в ООП для передачи объектов.

Все же, никак не пойму :(

<?  function increment($a) {  $a=$a+110; return $a; }  $a = 25;  echo increment($a);  ?>

Как я понял - это сделано просто для того, чтобы не приходилось $var=my_func($a); делать ... А достаточно было бы использовать
function (&$a){}

my_func($a);

print $a;

Возможно, это просто разные стили - кому как удобнее. Ну что-то наподобие print и echo ... или die и exit

А если в $a прочтенный 5 меговый файл, будете 5мб гонять по функциям? Разумнее передать только ссылку...

Почитайте http://php.rinet.ru/manual/ru/language.references.php, хорошо и понятно написано по-русски

Неужели в таком случае - пять мегов так-таки и будут бегать между функциями? Мне казалось, что это как-то решено...

p.s. Пошел читать вашу ссылку.

Ага, то есть вы хотите сказать, что:

<?php function myfunc(&$var) {    $var="he-he-he"; } $a=""; foo($a); print $a; ?>

Напечатает "he-he-he" ? Но если я прав, то это... по сути - один из методов глобализации переменной. Только $a будет являться не этой глобальной переменной, а ссылкой (unix) или ярлычком (win) к настоящим данным.

Да, напечатает (только имя функции не foo, а myfunc). По сути примерно да.

Благодю.

Имя функции - да... просто пока переписывал под свой пример - не затер чужой.

Ссылки применяются для того, чтобы из функции во внешний мир можно было передавать значения через параметры. В PHP нет остой необходимости в этом, так как действительно можно массивы возвращать через return - ссылки достались в наследство от других языков. Например, в C/C++ ссылки и указатели имеют уже принципиальное значение, так как без них уже сложно... например нельзя передать указатель на функцию и реализовывать механизм обратного вызова, который так широко используется в том же PHP.

>Всем =) А особенно тем что он возращает массив. И его уже
>никуда не "вставишь"
>

><? >function is_my($var, $var2) >{ >if($my > 100) $var2 = 'slishkom mnogo'; >if($my > 0) return true; >else return  false; >} > >$v = 101; > >if ( is_my($v, &$var2) ) >echo $var2; > >?> >

Для того, чтобы этот пример работал, его нужно переписать так:

function is_my($var, &$var2) { if($var > 100)    $var2 = 'slishkom mnogo'; if($var > 0)    return true; else    return  false; } $v = 101; if (is_my($v, $var2) )  echo "$var2";

Сылку удобнее использовать в аргументе определения функции, а не при ее вызове (определение делается один раз, а вызовов - сколько угодно и каждый раз нужно будет не забыть про значок & ).
Тем не менее, ссылками пользоваться не рекомендуется для повышения быстродействия программ . Это связано с особенностями реализации ядра PHP (Zend Engine). Реальное замедление при использовании ссылок - 30%.

Тем не менее, ссылками пользоваться не рекомендуется для повышения быстродействия программ . Это связано с особенностями реализации ядра PHP (Zend Engine). Реальное замедление при использовании ссылок - 30%.

Не соглашусь с этим. Можно ли узнать, где написано что не рекомендуется. Откуда такая цифра, 30%?
Вообще если чисто логически подумать, то при использовании ссылок можно получить прирост в производительности. К примеру:

<?php function a($a) { $a = str_replace('11','22',$a); return $a; } $str = "11  результат от чтения файла размером 1 мбайт"; $str = a($str); echo $str; ?>

В таком коде будет передано функции a() строка размером 1 мбайт. Уже используется 2 мбайта памяти - 1мбайт - $str, 1мб - $a у функции a().
Другой вариант:

<?php function a(&$a) { $a = str_replace('11','22',$a); } $str = "11 результат от чтения файла размером 1 мбайт"; $str = a($str); echo $str; ?>

В этом варианте передается только ссылка, которая имеет размер 8 байт (может и чуть больше/меньше, точного размера я не помню). Уже используется не 2 мбайта, 1 мбайта + 8 байт.


Теперь объясните, что можно было сделать в ZendEngine чтобы ссылки отрицательно влияли на производительность?

Один из создателей (творцов) PHP - Зеев Сураски написал книжку (в соавторстве с Леоном Сураски), которая называется (в русском переводе) "PHP5 Библиотека профессионала".
В этой книжке есть глава, посвященная оптимизации и эффективности.

Приведенные мною проценты - на стр. 865 (глава 28.13).
Ну и там подробно объясняется, почему не надо пользоваться (злоупотреблять) ссылками.

Провел тесты, при правильном использовании ссылок скорость не отличается, оба варианта выполняются одинаковое время.
Вывод: для работы с мелкими (по размеру) данными надо передавать без ссылок, но для больших данных лучше ссылкой.

Не могли бы вы отсканировать эту часть, где объясняется почему ?

Прежде всего хочу принести свои извинения, за то, что перепутал фамилию второго
автора (такая вот опечатка случилась...:-).

Конечно же его зовут - Леон Аткинсон (и авторы - не братья).
В оригинале книжка называется "Core PHP Programming".
На сайте автора есть архив с примерами из этой книжки.
Вот ссылка.

http://www.leonatkinson.com/downloads/corephp_3e_listings.tar.gz

С содержанием этой книжки (русский перевод) можно познакомиться вот по этой
ссылке:
http://www.williamspublishing.com/PDF/5-8459-0735-7/part.pdf

Отсканировать страницы быстро не получилось по техническим причинам:
сканер - в одной точке пространства, а книжка - в другой. Кроме того, опубликовать
этот ткст все равно нельзя из-за авторских прав (копирайт - у издательства).

Поэтому я чуть позже попробую рассказать об этой проблеме своими словами.

Проблемы с производительностью возникают, когда приходится иметь дело с большими
массивами (или строками, как частным случаем массивов).
Поэтому разработчики умной машинки Zend сделали так, чтобы не происходило лишних
пересылок (копирований) массивов. Для этого используются указатели (на которых
и держится эффективность Си).
Это означает, что в выражении $a = $b,
где $b - массив, копирования не происходит, а Zend просто сам создает ссылку и
учитывает ее в своем счетчике ссылок.
Но... ! Если Zend обнаружит, что переменная $b изменена, то он обязан сделать вторую копию.

Теперь вернемся к нашей загогулине (&).
Когда в аргументе функции стоит просто пременная, то всегда есть гарантия, что она
будет использоваться только внутри функции локально и функция никак не сможет изменить
состояние переданной в функцию переменной.
Совсем другое дело, если аргументом служит ссылка на переменную. В этом случае
всегда есть верочтность, что функция изменит значение этой переменной.
Поэтому, когда Zend видит такую конструкцию, то он обязан сделать лишнюю копию для этой переменной, т.е. осуществить пересылку возможно даже и не одного мегабайта в памяти.

Таким образом, передача в функцию значения гарантирует, что лишних копирований
не будет, а передача в функцию ссылки - гарантирует, что лишняя копия будет обязательно
создана. Отсюда и разница в производительности, которая может быть ощутимой при
работе с большими массивами (и при условии, что все остальное - тоже оптимизированно !).

Кроме того, использование ссылки (с целью оптимизации) в PHP-сценарии просто бесполезно по той простой причине, что это делает эффективно уже сам Zend и заботиться об этом программисту не нужно, главное - не мешать машинке думать, считая ее недостаточно интелектуальной...

Если это так, то разработчики умной машинки Zend сделали большую глупость... То, что массивы передаются по ссылке в параметрах - это хорошо и правильно, на современных разработчиков здесь лучше не надеятся, на кой ляд нужно создавать копию при передаче по ссылке & - совершенно не понятно. Ведь когда параметр передаётся по ссылки я просто требую, чтобы все изменения происходили непосредственно над этим параметром без создания дополнительных копий... Меня, да и любого C-программиста, обратное поведение очень озадачивает (надеюсь, что это некорректный перевод)...

Все, о чем я сказал выше, это не цитата и не перевод, а только лишь мое понимание ситуации с обработкой ссылок, основанное на информации, почрпнутой из той книжки.
Поэтому глупцом имеет смысл объявить меня, В переводной книжке текст совсем другой и с примерами. Оригинала не видел. Желающие могут самостоятельно открыть эту книжку на указанной странице, прочесть и понять: глукпость или нет. Или отыскать первоисточник.
Или написать разработчикам Zend и спросить. Способов поиска истины много.

Хотя, гораздо проще объявить те вещи, которые ты не понимаешь - глупостью...:-)

Вроде небольшого теста.

<?php // файл размером больше 1Мб $mas1 = file("file.txt"); $mas2  = file("file.txt"); function sort_my_mas_1(&$array) {     sort($array); } function sort_my_mas_2($array) {     return sort($array); } sort_my_mas_1($mas1); $mas2 = sort_my_mas_2($mas2); ?>

Profile:
test.php :: main()---------------1,6 sec
test.php :: sort_my_mas_1--2,5 sec
test.php :: sort_my_mas_2--4,2 sec

TEST 2

<?php // файл размером больше 1Мб $mas1 = file("file.txt"); $mas2  = file("file.txt"); function sort_my_mas_1(&$array) {     sort($array); } function sort_my_mas_2($array) {     return sort($array); } sort_my_mas_1($mas1); sort_my_mas_2($mas2); ?>

Profile:
test.php :: main()---------------1,5 sec
test.php :: sort_my_mas_1--2,4 sec
test.php :: sort_my_mas_2--3,1 sec

Делайте выводы

Ссылки в НеООпрограммировании применяются действительно редко( в основном для сбора информации, например, об ошибках), но с другой стороны помогают сокращать время выполнения той или иной функции за счет того, что при передаче по ссылке в функцию, не создается копия этого параметра, т.е. фунция работает с целевой переменной-параметром, а не ее копией как при передачи по значению

Из приведенного примера трудно сделать какие-то выводы, т.к. имеет смысл сравнивать коды, одинаково работающие, т.е. дающие один и тот же результат.
В приведенных примерах этого нет (см. ниже). Поэтому эти цифры почти ни о чем не говорят.
Но из этих примеров видно следующее:
1.
Выражение

$mas2 = sort_my_mas_2($mas2);

предполагает, очевидно, что в результате будет получен отсортированный массив $mas2.
К сожалению, этого не произойдет и мы получим

$mas2 = 1

, по той простой причине, что функция sort возвращает не массив, а логическое значение. Или вообще ничего не возвращает (это зависит от ее второго аргумента).
Более того, масссив здесь вообще не будет отсортирован (точнее, он будет
отсортирован внутри функции, но результаты пропадут, как только функция закончится).
При этом вариант с передачей в качестве аргумента ссылки работать будет, т.к.
функция sort работает непосредственно с переданной ей переменной.
(В этом смысле для понимания особенностей применения ссылок функция sort не очень
удачна).

2.
Дважды читать один и тот же файл нет необходимости.
После строк

$mas1 = file("file.txt"); $mas2 = $mas1;

результат будет тот же ,что и после

$mas1 = file("file.txt"); $mas2 = file("file.txt");

но только быстрее, т.к. файл дважды не читается.
При этом в выражении

$mas2 = $mas1;

никакого копирования массива не происходит, а вместо этого PHP автоматически (т.е. без участия программиста) создает ссылку на переменную $mas1.
Кроме того, будет занято вдвое меньше памяти.


Главный вывод (из сказанного):
при работе с массивами PHP автоматически создает ссылки в операциях присваивания или при передаче аргументов и в таких случаях копирования массивов не происходит (при условии, что в исходный массив не было записи).

Вы стоите на своей точке зрения, не пытаясь понят других, лишь раз прочитав "умную книжку". Я не хотел сказать, что вы не правы - я двигаю фактами. Если что-то было не так в тестах - давайте исправим. Главное тут не решить, кто прав, а как нужно делать. Итак:
>> $mas2 = sort_my_mas_2($mas2);
Да согласен - лоханулся
>> 2. Дважды читать один и тот же файл нет необходимости.
Это пример НЕ показывает, как нужно делать "быстро", я лишь хотел добиться правильных цифр.
>> никакого копирования массива не происходит, а вместо этого PHP автоматически (т.е. без участия программиста) создает ссылку на переменную $mas1.
Именно ради этого и не было $mas1 = $mas2 т.к. это может повлиять на цифры (может быть), а так
$mas1 = file("file.txt");
$mas2 = file("file.txt");
Создать два ОДИНАКОВЫХ, но не зависящих друг от друга массивов.

Смотрите на 2 тест. Тут ни одна функция не возвращает ничего, и все равно при передаче ссылки мы выигрываем. А это значит, что PHP потратил время на копирование (или какие то косвенные действия) массива, что не было в первой функции.

2. При использовании ссылки мы получаем обработанную переменную "сразу". В другом случае PHP тратит время еще на присвоение значения переменной после работы функции
$a = go($a); Но это время мало, но все же оно есть.

Я не призываю использовать ссылки в каждой функции, но от их удобства отказываться не стоит.

при работе с массивами PHP автоматически создает ссылки в операциях присваивания или при передаче аргументов и в таких случаях копирования массивов не происходит (при условии, что в исходный массив не было записи).

Докажите это примером кода.


PHP не может создавать сам ссылки, иначе если бы мы обнулили $mas2, то обнулился бы и $mas1

>

>при работе с массивами PHP автоматически создает ссылки в >операциях присваивания или при передаче аргументов и в таких >случаях копирования массивов не происходит (при условии, что >в исходный массив не было записи). >

>Докажите это примером кода.

Показать это на примере невозможно, т.к. описанный механизм действует не на уровне
кодов в тексте PHP-программы, а на уровне Zend-машины (процессора PHP).
Поэтому приходится верить на слово разработчикам PHP-процессора.

>PHP не может создавать сам ссылки, иначе если бы мы обнулили
>$mas2, то обнулился бы и $mas1

В том то и весь фокус, что не обнулится !
Я уже пытался дважды про это рассказать, но как-то бестолково.
PHP следит за состоянием всех внутренних ссылок и если обнаруживает, что происходит
запись в ссылаемую переменную (а ее обнуление - частный случай записи), то сразу же принимает меры, а именно: создает копию этой переменной.

Почему-то складывается впечатление, что все это мои измышления...:-), поэтому я дальше на эту тему продолжать не буду. Хотите верьте, хотите - нет...:-)
Мне все описанные механизмы показались вполне оптимальными и разумными.

Для тех, кто захочет в этой проблеме разобраться самостоятельно (и не имеет доступа к литературе) завтра отсканирую пару страниц и где-нибудь выложу.

Следить глупо, т.к. если понадобилось $mas2 = $mas1 то значит кто-то из них будет меняться и поэтому нужно создать именно копию, а не ссылку

Вот еще тест:

<?php $mas1 = range(0, 80000); $mas2 = range(0, 80000); function my_mas_1(&$array) {     for($i=0; $i<80000; $i++)     {         $array[$i]++;     } } function my_mas_2($array) {     for($i=0; $i<80000; $i++)     {         $array[$i]++;     }     return $array; } my_mas_1($mas1); $mas2 = my_mas_2($mas2); ?>

Profile:
test.php :: main() ----1,2 sec
my_mas_1()----------1,2 sec
my_mas_2()----------2,3 sec

А попробуйте:

function test_ref(&$arr) {    for($n=0; $n<sizeof($arr); $n++) $x = 1;  } function test_val($arr) {    for($n=0; $n<sizeof($arr); $n++) $x = 1; } $ar  = range(0,1000); test_ref($ar); test_val($ar);

И после:

function test_ref(&$arr) {    $count = sizeof($arr);    for($n=0; $n<$count ; $n++) $x = 1;  } function test_val($arr) {    for($n=0; $n<sizeof($arr); $n++) $x = 1; } $ar  = range(0,1000); test_ref($ar); test_val($ar);

Не имеет смысл.
1. В функции используется sizeof, в который массив передается по значению и смысла в & уже нет.
2. Скрипт выполняется достаточно быстро - погрешность большая.

Хм...

<? function test_ref(&$arr) {    sizeof($arr); } function test_val($arr) {    sizeof($arr); } $ar  = range(0,100000); test_ref($ar); test_val($ar); ?>

Profile:
test.php::main()-----1,8 sec
test_ref()--------------4,9 sec
test_val()--------------0,040 ms

<? function test_ref(&$arr) {    sizeof($arr); } function test_val($arr) {    return sizeof($arr); } $ar1  = range(0,80000); $ar2  = range(0,80000); test_ref($ar1); echo test_val($ar2); ?>

Profile:
test.php::main()-----1,4 sec
test_ref()--------------902,7 ms
test_val()--------------0,400 ms

Имхо со вторым кодом неточное время.

Оказывается, вопросы я задавать умею...

Вот по этой ссылке я выложил ZIP-архив, в котором содержатся две отсканированных странички по обсуждаемой проблеме.
http://valiv.pochta.ru/downl.htm

Для тех, кто интересуется работой PHP изнутри, можно порекомендовать почитать в PHP-мануале раздел
VI. Zend API, посвященный ядру PHP.

Ниже я привожу начало этого раздела, взятое из chm-файла перевода этого руководства.
--------------------------------------------------------------------------------------
Глава 25. Обзор

Что такое Zend и что такое PHP?
"Расширить PHP" легче сказать, чем сделать. PHP вырос в полноценную утилиту, состоящую из нескольких мегабайт исходного кода. При структурировании этой главы мы остановились на реализации подхода "обучения через выполнение". Это не самый научный и профессиональный подход, но этот метод более привлекателен и даёт наилучший конечный результат.
В последующих разделах вы быстро научитесь, как сделать так, чтобы самые основные расширения работали почти постоянно.
Затем вы узнаете о продвинутой API-функциональности Zend. Альтернативно можно было бы попытаться объединить функциональность, дизайн, подсказки, трюки, и т.п. в единое целое, давая таким образом полный обзор общей картины, прежде чем делать что-либо практически. Хотя это "лучший" метод, поскольку никаких неточностей не будет, он требует больших затрат времени и энергии, почему мы и решили использовать прямой подход.

Заметьте, что, хотя в этой главе сделана попытка дать как можно больше информации о внутренней работе PHP, невозможно дать абсолютно полный справочник расширения PHP, который обеспечивал бы 100% работоспособность во всех случаях. Можно разобраться в PHP, при таком сложном и объёмном пакете, только в том случае, если вы ознакомитесь с ним практически, поэтому мы советуем вам работать с исходным материалом.

Что такое Zend и что такое PHP?
Имя Zend это имя машины языка, ядра PHP. Термин PHP это вся система целиком. Это не так уж сложно понять (см. Рисунок 9.1). Чтобы реализовать интерпретатор Web-скриптов, необходимы три части:

Интерпретатор анализирует входной код, транслирует и выполняет его.
Функциональный модуль реализует функциональность языка (его функции и т.д.).
Интерфейс взаимодействует с Web-сервером и т.д.

Zend полностью выполняет работу части 1 и частично - части 2; PHP выполняет работу частей 2 и 3. Вместе они образуют законченный пакет PHP. Zend формирует только ядро языка, реализуя PHP в самой основе с помощью некоторых предопределённых функций. PHP содержит все модули, которые реально создают свойства языка.
-----------------------------------------------------------------------------------------------------------

Еще пару слов про ссылки. Хотите верьте - хотите нет, но...

В связи с распространившимся заболеванием под названием синдром WTMA
(Way Too Many Ampersand - "слишком много амперсандов" ) разработчиками PHP5
для облегчения жизни ООП-программистам были сделаны существенные изменения
в Zend 2 в отношении объектов. В результате - теперь можно почти совсем
забыть про этот значок & (амперсанд). Теперь за вас все сделает Zend.

Проверить это просто (если установлен PHP5): взять любой работающий скрипт,
в котором используются объекты, и тупо удалить все значки &.
Существует достаточно высокая вероятность, что этот скрипт будет продолжать
работать правильно.

Ох, боюсь только, что сейчас Уважаемый Cheops назовет это большой глупостью...:-)

Да нет я ничего против этого не имею, и тем более против вас - в книге действительно так всё и написано и не верить ей сложно, авторы наверняка знали о чём пишут. При организации счётчика памяти (особенно через ООП) - вполне можно ожидать падение производительности при использовании &. Меня возмущает, что разработчики не позаботились о том, чтобы & работал не медленнее передачи "по значению" - автоматическую передачу можно только приветствовать - сам я почти никогда не использую &, так как знаю об этой особенности, но меня неприятно удивило, то что использование & может приводить к более низкой производительности.

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