Статические методы PHP как средство против бюрократии в ООП


Статические методы PHP

В PHP есть возможность определить метод как статический. Статический метод не имеет доступа к свойствам объекта. Такие методы могут быть вызваны только в контексте класса, но не в контексте объекта.

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

На примере станет сразу понятно. Давайте создадим обект Math (сокращённое названием математики в английском).

Этот класс предоставляет инструменты для работы с математическими функциями без необходимости создания объекта. В классе есть конструктор, который увеличивает статическое свойство $count на единицу. Класс запоминает значение этого свойства, так как оно статическое.

Кстати, для объявления метода или свойства статическим используется слово static , а для доступа к статическому свойству используется слово self с двойным двоеточием » :: «.

Всё это лучше понять в сравнении, особенно в сравнении рабочего примера с ошибочным. Давайте немного расширим наш пример.

В этом примере мы добавили классу обычное свойство $counter , оно также увеличивалось на единицу в конструкторе. Но обычное свойство принадлежит объекту, поэтому оно не сохраняется между вызовами объектов. При любом создании экземпляра класса (объекта) свойство будет равно нолю, в конструкторе оно будет увеличено на единицу.

Статическое свойство принадлежит классу, поэтому его значение сохраняется.

Ниже ещё несколько примеров, которые раскрывают работу статических свойств и методов.

Попытка использовать в статическом методе переменную $this приведёт к ошибке (Fatal error: Using $this when not in object context).

Кстати, без строки:

ошибки не будет, но как только вы в коде попробуете запустить статический метод с переменной $this , вы сразу получите сообщение об ошибке.

Если в этом примере убрать слово static , то ошибки не будет.

Если из статического метода обратиться к свойству объекта, то это приведёт к ошибке. Можно обращаться только к статическим свойствам при помощи конструкции self::$age . Обратите внимание, что тут есть знак $ перед именем переменной, в отличии от конструкции $this->age .

Если в этом примере убрать слово static перед именем свойства, то возникнет ошибка «Access to undeclared static property».

Статические свойства отсутствуют в объектах класса.

Статический метод можно вызвать используя конструкцию self::метод() . Пример:

Статическое свойство можно получить в контексте класса используя синтаксис:

Причём попытка обращения к обычному свойству таким образом приведёт к ошибке: «Fatal error: Access to undeclared static property».

Статическое свойство можно менять в контексте класса используя синтаксис:

Ещё пример кода со статическими методами и свойствами

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

Обратите внимание, и это важно, в этом примере мы обратились к нестатическому методу sayHi() используя синтаксис обращения к статическим элементам класса.

Резюме

  • Главное: статические свойства принадлежат классам, а не объектам.
  • Из статического метода нельзя обратиться к обычным свойствам и методам класса, $this->name не работает тут.
  • Из статического метода можно обратиться к статическим свойствам используя self::$name .
  • Статические свойства класса не доступны объектам.
  • Обычный метод может обратиться к статическому свойству используя self::$name .
  • Статическое свойство можно получить в контексте класса использую синтаксис: TestClass::$age .
  • Обычный метод можно вызвать в контексте и объекта ( $object->метод() ), и класса используя синтаксис TestClass::метод() .
  • При помощи синтаксиса $object::$age у меня получилось получить доступ к статическому свойству через объект.

Параллели с JavaScript

В JavaScript есть такой класс Math, содержащий очень много различных математических функций.

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

На самом деле это очень удобно, иметь прямой доступ к математическим методам класса Math, избегая создания объекта.

Статические методы в ООП

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

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

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

Итак, в качестве примера вы можете иметь статический класс под названием Zip, который застегивает ZIP файлы и распаковывает их и предоставляет им множество разных классов, чтобы они могли что-то делать с ним.

Я прав? У меня есть правильная идея? Я уверен, что есть много способов его использовать.

4 ответа

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

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

Посмотрите это сравнение:

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

Технически ответы выше верны. Но примеры неверны с точки зрения ООП.

Например, у вас есть класс вроде этого:

Истина заключается в том, что здесь нет ничего объектно-ориентированного. Вы только что определили две функции, которые вам нужно вызвать, используя причудливый синтаксис, например Zip::zipFile($myFile) , а не только zipFile($myFile) .

