Просмотр архива WM_PITBULL


<?php  

include '../../config.php';

$title='Учебник PHP';

aut();

head();



 ?> 



<html><head>

        <title>Учебник PHP, Глава 2</title>

        <meta http-equiv="Content-type" content="text/html; charset=Windows-1251">

        </head>

        

      <DIV class=infotxt>

      <LI><A href="#a">Глава 2. Переменные и типы 

      данных </A>

      <UL>

        <LI><A href="#b">Целые числа </A>

        <LI><A href="#c">Восьмеричная и 

        шестнадцатеричная запись </A>

        <LI><A href="#d">Вещественные числа </A>

        <UL>

          <LI><A href="#e">Стандартная запись</A> 

          <LI><A href="#f">Научная запись</A> 

        </LI></UL>

        <LI><A href="#g">Строковые значения </A>

        <UL>

          <LI><A href="#h">Строковое 

          присваивание</A> 

          <LI><A href="#i">Синтаксис встроенной 

          документации</A> 

          <LI><A href="#j">Обращение к отдельным 

          символам строк</A> </LI></UL>

        <LI><A href="#k">Массивы </A>

        <UL>

          <LI><A href="#l">Одномерные 

          индексируемые массивы</A> 

          <LI><A href="#m">Одномерные 

          ассоциативные массивы</A> 

          <LI><A href="#n">Многомерные 

          индексируемые массивы</A> 

          <LI><A href="#o">Многомерные 

          ассоциативные массивы</A> 

          <LI><A href="#p">Смешанное 

          индексирование</A> </LI></UL>

        <LI><A href="#q">Объекты</A> 

        <LI><A href="#r">Логические 

        величины(истина/ложь)</A> 

        <LI><A href="#s">Идентификаторы</A> 

        <LI><A href="#t">Переменные </A>

        <UL>

          <LI><A href="#u">Объявление 

          переменных</A> 

          <LI><A href="#v">Область видимых 

          переменных</A> 

          <LI><A href="#w">Статические 

          переменные</A> </LI></UL>

        <LI><A href="#x">Переключение типов</A> 

        <LI><A href="#y">Преобразование типов</A> 

        <LI><A href="#z">Присваивание </A>

        <UL>

          <LI><A href="#aa">Присваивание по 

          значению</A> 

          <LI><A href="#bb">Присваивание по 

          ссылке</A> </LI></UL>

        <LI><A href="#cc">Переменные в 

        переменных</A> 

        <LI><A href="#dd">Стандартные 

        переменные</A> 

        <LI><A href="#ee">Константы</A> 

        <LI><A href="#ff">Итоги</A> </LI></UL>

      <UL></UL><A name=a></A>

      <P>&nbsp;</P>

      <P>Глава 2</P>

      <P>Переменные и типы данных</P>

      <P>Типы данных составляют основу любого языка программирования и являются 

      средством, с помощью которого программист представляет разные типы 

      информации. В РНР поддерживаются шесть основных типов данных:</P>

      <UL>

        <LI>целые числа; 

        <LI>вещественные числа; 

        <LI>строки; 

        <LI>массивы; 

        <LI>объекты; 

        <LI>логические величины. </LI></UL>

      <P>Одним из столпов любого языка программирования является поддержка 

      числовых данных. В РНР поддерживаются как целые, так и вещественные числа 

      (двойной точности). Разные числовые форматы подробно описываются в 

      следующих разделах.</P>

      <P><A href="http.html://doks.gorodok.net/0" name=b></A>Целые числа</P>

      <P>Целое число не имеет дробной части и представляется последовательностью 

      из одной или нескольких цифр. Примеры целых чисел:</P>

      <P>5</P>

      <P>591</P>

      <P>52</P>

      <P><A name=c></A>Восьмеричная и шестнадцатеричная запись</P>

      <P>В РНР поддерживается запись целых чисел в восьмеричной (по основанию 8) 

      и шестнадцатеричной (по основанию 16) системах счисления. Восьмеричные 

      числа начинаются с цифры 0, после которой следует серия цифр от 0 до 7. 

      Примеры:</P>

      <P>0422</P>

      <P>0534</P>

      <P>Шестнадцатеричные целые числа имеют префикс 0х или 0Х и могут состоять 

      из цифр от 0 до 9 и букв от а (А) до f (F). Примеры:</P>

      <P>0x3FF</P>

      <P>0x22abc</P>

      <P><A name=d></A>Вещественные числа</P>

      <P>Вещественные числа (числа с плавающей точкой) отличаются от целых 

      наличием дробной части. Они используются для представления значений, 

      требующих повышенной точности, — например, температур или денежных 

      величин. В РНР поддерживаются два вещественных формата: стандартная и 

      научная (экспоненциальная) запись.</P>

      <P><A name=e></A>Стандартная запись</P>

      <P>Стандартная запись удобна для представления типичных вещественных чисел 

      — скажем, денежных величин. Примеры:</P>

      <P>12.45</P>

      <P>98.6</P>

      <P><A name=f></A>Научная запись</P>

      <P>Научная запись лучше подходит для представления очень больших и очень 

      малых чисел — скажем, межпланетных расстояний или размеров атомов. 

      Примеры:</P>

      <P>Зе8</P>

      <P>5.9736е24</P>

      <P><A name=g></A>Строковые значения</P>

      <P>Строкой (string) называется последовательность символов, которая 

      рассматривается как единое целое, но при этом обеспечивает доступ к 

      отдельным символам. Примеры строк:</P>

      <P>thesaurus</P>

      <P>49ers</P>

      <P>abc</P>

      <P>&amp;%/$#</P>

      <P>Обратите внимание: в РНР не поддерживается символьный тип данных. 

      Строковый тип может рассматриваться как единое представление для 

      последовательностей, состоящих из одного или нескольких символов.</P>

      <P><A href="http.html://doks.gorodok.net/996" name=h></A>Строковое 

      присваивание</P>

      <P>Строки делятся на две категории в зависимости от типа ограничителя — 

      они могут ограничиваться парой кавычек (" ") или апострофов (' '). Между 

      этими категориями существуют два принципиальных различия. Во-первых, имена 

      переменных в строках, заключенных в кавычки, заменяются соответствующими 

      значениями, а строки в апострофах интерпретируются буквально, даже если в 

      них присутствуют имена переменных,</P>

      <P>Два следующих объявления дают одинаковый результат:</P>

      <P>$food = "meatloaf";</P>

      <P>$food = 'meatloaf';</P>

      <P>Однако результаты следующих объявлений сильно различаются:</P>

      <P>$sentence = "My favorite food is $food";</P>

      <P>$sentence2 = 'My favorite food is $food';</P>

      <P>Переменной $sentence присваивается строка</P>

      <P>My favorite food is meatloaf.</P>

      <P>Обратите внимание: переменная $food автоматически интерпретируется. С 

      другой стороны, переменной $sentence2 присваивается строка</P>

      <P>My favorite food is $food.</P>

      <P>В отличие от переменной $sentence, в $sentence2 осталась не 

      интерпретированная переменная $food. Различия обусловлены использованием 

      кавычек и апострофов при присваивании переменным $sentence и 

      $sentence2.</P>

      <P>Прежде чем рассматривать второе фундаментальное различие между 

      строками, заключенными в апострофы и в кавычки, необходимо познакомиться 

      со служебными символами, используемыми в строках РНР. В РНР, как и в 

      большинстве современных языков программирования, строки могут содержать 

      служебные символы (например, символы табуляции или новой строки), 

      перечисленные в табл. 2.1.</P>

      <P>Таблица 2.1. Служебные символы в строках</P>

      <P>

      <TABLE width="100%" border=1>

        <TBODY>

        <TR>

          <TD width=127>Последовательность </TD>

          <TD width=333>

            <P align=center>Смысл </P></TD></TR>

        <TR>

          <TD align=middle width=127>n</TD>

          <TD width=333>Новая строка</TD></TR>

        <TR>

          <TD align=middle width=127>&nbsp;r</TD>

          <TD width=333>Возврат курсора</TD></TR>

        <TR>

          <TD align=middle width=127>&nbsp;t</TD>

          <TD width=333>Горизонтальная табуляция</TD></TR>

        <TR>

          <TD align=middle width=127>\</TD>

          <TD width=333>Обратная косая черта</TD></TR>

        <TR>

          <TD align=middle width=127>&nbsp; $</TD>

          <TD width=333>Знак доллара</TD></TR>

        <TR>

          <TD align=middle width=127>"</TD>

          <TD width=333>Кавычка</TD></TR>

        <TR>

          <TD align=middle width=127>[0-7]{1,3}</TD>

          <TD width=333>Восьмеричная запись числа (в виде регулярного 

            выражения)</TD></TR>

        <TR>

          <TD align=middle width=127>&nbsp;x[0-9A-Fa-f]{l,2}</TD>

          <TD width=333>Шестнадцатиричная запись числа (в виде регулярного 

            выражения)</TD></TR></TBODY></TABLE></P>

      <P>Второе принципиальное различие заключается в том, что в строках, 

      заключенных в кавычки, распознаются все существующие служебные символы, а 

      в строках, заключенных в апострофы, — только служебные символы «\» и «». 

      Следующий пример наглядно демонстрирует различия между присваиванием 

      строк, заключенных в кавычки и апострофы:</P>

      <P>$double_list = "item1nitem2nitem2";</P>

      <P>$single_list = 'item1nitem2nitem2';</P>

      <P>Если вывести обе строки в браузере, окажется, что строка в кавычках 

      содержит внутренние символы новой строки, а в строке в апострофах 

      последовательность n выводится как обычные символы. Хотя многие служебные 

      символы в браузерах несущественны, при форматировании для других условий 

      они играют очень важную роль. Помните об этом, выбирая между кавычками и 

      апострофами, и вам удастся избежать многих неожиданностей.</P>

      <P><A name=i></A>Синтаксис встроенной документации</P>

      <P>Второй вариант синтаксиса ограничения строк, представленный в HTML4, 

      называется встроенной документацией (here doc). В этом варианте синтаксиса 

      строка начинается с символов &lt;&lt;&lt;, за которыми следует некоторый 

      идентификатор по вашему выбору, затем строка, присваиваемая переменной. 

      Конструкция заканчивается вторым экземпляром того же идентификатора. 

      Пример:</P>

      <P>$paragraph = &lt;&lt;&lt;DELIM</P>

      <P>This is a string that</P>

      <P>Will be interpreted exactly</P>

      <P>As it is written in the</P>

      <P>variable assignment,</P>

      <P>DELIM;</P>

      <P>Выбранный идентификатор не должен присутствовать в присваиваемой 

      строке. Более того, первый символ завершающего идентификатора должен 

      находиться в первом столбце строки, завершающей конструкцию.</P>

      <P><A name=j></A>Обращение к отдельным символам строк</P>

      <P>К отдельным символам строки можно обращаться как к элементам массива с 

      последовательной нумерацией (см. следующий раздел). Пример:</P>

      <P>$sequence_number = "04efgh";</P>

      <P>$letter = Ssequence_number[4];</P>

      <P>Переменной $ letter будет присвоено значение g. Как вы узнаете из 

      следующего раздела, в РНР нумерация элементов массивов начинается с 0. 

      Соответственно, выражение $sequence_number[l] будет равно 4.</P>

      <P><A name=k></A>Массивы</P>

      <P>Массив представляет собой список однотипных элементов. Существует два 

      типа массивов, различающиеся по способу идентификации элементов. В 

      массивах первого типа элемент определяется индексом в последовательности. 

      Массивы второго типа имеют ассоциативную природу, и для обращения к 

      элементам используются ключи, логически связанные со значениями. Впрочем, 

      на практике операции с массивами обоих типов выполняются сходным образом. 

      По размерности массивы делятся на одномерные и многомерные.</P>

      <P><A name=l></A>Одномерные индексируемые массивы</P>

      <P>При обращении к элементам одномерных индексируемых массивов 

      используется целочисленный индекс, определяющий позицию заданного 

      элемента.</P>

      <P>Обобщенный синтаксис элементов одномерного массива:</P>

      <P>$имя[индекс1];</P>

      <P>Одномерные массивы создаются следующим образом:</P>

      <P>$meat[0] = "chicken";</P>

      <P>$meat[l] = "steak";</P>

      <P>$meat[2] = "turkey";</P>

      <P>При выполнении следующей команды:</P>

      <P>print $meat[1]:</P>

      <P>в браузере выводится строка</P>

      <P>steak</P>

      <P>При создании массивов также можно воспользоваться функцией array (). 

      Массив $meat из предыдущего примера создается командой</P>

      <P>$meat = аrrау("chicken", "steak", "turkey");</P>

      <P>Приведенная выше команда pri nt приводит к тому же результату — выводу 

      строки steak.</P>

      <P>Чтобы включить новый элемент в конец массива, можно просто присвоить 

      значение переменной массива без указания индекса. Следовательно, массив 

      $meat можно создать еще одним способом:</P>

      <P>Smeat[] = "chicken";</P>

      <P>$meat[] = "steak";</P>

      <P>Smeat[] = "turkey";</P>

      <P><A name=m></A>Одномерные ассоциативные массивы</P>

      <P>Ассоциативные массивы особенно удобны в ситуациях, когда элементы 

      массива удобнее связывать со словами, а не с числами.</P>

      <P>Предположим, вы хотите сохранить в массиве лучшие сочетания вин и блюд. 

      Проще всего было бы хранить в массиве пары «ключ/значение» — например, 

      присвоить сорт вина названию блюда. Самым разумным решением будет 

      использование ассоциативного массива:</P>

      <P>Spairings["zinfandel"] = "Broiled Veal Chops";</P>

      <P>$pairings["merlot"] = "Baked Ham";</P>

      <P>$pairings["sauvignon"] = "Prime Rib";</P>

      <P>$pairings["sauternes"] = "Roasted Salmon";</P>

      <P>Ассоциативный массив заметно экономит время и объем программного кода, 

      необходимого для вывода определенных элементов массива. Допустим, вы 

      хотите узнать, с каким блюдом лучше всего идет «Мерло». Нужная информация 

      выводится простой ссылкой на элемент массива $pairings: print 

      $pairings["merlot"]; // Выводится строка "Baked Ham" Ассоциативные массивы 

      также можно создавать функцией РНР аггау():</P>

      <P>Spairings = аrrау(</P>

      <P>zinfandel =&gt; "Broiled Veal Chops",</P>

      <P>merlot =&gt; "Baked Ham",</P>

      <P>sauvignon =&gt; "Prime Rib",</P>

      <P>sauternes =&gt; "Roasted Salmon");</P>

      <P>Отличается только способ создания массива pairings, а функциональные 

      возможности остаются без изменений.</P>

      <P><A name=n></A>Многомерные индексируемые массивы</P>

      <P>Многомерные индексируемые массивы работают практически так же, как и их 

      одномерные прототипы, однако элементы в них определяются несколькими 

      индексами вместо одного. Теоретически размерность индексируемого массива 

      не ограничивается, хотя в большинстве приложений практически не 

      встречаются массивы с размерностью выше 3.</P>

      <P>Обобщенный синтаксис элементов многомерного массива:</P>

      <P>$имя[индекс1][индекс2]..[индексN];</P>

      <P>Пример ссылки на элемент двухмерного индексируемого массива:</P>

      <P>$position = $chess_board[5][4];</P>

      <P><A href="http.html://doks.gorodok.net/19587" name=o></A>Многомерные 

      ассоциативные массивы</P>

      <P>Многомерные ассоциативные массивы также существуют в РНР (и приносят 

      определенную пользу). Допустим, в массиве $раirings из предыдущего примера 

      должна храниться информация не только о сорте, но и о производителе вина. 

      Это можно сделать следующим образом:</P>

      <P>$pairings["Martinelli"]["zinfandel"] = "Broiled Veal Chops";</P>

      <P>$pairings["Beringer"]["merlot"] = "Baked Ham";</P>

      <P>$pairings["Jarvis"]["sauvignon"] = "Prime Rib";</P>

      <P>$pairings["Climens"]["sauternes"] = "Roasted Salmon";</P>

      <P><A name=p></A>Смешанное индексирование</P>

      <P>В многомерных массивах допускается смешанное индексирование (числовое и 

      ассоциативное). Допустим, вы хотите расширить модель одномерного 

      ассоциативного массива для хранения информации об игроках первого и 

      второго состава футбольной команды. Решение может выглядеть следующим 

      образом:</P>

      <P>$Buckeyes["quarterback"] [1] = "Bellisari";</P>

      <P>$Buckeyes["quarterback"] [2] = "Moherman":</P>

      <P>$Buckeyes["quarterback"] [3] = "Wiley";</P>

      <P>В РНР существует множество функций для создания массивов и операций с 

      ними — эта тема настолько обширна, что заслуживает отдельной главы. Работа 

      с массивами в РНР подробно описана в главе 13.</P>

      <P><A name=q></A>Объекты</P>

      <P>К пятому типу данных РНР относятся объекты. Объект представляет собой 

      переменную, экземпляр которой создается по специальному шаблону, 

      называемому классом. Концепции объектов и классов являются неотъемлемой 

      частью парадигмы объектно-ориентированного программирования (ООП).</P>

      <P>В отличие от других типов данных, поддерживаемых в языке РНР, объекты 

      должны объявляться явно. Необходимо понимать, что объект — всего лишь 

      конкретный экземпляр класса, используемого в качестве шаблона для создания 

      объектов с конкретными характеристиками и функциональными возможностями. 

      Следовательно, объявление класса должно предшествовать объявлению 

      объектов, создаваемых на их основе. Пример объявления класса и 

      последующего создания объектов на его основе:</P>

      <P>class appliance { </P>

      <P>var power: </P>

      <P>function set_power($on_off) { </P>

      <P>$this-&gt;power = $on_off;&nbsp; </P>

      <P>} </P>

      <P>}</P>

      <P>...</P>

      <P>$blender = new appliance; </P>

      <P>Определение класса задает атрибуты и функции, связанные с некоторой 

      структурой данных — в данном примере это структура с именем appliance 

      (устройство). У этой структуры имеется всего один атрибут power 

      (мощность). Для изменения этого атрибута создается метод set_power.</P>

      <P>Помните: определение класса — всего лишь шаблон, и выполнять операции с 

      ним в программе невозможно; сначала нужно создать объекты на основе этого 

      шаблона. Объекты создаются при помощи ключевого слова new. Например, в 

      приведенном выше фрагменте создается объект $blender класса appliance.</P>

      <P>После создания объекта $blender можно задать его мощность при помощи 

      метода</P>

      <P>set_power: $blender-&gt;set_power("on");</P>

      <P>Объектно-ориентированное программирование занимает столь важное место в 

      современных стандартах программирования, что его применение в РНР 

      заслуживает отдельной главы. Реализация ООП в РНР описана в главе 6.</P>

      <P><A name=r></A>Логические величины (истина/ложь)</P>

      <P>Логический тип данных принимает всего два значения: истинное (true) и 

      ложное (false). Логические величины создаются двумя способами: при 

      проверке условий и в виде значений переменных. Обе ситуации достаточно 

      просты.</P>

      <P>Сравнения существуют в нескольких формах. Чаще всего они встречаются 

      при использовании оператора = в условной команде if. Пример:</P>

      <P>if ($sum == 40) :</P>

      <P>...</P>

      <P>Результатом проверки является либо истина, либо ложь: переменная $sum 

      либо равна 40, либо не равна. Если переменная $sum равна 40, проверка дает 

      истинный результат. В противном случае результат равен false.</P>

      <P>Логические величины также могут определяться явным присваиванием 

      переменной истинного или ложного значения. Пример:</P>

      <P>$flag = TRUE;</P>

      <P>if ($flag == TRUE) :</P>

      <P>print "The flag is true!";</P>

      <P>else :</P>

      <P>print "The flag is false!";</P>

      <P>endif;</P>

      <P>Если переменная $flag истинна, выводится первое сообщение, а если ложна 

      — второе сообщение.</P>

      <P>Возможен и другой вариант — представление истинных и ложных логических 

      величин в виде значений 1 и 0 соответственно. В этом случае предыдущий 

      пример выглядит так:</P>

      <P>$flag = 1;</P>

      <P>if ($flag == TRUE) ;</P>

      <P>print "The flag is true!";</P>

      <P>else :</P>

      <P>print "The flag is false!";</P>

      <P>endif;</P>

      <P>Наконец, существует еще один способ:</P>

      <P>$flag = TRUE: </P>

      <P>// При выполнении этой команды косвенно&nbsp; </P>

      <P>// проверяется условие "if ($flag == TRUE)" </P>

      <P>if ($flag) :</P>

      <P>print "The flag is true!"; </P>

      <P>else :</P>

      <P>print "The flag is false!"; </P>

      <P>endif:</P>

      <P><A name=s></A>Идентификаторы</P>

      <P>Общий термин идентификатор применяется к переменным, функциям и другим 

      объектам, определяемым пользователем. Идентификаторы РНР должны 

      удовлетворять нескольким условиям:</P>

      <P>Идентификатор состоит из одного или нескольких символов и начинается с 

      буквы или символа подчеркивания. Идентификатор может содержать только 

      буквы, цифры, символы подчеркивания и другие ASCII-символы с кодами от 127 

      до 255. Примеры:</P>

      <P>

      <TABLE border=1 width="100%">

        <TBODY>

        <TR>

          <TD width=250>Допустимые идентификаторы</TD>

          <TD width=250>

            <P align=left>Недопустимые идентификаторы</P></TD></TR>

        <TR>

          <TD width=114>

            <P>my_function</P></TD>

          <TD width=178>

            <P align=left>This&amp;that</P></TD></TR>

        <TR>

          <TD width=114>Size</TD>

          <TD width=178>!counter</TD></TR>

        <TR>

          <TD width=114>_someword</TD>

          <TD width=178>4ward</TD></TR></TBODY></TABLE></P>

      <P>В идентификаторах учитывается регистр символов. Следовательно, 

      переменная с именем $recipe отличается от переменных с именами $Recipe, 

      $rEciPe и $recipE.</P>

      <P>Длина идентификаторов не ограничивается. Это удобно, поскольку 

      программист может точно описать смысл идентификатора в его имени.</P>

      <P>Идентификатор не может совпадать с каким-либо из стандартных ключевых 

      слов РНР.</P>

      <P><A href="http.html://doks.gorodok.net/0" name=t></A>Переменные</P>

      <P>В примерах, приведенных выше, я попутно показал, как происходит 

      присваивание и изменение значений переменных. И все же стоит четко 

      сформулировать правила объявления переменных и выполнения операций с ними. 

      Ниже приводится подробное описание этих правил.</P>

      <P><A name=u></A>Объявление переменных</P>

      <P>Переменная представляет собой именованную область памяти, содержащую 

      данные, с которыми можно выполнять операции во время выполнения 

      программы.</P>

      <P>Имена переменных всегда начинаются со знака доллара, $. Ниже приведены 

      примеры допустимых имен переменных:</P>

      <P>$соlоr</P>

      <P>$operating_system</P>

      <P>$_some_variable</P>

      <P>$model</P>

      <P>Имена переменных должны соответствовать тем же условиям, что и 

      идентификаторы. Другими словами, имя переменной начинается с буквы или 

      символа подчеркивания и состоит из букв, символов подчеркивания, цифр или 

      других ASCII-символов в интервале от 127 до 255.</P>

      <P>Следует заметить, что переменные в РНР, как и в языке Perl, не требуют 

      специального объявления. Вместо этого переменная объявляется при первом ее 

      использовании в программе. Более того, тип переменной косвенно 

      определяется по типу хранящихся в ней данных. Рассмотрим следующий 

      пример:</P>

      <P>$sentence = "This is a sentence."; // $sentence интерпретируется как 

      строка</P>

      <P>$price = 42.99: // $price интерпретируется как вещественное число</P>

      <P>$weight = 185; // $weight интерпретируется как целое число</P>

      <P>Переменные могут объявляться в любой точке сценария РНР, однако от 

      расположения объявления зависит то, откуда можно обращаться к данной 

      переменной.</P>

      <P><A name=v></A>Область видимости переменных</P>

      <P>Область видимости (scope) определяется как область доступности 

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

      области видимости переменные РНР делятся на четыре типа:</P>

      <UL>

        <LI>&nbsp;локальные переменные; 

        <LI>параметры функций; 

        <LI>глобальные переменные; 

        <LI>статические переменные. </LI></UL>

      <P>Локальные переменные</P>

      <P>Переменная, объявленная внутри функции, считается локальной; другими 

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

      присваивании вне функции будет использоваться совершенно другая 

      переменная, которая не имеет ничего общего (кроме имени) с переменной, 

      объявленной внутри функции. При выходе из функции, в которой была 

      объявлена локальная переменная, эта переменная и ее значение 

      уничтожаются.</P>

      <P>Основное достоинство локальных переменных — отсутствие непредвиденных 

      побочных эффектов, связанных со случайной или намеренной модификацией 

      глобальной переменной. Рассмотрим следующий пример:</P>

      <P>$х = 4; </P>

      <P>function assignx () { </P>

      <P>$х = 0;</P>

      <P>print "$x inside function is $x. &lt;br&gt;";</P>

      <P>}</P>

      <P>assignx(); </P>

      <P>print "$x outside of function is $x. &lt;br&gt;";</P>

      <P>При выполнении этого фрагмента выводится следующий результат: </P>

      <P>$х inside function is 0. </P>

      <P>$х outside of function is 4. </P>

      <P>Как видите, программа выводит два разных значения переменной $х. Дело в 

      том, что переменная $х внутри функции assignx имеет локальную природу, и 

      изменение ее значения никак не отражается на значении, существующем за 

      пределами этой функции. Справедливо и обратное — модификация $х за 

      пределами функции никак не отражается на локальных переменных функции 

      assignx().</P>

      <P>Параметры функций</P>

      <P>В РНР, как и во многих других языках программирования, любые параметры, 

      передаваемые функции при вызове, должны быть объявлены в заголовке 

      функции. Хотя параметрам присваиваются аргументы, переданные извне, после 

      выхода из функции они становятся недоступными.</P>

      <P>Параметры объявляются в круглых скобках после имени функции. Объявление 

      параметров практически не отличается от объявления типичной 

