php class global class
So I’ve come across a «problem» with PHP classes.
I have a few classes that require functions from one another, so at the moment I am doing the following:
then within the file:
However instead of doing this for each file that required additional functions, would it be better to write
within each of the functions that require it?
4 Answers 4
The Name of the Pattern that you are talking about is called «Dependency Injection» or DI in short.
A (bad) solution is to make your database and core Class use the Singleton Pattern to avoid global but have the same effect. (not testable, not configurable)
The solution for this is usually to create a Factory function that creates all of your Services that need the Database and the Core.
And this Function is usually part of a Registry or better an DI Container like for example PIMPLE
Example with Only one Instance of each Service:
Be aware that you should NOT test with your Registry / DI Container since you have a «global» state inside of your container. (e.g. fetching the same service twice)
I would not use globals.
It’s just not the OOP way.
The resulting code would not be testable. If you want your application to be covered by unit tests you should use Dependcy Injection as you currently do. I’ll try to briefly explain why. Unit testing as its name implies is just that: testing a single unit of your application, i.e. your classes (their public methods).
Here’s a nice source for more detailed explanation on how to write testable and maintainable code.
And here you could find more information about mocking and whether and what you can benefit from using it.
Можно ли использовать global в php?
Здравствуйте, кто знает можно ли использовать (Поразумеваеться целесообразность и безопасность) Ключевое слово global в php.
Чем это черевато? Нормальная это практика или нет?
Геттер к пример можно использовать, чтоб в другом месте получить и всякие другие варианты..
IceJOKER Можно пожалуйста по подробнее, по чему плохо?
Если я вас правильно понял, то «Геттер» это __get()
Нельзя.
Нет ни одного примера кода, где его использование было бы оправдано.
Любое его использование можно заменить с улучшением качества кода.
Даже суперглобальные переменные сразу же прячут с созданием нормального объекта запроса сразу же в индексном файле:
$request = Request::createFromGlobals();
Вот такой код еще куда ни шло но и он я бы сказал не очень хорош.
Использовать global можно только в конструкторе класса чтобы присвоить внутренним полям класса глобальные значения. При условии что эти глобальные переменные не объекты, и создаются кодом который находится в большой зависимости, например в index.php на котором 5 лет группа программистов писала код. Естественно поменять такие переменные не всегда возможно (ввиду необходимости глобального рефакторинга). Либо когда это «псевдоконстанты» как я их называю, когда переменной присваивается значение и оно не меняется на протяжении всего выполнения скрипта. В любом другом случае это крайне не рекомендуется.
Если следовать этому правилу (которое я придумал сам) то в принципе ничего страшного случится не может.
А вообще лучше всетаки посмотреть в сторону Dependency injection.
PHP class: глобальная переменная как свойство в классе
Как объявить это как свойство в myClass?
Для каждого метода в моем классе, это то, что я делаю:
7 ответов
Вы, наверное не действительно хочу это сделать, так как это будет кошмар для отладки, но это кажется возможным. Ключ-это часть, где вы назначаете на ссылка в конструкторе.
что означает, что он назначается по ссылке, а не по значению.
Как я уже сказал, это будет кошмар для отладки, поэтому вы действительно не должны этого делать. Прочтите статья Википедии о инкапсуляция; в принципе, ваш объект должен идеально управлять своими собственными данными и методами, в которых эти данные изменяются; даже общедоступные свойства, как правило, ИМХО, плохая идея.
старайтесь избегать глобальных переменных, вместо этого вы можете использовать что-то вроде этого
теперь вы можете звонить
$MyNumber затем станет доступным (и действительно модифицируемым) в этом методе.
однако использование глобалов часто неодобрительно (они могут испускать плохой запах кода), поэтому вы может использовать одноэлементный класс в магазине ничего подобного. (Опять же, не зная больше о том, что вы пытаетесь достичь, это может быть очень плохо идея-а определение может быть более полезным.)
С кодом прямо выше, вы получаете сообщение об ошибке»ошибка синтаксического анализа: синтаксическая ошибка, неожиданные «$ GLOBALS»«
но если мы сделаем что-то подобное,
наш код будет работать нормально.
где мы назначаем глобальную переменную переменной класса, она должна быть внутри функции. И я использовал конструктор функция для этого.
таким образом, вы можете получить доступ к глобальной переменной внутри каждой функции класса просто с помощью $это->var;
а как насчет конструктора?
или гораздо лучше таким образом (передача глобальной переменной в качестве параметра при inicializin объекта только для чтения)
Если вы хотите получить доступ к свойству внутри класса, вам необходимо:
Подробно об объектах и классах в PHP
Сегодня объекты используются очень активно, хотя это трудно было предположить после выхода PHP 5 в 2005 году. Тогда я ещё мало что знал о возможностях этого языка. Пятую версию PHP сравнивали с предыдущей, четвёртой, и главным преимуществом нового релиза стала новая, очень мощная объектная модель. И сегодня, десять лет спустя, около 90% всего PHP-кода содержит объекты, не изменившиеся со времени PHP 5.0. Это убедительно говорит о том, какую роль сыграло внедрение объектной модели, неоднократно улучшавшейся на протяжении последующих лет. В этом посте я хотел бы рассказать о том, как всё устроено «под капотом». Чтобы люди понимали суть процессов — почему сделано так, а не иначе — и лучше, полнее использовали возможности языка. Также я затрону тему использования памяти объектами, в том числе в сравнении с эквивалентными массивами (когда это возможно).
Я буду рассказывать на примере версии PHP 5.4, и описываемые мной вещи справедливы для 5.5 и 5.6, потому что устройство объектной модели там почти не претерпело изменений. Обратите внимание, что в версии 5.3 всё не так хорошо с точки зрения возможностей и общей производительности.
В PHP 7, который пока ещё активно разрабатывается, объектная модель переработана не сильно, были внесены лишь незначительные изменения. Просто потому что всё и так хорошо работает, а лучшее — враг хорошего. Были добавлены возможности, не затрагивающие ядро, но здесь об этом речи не пойдёт.
В качестве демонстрации начну с синтетических бенчмарков:
Здесь объявляется простой класс с тремя атрибутами, а затем в цикле создаётся 1000 объектов этого класса. Обратите внимание, как в этом примере используется память: при создании объекта класса Foo и переменной для его хранения выделяется 262 байт динамической памяти PHP.
Давайте заменим объект на эквивалентный массив:
Вот ещё один пример:
Теперь давайте разберём, как всё это устроено в недрах PHP, подкрепив теорией практические наблюдения.
Всё начинается с классов
Внутри PHP класс представляется с помощью структуры zend_class_entry:
Важно знать ещё об одном моменте, связанном с zend_class_entry — о PHP-комментариях. Они также известны как аннотации. Это строковые переменные (в языке С — буферы char* ), которые тоже надо разместить в памяти. Для языка С, не использующего Unicode, в отличие от PHP, правило очень простое: один символ = один байт. Чем больше у вас в классе аннотаций, тем больше памяти будет использовано после парсинга.
У zend_class_entry поле doc_comment содержит аннотации класса. У методов и атрибутов тоже есть такое поле.
Пользовательские и внутренние классы
Пользовательский класс — это класс, заданный с помощью PHP, а внутренний класс задаётся либо благодаря внедрению исходного кода в сам PHP, либо с помощью расширения. Самое большое различие между этими двумя видами классов заключается в том, что пользовательские классы оперируют памятью, выделяемой по запросу, а внутренние — «постоянной» памятью.
Это означает, что когда PHP заканчивает обработку текущего HTTP-запроса, он убирает из памяти и уничтожает все пользовательские классы, готовясь к обработке следующего запроса. Этот подход известен под названием «архитектура без разделения ресурсов» (the share nothing architecture). Так было заложено в PHP с самого начала, и изменять это пока не планируется.
Итак, каждый раз при формировании запроса и парсинге классов происходит выделение памяти для них. После использования класса уничтожается всё, что с ним связано. Так что обязательно используйте все объявленные классы, в противном случае будет теряться память. Применяйте автозагрузчики, они задерживают парсинг/объявление во время выполнения, когда PHP нужно задействовать класс. Несмотря на замедление выполнения, автозагрузчик позволяет грамотно использовать память, поскольку он не будет запущен, пока действительно не возникнет потребность в классе.
С внутренними классами всё иначе. Они размещаются в памяти постоянно, вне зависимости от того, использовали их или нет. То есть они уничтожаются только тогда, когда прекращается работа самого PHP — после завершения обработки всех запросов (подразумеваются веб SAPI, например, PHP-FPM). Поэтому внутренние классы более эффективны, чем пользовательские (в конце запроса уничтожаются только статические атрибуты, больше ничего).
Обратите внимание, что даже при кешировании опкодов, как OPCache, создание и уничтожение класса осуществляется при каждом запросе, как и в случае с пользовательскими классами. OPCache просто ускоряет оба этих процесса.
Как вы заметили, если активировать много PHP-расширений, каждое из которых объявляет много классов, но при этом использовать лишь небольшое их количество, то теряется память. Помните, что PHP-расширения объявляют классы во время запуска PHP, даже если в последующих запросах эти классы использоваться не будут. Поэтому не рекомендуется держать расширения активными, если они не применяются в данный момент, иначе вы будете терять память. Особенно если эти расширения объявляют много классов — хотя они могут забить память и чем-нибудь другим.
Классы, интерфейсы или трейты — без разницы
Не слишком хорошо, что здесь используется 912 байт всего лишь для декларирования интерфейса BarException.
Привязка класса
Многие разработчики не вспоминают о привязке класса, пока не начинают задавать вопросом, а как же всё устроено на самом деле. Привязку класса можно описать как «процесс, в ходе которого сам класс и все связанные с ним данные подготавливаются для полноценного использования разработчиком». Этот процесс очень прост и не требует много ресурсов, если речь идёт о каком-то одном классе, не дополняющем другой, не использующем трейты и не внедряющим интерфейс. Процесс привязки для таких классов полностью протекает во время компиляции, а в ходе выполнения ресурсы на это уже не тратятся. Обратите внимание, что речь шла привязке класса, задекларированного пользователем. Для внутренних классов тот же самый процесс выполняется, когда классы зарегистрированы ядром или расширениями PHP, как раз перед запуском пользовательских скриптов — и делается это лишь один раз за всё время работы PHP.
Всё сильно усложняется, если речь заходит о внедрении интерфейсов или наследовании классов. Тогда в ходе привязки класса у родительских и дочерних объектов (будь то классы или интерфейсы) копируется абсолютно все.
Тут добавить нечего, простой случай.
Для каждой из таблиц функций (методов) используется do_inherit_method :
Что касается наследования, то здесь, в принципе, всё то же самое, что и при внедрении интерфейса. Только вовлечено ещё больше «участников». Но хочу отметить, что если PHP уже знает о классе, то привязка осуществляется во время компилирования, а если не знает — то во время выполнения. Так что лучше объявлять так:
Кстати, рутинная процедура привязки класса может привести к очень странному поведению:
В первом варианте привязка класса В отложена на время выполнения, потому что когда компилятор доходит до объявления этого класса, он ещё ничего не знает о классе А. Когда начинается выполнение, то привязка класса А происходит без вопросов, потому что он уже скомпилирован, будучи одиночным классом. Во втором случае всё иначе. Привязка класса С отложена на время выполнения, потому что компилятор ещё ничего не знает о В, пытаясь скомпилировать его. Но когда во время выполнения начинается привязка класса С, то он ищет В, который не существует, поскольку не скомпилирован по причине того, что В является дополнением. Вылетает сообщение “Class B doesn’t exist”.
Объекты
Итак, теперь мы знаем, что:
Теперь поговорим об объектах. В первой главе показано, что создание «классического» объекта («классического» пользовательского класса) потребовало очень мало памяти, около 200 байт. Всё дело в классе. Дальнейшая компиляция класса тоже потребляет память, но это к лучшему, потому что для создания одиночного объекта требуется меньше байт. По сути, объект представляет собой крохотный набор из крохотных структур.
Управление методами объекта
Вы могли заметить интересную вещь, посмотрите на первые строки:
Во время компиляции функции/метода происходит немедленный перевод в нижний регистр. Вышеприведённая функция BAR() превращается в bar() компилятором при добавлении метода таблице классов и функций.
В приведённом примере первый вызов статический: компилятор вычислил key для строковой “bar”, а когда приходит время вызова метода, ему нужно делать меньше работы. Второй вызов уже динамический, компилятор ничего не знает о “$b”, не может вычислить key для вызова метода. Затем, во время выполнения, нам придётся перевести строковую в нижний регистр и вычислить её хеш ( zend_hash_func() ), что не лучшим образом сказывается на производительности.
Управление атрибутами объекта
Вот что происходит:
Так что, создавая объект, мы «всего лишь» создаём структуру zend_object весом 32 байта:
Далее движок создаёт вектор признаков нашего объекта:
Вероятно, у вас возникли два вопроса:
Пока вы не пишете в объект, его потребление памяти не меняется. После записи он занимает уже больше места (пока не будет уничтожен), поскольку содержит все записанные в него атрибуты.
Объекты, ведущие себя как ссылки благодаря хранилищу объектов
Объекты не являются ссылками. Это демонстрируется на маленьком скрипте:
Все сейчас скажут, что «в PHP 5 объекты являются ссылками», об этом упоминает даже официальный мануал. Технически это совершенно неверно. Тем не менее, объекты могут вести себя так же, как и ссылки. Например, когда вы передаёте переменную, являющуюся объектом функции, эта функция может модифицировать тот же объект.
object(MyClass)#1 (0) < >/* #1 is the object handle (number), it is unique */
Когда мы вызываем метод, движок изменяет область видимости:
Вот так можно получать доступ к приватным членам объектов, не принадлежащим вам, но являющимся дочерними по отношению к вашей текущей области видимости:
Эта особенность стала причиной большого количества баг-репортов от разработчиков. Но так устроена объектная модель в PHP — на самом деле, мы задаём область видимости на основе не объекта, а класса. В случае с нашим классом “Foo”, вы можете работать с любым приватным Foo любого другого Foo, как показано выше.
О деструкторе
Деструкторы опасны, не полагайтесь на них, поскольку PHP их не вызывает даже в случае фатальной ошибки:
А что насчёт порядка вызова деструкторов в том случае, если они всё-таки вызываются? Ответ хорошо виден в коде:
Здесь продемонстрированы три стадии вызова деструктора:
PHP не вызывает деструкторы в случае возникновения какой-либо фатальной ошибки. Дело в том, что в этом случае Zend работает нестабильно, а вызов деструкторов приводит к выполнению пользовательского кода, который может получить доступ к ошибочным указателям и, в результате, к падению PHP. Уж лучше сохранять стабильность системы — поэтому вызов деструкторов и блокируется. Возможно, в PHP 7 что-то и поменяется.
Суммируя вышесказанное: не доверяйте деструкторам критически важный код, например, управление механизмом блокировки (lock mechanism), поскольку PHP может и не вызвать деструктор или вызвать его в неконтролируемой последовательности. Если всё-таки важный код обрабатывается деструктором, то как минимум самостоятельно контролируйте жизненный цикл объектов. PHP вызовет деструктор, когда refcount вашего объекта упадёт до нуля, а это значит, что объект больше не используется и его можно безопасно уничтожить.
Впервые базовая поддержка классов в PHP была введена в 4 версии языка, но затем для более полной поддержки ООП повторно реализована для 5 версии. Сегодня PHP пригоден для работы с классами, но в то же время библиотека языка до сих пор в основном состоит из функций, классы теперь добавляются в различных целях. Тем не менее, основным средством PHP является использование своих собственных классов.
Классы можно рассматривать как совокупность методов, переменных и констант. Они часто отражают реальные предметы, как класс автомобиля или класс фруктов. Вы объявляете класс только один раз, но можете создать множество его экземпляров, которые могут храниться в памяти. Экземпляр класса обычно называют объектом. Если вы все еще немного путаетесь в том, какие классы и зачем они нужны, не волнуйтесь. В этой статье мы напишем наш самый первый класс и используем его.
Классы в PHP — определение и использование
После введения в классы в PHP мы готовы написать наш собственный класс. Он будет содержать информацию об основном пользователе, например, вашего сайта.
На данный момент этот класс PHP ничего не может сделать. Мы можем создать экземпляр, это делается с помощью ключевого слова new :
Попробуем использовать наш новый класс php. Следующий код должен идти после того, как класс был объявлен или подключен:
Результат должен выглядеть следующим образом:
Конструкторы и деструкторы
Конструктор и деструктор — специальные функции, которые автоматически вызываются, когда объект создается и уничтожается. Из них наиболее полезным является конструктор, потому что позволяет при создании нового объекта передавать ему параметры, которые затем используются для инициализации переменных объекта. Вот пример класса с простым конструктором:
Конструктор выглядит как обычная функция, за исключением того, что начинается с двух символов нижнего подчеркивания. В PHP так указывается волшебная функция, которая обладает дополнительной функциональностью по сравнению с обычными функциями. Таким образом, функция типа « __construct «, является конструктором класса и будет вызываться автоматически при создании объекта. Давайте попробуем сделать это в следующем PHP class примере:
С помощью этой строки кода будет создан объект, вызван конструктор и в нем выполнится код, что приведет к выводу строки “ I’m alive! ”. Но как уже упоминалось ранее, основным преимуществом конструктора является возможность передавать параметры, которые могут быть использованы для инициализации переменных – членов класса.
Давайте попробуем сделать это:
Объявление конструктора с параметрами такое же, как объявление функции, и передача параметров очень похожа на вызов обычной функции, но с ключевым словом “ new ”. Конструктор может иметь столько параметров, сколько вам хочется.
Деструкторы
Деструктор вызывается при уничтожении объекта. В некоторых языках программирования нужно вручную избавиться от созданных объектов, но в PHP это делает сборщик мусора, который следит за объектами и автоматически уничтожает их, когда они больше не нужны. Посмотрите на следующий пример, который является расширенной версией предыдущего PHP class :
Как видите, деструктор такой же как конструктор, только имя отличается. Если попробуете запустить этот пример, то сначала увидите сообщение конструктора, а затем название животного, которое мы вручную выводим в последней строке. После этого сценарий заканчивается, объект уничтожается деструктором, и выводится сообщение о нашем бедном умершем животном.