Здесь вы не создаете никаких объектов, а класс Zip используется только как пространство имен.

Поэтому в этом случае лучше просто определить эти функции вне класса, как обычные функции. Есть namespaces в php с версии 5.3, вы можете использовать их, если хотите сгруппировать свои функции.

С помощью подхода ООП класс будет выглядеть следующим образом:

И тогда вы можете использовать его следующим образом:

Что более важно, теперь вы можете использовать zip-функцию в способе OOP.

Например, вы можете иметь базовый класс Archive и подклассы типа ZipArchive , TarGzArchive и т.д.

Теперь вы можете создать экземпляр конкретного подкласса и передать его другому коду, который даже не знает, будут ли файлы zip-ped или tag.gz-ipped. Например:

Теперь объект $backup будет использовать указанный тип архива. Внутри он не знает и не заботится о том, как файлы будут архивироваться. Вы можете даже иметь класс CopyArchive , который просто скопирует файлы в другое место.

Это легко сделать так, потому что ваша поддержка архива написана способом OOP. У вас есть небольшой объект, ответственный за конкретные вещи, вы создаете и объединяете их и получаете желаемый результат.

И если у вас просто куча статических методов вместо реального класса, вы будете вынуждены написать процедурный стиль.

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

Статические методы могут быть полезны для поддержки протоколирования, отладки, тестирования и т.д. Например, если вы хотите подсчитать количество созданных объектов, вы можете использовать статический счетчик класса, увеличивать его в конструкторе, и у вас может быть статический метод, который считывает счетчик и печатает его или записывает в файл журнала.

0 Lefsler [2020-01-29 19:47:00]

AFAIK. Статические методы не зависят от экземпляра класса. Только это.

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

Топ-пост этого месяца:  Категории Хуков — WooCommerce — WordPress

Существуют и другие примеры.

Если вы создаете класс для преобразования значений.

Таким образом, вам не нужно будет создавать преобразование класса каждый раз, когда вам нужно преобразовать из целого в строку.

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

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

Да, статические классы используются для проблем, требующих вычисления без учета состояния. Например, добавление двух чисел. Закрепление файла. Etc.

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

oop — статический метод против экземпляра

Я немного запутался, так как у меня нет большого опыта в ООП в PHP. Я всегда слышал, что использование методов экземпляра — лучшая практика, чем использование статических методов. Зачем?

Мне нужен глубокий ответ с объяснением, пожалуйста.

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

контроллер:

Модель:

Я читаю о setter / getter, instance vs static и т. Д. Но мне нужен полный ответ, чтобы понять как а также Зачем вещей.

Решение

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

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

Возьмите следующий код в качестве примера:

Учебный класс Foo имеет статическое свойство $tavern и нестатическое свойство $bar ,

Если экземпляр Foo создается, то все свойства и методы доступны для этого объект.

Если Foo ссылается статически, тогда только $tavern имущество, changeTavern() метод и getTavern() метод доступен для учебный класс.

Давайте посмотрим на следующий код:


поскольку $foo это пример Foo , он имеет доступ ко всему классу. призвание changeBar() будет изменять $bar имущество. Чтобы изменить $bar свойство напрямую из статического метода вызовет ошибку, так как $bar доступен для объект а не учебный класс.

Если вы хотите получить доступ к свойствам класса из статических методов, эти свойства также должны быть объявлены как статические. Это будет работать в контексте класса выше. Вы также заметите, что экземпляр Foo не имеет проблем с чтением статических свойств.

Еще одна вещь, которую нужно помнить о статическом коде, это то, что он не ведет себя как экземпляр. Когда первый экземпляр Foo был построен оба свойства $bar а также $tavern не имел значения. Если бы вы должны были создать еще один экземпляр Foo вы обнаружите, что только одно из этих свойств больше не содержит значения. (Я уверен, что теперь вы можете догадаться, какой из них.)

Опять же, статический код означает, что вы работаете напрямую с учебный класс — случаи означают, что вы работаете с объект. Важно отметить, что любой тип класса, который вы пишете и который имеет какое-то состояние, должен использоваться в качестве экземпляра.