переменной:</P>

      <P>// Функция умножает переданное значение на 10 и возвращает 

результат</P>

      <P>function x10 ($value) {</P>

      <P>$value = $value * 10;</P>

      <P>return $value;</P>

      <P>}</P>

      <P>Хотя вы можете обращаться к параметрам в той функции, в которой они 

      были объявлены, и выполнять с ними необходимые операции, после завершения 

      функции параметры уничтожаются.</P>

      <P>Глобальные переменные</P>

      <P>Глобальные переменные, в отличие от локальных, доступны в любой точке 

      программы. Но чтобы изменить значение глобальной переменной, необходимо 

      специально объявить ее как глобальную в соответствующей функции. Для этого 

      перед именем переменной ставится ключевое слово GLOBAL. Пример:</P>

      <P>$somevar = 15;</P>

      <P>function addit() { </P>

      <P>GLOBAL $somevar; </P>

      <P>$somevar++; </P>

      <P>print "Somevar is $somevar"; </P>

      <P>} </P>

      <P>addit(); </P>

      <P>Будет выведено значение $somevar, равное 16. Допустим, вы забыли 

      включить следующую строку:</P>

      <P>GLOBAL $somevar;</P>

      <P>В этом случае $somevar будет присвоено значение 1, поскольку эта 

      переменная будет считаться локальной по отношению к функции addit( ). 

      Локальная переменная по умолчанию инициализируется 0, а затем к ней 

      прибавляется 1; таким образом, будет выведено значение 1.</P>

      <P>Альтернативный способ объявления глобальных переменных связан с 

      использованием массива РНР $GLOBALS( ). Давайте вернемся к предыдущему 

      примеру и воспользуемся этим массивом для объявления глобальной переменной 

      $somevar: $somevar = 15;</P>

      <P>function addit() { </P>

      <P>$GLOBALS["somevar"]; </P>

      <P>$somevar++; </P>

      <P>}</P>

      <P>addit();</P>

      <P>print "Somevar is $somevar";</P>

      <P>Каким бы способом ни обеспечивалась глобальная видимость переменной, 

      помните, что неосторожное использование глобальных переменных нередко 

      приводит к неожиданным результатам, причиняющим немало хлопот 

      программистам. Таким образом, хотя глобальные переменные очень удобны, при 

      их использовании необходима умеренность.</P>

      <P><A href="http.html://doks.gorodok.net/996" name=w></A>Статические 

      переменные</P>

      <P>Последний тип видимости переменных называется статическим. В отличие от 

      переменных, объявленных параметрами и уничтожаемых при выходе из функции, 

      статическая переменная сохраняет свое значение при повторном вызове. Для 

      объявления статической переменной перед ее именем ставится ключевое слово 

      STATIC: </P>

      <P>STATIC $somevar; </P>

      <P>Рассмотрим пример: </P>

      <P>function keep_track() { </P>

      <P>STATIC $count = 0; </P>

      <P>$count++;</P>

      <P>print $count;</P>

      <P>print "&lt;br&gt;";</P>

      <P>} </P>

      <P>keep_track(); </P>

      <P>keep_track(); </P>

      <P>keep_track(); </P>

      <P>Как будут выглядеть результаты работы этого сценария? Если бы 

      переменная $count не была объявлена статической (то есть являлась 

      локальной), результат выглядел бы так:</P>

      <P>1 </P>

      <P>1 </P>

      <P>1 </P>

      <P>Но поскольку переменная $count является статической, при каждом вызове 

      функции будет сохраняться ее предыдущее значение, поэтому результат будет 

      таким:</P>

      <P>1 </P>

      <P>2</P>

      <P>3</P>

      <P>Статические переменные особенно удобны при написании рекурсивных 

      функций — особого класса функций, которые многократно вызывают сами себя 

      до выполнения некоторого условия. Рекурсивные функции рассматриваются в 

      главе 4.</P>

      <P><A name=x></A>Переключение типов</P>

      <P>Иногда бывает удобно использовать переменные способами, не 

      предусмотренными при их создании. Допустим, вам захочется прибавить 

      строковое значение "15" к целому числу 12. К счастью, тип переменных РНР 

      может изменяться и без использования механизма явного преобразования. Этот 

      процесс, независимо от того, выполняется ли он прямо или косвенно, 

      называется переключением (juggling) типов. Лучше всего продемонстрировать 

      сказанное на конкретных примерах.</P>

      <P>Предположим, вы суммируете две величины — строку и целое число. Как вы 

      думаете, что при этом произойдет? Результат зависит от содержимого строки. 

      Например, при суммировании целого числа со строковым представлением числа 

      будет получено целое число:</P>

      <P>$variablel = 1;</P>

      <P>$variable2 = "1";</P>

      <P>$variable3 = $variablel + $variable2;</P>

      <P>// $variable3 присваивается 4.</P>

      <P>Другой пример переключения типов — суммирование целого числа с 

      вещественным. При этом целое число преобразуется к вещественному типу, 

      чтобы избежать потери точности:</P>

      <P>$variablel = 3;</P>

      <P>$variable2 = 5.4;</P>

      <P>$variable3 = $variablel + $variable2;</P>

      <P>// $variablel интерпретируется как вещественное число.</P>

      <P>// и $variable3 присваивается 8.4.</P>

      <P>Следует упомянуть о некоторых малоизвестных особенностях переключения 

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

      содержащей целое число, но не являющейся строковым представлением? 

      Рассмотрим следующий пример:</P>

      <P>$variablel = 5;</P>

      <P>$variable2 = "100 bottles of beer on the wall";</P>

      <P>$variable3 = ;variable1 + $variable2;</P>

      <P>// $variable3 присваивается 105</P>

      <P>В результате переменной ;variable3 присваивается значение 105. Это 

      происходит из-за того, что лексический анализатор РНР определяет тип по 

      началу строки. Допустим, мы привели переменную $variable2 к виду "There 

      are 100 bottles of beer on the wall". Поскольку алфавитные символы трудно 

      интерпретировать как целое число, строка интерпретируется как 0, и 

      переменной $variable3 присваивается 5.</P>

      <P>Хотя в большинстве случаев переключение типов обеспечивает желаемый 

      результат, существует способ явного приведения переменных к конкретному 

      типу. Эта тема рассматривается в следующем разделе.</P>

      <P><A name=y></A>Преобразование типов</P>

      <P>Явное приведение переменной к типу, отличному от того, который 

      изначально предназначался для нее, называется преобразованием (casting) 

      типа. Изменение типа может быть как временным, одноразовым, так и 

      постоянным.</P>

      <P>Чтобы временно привести переменную к другому типу, достаточно 

      воспользоваться оператором преобразования типа — указать нужный тип перед 

      именем переменной в круглых скобках (табл. 2.2).</P>

      <P>Таблица 2.2. Операторы преобразования типа переменных</P>

      <P>

      <TABLE width="100%" border=1>

        <TBODY>

        <TR>

          <TD width=250>Оператор преобразования типа</TD>

          <TD width=153>Новый тип</TD></TR>

        <TR>

          <TD width=231>&nbsp;(int) или (integer)</TD>

          <TD width=150>Целое число</TD></TR>

        <TR>

          <TD width=231>(real), (double) или (float)</TD>

          <TD width=153>Вещественное число</TD></TR>

        <TR>

          <TD width=231>(string)</TD>

          <TD width=153>Строка</TD></TR>

        <TR>

          <TD width=231>(array)</TD>

          <TD width=160>Массив</TD></TR>

        <TR>

          <TD width=231>(object)</TD>

          <TD width=153>Объект</TD></TR></TBODY></TABLE></P>

      <P>Простой пример преобразования типов: </P>

      <P>$variable1= 13; // $variable1 присваивается целое число 13</P>

      <P>$variable2 = (double) $variable1; // $variable2 присваивается 13.0</P>

      <P>Хотя переменная $variable1 первоначально содержала целое число 13, 

      преобразование (double) преобразует ее к вещественному типу (поэтому число 

      13 превращается в 13.0). Полученное значение присваивается переменной 

      $variable2.</P>

      <P>Из предыдущего раздела вы знаете, что при суммировании целого числа с 

      вещественным получается вещественный результат. Однако тип результата 

      можно изменить посредством явного преобразования типа:</P>

      <P>$variablel = 4.0;</P>

      <P>$variable2 = 5;</P>

      <P>$variable3 = (int) $variable1 + $variable2; // $variable3 = 9</P>

      <P>Следует заметить, что преобразование вещественного типа к целому всегда 

      сопровождается округлением:</P>

      <P>$variablel = 14.7:</P>

      <P>$variable2 = (int) $varlable1; // $variable2 = 14:</P>

      <P>Строку или переменную другого типа также можно преобразовать в элемент 

      массива. В этом случае преобразованная переменная становится первым 

      элементом массива:</P>

      <P>$variable1 = 1114;</P>

      <P>$array1 = (array) $varable1;</P>

      <P>print $array1[0]; // Выводится значение 1114</P>

      <P>Наконец, любой тип данных можно преобразовать в объект. Переменная 

      становится атрибутом объекта, и ей присваивается имя scalar:</P>

      <P>$model = "Toyota";</P>

      <P>$new_obj = (object) $model;</P>

      <P>Ссылка на исходное строковое значение выглядит так:</P>

      <P>print $new_obj-&gt;scalar;</P>

      <P><A name=z></A>Присваивание</P>

      <P>Вы уже знаете, как присвоить значение переменной в сценарии РНР. Тем не 

      менее, некоторые тонкости, связанные с присваиванием, стоит выделить 

      особо. Вероятно, вам хорошо знаком механизм присваивания по значению, при 

      котором именованной переменной присваивается конкретное значение — 

      например, целое число 1 или строка "ciao". Однако существует и второй 

      механизм — присваивание по ссылке, также открывающее перед программистами 

      немало полезных возможностей. В следующих разделах оба механизма 

      рассматриваются более подробно.</P>

      <P><A name=aa></A>Присваивание по значению</P>

      <P>Это самый распространенный способ присваивания, при котором значение 

      просто заносится в область памяти, представленную именем переменной. 

      Примеры присваивания по значению:</P>

      <P>$vehicle = "car"; </P>

      <P>$amount =10.23; </P>

      <P>В результате выполнения этих двух команд по адресу памяти, 

      представленному именем $vehicle, сохраняется строка "car", а по адресу, 

      представленному именем $amount, — значение 10.23.</P>

      <P>Присваивание по значению также может выполняться в результате 

      выполнения команды return в функциях:</P>

      <P>function simple () {</P>

      <P>return 5;</P>

      <P>}</P>

      <P>$return_value = simple();</P>

      <P>Функция simple( ) всего лишь возвращает значение 5, которое 

      присваивается некоторой переменной. В данном примере значение 5 будет 

      присвоено переменной $return_value. </P>

      <P><A name=bb></A>Присваивание по ссылке</P>

      <P>Другой способ заключается в присваивании переменной ссылки на область 

      памяти, занимаемую другой переменной. Вместо конкретного значения 

      переменная-приемник связывается с указателем (или ссылкой) на область 

      памяти, поэтому фактическое копирование не выполняется.</P>

      <P>Чтобы присвоить значение по ссылке, укажите перед именем 

      переменной-источника символ &amp; (амперсанд):</P>

      <P>$dessert = "cake";</P>

      <P>$dessert2 = $Sdessert;</P>

      <P>$dessert2 = "cookies";</P>

      <P>print "$dessert2 &lt;br&gt;"; // Выводится строка cookies</P>

      <P>print Sdessert; // Снова выводится строка cookies</P>

      <P>Как видно из приведенного фрагмента, после связывания переменной 

      $dessert2 со ссылкой на область памяти, занимаемую переменной $dessert, 

      любые изменения $dessert2 приводят к автоматической модификации $dessert 

      (и всех остальных переменных, ссылающихся на эту же область памяти).</P>

      <P><A name=cc></A>Переменные в переменных</P>

      <P>В некоторых ситуациях бывает удобно использовать переменные, содержимое 

      которых может динамически интерпретироваться как имя другой переменной. 

      Рассмотрим типичный случай присваивания:</P>

      <P>$recipe = "spaghetti";</P>

      <P>Оказывается, строку "spaghetti" можно интерпретировать как имя 

      переменной — для этого в команде присваивания перед именем исходной 

      переменной ставится второй знак $:</P>

      <P>$$recipe = "&amp; meatballs";</P>

      <P>Эта команда присваивает строку "&amp; meatballs" переменной с именем 

      "spaghetti". Следовательно, следующие две команды выводят одинаковые 

      результаты:</P>

      <P>print $recipe $spaghetti;</P>

      <P>print $recipe $($recipe);</P>

      <P>В обоих случаях будет выведена строка "spaghetti &amp; meatballs".</P>

      <P><A name=dd></A>Стандартные переменные</P>

      <P>В РНР поддерживается ряд стандартных переменных, предоставляющих в 

      распоряжение программиста довольно подробную информацию о внутренней 

      конфигурации. Значения одних переменных задаются РНР, другие изменяются в 

      зависимости от операционной системы и web-сервера, с которыми работает 

      РНР.</P>

      <P>Вместо подробного описания всех стандартных переменных я выделю лишь те 

      переменные и функции, которые используются на практике многими 

      программистами.</P>

      <P>Чтобы получить полный список переменных web-сервера, окружения и РНР, 

      определенных для вашей конфигурации системы, достаточно выполнить 

      следующий фрагмент:</P>

      <P>while (list($var,$value) = each($GLOBALS)) :</P>

      <P>echo "&lt;BR&gt;$var =&gt; $value";</P>

      <P>endwhile;</P>

      <P>В результате выводится список наподобие приведенного ниже. Потратьте 

      немного времени на просмотр полученных данных, а затем разберите 

      приведенные примеры.</P>

      <P>GLOBALS =&gt;</P>

      <P>HTTP_GET_VARS =&gt; Array </P>

      <P>HTTP_COOKIE_VARS =&gt; Array </P>

      <P>HOSTSIZE =&gt; 1000 </P>

      <P>HOSTNAME =&gt; server1.apress.com </P>

      <P>LOGNAME =&gt; unstrung </P>

      <P>HISTFILESIZE =&gt; 1000 </P>

      <P>REMOTEHOST =&gt; apress.com </P>

      <P>MAIL -&gt; /var/spool/mail/apress </P>

      <P>MACHTYPE =&gt; 1386 </P>

      <P>TERM =&gt; vt100 </P>

      <P>HOSTTYPE =&gt; i386-linux </P>

      <P>PATH =&gt; </P>

      <P>/usr/sbin:/sbin:/usr/local 

      /bin:/bin:/usr/bin:/usr/X11R6/bin:/usr/local/Java/bin </P>

      <P>HOME =&gt; /root </P>

      <P>INPUTRC =&gt; /etc/inputrc </P>

      <P>SHELL =&gt; /bin/csh </P>

      <P>USER =&gt; nobody </P>

      <P>VENDOR =&gt; intel </P>

      <P>GROUP =&gt; root </P>

      <P>HOST =&gt; server1.apress.com </P>

      <P>OSTYPE =&gt; linux </P>

      <P>PWD =&gt; /www/bin </P>

      <P>SHLVL =&gt; 3_ =&gt; /www/bin/httpd </P>

      <P>DOCUMENT_ROOT =&gt; /usr/local/apress/site.apress </P>

      <P>HTTP_ACCEPT =&gt; */* </P>

      <P>HTTP_ACCEPT_ENCODING =&gt; gzip, deflate </P>

      <P>HTTP_ACCEPT_LANGUAGE =&gt; it.en-us;q=0.5 </P>

      <P>HTTP_CONNECTION -&gt; Keep-Alive </P>

      <P>HTTP_HOST =&gt; www.apress.com </P>

      <P>HTTP_USER_AGENT =&gt; Mozilla/4.0 (compatible; MSIE 5.0: Windows 98; 

      </P>

      <P>CNETHomeBuild051099) </P>

      <P>REMOTE_ADOR =&gt; 127.0.0.1 </P>

      <P>REMQTE_PORT =&gt; 3207 </P>

      <P>SCRIPT_FILENAME =&gt; 

      /usr/local/apress/site.apress/j/environment_vars.php </P>

      <P>SERVER_ADDR =&gt; 127.0.0.1 </P>

      <P>SERVER_AOMIN =&gt; admin@apress.com </P>

      <P>SERVER_NAME =&gt; www.apress.com </P>

      <P>SERVERJORT =&gt; 80 </P>

      <P>SERVER SIGNATURE =&gt; </P>

      <P>Apache/1.3.12 Server at www.apress.com Port 80 </P>

      <P>SERVER_SOFTWARE =&gt; Apache/1.3.12 (Unix) PHP/4.0.1 </P>

      <P>GATEWAY_INTERFACE =&gt; CGI/1.1 </P>

      <P>SERVER_PROTOCOL =&gt; HTTP/1.1 </P>

      <P>REQUEST_METHOD =&gt; GET </P>

      <P>QUERY_STRING =&gt; </P>

      <P>REQUEST_URI =&gt; /j/environment_vars.php </P>

      <P>SCRIPT_NAME =&gt; /j/environment_vars.php </P>

      <P>PATH_TRANSLAETD =&gt; 

      /usr/local/apress/site.apress/j/environment_vars.php </P>

      <P>PHP_SELF =&gt; /j/environment_vars.php </P>

      <P>argv =&gt; Array </P>

      <P>argc =&gt; 0 </P>

      <P>var =&gt; argc </P>

      <P>value =&gt; argc </P>

      <P>Как видите, стандартные переменные содержат разнообразные сведения — 

      как полезные, так и не очень. Вы можете вывести любую из этих переменных 

      по имени. Например, следующая команда выводит IP-адрес пользователя:</P>

      <P>print "Hi! Your IP address is: $REMOTE_ADDR";</P>

      <P>IP-адрес выводится в числовой форме (например, 208.247.106.187).</P>

      <P>Кроме того, стандартные переменные могут использоваться для сбора 

      информации о браузере и операционной системе пользователя. Команда</P>

      <P>print "Your browser is: $HTTP_USER_AGENT";</P>

      <P>возвращает информацию следующего вида:</P>

      <P>Your browser is: Mozina/4.0 (compatible: MSIE 5.0; Windows 98: 

      CNETHomeBuild051099)</P>

      <P>Информация о браузере и операционной системе, в которой он работает, 

      может пригодиться при построении страниц, рассчитанных на специфические 

      форматы конкретных браузеров.</P>

      <P>Для работы с массивами стандартных переменных необходимо включить 

      директиву track_vars в файл php.ini. В РНР версии 4.0.3 директива 

      track_vars включена постоянно.</P>

      <P><A name=ee></A>Константы</P>

      <P>Константой называется именованная величина, которая не изменяется в 

      процессе выполнения программы. Константы особенно удобны при работе с 

      заведомо постоянными величинами — например, числом &#960; (3,141592) или 

      количеством футов в миле (5280).</P>

      <P>В РНР константы определяются функцией define( ). После того как 

      константа будет определена, вы не сможете изменить (или переопределить) ее 

      в этой программе.</P>

      <P>Например, определение числа я в сценарии РНР может выглядеть так:</P>

      <P>define("'PI", "3.141592"); </P>

      <P>Определенную константу можно использовать в программе:</P>

      <P>print "The value of pi is". PI."&lt;br&gt;";</P>

      <P>$pi2 - 2 * PI:</P>

      <P>print "Pi doubled equals $pi2.";</P>

      <P>Результат работы этого фрагмента будет таким:</P>

      <P>The value of pi is 3.141592.</P>

      <P>Pi doubled equals 6.283184.</P>

      <P>В этом фрагменте следует обратить внимание на два обстоятельства. 

      Во-первых, в именах констант не указывается знак доллара. Во-вторых, 

      константу невозможно модифицировать (например, присвоить ей величину 

      2*РI); если константа используется в вычислениях, то результат приходится 

      сохранять в другой переменной.</P>

      <P><A name=ff></A>Итоги</P>

      <P>В этой главе был изложен довольно обширный материал, необходимый для 

      понимания и самостоятельного написания простых программ на РНР. В 

      частности, мы рассмотрели следующие темы:</P>

      <UL>

        <LI>допустимые типы данных (целые и вещественные числа, строки, массивы, 

        объекты, логические величины); 

        <LI>идентификаторы; 

        <LI>переменные (объявление, область действия); 

        <LI>переключение типов; 

        <LI>преобразование типов; 

        <LI>присваивание значений переменным (по значению, по ссылке); 

        <LI>константы. </LI></UL>

      <P>Этот материал закладывает основу для создания более сложных сценариев. 

      В следующей главе мы перейдем к подробному изучению выражений, операторов 

      и управляющих конструкций языка РНР. К концу главы 3 ваших новых знаний 

      хватит для того, чтобы построить первое приложение РНР — простейший 

      календарь.</P></LI></DIV>

      <center>

      [ <a href="01.php">Назад</a> | <a href="index.php">Содержание</a> | <a href="03.php">Вперед</a> ]

      </center><br>

 <p style="color:#777777;">Другая полезная информация по языку PHP на портале <a href="http://www.php.su">PHP.SU</a></p>

        </body>

        </html>

<?php

echo gb.'<a href="../../ycheb">Учебники</a>'.div;

echo gb.'<a href="'.H.'enter">Прихожая</a>'.div;

foot(); ?>