«PHP основы» – второй урок учебника PHP. В этом уроке мы более детально взглянем на грамматику PHP: научимся разделять инструкции и создавать комментарии.
При изучении любого языка программирования первым делом необходимо разобраться с его грамматикой, чем мы с вами сейчас и займемся.
Основы PHP: Разделение инструкций.
Программа на любом языке программирования представляет упорядоченный набор инструкций, выполняющийся по определенным алгоритмам (линейно, циклически и т.д.). И PHP с этой точки зрения не является исключением.
Для отделения одной команды от другой необходимо использовать специальные символы – разделители. В PHP эту роль выполняет символ «; «.
Символ разделения должен находиться в конце каждой инструкции за рядом некоторых исключений, например в конце программы перед символом ?> не обязательно ставить «; «
Внимательно посмотрите на приведенный пример. В нем два вызова одного и того же оператора при одинаковых условиях происходят с «; » и без «; «, но несмотря на это, программа не выдает сообщения об ошибке. Связанно это с тем, что используется единственный оператор в программе, а как мы уже говорили, перед ?> можно опустить символ разделения.
Использование комментариев в PHP.
В любом языке программирования поддерживается возможность оставлять комментарии (HTML, CSS, JavaScript, C++ и т.д.). Говорить о необходимости использования комментариев, я думаю не стоит т.к. это неоднократно обсуждалось в других учебниках этого сайта.
Как и в других языках, в PHP имеется поддержка как однострочных, так и многострочных комментариев. Для создания однострочного комментария используются символы // :
// Это однострочный комментарий
// А это его продолжение
Для создания многострочного комментария используется контейнер /*…*/ :
/* Это многострочный комментарий,
он может вместить внутри себя
абсолютно любое количество строк */
В этом уроке мы познакомились с основами PHP на начальном уровне и научились создавать комментарии. Но это только начало, впереди нас ждет еще много интересных вещей, которые помогут раскрыть весь потенциал вашего будущего сайта.
В следующем уроке мы поговорим об основных типах данных, используемых в PHP, остановившись на каждом из них максимально подробно.
Последнее обновление: 1.11.2015
При создании первой программы на PHP уже были затронуты некоторые основные принципы создания скриптов на языке PHP. Теперь, рассмотрим их более подробно.
Программа или скрипт на PHP, как правило, находится в файле расширением .php . Хотя разработчики могут также вставлять код php и в файлы с расширениями .html/.htm .
Когда пользователь обращается к скрипту в адресной строке браузера, набирая, например, http://localhost:8080/display.php , то веб-сервер передает его интерпретатору PHP. Затем интерпретатор обрабатывает код и генерирует на его основе html-разметку. И затем сгенерированный html-код отправляется пользователю.
Документ PHP может содержать как разметку html, так и код на языке php. Для перехода от разметки html к коду php используются теги , между которыми идет код php. Данные теги служат указанием интерпретатору, что их содержимое надо интерпретировать как код php, а не разметку html.
Также можно использовать краткую версию тегов: . Для этого в файле php.ini надо изменить значение short_open_tag = Off на short_open_tag = On
Рассмотрим простейший скрипт на php:
После обработки файла интерпретатор сформирует следующую разметку:
Привет мир!
2 + 2 = 4Здесь использованы две инструкции echo "
Привет мир!
" и echo "2 + 2 = " . (2+2) , который выводят определенное значение на страницу. Каждая отдельная инструкция в PHP завершается точкой с запятой.PHP, в настоящее время, – один из наиболее популярных языков для реализации веб-приложений. Данный курс посвящен изучению его основ. Акцент делается на практическое применение полученных навыков.
Язык PHP был создан для решения конкретной практической задачи в среде интернет (какой именно можно узнать, прочитав первую лекцию курса). Мы тоже постараемся не отвлекаться слишком сильно на теоретические рассуждения, и будем стремиться к решению какой-нибудь конкретной задачи в каждой из лекций. Большинство примеров взяты из реально существующей системы: виртуального музея истории информатики. Первая часть курса посвящена изучению основ синтаксиса и управляющим конструкциям. После этого рассматривается технология клиент-сервер, как основная сфера приложения языка PHP. Затем переходим к изучению наиболее полезных на наш взгляд встроенных функций и решению с их помощью практических задач. Хотя объектная модель в языке PHP не самая богатая, ее принципиальное наличие позволяет естественным образом описывать объектные модели данных. В качестве базовой модели будет рассмотрена модель документа виртуального музея информатики. После этого будет рассмотрен ряд прикладных аспектов: работа с файловой системой, с БД, строками, сессиями, DOM XML - все это позволит рассмотреть ключевые задачи практического использования языка.
Книга:
Основы синтаксиса
Основы синтаксиса
Мы приступаем к изучению основных элементов синтаксиса языка PHP. Рассмотрим способы разделения инструкций и создания комментариев, переменные, константы, типы данных и операторы.
В качестве примера решим задачу создания заготовки электронного письма. Ее смысл заключается в следующем.
Допустим, у вас есть какое-то объявление и несколько разных людей, которым нужно это объявление отправить. Для этого вы делаете заготовку с содержанием объявления, внутри которого есть ряд изменяющихся (в зависимости от потенциального получателя) параметров.
Основной синтаксис
Первое, что нужно знать относительно синтаксиса PHP, – это то, как он встраивается в HTML-код, как интерпретатор узнает, что это код на языке PHP. В предыдущей лекции мы уже говорили об этом. Повторяться не будем, отметим только, что в примерах мы чаще всего будем использовать вариант , и иногда сокращенный вариант .
Разделение инструкций
Программа на PHP (да и на любом другом языке программирования) – это набор команд (инструкций). Обработчику программы (парсеру) необходимо как-то отличать одну команду от другой. Для этого используются специальные символы – разделители. В PHP инструкции разделяются так же, как и в Cи или Perl, – каждое выражение заканчивается точкой с запятой.
Закрывающий тег «?>» также подразумевает конец инструкции, поэтому перед ним точку с запятой не ставят. Например, два следующих фрагмента кода эквивалентны:
echo "Hello, world!"; // точка с запятой
// в конце команды
// обязательна
?>
echo "Hello, world!" ?>
Комментарии
Часто при написании программ возникает необходимость делать какие-либо комментарии к коду, которые никак не влияют на сам код, а только поясняют его. Это важно при создании больших программ и в случае, если несколько человек работают над одной программой. При наличии комментариев в программе в ее коде разобраться гораздо проще. Кроме того, если решать задачу по частям, недоделанные части решения также удобно комментировать, чтобы не забыть о них в дальнейшем. Во всех языках программирования предусмотрена возможность включать комментарии в код программы. PHP поддерживает несколько видов комментариев: в стиле Cи, C++ и оболочки Unix. Символы // и # обозначают начало однострочных комментариев, /* и */ – соответственно начало и конец многострочных комментариев.
echo "Меня зовут Вася";
// Это однострочный комментарий
// в стиле С++
echo "Фамилия моя Петров";
/* Это многострочный комментарий.
Здесь можно написать несколько строк.
При исполнении программы все, что
находится здесь (закомментировано),
будет игнорировано. */
echo "Я изучаю PHP в INTUIT.ru";
# Это комментарий в стиле
# оболочки Unix
?>
Переменные, константы и операторы
Важным элементом каждого языка являются переменные, константы и операторы, применяемые к этим переменным и константам. Рассмотрим, как выделяются и обрабатываются эти элементы в PHP.
Переменные
Переменная в PHP обозначается знаком доллара, за которым следует ее имя. Например:
Имя переменной чувствительно к регистру, т.е. переменные $my_var и $My_var различны.
Имена переменных соответствуют тем же правилам, что и остальные наименования в PHP: правильное имя переменной должно начинаться с буквы или символа подчеркивания с последующими в любом количестве буквами, цифрами или символами подчеркивания.
В PHP 3 переменные всегда присваивались по значению. То есть когда вы присваиваете выражение переменной, все значения оригинального выражения копируются в эту переменную. Это означает, к примеру, что после присвоения одной переменной значения другой изменение одной из них не влияет на значение другой.
// значение
// " Text "
$second = $first; // Присваиваем $second
// значение
// переменной $first
$first = " New text "; // Изменяем
// значение
// $first
// на " New text "
echo "Переменая с именем first " .
"равна $first
";
// выводим значение $first
echo "Переменая с именем second " .
"равна $second";
// выводим значение $second
?>
Результат работы этого скрипта будет следующим:
Переменная с именем first равна New text
Переменная с именем second равна Text
PHP 4, кроме этого, предлагает еще один способ присвоения значений переменным: присвоение по ссылке. Для того чтобы присвоить значение переменной по ссылке, это значение должно иметь имя, т.е. оно должно быть представлено какой-либо переменной. Чтобы указать, что значение одной переменной присваивается другой переменной по ссылке, нужно перед именем первой переменной поставить знак амперсанд &.
Рассмотрим тот же пример, что и выше, только будем присваивать значение переменной first переменной second по ссылке:
$first = " Text "; // Присваиваем $first
// значение " Text "
$second = &$first;
/* Делаем ссылку на $first через $second.
Теперь значения этих переменных
будут всегда совпадать */
// Изменим значение $first
// на " New text "
$first = " New text ";
echo "Переменная с именем first " .
"равна $first
";
// выведем значения обеих переменных
echo "Переменная с именем second " .
"равна $second";
?>
Этот скрипт выведет следующее:
Переменная с именем first равна New text.
Переменная с именем second равна New text.
То есть вместе с переменной $first изменилась и переменная $second.
Константы
Для хранения постоянных величин, т.е. таких величин, значение которых не меняется в ходе выполнения скрипта, используются константы. Такими величинами могут быть математические константы, пароли, пути к файлам и т.п. Основное отличие константы от переменной состоит в том, что ей нельзя присвоить значение больше одного раза и ее значение нельзя аннулировать после ее объявления. Кроме того, у константы нет приставки в виде знака доллара и ее нельзя определить простым присваиванием значения. Как же тогда можно определить константу? Для этого существует специальная функция define(). Ее синтаксис таков:
define("Имя_константы",
"Значение_константы",
[Нечувствительность_к_регистру])
По умолчанию имена констант чувствительны к регистру. Для каждой константы это можно изменить, указав в качестве значения аргумента Нечувствительность_к_регистру значение True. Существует соглашение, по которому имена констант всегда пишутся в верхнем регистре.
Получить значение константы можно, указав ее имя. В отличие от переменных, не нужно предварять имя константы символом $. Кроме того, для получения значения константы можно использовать функцию constant() с именем константы в качестве параметра.
// определяем константу
// PASSWORD
define("PASSWORD","qwerty");
// определяем регистронезависимую
// константу PI со значением 3.14
define("PI","3.14", True);
// выведет значение константы PASSWORD,
// т.е. qwerty
echo (PASSWORD);
// тоже выведет qwerty
echo constant("PASSWORD");
echo (password);
/* выведет password и предупреждение,
поскольку мы ввели регистрозависимую
константу PASSWORD */
echo pi;
// выведет 3.14, поскольку константа PI
// регистронезависима по определению
?>
Кроме переменных, объявляемых пользователем, о которых мы только что рассказали, в PHP существует ряд констант, определяемых самим интерпретатором. Например, константа __FILE__ хранит имя файла программы (и путь к нему), которая выполняется в данный момент, __FUNCTION__ содержит имя функции, __CLASS__ – имя класса, PHP_VERSION – версия интерпретатора PHP. Полный список предопределенных констант можно получить, прочитав руководство по PHP.
Операторы
Операторы позволяют выполнять различные действия с переменными, константами и выражениями. Мы еще не упоминали о том, что такое выражение. Выражение можно определить как все, что угодно, что имеет значение. Переменные и константы – это основные и наиболее простые формы выражений. Существует множество операций (и соответствующих им операторов), которые можно производить с выражениями. Рассмотрим некоторые из них подробнее.
Сложение
Вычитание
Умножение
Остаток от деления
Конкатенация (сложение строк)
(это строка, состоящая из $a и $b)
Присваивание
Переменной слева от оператора будет присвоено значение, полученное в результате выполнения каких-либо операций или переменной/константы с правой стороны
$a = ($b = 4) +5;
($a будет равна 9, $b будет равна 4)
Сокращение. Прибавляет к переменной число и затем присваивает ей полученное значение
(эквивалентно $a = $a + 5;)
Сокращенно обозначает комбинацию операций конкатенации и присваивания (сначала добавляется строка, потом полученная строка записывается в переменную)
$b = "Привет ";
$b .= "всем";
В результате: $b="Привет всем"
$a и $b истинны (True)
Хотя бы одна из переменных $a или $b истинна (возможно, что и обе)
Исключающее или
Одна из переменных истинна. Случай, когда они обе истинны, исключается
Инверсия (NOT)
Если $a=True, то!$a=False и наоборот
Равенство
Значения переменных равны
Эквивалентность
Равны значения и типы переменных
Неравенство
Значения переменных не равны
Неравенство
Неэквивалентность
Переменные не эквивалентны
Меньше или равно
Больше или равно
Пре-инкремент
Увеличивает $a на единицу и возвращает $a
$a=4;
echo "Должно быть 4:" .$a++;
echo "Должно быть 6:" .++$a;
?>
Пост-инкремент
Возвращает $a, затем увеличивает $a на единицу
Пре-декремент
Уменьшает $a на единицу и возвращает $a
Пост-декремент
Возвращает $a, затем уменьшает $a на единицу
Типы данных
PHP поддерживает восемь простых типов данных.
Четыре скалярных типа:
Boolean (логический);
Integer (целый);
Float (с плавающей точкой);
String (строковый).
Два смешанных типа:
Array (массив);
Object (объект).
И два специальных типа:
Resource (ресурс);
В PHP не принято явное объявление типов переменных. Предпочтительнее, чтобы это делал сам интерпретатор во время выполнения программы в зависимости от контекста, в котором используется переменная. Рассмотрим по порядку все перечисленные типы данных.
Тип boolean (булев или логический тип)
Этот простейший тип выражает истинность значения, то есть переменная этого типа может иметь только два значения – истина TRUE или ложь FALSE.
Чтобы определить булев тип, используют ключевое слово TRUE или FALSE. Оба регистронезависимы.
$test = True;
?>
Логические переменные используются в различных управляющих конструкциях (циклах, условиях и т.п., более подробно речь о них пойдет в одной из следующих лекций). Иметь логический тип, т.е. принимать только два значения, истину или ложь, могут также и некоторые операторы (например, оператор равенства). Они также используются в управляющих конструкциях для проверки каких-либо условий. Например, в условной конструкции проверяется истинность значения оператора или переменной и в зависимости от результата проверки выполняются те или иные действия. Здесь условие может быть истинно или ложно, что как раз и отражает переменная и оператор логического типа.
// Оператор "==" проверяет равенство
// и возвращает
// булево значение
if ($know == False) { // если $know
// имеет значение
// false
echo "Изучай PHP!";
}
if (!$know) { // то же самое, что
// и выше, т.е. проверка
// имеет ли $know значение
// false
echo "Изучай PHP!";
}
/* оператор == проверяет, совпадает ли
значение переменной $action со строкой
"Изучить PHP". Если совпадает, то
возвращает true, иначе – false.
Если возвращено true, то выполняется
то, что внутри фигурных скобок */
if ($action == "Изучить PHP")
{ echo "Начал изучать"; }
?>
Тип integer (целые)
Этот тип задает число из множества целых чисел Z = {..., -2, -1, 0, 1, 2, ...}. Целые могут быть указаны в десятичной, шестнадцатеричной или восьмеричной системе счисления, по желанию с предшествующим знаком «-» или «+».
Если вы используете восьмеричную систему счисления, вы должны предварить число 0 (нулем), для использования шестнадцатеричной системы нужно поставить перед числом 0x.
# десятичное число
$a = 1234;
# отрицательное число
$a = -123;
# восьмеричное число (эквивалентно
# 83 в десятичной системе)
$a = 0123;
# шестнадцатеричное число (эквивалентно
# 26 в десятичной системе)
$a = 0x1A;
?>
Размер целого зависит от платформы, хотя, как правило, максимальное значение около двух миллиардов (это 32-битное знаковое). Беззнаковые целые PHP не поддерживает.
Если вы определите число, превышающее пределы целого типа, оно будет интерпретировано как число с плавающей точкой. Также если вы используете оператор, результатом работы которого будет число, превышающее пределы целого, вместо него будет возвращено число с плавающей точкой.
В PHP не существует оператора деления целых. Результатом 1/2 будет число с плавающей точкой 0.5. Вы можете привести значение к целому, что всегда округляет его в меньшую сторону, либо использовать функцию round(), округляющую значение по стандартным правилам. Для преобразования переменной к конкретному типу нужно перед переменной указать в скобках нужный тип. Например, для преобразования переменной $a=0.5 к целому типу необходимо написать (integer)(0.5) или (integer) $a или использовать сокращенную запись (int)(0.5). Возможность явного приведения типов по такому принципу существует для всех типов данных (конечно, не всегда значение одного типа можно перевести в другой тип). Мы не будем углубляться во все тонкости приведения типов, поскольку PHP делает это автоматически в зависимости от контекста.
Тип float (числа с плавающей точкой)
Числа с плавающей точкой (они же числа двойной точности или действительные числа) могут быть определены при помощи любого из следующих синтаксисов:
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>
Размер числа с плавающей точкой зависит от платформы, хотя максимум, как правило, ~1.8e308 с точностью около 14 десятичных цифр.
Тип string (строки)
Строка – это набор символов. В PHP символ – это то же самое, что байт, это значит, что существует ровно 256 различных символов. Это также означает, что PHP не имеет встроенной поддержки Unicode. В PHP практически не существует ограничений на размер строк, поэтому нет абсолютно никаких причин беспокоиться об их длине.
Строка в PHP может быть определена тремя различными способами:
С помощью одинарных кавычек;
С помощью двойных кавычек;
Heredoc-синтаксисом.
Одинарные кавычки
Простейший способ определить строку – это заключить ее в одинарные кавычки «"». Чтобы использовать одинарную кавычку внутри строки, как и во многих других языках, перед ней необходимо поставить символ обратной косой черты «», т. е. экранировать ее. Если обратная косая черта должна идти перед одинарной кавычкой либо быть в конце строки, необходимо продублировать ее «"».
Если внутри строки, заключенной в одинарные кавычки, обратный слэш «» встречается перед любым другим символом (отличным от «» и «"»), то он рассматривается как обычный символ и выводится, как и все остальные. Поэтому обратную косую черту необходимо экранировать, только если она находится в конце строки, перед закрывающей кавычкой.
В PHP существует ряд комбинаций символов, начинающихся с символа обратной косой черты. Их называют управляющими последовательностями, и они имеют специальные значения, о которых мы расскажем немного позднее. Так вот, в отличие от двух других синтаксисов, переменные и управляющие последовательности для специальных символов, встречающиеся в строках, заключенных в одинарные кавычки, не обрабатываются.
echo "Также вы можете вставлять в строки
символ новой строки таким образом,
поскольку это нормально";
// Выведет: Чтобы вывести " надо
// перед ней поставить
echo "Чтобы вывести " надо перед "
"ней поставить ";
// Выведет: Вы хотите удалить C:*.*?
echo "Вы хотите удалить C:*.*?";
// Выведет: Это не вставит: n
// новую строку
echo "Это не вставит: n новую строку";
// Выведет: Переменные $expand также
// $either не подставляются
echo "Переменные $expand также $either" .
"не подставляются";
?>
Двойные кавычки
Если строка заключена в двойные кавычки «"», PHP распознает большее количество управляющих последовательностей для специальных символов. Некоторые из них приведены в таблице 2.7.
Новая строка (LF или 0x0A (10) в ASCII)
Возврат каретки (CR или 0x0D (13) в ASCII)
Горизонтальная табуляция (HT или 0x09 (9) в ASCII)
Обратная косая черта
Знак доллара
Двойная кавычка
Повторяем, если вы захотите экранировать любой другой символ, обратная косая черта также будет напечатана!
Самым важным свойством строк в двойных кавычках является обработка переменных.
Другой способ определения строк – это использование heredoc-синтаксиса. В этом случае строка должна начинаться с символа <<<, после которого идет идентификатор. Заканчивается строка этим же идентификатором. Закрывающий идентификатор должен начинаться в первом столбце строки. Кроме того, идентификатор должен соответствовать тем же правилам именования, что и все остальные метки в PHP: содержать только буквенно-цифровые символы и знак подчеркивания и начинаться не с цифры или знака подчеркивания.
Heredoc-текст ведет себя так же, как и строка в двойных кавычках, при этом их не имея. Это означает, что вам нет необходимости экранировать кавычки в heredoc, но вы по-прежнему можете использовать перечисленные выше управляющие последовательности. Переменные внутри heredoc тоже обрабатываются.
$str = <<
строчек, с использованием
heredoc-синтаксиса
EOD;
// Здесь идентификатор – EOD. Ниже
// идентификатор EOT
$name = "Вася";
echo <<
EOT;
// это выведет "Меня зовут "Вася"."
?>
Замечание: Поддержка heredoc была добавлена в PHP 4.
Тип array (массив)
Массив в PHP представляет собой упорядоченную карту – тип, который преобразует значения в ключи. Этот тип оптимизирован в нескольких направлениях, поэтому вы можете использовать его как собственно массив, список (вектор), хеш-таблицу (являющуюся реализацией карты), стэк, очередь и т.д. Поскольку вы можете иметь в качестве значения другой массив PHP, можно также легко эмулировать деревья.
Определить массив можно с помощью конструкции array() или непосредственно задавая значения его элементам.
Определение при помощи array()
array ( => value,
=> value1, ...)
Языковая конструкция array() принимает в качестве параметров пары ключ => значение, разделенные запятыми. Символ => устанавливает соответствие между значением и его ключом. Ключ может быть как целым числом, так и строкой, а значение может быть любого имеющегося в PHP типа. Числовой ключ массива часто называют индексом. Индексирование массива в PHP начинается с нуля. Значение элемента массива можно получить, указав после имени массива в квадратных скобках ключ искомого элемента. Если ключ массива представляет собой стандартную запись целого числа, то он рассматривается как число, в противном случае – как строка. Поэтому запись $a["1"] равносильна записи $a, так же как и $a["-1"] равносильно $a[-1].
$books = array ("php" =>
"PHP users guide",
12 => true);
echo $books["php"];
//выведет "PHP users guide"
echo $books; //выведет 1
?>
Если для элемента ключ не задан, то в качестве ключа берется максимальный числовой ключ, увеличенный на единицу. Если указать ключ, которому уже было присвоено какое-то значение, то оно будет перезаписано. Начиная с PHP 4.3.0, если максимальный ключ – отрицательное число, то следующим ключом массива будет ноль (0).
// массивы $arr и $arr1 эквиваленты
$arr = array(5 => 43, 32, 56, "b" => 12);
$arr1 = array(5 => 43, 6 => 32,
7 => 56, "b" => 12);
?>
Если использовать в качестве ключа TRUE или FALSE, то его значение переводится соответственно в единицу и ноль типа integer. Если использовать NULL, то вместо ключа получим пустую строку. Можно использовать и саму пустую строку в качестве ключа, при этом ее надо брать в кавычки. Так что это не то же самое, что использование пустых квадратных скобок. Нельзя использовать в качестве ключа массивы и объекты.
Определение с помощью синтаксиса квадратных скобок
Создать массив можно, просто записывая в него значения. Как мы уже говорили, значение элемента массива можно получить с помощью квадратных скобок, внутри которых нужно указать его ключ например, $book["php"]. Если указать новый ключ и новое значение например, $book["new_key"]="new_value", то в массив добавится новый элемент. Если мы не укажем ключ, а только присвоим значение $book="new_value", то новый элемент массива будет иметь числовой ключ, на единицу больший максимального существующего. Если массив, в который мы добавляем значения, еще не существует, то он будет создан.
$books["key"]= value; // добавили в массив
// $books значение
// value с ключом key
$books = value1; /* добавили в массив
значение value1 с
ключом 13, поскольку
максимальный ключ у
нас был 12 */
?>
Для того чтобы изменить конкретный элемент массива, нужно просто присвоить ему с его ключом новое значение. Изменить ключ элемента нельзя, можно только удалить элемент (пару ключ/значение) и добавить новую. Чтобы удалить элемент массива, нужно использовать функцию unset().
$books = array ("php" =>
"PHP users guide",
12 => true);
$books =
"Book about Perl"; // добавили элемент
// с ключом (индексом)
// 13 это эквивалентно
// $books =
// "Book about Perl";
$books["lisp"] =
123456; /* Это добавляет к массиву новый
элемент с ключом "lisp" и
значением 123456 */
unset($books); // Это удаляет элемент
// c ключом 12 из массива
unset ($books); // удаляет массив полностью
?>
Заметим, что, когда используются пустые квадратные скобки, максимальный числовой ключ ищется среди ключей, существующих в массиве с момента последнего переиндексирования. Переиндексировать массив можно с помощью функции array_values().
$arr =
array ("a","b","c"); /* Создаем массив
со значениями
"a", "b" и "c".
Поскольку ключи
не указаны, они
будут 0,1,2
соответственно */
// и значения)
unset($arr);
unset($arr);
unset($arr);
// удаляем из него все значения
print_r($arr); // выводим массив (и ключи,
// и значения)
$arr = "aa"; // добавляем новый элемент
// в массив.
// Его индексом (ключом)
// будет 3, а не 0
print_r($arr);
$arr =
array_values($arr); // переиндексируем
// массив
$arr = "bb"; // ключом этого элемента
// будет 1
print_r($arr);
?>
Результатом работы этого скрипта будет:
Array ( => a => b => c)
Array ()
Array ( => aa)
Array ( => aa => bb)
Тип object (объекты)
Объекты – тип данных, пришедший из объектно-ориентированного программирования (ООП). Согласно принципам ООП, класс – это набор объектов, обладающих определенными свойствами и методами работы с ним, а объект соответственно – экземпляр класса. Например, программисты – это класс людей, которые пишут программы, изучают компьютерную литературу и, кроме того, как все люди, имеют имя и фамилию. Теперь, если взять одного конкретного программиста, Васю Иванова, то можно сказать, что он является объектом класса программистов, обладает теми же свойствами, что и другие программисты, тоже имеет имя, пишет программы и т.п.
В PHP для доступа к методам объекта используется оператор ->. Для инициализации объекта используется выражение new, создающее в переменной экземпляр объекта.
//создаем класс людей
class Person
{
// метод, который обучает человека PHP
function know_php()
{
echo "Теперь я знаю PHP";
}
}
$bob = new Person; // создаем объект
// класса человек
$bob -> know_php(); // обучаем его PHP
?>
Более подробно реализацию принципов ООП в языке PHP мы рассмотрим в одной из следующих лекций.
Тип resource (ресурсы)
Ресурс – это специальная переменная, содержащая ссылку на внешний ресурс (например, соединение с базой данных). Ресурсы создаются и используются специальными функциями (например, mysql_connect(), pdf_new() и т.п.).
Тип Null
Специальное значение NULL говорит о том, что переменная не имеет значения.
Переменная считается NULL, если:
Ей была присвоена константа NULL ($var = NULL);
Ей еще не было присвоено какое-либо значение;
Она была удалена с помощью unset().
Существует только одно значение типа NULL – регистронезависимое ключевое слово NULL.
Решение задачи
Теперь вернемся к задаче, которую мы поставили в самом начале лекции. Напомним, что она состояла в составлении письма разным людям по поводу разных событий. Попытаемся использовать для решения этой задачи изученные средства – переменные, операторы, константы, строки и массивы. В зависимости от получателя изменяется событие и обращение, указанные в письме, поэтому естественно вынести эти величины в переменные. Более того, поскольку событий и людей много, удобно использовать переменные типа массив. Подпись в письме остается постоянной всегда, поэтому логично задать ее как константу. Чтобы не писать слишком длинные и громоздкие строки, используем оператор конкатенации. Итак, вот что получилось:
// пусть наша подпись
// будет константой
define("SIGN","С уважением, Вася");
// зададим массивы людей и событий
$names = array("Иван Иванович",
"Петр Петрович",
"Семен Семенович");
$events = array(
"f" => "день открытых дверей",
"o" => "открытие выставки",
"p" => "бал выпускников");
// составим текст приглашения
$str = "Уважаемый (ая), $names";
$str .= "
Приглашаем Вас на ".
$events["f"];
$str .= "
" . SIGN;
echo $str; // выведем текст на экран
?>
Заключение
Итак, в этой лекции мы познакомились с основами синтаксиса языка PHP, научились работать с переменными различных типов, константами, операторами, познакомились со всеми существующими в PHP типами данных. Говоря о таких типах данных, как строки и массивы, мы разобрали только самые основы. Эти конструкции настолько удобны и просты в использовании, что заслуживают отдельного разговора. Подробности будут изложены в последующих лекциях. Решая задачу, мы старались использовать только имеющиеся знания и не забегать вперед, поэтому решение не слишком подходит для практического применения. В следующей лекции мы исправим этот недостаток и создадим более универсальный шаблон электронного письма.
Синтаксис PHP заимствован непосредствено из C. Java и Perl также повлияли на синтаксис данного языка.
Переход из HTML
Есть три способа выхода из HTML и перехода в
"режим PHP кода":
Разделение инструкций
Инструкции (утверждения) разделяются также как в C или Perl - точкой с запятой.
Закрывающий тэг (?>) тоже подразумевает конец утверждения, поэтому следующие записи эквивалентны:
PHP поддерживает переменные следующих типов: Тип переменной обычно не устанавливается
программистом; вместо этого, он определяется PHP
во время выполнения программы, в зависимости от
контекста в котором данная переменная
используется. Если вам нравится указывать тип переменной
непосредственно, вы можете использовать для
этого инструкцию
либо функцию . Учтите, что переменная может вести себя по
разному в определенных ситуациях, в
зависимости от того, какой тип определен для нее
в данное время. Более подробно это описано в
разделе . Для инициализации переменной в PHP вы просто
присваиваите ей значение. Для большинства
переменных это именно так; для массивов и
объектных переменных, однако, может
использоваться несколько иной механизм. Массив может инициализироваться одним из двух
способов: последовательным присвоением
значений, или посредством конструкции (которая описана в разделе ). При последовательном добавлении значений в
массив вы просто записываете значения элементов
массива, используя пустой индекс. Каждое
последующее значение будет добавляться в
качестве последнего элемента массива. $names = "Jill"; // $names = "Jill"
$names = "Jack"; // $names = "Jack" Как в C и Perl, элементы массива нумеруются
начиная с 0, а не с 1. Для инициализации объектной переменной
используйте новое предписание для сопоставления
данного объекта объектной переменной. Class foo {
function do_foo () {
echo "Doing foo.";
}
}
$bar = new foo;
$bar -> do_foo (); Областью переменной является контекст, внутри
которого она определена. Главным образом, все
переменные PHP имеют одну область. Однако, внутри
функций определенных пользователем,
представлена локальная область функции. Любая
переменная, определенная внутри функции, по
умолчанию ограничена локальной областью
функции. Например: $a = 1; /* глобальная область */
Function Test () {
echo $a; /* ссылка на переменную локальной области */
}
Test (); Этот скрипт не выдаст что-либо на выходе,
поскольку инструкция echo относится к локальной
версии переменной $a, значение которой
присваивается не внутри этой области. Вы можете
заметить, что здесь имеется некоторое отличие от
языка C, в том что глобальные переменные в C
автоматически действуют и внутри функций,
если только они не переписываются локальными
определениями. Это может вызвать некоторые
проблемы, т.к. по неосторожности можно изменить
глобальную переменную. В PHP глобальные
переменные должны быть продекларированы
глобально внутри функции, если предполагается их
использование в данной функции. Например: $a = 1;
$b = 2;
Function Sum () {
global $a, $b;
$b = $a + $b;
}
Sum ();
echo $b; Вышеописанный скрипт выдаст значение "3".
Поскольку $a и $b декларируются глобально внутри
функции, ссылки на данные переменные трактуются
как ссылки на их глобальные версии. Нет
ограничений на количество глобальных
переменных, которыми можно манипулировать
внутри функции. Вторым способом доступа к переменным из
глобальной области является использование
специального опеределяемого PHP массива $GLOBALS. При
этом предыдущий пример может быть записан как: $a = 1;
$b = 2;
Function Sum () {
$GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
}
Sum ();
echo $b; Массив $GLOBALS является ассоциативным массивом, в
котором имя глобальной переменной является
ключом, а значение этой переменной является
значением элемента массива. Другой важной характеристикой от области
определения переменной является статическая
переменная. Статическая переменная существует
только в локальной области функции, но она не
теряет своего значения когда программа, при
исполнении, покидает эту область. Рассмотрим
следующий пример: Function Test () {
$a = 0;
echo $a;
$a++;
} Эта функция совершенно бесполезна практически,
поскольку каждый раз при ее вызове она
устанавливает $a в 0 и выводит "0".
Выражение $a++ , которое увеличивает значение
переменной, так же бесполезно, поскольку при
выходе из функции переменная $a исчезает. Для
придания дееспособности функции подсчета,
которая не теряла бы нить текущего счета,
переменная $a декларируется как статическая: Function Test () {
static $a = 0;
echo $a;
$a++;
} Теперь, каждый раз при вызове функции Test() она
будет выводить значение $a и увеличивать его. Статические переменные также весьма
существенны, когда функции вызываются
рекурсивно. Рекурсивные функции - это те, которые
вызывают сами себя. Составлять рекурсивную
функцию нужно внимательно, т.к. при неправильном
написании можно сделать рекурсию
неопределенной. Вы должны быть уверены в
адекватности способа прекращения рекурсии.
Следующая простая функция рекурсивно считает до
10: Function Test () {
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
Test ();
}
$count--;
} Иногда бывает удобно давать переменным
изменяемые имена. Такие имена могут изменяться
динамически. Обычная переменая устанавливается
так: Изменяемая переменная берет некое значение и
обрабатывает его как имя переменной. В
приведенном выше примере значение hello
может быть использовано как имя переменной,
посредством применения двух записанных подряд
знаков доллара, т.е.: С этой точки зрения, две переменных определены
и сохранены в символьном дереве PHP: $a с содержимым
"hello" и $hello с содержимым "world". Так,
инструкция: Echo "$a ${$a}"; осуществляет то же самое, что и инструкция: Echo "$a $hello"; а именно, обе они выводят: hello world
. Чтобы использовать изменяемые переменные с
массивами, необходимо решить проблему
неоднозначности. Это означает, что если вы пишете
$$a, то синтаксическому анализатору необходимо
знать, имеете ли вы в виду использовать $a как
переменую, или вы предполагаете $$a как
переменную а как индекс этой переменной.
Синтаксис для разрешения подобной
неоднозначности такой: ${$a} для первого случая и
${$a} для второго. Когда программой-обработчиком формы является
PHP-скрипт, переменные этой формы автоматически
доступны для данного скрипта PHP. Например,
рассмотрим следующую форму:
Пример 5-2. Простая переменная
формы
При активизации формы PHP создаст переменную $name , значением которой будет то
содержимое, которое было введено в поле Name:
данной формы. PHP также воспринимает массивы в контексте
переменных формы, но только одномерные. Вы
можете, например, группировать взаимосвязанные
переменные вместе или использовать это свойство
для определения значений переменных при
множественном выборе на входе:
Если PHP-атрибут track_vars включен, через установку
конфигурации
или директивой ,
тогда переменные, активизированные посредством
методов POST или GET, будут также находиться в
глобальных ассоциативных массивах $HTTP_POST_VARS и
$HTTP_GET_VARS соответственно. При активизации (запуске) формы можно
использовать рисунок (изображение) вместо
стандартной кнопки запуска, в тэге подобном
этому: Когда пользователь нажимает кнопку мыши где-либо
над таким рисунком, сопровождающая форма
передается на сервер с двумя дополнительными
переменными, sub_x и sub_y. Они содержат координаты
места нажатия кнопки мыши пользователем внутри
данного рисунка. Можно отметить, что практически,
реальные имена переменных передаваемые
браузером, содержат точку вместо символа
подчеркивания, но PHP конвертирует точку в элемент
подчеркивания (underscore) автоматически. PHP очевидным образом поддерживает HTTP кукисы,
как это определено в .
Кукисы являются механизмом хранения данных в
удаленном браузере, используемым для поддержки
процедуры обмена или идентификации ответа
пользователя. Кукисы можно устанавливать
используя функцию .
Кукисы являются частью заголовка HTTP, поэтому
функция должна вызываться прежде чем какие-либо
передаваемые данные посылаются браузеру. Это
такое же ограничение, как и для функции .
Любые кукисы, посылаемые вам клиентом,
автоматически преобразовываются в переменные PHP,
также как данные методов GET и POST. Если необходимо назначить множественные
значения одному кукису, просто добавьте
квадратные скобки к имени кукиса. Например: SetCookie ("MyCookie", "Testing", time()+3600); Учтите, что текущий кукис заменит предыдущий с
тем же именем в вашем браузере, если только путь
или домен не являются различными. Поэтому, при
работе с программами обслуживания карт вы можете
использовать для сохранения данных счетчик и
посылать его значения дальше и т.п.
Пример 5-4. Пример функции SetCookie
$Count++;
SetCookie ("Count", $Count, time()+3600);
SetCookie ("Cart[$Count]", $item, time()+3600); PHP автоматически создает переменные окружения,
как и обычные переменные. Echo $HOME; /* Показывает переменную окружения HOME,
если она установлена. */ Хотя при поступлении информации механизмы GET,
POST и Cookie также атоматически создают переменные PHP,
иногда лучше явным образом прочитать переменную
окружения, для того чтобы быть уверенным в
получении ее правильной версии. Для этого может
использоваться функция .
Для установки значения переменной окружения
пользуйтесь функцией .
PHP не требует явного определения типа при
объявлении переменной, тип переменной
определяется по контексту в котором она
используется. То есть, если вы присваиваете
строковое значение переменной var
,
var
становится строкой. Если
затем присвоить переменной var
значение
целого (числа), то она станет целым. Примером автоматического преобразования типа
в PHP может служить оператор сложения "+". Если
какой-либо из оперендов является числом с
дробной частью (тип double), то затем все операнды
оцениваются как double и результат будет иметь тип
double. Иначе, эти операнды будут интерпретированы
как целые (integers) и результат будет так же иметь
тип integer. Отметим, что при этом НЕ меняются типы
самих операндов, меняется только оценка этих
операндов. $foo = "0"; // $foo является строкой (ASCII 48)
$foo++; // $foo является строкой "1" (ASCII 49)
$foo += 1; // $foo сейчас является целым (2)
$foo = $foo + 1.3; // $foo сейчас имеет тип double (3.3)
$foo = 5 + "10 Little Piggies"; // $foo является целым (15)
$foo = 5 + "10 Small Pigs"; // $foo является целым (15) Если вы хотите чтобы переменная принудительно
оценивалась как имеющая определенный тип,
смотрите раздел . Если вы желаете изменить тип переменной,
смотритеТипы переменных
Инициализация переменной
Инициализация
Массивов
Инициализация
объектов
Область Переменной
Изменяемые переменные
Переменные вне PHP
HTML Формы (GET и POST)
Имена переменных РИСУНКА
АКТИВИЗАЦИИ
HTTP Кукисы
Переменные окружения
Директивы конфигурации
сервера
Изменение типа