Статические классы могут быть немного сложными для отладки и тестирования. Тестирование может быть проблематичным, поскольку статические свойства не изменяются при создании нового экземпляра. Отладка также может быть затруднена, поскольку значение статического свойства одинаково во всех экземплярах класса. Сделайте изменение в одном, и вы внесете это изменение во всех них. Отслеживать, какой экземпляр внес изменения, — боль.

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

Надеюсь, что это поможет пролить свет на эту тему.

Другие решения

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

Обычно делают метод instance, когда метод имеет отношение к текущий экземпляр класса (использует некоторое состояние этого объекта, возможно, параметры конфигурации) и статический, если он просто принадлежит классу в целом, как создание нового объекта, обработка примитивов …

Например. ActiveRecords Паттерн часто использует экземпляр как отображение записи, поэтому методы экземпляра читают / обрабатывают запись, а также статические методы, такие как поиск, массовое обновление / удаление и т. д.

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

Я хотел бы объяснить, используя небольшой пример, основанный на его шаблон ActiveRecord.

Давайте посмотрим, что мы пишем наш собственный AR-шаблон, используя класс, который представляет «заказы» таблицы, которые содержат (как вы можете себе представить) несколько записей заказов.

Если вы используете PDO в качестве класса соединения, вам нужно его где-то инициировать.
В этом примере инициализация инициируется в статическом методе класса order. Так как вам нужно иметь возможность «запустить это», прежде чем вы сможете запросить базу данных, чтобы получить заказ.

Пожалуйста, не обращайте внимания на тот факт, что вы можете сделать много оптимизаций для фактического набора результатов или сохранить его для реального объекта. Основная цель этого кода состоит в том, чтобы объяснить тот факт, когда я буду использовать статические против экземпляров.

Прежде всего, это не всегда лучше, но в большинстве случаев так и есть.
Есть несколько причин не использовать статические методы:

  1. Сложнее ставить класс на тесты, если у него есть статические методы
  2. Сложнее расширить этот класс, если вы хотите немного отличаться для одного и того же метода
  3. Очень часто ваши статические методы в классе — это просто способ сделать его глобальной переменной, что почти всегда является плохой идеей.
  4. Рефакторинг этого класса станет адом, если вдруг вы решите, что вам нужна переменная класса внутри статического метода (измените все вызовы > Method ())

Я настоятельно рекомендую вам прочитать немного больше о модульных тестах. Когда какой-то другой класс использует ваш со статическим методом, то его тестирование может быть проблемой.

Объектное программирование

Объектно-ориентированное программирование (ООП) на PHP

Объект — это набор специальных переменных — свойств и специальных функций — методов. То, что в процедурном программировании называлось переменной — в ООП называется свойство. То, что в процедурном программировании называлось функцией — в ООП называется методом класса. Созданные на основе класса объекты называются экземплярами класса или просто объекты.

Обращение из метода к свойствам только через служебное слово $this: $this->name; (обратите внимание на отсутствие знака доллара перед name) Обращение внутри метода к другому методу тоже через $this: $this->foo(); Для доступа к свойствам и методам объекта служит оператор «->»: $this->name; (обратите внимание на отсутствие знака доллара перед name)
Обращение внутри метода к другому методу тоже через $this: $this->foo(); . Объект создается с помощью оператора new на основании шаблона, называемого классом. Класс определяется ключевым словом class.

Пример 1

Модификаторы доступа в ООП:

  • public — позволяет иметь доступ к свойствам и методам из любого места (глобальная область)
  • protected — доступ к родительскому и наследуемому классу (область класса наследника)
  • private — доступ только из класса, в котором объявлен сам элемент (область самого класса)

Метод по умолчанию — public. У свойств значения модификатора по умолчанию нет.

Константы класса в ООП

this и self

Внутри класса использована специальная переменная this. Это указатель, с помощью которого объект может ссылаться на самого себя.

Для обращения к статическим методам используется self::

Методу Пока передан аргумент точно так же, как и обычной функции. При вызове этого метода объект меняет свое свойство имя.

Маша! Привет!

Миша! Привет!

Яша! Пока!

Яша! Привет!

Конструктор — это метод, который автоматически вызывается при создании нового объекта: public function __construct()<> . При инициализации6 объекта через служебную конструкцию new, PHP ищет __construct и если он есть, то вызывается.

