php use что это
Php use что это
(PHP 5 >= 5.3.0, PHP 7, PHP 8)
Ниже приведён пример трёх вариантов синтаксиса в реальном коде:
namespace Foo \ Bar \ subnamespace ;
const FOO = 1 ;
function foo () <>
class foo
<
static function staticmethod () <>
>
?>
namespace Foo \ Bar ;
include ‘file1.php’ ;
const FOO = 2 ;
function foo () <>
class foo
<
static function staticmethod () <>
>
/* Неполные имена */
foo (); // определяется как функция Foo\Bar\foo
foo :: staticmethod (); // определяется как класс Foo\Bar\foo с методом staticmethod
echo FOO ; // определяется как константа Foo\Bar\FOO
/* Полные имена */
subnamespace \ foo (); // определяется как функция Foo\Bar\subnamespace\foo
subnamespace \ foo :: staticmethod (); // определяется как класс Foo\Bar\subnamespace\foo
// c методом staticmethod
echo subnamespace \ FOO ; // определяется как константа Foo\Bar\subnamespace\FOO
/* Абсолютные имена */
\ Foo \ Bar \ foo (); // определяется как функция Foo\Bar\foo
\ Foo \ Bar \ foo :: staticmethod (); // определяется как класс Foo\Bar\foo с методом staticmethod
echo \ Foo \ Bar \ FOO ; // определяется как константа Foo\Bar\FOO
?>
Пример #1 Доступ к глобальным классам, функциям и константам из пространства имён
function strlen () <>
const INI_ALL = 3 ;
class Exception <>
$a = \ strlen ( ‘hi’ ); // вызывает глобальную функцию strlen
$b = \ INI_ALL ; // получает доступ к глобальной константе INI_ALL
$c = new \ Exception ( ‘error’ ); // Создаёт экземпляр глобального класса Exception
?>
Php use что это
(PHP 5 >= 5.3.0, PHP 7, PHP 8)
PHP может создавать псевдонимы имени/импортировать константы, функции, классы, интерфейсы и пространства имён.
Пример #1 импорт/создание псевдонима имени с помощью оператора use
namespace foo ;
use My \ Full \ Classname as Another ;
// это тоже самое, что и использование My\Full\NSname as NSname
use My \ Full \ NSname ;
// импортирование глобального класса
use ArrayObject ;
// импортирование функции
use function My \ Full \ functionName ;
// псевдоним функции
use function My \ Full \ functionName as func ;
// импортирование константы
use const My \ Full \ CONSTANT ;
$obj = new namespace\ Another ; // создаёт экземпляр класса foo\Another
$obj = new Another ; // создаёт объект класса My\Full\Classname
NSname \ subns \ func (); // вызывает функцию My\Full\NSname\subns\func
$a = new ArrayObject (array( 1 )); // создаёт объект класса ArrayObject
// без выражения «use ArrayObject» мы создадим объект класса foo\ArrayObject
func (); // вызывает функцию My\Full\functionName
echo CONSTANT ; // выводит содержимое константы My\Full\CONSTANT
?>
PHP дополнительно поддерживает удобное сокращение для задания нескольких операторов use в одной и той же строке
Пример #2 импорт/создание псевдонима имени с помощью оператора use, комбинирование нескольких операторов use
$obj = new Another ; // создаёт объект класса My\Full\Classname
NSname \ subns \ func (); // вызывает функцию My\Full\NSname\subns\func
?>
Импорт выполняется во время компиляции и поэтому не влияет на имена динамических классов, функций или констант.
Пример #3 Импорт и динамические имена
В дополнение, импорт распространяется только на неполные и полные имена. Абсолютные имена не затрагиваются операцией импорта.
Пример #4 Импортирование и абсолютные имена
$obj = new Another ; // создаёт объект класса My\Full\Classname
$obj = new \ Another ; // создаёт объект класса Another
$obj = new Another \ thing ; // создаёт объект класса My\Full\Classname\thing
$obj = new \ Another \ thing ; // создаёт объект класса Another\thing
?>
Обзор правил для импорта
Ключевое слово use должно быть указано в самом начале файла (в глобальной области) или внутри объявления пространства имён. Это необходимо потому, что импорт выполняется во время компиляции, а не во время исполнения, поэтому оно не может быть заключено в блок. Следующий пример показывает недопустимое применение ключевого слова use :
Пример #5 Недопустимое правило импорта
function toGreenlandic ()
<
use Languages \ Danish ;
Правила импорта задаются на каждый файл отдельно. Это означает, что присоединяемые файлы НЕ будут наследовать правила импорта из родительского файла.
Описание группирования в одном операторе use
use some \namespace\ ClassA ;
use some \namespace\ ClassB ;
use some \namespace\ ClassC as C ;
use function some \namespace\ fn_a ;
use function some \namespace\ fn_b ;
use function some \namespace\ fn_c ;
use const some \namespace\ ConstA ;
use const some \namespace\ ConstB ;
use const some \namespace\ ConstC ;
Пространства имен в PHP, разъяснение
Прим.пер.: Я в курсе, что на момент перевода актуальная версия PHP — 5.5, а также что есть мудрая книга мануал. Но мне показалось интересным, то как автор преподносит namespace функционал, возможно кому-то из тех, кто только постигает азы (да и не только, есть немало бородатых разработчиков, остановившихся на PHP 5.2), статья поможет проникнуться. Ходор.
Глобальное пространство имен
Вот такой, очень простой класс:
Ничего особенно, как видите, и если вы хотите использовать его, просто сделайте так:
Хорошо, хорошо, извини. Суть в том, что мы можем думать об этом классе, как находящимся в глобальном пространстве имён.Я не совсем уверен, что это правильный термин, но на мой взгляд это звучит вполне уместно. Собственно, это значит то, что класс не принадлежит никакому пакету, просто обычный класс.
Простое использование пространств имён
Давайте создадим еще одного Эддарда, рядом с тем, глобальным. 
Здесь у нас очень похожий класс с одним небольшим изменением, добавлена директива пространства имен. Строка namespace Stark; говорит PHP что мы работаем в пространстве имен Stark и любой код (объявление классов, функций, переменных и т.д.) будет относиться к нему.
Итак, нам нужно создать нового Эдда, если вы решили что это нужно сделать вот так:
То нет, это не так. Здесь мы получаем экземпляр класса из первого примера, который мы создали ранее. Не тот, в пространстве имен Stark. Давайте попробуем создать экземпляр Эддарда Старка.
Для создания экземпляра класса нам нужно предварить имя класса префиксом из названия пространства имен, которому класс принадлежит, а в качестве разделителя использовать обратную косую черту. В итоге у нас есть экземпляр именно того класса, что нам нужен. Разве это не волшебно?
К слову сказать, пространства имён могут образовывать сколь угодно сложную иерархию, используя столько уровней, сколько потребуется. Например:
Теория относительности
Помните, как я сказал вам, что PHP всегда работает относительно текущего пространства имен. Давайте взглянем на это в действии:
Добавив директиву пространства имён, мы дали понять PHP, что мы находимся в пространстве имён Stark. Так как именно в нем мы определили класс Eddard, то именно его мы и получим. Видите — все относительно.
Сейчас, когда мы изменили пространство имён, у нас возникла одна маленькая проблема. Есть идеи, о чем я? А как нам теперь получить наш оригинальный класс Eddard? Ну тот, который в глобальном пространстве?
К счастью в PHP есть трюк, который позволит нам решить эту проблему — просто добавив \ к имени класса.
Видя ведущий слеш PHP понимает, что нужно выглянуть за пределы текущего namespace и создает экземпляр нужного нам класса.
А сейчас включи свое воображение. Представь, что у нас есть класс из другого пространства имен, названный Tully\Edmure. Сейчас нам нужно использовать его внутри пространства Stark. И как нам это сделать? 
И снова нам пришлось использовать обратный слеш, чтобы перейти к глобальной видимости, прежде чем создать экземпляр класса в пространстве Tully.
Вообще, ссылаться вот так на классы из других пространств имен, используя полную иерархию в названии, может быть довольно утомительно. Но к счастью, есть возможность сделать ярлык, давайте посмотрим:
А, еще один маленький трюк! Мы можем дать нашим импортируемым классам прозвища:
Давая Daenerys из пространства Dothraki прозвище Khaleesi, мы можем использовать оба класса Daenerys. Довольно удобно, там мы можем использовать все необходимые классы в нашем приложении. 
Структура
Пространства имен также могут помочь нам в организации нашего кода. Позвольте, я продемонстрирую.
Скажем, я хочу создать библиотеку с открытым исходным кодом. Мне бы очень хотелось, чтобы другие могли использовать мой код, это было бы здорово! Беда в том, что имена классов в моем коде конфликтовали с собственным приложением пользователя моей библиотеки. Это было бы ужасно неудобно. Вот как я решу эту проблему:
Здесь я использовал свое имя, чтобы показать, что код принадлежит мне, и отделить свой код от кода пользователя моей библиотеки. Внутри базового пространства имен я создал структуру классов в соответствии с их иерархией.
Начав использовать composer, вы узнаете, как использовать пространства имён для упрощения автозагрузки кода. Я настоятельно рекомендую вам взглянуть на этот полезный механизм.
Недостатки
По правде говоря, я чувствую себя немного виноватым за то, что назвал этот подзаголовок «Недостатки». То, о чем я собираюсь говорить, на самом деле ошибкой не является.
Дело в том, что в других языках функционал пространств имён реализован похожим образом, и при этом языки обеспечивают дополнительный функционал для взаимодействия с пространствами имён.
В Java, например, вы можете импортировать несколько классов в текущее пространство имен, используя оператор импорта. В Java, import является аналогом use и он использует точки, чтобы отделить вложенные пространства имен (или пакеты). Вот пример:
В PHP у вас так не выйдет. Вы должны импортировать каждый класс в отдельности. Извините. Собственно, почему я извиняюсь? Идите и жалуйтесь команде разработчиков PHP, но я прошу вас — будьте вежливы. Они сделали много интересного в последнее время.
Вот изящный трюк, чтобы немного сгладить озвученную проблему. Представьте себе, что у нас есть структура классов из предыдущего примера. Мы можем взять часть подпространства и дать ему псевдоним. 
Это может быть полезным при использовании большого числа классов. Добра всем!
Все пожелания и предложения с радостью приму в личку, спасибо.
Как использовать пространства имён в PHP, Часть 2: импортирование, псевдонимы и правила разбора имён
В части 1, мы обсуждали для чего нужны пространства имён (namespaces) в PHP, и что обозначает зарезервированное слово namespace. В этой статье мы исследуем оператор use и способ, которым PHP разрешает имена пространств имён.
В целях данной статьи мы будем использовать два почти идентичных кода, единственное различие которых — в их пространствах имён:
lib1.php:
lib2.php:
Прежде чем мы начнём, давайте вспомним несколько определений из PHP терминологии:
Полное квалифицированное имя (Fully-qualified name)
Любой PHP код может ссылаться на полное квалифицированное имя — идентификатор, начинающийся с разделителя пространства имён (т. е. обратного слэша — backslash), например: \App\Lib1\MYCONST, \App\Lib2\MyFunction() и т.д.
В полных квалифицированных именах нет никакой двусмысленности. Начальный обратный слэш действует аналогичным образом как и путь к файлу, обозначая «корень (root)» глобального пространства. Если бы мы выполняли различные MyFunction() в нашем глобальном пространстве, они могли бы быть вызваны из lib1.php или lib2.php с помощью \MyFunction().
Полные квалифицированные имена полезны для одноразового вызова функций или инициализации объектов. Однако, когда вы делаете много вызовов, они становятся непрактичными. Как мы узнаем ниже, PHP предлагает другие варианты в этих случаях.
Квалифицированное имя (Qualified name)
Идентификатор, имеющий как минимум хотя бы один разделитель пространства имён (namespace separator, фактически — обратный слэш), например Lib1\MyFunction().
Неквалифицированное имя (Unqualified name)
Идентификатор без разделителя пространства имён, например MyFunction().
Работа с одинаковыми пространствами имён
Обсудим следующий код:
myapp1.php:
Хотя мы присоединили и lib1.php и lib2.php, идентификаторы MYCONST, MyFunction и MyClass будут относиться только к lib1.php. Это произойдет потому что код myapp1.php расположен в едином с App\Lib1 пространстве имён:
результат:
Импортирование пространств имён (Namespace Importing)
Пространства имён могут быть импортированы с помощью оператора use, например:
myapp2.php:
Вы можете импортировать с помощью use одно или несколько пространств имён, разделяя их запятой. В данном примере, мы импортировали пространство имён App\Lib2. Мы все еще не можем ссылаться прямо на MYCONST, MyFunction или MyClass потому что наш код находится в глобальном пространстве и PHP будет искать их именно там. Но если мы добавим префикс «Lib2\», они станут квалифицированными именами, а PHP станет искать их в импортированных пространствах имён, пока не найдет полного совпадения.
результат:
Псевдонимы пространства имён (Namespace Aliases)
Псевдонимы пространства имён, возможно, самая полезная конструкция. Псевдонимы позволяют ссылаться на длинные пространства имён с помощью короткого имени.
myapp3.php:
Первый оператор use определяет App\Lib1 как «L». Любое квалифицированное имя, использующее «L», будет преобразовано во время компиляции в «App\Lib1». Поэтому, мы скорее сошлемся на L\MYCONST или L\MyFunction, чем на полное квалифицированное имя.
Второй оператор use более интересен. Он определяет «Obj» как псевдоним для класса «MyClass» в пределах пространства имён App\Lib2\. Эта операция применительна только для классов — не для констант или функций. Теперь мы можем использовать new Obj(), или вызывать статические методы, как показано выше.
результат:
Правила разбора имён
Читайте также:
Примечания:
A/ Замечания, поправки, указания на неточности и проч. — приветствуются!
Как использовать пространства имен в PHP, Часть 1: Основы
Предисловие: На Хабре уже публиковались несколько статей, посвященных пространству имен в PHP (все ссылки на них я привожу в приложении). Однако, этот интересный и полезный вопрос был раскрыт не полностью. Поэтому я привожу перевод первой из трех статей по данной теме (остальные переведу в ближайшее время). P.S. Статья для начинающих
Пространства имен (namespaces) — это одно из самых значительных изменений в PHP 5.3. Они будут хорошо знакомы С# и Java разработчикам, и, вероятно, они изменят к лучшему структуру PHP-приложений.
Почему мы нуждаемся в пространстве имен?
Поскольку размер библиотеки Вашего PHP кода растет, возрастает и риск случайного переопределения функции или имени класса, которые были объявлены ранее. Проблема усугубляется, когда Вы пытаетесь добавлять сторонние компоненты или плагины; что будет, если два или более наборов кода будут выполнять классы «Database» или «User»?
Ранее, единственным решением были длинные имена классов/функций. Например, WordPress добавлял к каждому имени префикс «WP_». Zend Framework обычно дает детально описывающие названия, что приводит к длиннющим именам классов, таким как Zend_Search_Lucene_Analysis_Analyzer_Common_Text_CaseInsensitive.
Проблемы совпадения имен снимаются введением пространств имен. PHP константы, классы и функции могут быть сгруппированы в библиотеки пространств имен (namespaced libraries).
Как определяются пространства имен?
По умолчанию, все имена констант, классов и функций размещены в глобальном пространстве — как это и было до того, как PHP стал поддерживать пространства имен.
В коде, пространства имен определяются с помощью единственного слова namespace в самом начале Вашего PHP файла. Это слово должно быть самой первой командой (за исключением declare) и ни не-PHP код, ни HTML, ни даже пробел не должен предшествовать этой команде, например:
Весь код, следующий за этими строками, будет относиться к пространству имен «MyProject». Невозможно вкладывать в него другие пространства имен, или определять более чем одно пространство имен для одной и той же части кода (поскольку распознано будет лишь последнее объявление пространства имен, предшествующие же — игнорируются). Тем не менее, Вы можете определить различные пространства имен в одном и том же файле, например:
Но, хотя это и возможно, я бы не советовал делать так: будьте благоразумны, определяя только одно пространство имен для каждого файла.
Подпространства имен (Sub-namespaces)
Вызов кода, относящегося к пространству имен
В файле с именем lib1.php мы определим константу, функцию и класс в пределах пространства имен App\Lib1:
lib1.php
Теперь мы можем включить этот код в другой PHP файл, например:
myapp.php
Никаких пространств имен не определено в файле myapp.php, поэтому код существует в глобальном пространстве. Любая прямая ссылка на MYCONST, MyFunction или MyClass вызовет сбой, поскольку они существуют только в пространстве имен App\Lib1. Чтобы вызвать код из lib1.php, мы можем добавить префикс \App\Lib1, чтобы определить полное квалифицированное имя. На выходе, когда загрузим myapp.php, мы получим следующий результат:
Полные квалифицированные имена могут становиться достаточно длинными; вместе с тем, существует несколько очевидных преимуществ в определении длинных имен классов, наподобие App-Lib1-MyClass. Поэтому, в следующей статье, мы обсудим использование псевдонимов (aliasing) и разберемся как PHP разрешает имена пространств имен.