Также можно создать метод, имя которого совпадает с именем класса, — такой метод также будет считаться конструктором. Конструктор может принимать аргументы, что значительно упрощает работу с классами.

Пример 2

Кто-то там! Привет!

Миша! Привет!

Маша! Привет!

Сложив все, изложенное выше, можно создать более осмысленный класс. Например, класс, который будет располагать данные в виде таблицы с поименнованными столбцами.

Статические свойства и методы в PHP

Очень важной особенностью ООП является наличие статических свойств и методов. Главное, что необходимо сразу понять, что такие свойства и методы принадлежат не объекту, а классу. Это нужно понять с самого начала, а вот применение статических свойств и методов в PHP я рассмотрю в этой статье.

Топ-пост этого месяца:  Вебинар — что это такое

Самый классический пример — это класс, отвечающий за математические функции. Если кто-то знает Java, то он знает, что там имеется класс MathJavaScript такой класс тоже есть), содержащий множество математических функций. И там методы являются статическими. Это означает, что для того, чтобы посчитать какой-нибудь синус или экспоненту, не нужно создавать объект данного класса, что очень удобно.

Давайте мы с Вами напишем уменьшенную копию данного класса, но только для PHP:

В данном коде я показал использование статических методов и свойств. Обратите внимание, что я реализовал классический способ счётчика объектов. Это получилось лишь благодаря тому, что поле count является статическим, и оно имеет одно и то же значение для всех объектов.

Ещё один популярный пример использования статических методов и свойств — это ведение лога. Все записи добавляются через статические методы. Также очень часто делают класс, состоящий из множества настроек, и там также все поля являются статическими. Как видите, примеров использования статических методов и свойств в PHP и других языках более, чем достаточно, поэтому уметь с ними работать надо обязательно.

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

Она выглядит вот так:

  • BB-код ссылки для форумов (например, можете поставить её в подписи):
  • Комментарии ( 4 ):

    Уважаемый Михаил Русаков.Я не могу зайти к вам на страницу вконтакте и на ваш сайт ТНТ который вы зарегистрировали в интернете.По причине того что у меня стоит родительский контроль он ваши сайты считает сайтами для взрослых но он не только считает эти сайты взрослыми.free php hosting тоже считает таки.Пожалуйста свяжитесь со мной мой e-mail адрес [email protected]

    Используйте анонимайзер для входа: http://anonymizer.ru/ или http://cameleo.ru/

    Михаил Русаков спасибо вам огромное что вы не отказали мне в помощи,но для чего нужен сайт http://cameleo.ru/? он пишется как не рекомендуемый сайт.

    Это анонимайзер, чтобы заходить на те сайты, которые с Вашего компьютера посещать нельзя.

    Для добавления комментариев надо войти в систему.
    Если Вы ещё не зарегистрированы на сайте, то сначала зарегистрируйтесь.

    Copyright © 2010-2020 Русаков Михаил Юрьевич. Все права защищены.

    Зачем нужны в php статические методы и свойства?

    Как используется в php статические методы и свойства? Одно из применений это реализация паттерна singleton. Есть ли еще практические примеры их использования? Буду рад примеру где с помощью фабричного метода, была решена задача, которая без него решалась сложнее.

    4 ответа 4

    Использовать статические функции класса можно, не создавая самого экземпляра класса. Т.е вам не нужно создавать объект. (ну я думаю суть понята) Плюсы тут в том что объект может иметь некоторые методы которые могут быть использованы как в контекcте данного объекта так и без него.

    Пример: есть объект ‘Сотрудник’ и есть метод ‘Узнать всех кто работает в компании’, да создав такой объект вы можеет захотеть узнать кто же работает в компании, (т.е сам сотрудник это узнает), но вы также можете захотеть это узнать (не афишируя кто именно воспользовался узнаванием), т.е не создавая вообще объекта сорудник. В данном случае у вас по сути данный статическй метод практически является обычной функцией , которая не зависит от класса.

    Статические переменные наделены другим свойством, создавая различные экземпляры объектов, их свойтсва будут ссылаться на один участок памяти. Т.е меняя статические свойства в одном объекте они будут изменяться и в других объектах (созданных на базе данного класса) автоматически.

    Наибольший эффект это даёт, когда действительно нужно реализовать работу фабрики. К примеру: нужно получить новый ассоциативный массив данных, на основе одного или двух массивов.

    Каждый элемент окончательного массива получаем с помощью различных сложных преобразований в различных функциях. Так вот, чтобы не плодить различные передачи и присвоения данных в функциях расчета, очень удобно использовать static : это экономит память, время на различных присвоениях и тому подобное.

    Если не использовать static , то функции придется писать вот так:

    И таким образом будет выглядеть каждая функция без static . Очень полезна для построения календаря, различных матриц и т.п.

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

    Например их можно использовать ВМЕСТО паттерна синглтон.

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

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

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

    Статические методы и свойства

    28 февраля 2008 г. 14:40, спустя 31 минуту 20 секунд

    28 февраля 2008 г. 14:50, спустя 9 минут 55 секунд

    если код в методе может работать сам по себе, не обращаясь к соседним методам, то можно юзать статический, особенно если его приходится часто вызывать..
    наверное не совсем ясно изложил, но вот на примере:
    статический класс работы с файлом, методы getMimeType(), move(), delete() и т.д.
    т.е. где то на бескрайних просторах кода понадобилось удалить файл, пишем

    товарищ Вася прав, когда удобно — тогда и юзать

    28 февраля 2008 г. 14:53, спустя 3 минуты 20 секунд


    28 февраля 2008 г. 21:02, спустя 6 часов 8 минут 47 секунд

    Там где удобно оправдано, там где нет — не оправдано.

    28 февраля 2008 г. 21:17, спустя 15 минут 7 секунд

    mechanic, File::delete() лучше не только, потому что проще, но и потому что более правильно. Объект не должен сам себя удалять.
    Так же в статику можно вынести и открытие файла (по сути конструктор объекта не должен открывать внешний ресурс):

    29 февраля 2008 г. 14:52, спустя 17 часов 35 минут 4 секунды

    метод не относящийся к конкретному объекту лучше делать статическим.
    напр есть объект session

    метод delOld($time=2000), чистящий старые сессии, должен быть статикой
    метод update() относится к конкретной сессии, след не статика.

    1 марта 2008 г. 11:37, спустя 20 часов 44 минуты 32 секунды

    2 марта 2008 г. 0:36, спустя 12 часов 59 минут 1 секунду

    Всё у вас хорошо и прекрасно, но на практике выходят грабли.

    При использовании в каком-либо классе статического метода мы явно указываем название класса со статическим методом. Таким образом возникает зависимость нашего от класса со статическим методом.

    Такая зависимость нашего кода от класса со статическим методом является нарушением принципа инверсии зависимостей. В книге Роберта Мартина «Быстрая разработка программ», данный принцип раскрыт следующим образом — рекомендуется не использовать зависимость от статичного класса — все взаимоотношения в программе поддерживаются с помощью абстрактного класса или интерфейса. Тестирование позволяет находить такие места, где данное нарушение особо опасно для дизайна системы.

    2 марта 2008 г. 2:45, спустя 2 часа 9 минут 31 секунду

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

    поясни каким образом и где возможны грабли.

    2 марта 2008 г. 3:52, спустя 1 час 6 минут 22 секунды

    поясни каким образом и где возможны грабли.

    2 марта 2008 г. 11:01, спустя 7 часов 9 минут 31 секунду

    Топ-пост этого месяца:  WordPress шаблон для строительной компании, Build Lite

    Patrick, поясни примером.

    Допустим тот же класс сеансов, о котором говорит ghost:

    объекты соответствуют сессиям и имеют методы:
    setUser() — установить авторизованного пользователя
    setVar() — установить переменную сеанса
    getVar() — получить переменную сеанса

    конструктор закрытый, получить объект можно из двух статических методов:
    cSession::make() — создать новую сессию
    cSession::getBySID($sid) — получить сессию по идентификатору (пришедшему в куках)

    плюс еще статические методы:
    cSession::delete() — удалить сессию
    cSession::deleteOld() — удалить старые

    Где здесь подводные камни и как от них спастись абстрактными классами и интерфейсами?

    2 марта 2008 г. 14:52, спустя 3 часа 50 минут 30 секунд

    vasa_c
    Сеанс можно хранить как в файлах(средствами PHP), в БД и в memcache, к примеру, вот реалии изменились и нам надо сменить драйвер, что ты будешь делать? Переписывать класс cSession?

    Не говоря уже что все наши клиенты класса cSession будут зависить от реализации этого класса, а не от интерфейса.
    Выход использовать IoC контейнеры. В одном месте программы мы указываем какой класс у нас будет отвечать за сеанс, и всё вся программа будет работать именно с этой реализацией сеанса, поменялись требования, мы создали 1 класс и переписали 1 строчку кода.

    Статические методы PHP как средство против бюрократии в ООП

    Эта страница описывает использование ключевого слова static для определения статических методов и свойств. static также может использоваться для определения статических переменных и позднего статического связывания. Для получения информации о таком применении ключевого слова static обратитесь по вышеуказанным страницам.

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

    В целях совместимости с PHP 4, если определение области видимости не используется, то свойство или метод будут обрабатываться так, как если бы он был объявлен как public.

    Статические методы

    Так как статические методы вызываются без создания экземпляра класса, то псевдопеременная $this недоступна внутри метода, объявленного как статический.

    В PHP 5 вызов нестатических методов статически вызовет ошибку уровня E_STRICT .

    В PHP 7 вызов нестатических методов статически объявлен устаревшим и вызовет ошибку уровня E_DEPRECATED . Поддержка вызова нестатических методов статически может быть удалена в будущем.

    Пример #1 Пример статического метода

    class Foo <
    public static function aStaticMethod () <
    // .
    >
    >

    Foo :: aStaticMethod ();
    $classname = ‘Foo’ ;
    $classname :: aStaticMethod (); // Начиная с PHP 5.3.0
    ?>

    Статические свойства

    Статические свойства не могут быть доступны через объект с помощью оператора «->».

    Как и любая другая статическая переменная PHP, статические свойства могут инициализироваться только используя литерал или константу до PHP 5.6; выражения не допускается. В PHP 5.6 и более новых версиях применяются те же правила, что и для выражений const: возможны некоторые выражения, если они могут быть вычислены во время компиляциии.

    Начиная с PHP 5.3.0, существует возможность ссылаться на класс используя переменную. Значение переменной в таком случае не может быть ключевым словом (например, self, parent и static).

    Пример #2 Пример статического свойства

    class Foo
    <
    public static $my_static = ‘foo’ ;

    public function staticValue () <
    return self :: $my_static ;
    >
    >

    class Bar extends Foo
    <
    public function fooStatic () <
    return parent :: $my_static ;
    >
    >

    print Foo :: $my_static . «\n» ;

    $foo = new Foo ();
    print $foo -> staticValue () . «\n» ;
    print $foo -> my_static . «\n» ; // Не определено свойство my_static

    print $foo :: $my_static . «\n» ; // Начиная с PHP 5.3.0
    $classname = ‘Foo’ ;
    print $classname :: $my_static . «\n» ; // Начиная с PHP 5.3.0

    print Bar :: $my_static . «\n» ;
    $bar = new Bar ();
    print $bar -> fooStatic () . «\n» ;
    ?>

    User Contributed Notes 26 notes

    Here statically accessed property prefer property of the class for which it is called. Where as self keyword enforces use of current class only. Refer the below example:

    static protected $test = «class a» ;

    public function static_test ()<

    echo static:: $test ; // Results class b
    echo self :: $test ; // Results class a

    class b extends a <

    static protected $test = «class b» ;

    $obj = new b ();
    $obj -> static_test ();
    ?>

    It is important to understand the behavior of static properties in the context of class inheritance:

    — Static properties defined in both parent and child classes will hold DISTINCT values for each class. Proper use of self:: vs. static:: are crucial inside of child methods to reference the intended static property.

    — Static properties defined ONLY in the parent class will share a COMMON value.

    declare( strict_types = 1 );

    class staticparent <
    static $parent_only ;
    static $both_distinct ;

    function __construct () <
    static:: $parent_only = ‘fromparent’ ;
    static:: $both_distinct = ‘fromparent’ ;
    >
    >

    class staticchild extends staticparent <
    static $child_only ;
    static $both_distinct ;

    function __construct () <
    static:: $parent_only = ‘fromchild’ ;
    static:: $both_distinct = ‘fromchild’ ;
    static:: $child_only = ‘fromchild’ ;
    >
    >

    $a = new staticparent ;
    $a = new staticchild ;

    echo ‘Parent: parent_only=’ , staticparent :: $parent_only , ‘, both_distinct=’ , staticparent :: $both_distinct , «
    \r\n» ;
    echo ‘Child: parent_only=’ , staticchild :: $parent_only , ‘, both_distinct=’ , staticchild :: $both_distinct , ‘, child_only=’ , staticchild :: $child_only , «
    \r\n» ;
    ?>

    will output:
    Parent: parent_only=fromchild, both_distinct=fromparent
    Child: parent_only=fromchild, both_distinct=fromchild, child_only=fromchild

    On PHP 5.2.x or previous you might run into problems initializing static variables in subclasses due to the lack of late static binding:

    class A <
    protected static $a ;

    public static function init ( $value ) < self :: $a = $value ; >
    public static function getA () < return self :: $a ; >
    >

    class B extends A <
    protected static $a ; // redefine $a for own use

    // inherit the init() method
    public static function getA () < return self :: $a ; >
    >

    B :: init ( ‘lala’ );
    echo ‘A::$a = ‘ . A :: getA (). ‘; B::$a = ‘ . B :: getA ();
    ?>

    This will output:
    A::$a = lala; B::$a =

    If the init() method looks the same for (almost) all subclasses there should be no need to implement init() in every subclass and by that producing redundant code.

    Solution 1:
    Turn everything into non-static. BUT: This would produce redundant data on every object of the class.

    Solution 2:
    Turn static $a on class A into an array, use classnames of subclasses as indeces. By doing so you also don’t have to redefine $a for the subclasses and the superclass’ $a can be private.

    Short example on a DataRecord class without error checking:

    abstract class DataRecord <
    private static $db ; // MySQLi-Connection, same for all subclasses
    private static $table = array(); // Array of tables for subclasses

    public static function init ( $classname , $table , $db = false ) <
    if (!( $db === false )) self :: $db = $db ;
    self :: $table [ $classname ] = $table ;
    >

    public static function getDB () < return self :: $db ; >
    public static function getTable ( $classname ) < return self :: $table [ $classname ]; >
    >

    class UserDataRecord extends DataRecord <
    public static function fetchFromDB () <
    $result = parent :: getDB ()-> query ( ‘select * from ‘ . parent :: getTable ( ‘UserDataRecord’ ). ‘;’ );

    // and so on .
    return $result ; // An array of UserDataRecord objects
    >
    >

    $db = new MySQLi (. );
    UserDataRecord :: init ( ‘UserDataRecord’ , ‘users’ , $db );
    $users = UserDataRecord :: fetchFromDB ();
    ?>

    I hope this helps some people who need to operate on PHP 5.2.x servers for some reason. Late static binding, of course, makes this workaround obsolete.

    Специальные методы в php

    В предыдущей статье мы использовали несколько специальных методов теперь рассмотрим только php специальные методы.

    Эти методы ещё называют магическими методами.

    Вот какие методы мы дальше рассмотрим:

    Специальный метод __set($name, $value)

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

    Он принимает 2 параметра:

    1. $name – это имя несуществующего свойства.
    2. $value – это значение свойства.

    PHP 5

    Статические методы классов в PHP 5, также как и статические свойства, принадлежат всему классу в целом. Это позволяет использовать такой метод без создания какого-либо объекта такого класса.

    static function statFunc() <
    echo «статический метод»;
    >
    >
    MyClass::statFunc(); // Выводит «статический метод»
    ?>

    Однако в статическом методе становится невозможным использовать указатель $this , так как при вызове статического метода или неизвестно в контексте какого объекта он вызывается, или такого объекта может и не существовать вовсе.

    Дата публикации: 11.07.04
    Последнее обновление: —
    Просмотров: 34248

    Copyright © PHP World — Леонид Лукин, 2004-2008.

    Добавить комментарий