php create object from object
How to Create an Object in PHP
PHP is an object-oriented language, although it does not have to be used since most PHP functions are not object-oriented. In object-oriented programming, the class is the object’s definition, whereas the object is an instance of an object, meaning that from one class, you can create many objects.
Class in PHP
Class is the programmer-defined data type, which includes the local methods and local variables. Class is the collection of objects. The object has properties and behavior.
Classes are the blueprints of objects.
One of the significant differences between the functions and classes is that a class contains data, variables, and functions that form the package called an: ‘object’.
See the syntax of the class in PHP.
We enclose a class using curly braces ( < >) … just like you do with functions.
PHP Objects
The Object is an individual instance of a data structure defined by the class. We define the class once and then make many objects that belong to them.
Objects are also known as instances.
Creating an Object in PHP
Now, let’s add constructor and method in the class.
In the above code, we have used parameterized constructor as well as added a method called details which prints the string in the PHP console.
Let’s analyze the complete code. Notice that the Actor class has a constructor function, which is executed when an object is created.
A constructor receives the arguments which are later provided when constructing an object with a new keyword.
After constructing the object into a variable $millie, we can now use the object’s methods.
We implemented an object method details(), which prints out both of the variables. Notice that the details() function does not receive any arguments, but it does have access to the $show and $character properties because they were previously defined in a constructor.
Here are some important points related to objects:
Constructors in PHP
A constructor is a key concept in object-oriented programming in PHP.
Constructor in PHP is a special type of function of the class which is automatically executed as the object of that class is created or instantiated.
The constructor is also called the magic function because, in PHP, magic methods usually start with two underscore characters.
Member Functions in PHP
After creating our objects, we can call the member functions related to that object.
A member function typically accesses members of the current object only.
Create an object without class in PHP
All objects in PHP have the class. A “default” class is stdClass, and you can create the objects of stdClass in the following way.
See the following code.
In PHP 7, it is possible to create anonymous classes to do things like the following.
That is it for creating an object in PHP tutorial.
Php create object from object
class foo
<
function do_foo ()
<
echo «Код foo.» ;
>
>
Полное рассмотрение производится в разделе Классы и Объекты.
Преобразование в объект
При преобразовании любого другого значения, оно будет помещено в поле с именем scalar соответствующему типу.
User Contributed Notes 28 notes
By far the easiest and correct way to instantiate an empty generic php object that you can then modify for whatever purpose you choose:
In PHP 7 there are a few ways to create an empty object:
= new \ stdClass ; // Instantiate stdClass object
$obj2 = new class<>; // Instantiate anonymous class
$obj3 = (object)[]; // Cast empty array to object
As of PHP 5.4, we can create stdClass objects with some properties and values using the more beautiful form:
Here a new updated version of ‘stdObject’ class. It’s very useful when extends to controller on MVC design pattern, user can create it’s own class.
echo «‘ ;
?>
works and displays:
stdClass Object
(
[a] => A
[b] => B
[0] => C
)
/**
* Used for checking empty objects/array
* @uses How to check empty objects and array in php code
* @author Aditya Mehrotra
*/
/**
* Empty class
*/
class EmptyClass <
$obj = new stdClass ();
//or any other class empty object
$emptyClassObj = new EmptyClass ();
$array = array();
//Result SET 1
//array is empty => expected result
//object is not empty => ouch what happened
//EmptyClass is not empty => ouch what happened
/**
* So what we do for checking empty object
* @solution use any known property or check property count
* Or you can use below method
* Count function will not return 0 in empty object
*/
//Result SET 2
//array is empty => expected result ##everything is all right
//object is empty => expected result ##everything is all right
//EmptyClass is empty => expected result ##everything is all right
If you use new to create items in an array, you may not get the results you want since the parameters to array will be copies of the original and not references.
This is extremely important if you intend on passing arrays of classes to functions and expect them to always use the same object instance!
Note: The following syntax is desired (or maybe even the default notation should translate as this):
$a = array( &new Store() );
Do you remember some JavaScript implementations?
// var timestamp = (new Date).getTime();
Now it’s possible with PHP 5.4.*;
print (new Foo )-> a ; // I’m a!
print (new Foo )-> getB (); // I’m b!
?>
or
In response to sirbinam.
You cannot call a function or method before it exists. In your example, the global instance of stdout is just being passed around to differnet references (pointers). It however exists in the «dump» function scope via the global keyword.
The code below works fine and illustrates that «stdout» has been defined before its instantiation.
?>
All classes and functions declarations within a scope exist even before the php execution reaches them. It does not matter if you have your classes defined on the first or last line, as long as they are in the same scope as where they are called and are not in a conditional statement that has not been evaluated yet.
If you need to force json_encode() to produce an object even when an array is empty or does not have successive 0-based numeric indices, you can simply convert the array to an object. JSON_FORCE_OBJECT does the same with ALL arrays, which might not be what you want.
echo json_encode ([[]]), «\n» ;
// output: [[]]
echo json_encode ([[]], JSON_FORCE_OBJECT ), «\n» ;
// output: <"0":<>>
echo json_encode ([(object)[]]), «\n» ;
// output: [<>]
in php 7.2 this code works despite documentation said it gives false
= (object) array( ‘1’ => ‘foo’ );
In PHP 5+, objects are passed by reference. This has got me into trouble in the past when I’ve tried to make arrays of objects.
For example, I once wrote something like the following code, thinking that I’d get an array of distinct objects. However, this is wrong. This code will create an array of multiple references to the same object.
notice that the value at each index in the array is the same. That is because the array is just 3 references to the same object, but we change the property of this object every time the for loop runs. This isn’t very useful. Instead, I’ve changed the code below so that it will create an array with three distinct references to three distinct objects. (if you’re having a hard time understanding references, think of this as an array of objects, and that this is just the syntax you have to use.)
Notice how the creation of a new object («$arrayItem = new myNumber();») must happen every time the for loop runs for this to work.
This took me forever to figure out, so I hope this helps someone else.
PHP supports recursive type definitions as far as I’ve tried. The class below (a _very_ simple tree) is an example:
As you can see, in addChild we reference Tree again.
However, you must be careful about references. See the chapter «References explained» for more details.
If you call var_export() on an instance of stdClass, it attempts to export it using ::__set_state(), which, for some reason, is not implemented in stdClass.
However, casting an associative array to an object usually produces the same effect (at least, it does in my case). So I wrote an improved_var_export() function to convert instances of stdClass to (object) array () calls. If you choose to export objects of any other class, I’d advise you to implement ::__set_state().
/* Output:
(object) array (‘prop1’ => true, ‘prop2’ => (object) array (‘test’ => ‘abc’, ‘other’ => 6.2, ‘arr’ => array (0 => 1, 1 => 2, 2 => 3)), ‘assocArray’ => array (‘apple’ => ‘good’, ‘orange’ => ‘great’))
*/
?>
Note: This function spits out a single line of code, which is useful to save in a cache file to include/eval. It isn’t formatted for readability. If you want to print a readable version for debugging purposes, then I would suggest print_r() or var_dump().
I’m using the Symfony2 PHP framework with Doctrine ORM and mysql for storing data.
My goal is to populate Doctrine entities(PHP objects) by loading the data from a legacy database system which returns the data in key:value pairs.
I have many PHP objects(‘Company’,’Employee’,etc.) that extend the same Abstract Class(‘AbstractDatabaseRecord’).
My abstract class(‘AbstractDatabaseRecord’) has a property(‘ DatabaseTable ‘) which tells me which table to use when loading data for each object(‘Company’,’Employee’,etc.).
My abstract class implements an interface (‘DatabaseLoadable’) which requires a method called getColumns() which should return an array of the columns that make up the objects properties. The interface also requires a method called loadDatabaseData() which should process the array returned from the legacy system, and run the appropriate setters to populate the PHP object.
I have a Symfony2 service(PHP class) called LegacyDatabase that has a couple methods called findOne() and findAll().
I think this one is structured OK, but I am not sure how to implement the findAll() function.
findAll(AbstractDatabaseRecord) accepts an object, uses the DatabaseTable property to determine which table to query, and then selects ALL records from that table. I then loop through the results and ideally will populate a new object for each record found, place the objects in an array, and return the array of newly created objects for me to use.
However in the function I only have the one instance of the object. What would be the best way to create additional instances given that I do now know the Concrete Parent class that is passed in?
From my research it seems like I want to clone the object to get a shallow copy, and then populate that new copy and add it to my array of objects. Is this the best approach?
Подробно об объектах и классах в 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 вашего объекта упадёт до нуля, а это значит, что объект больше не используется и его можно безопасно уничтожить.
How to define an empty object in PHP
with a new array I do this:
Is there a similar syntax for an object
17 Answers 17
stdClass is the default PHP object. stdClass has no properties, methods or parent. It does not support magic methods, and implements no interfaces.
When you cast a scalar or array as Object, you get an instance of stdClass. You can use stdClass whenever you need a generic object instance.
The standard way to create an «empty» object is:
But I personally prefer to use:
It’s shorter and I personally consider it clearer because stdClass could be misleading to novice programmers (i.e. «Hey, I want an object, not a class!». ).
See the PHP manual (here):
stdClass: Created by typecasting to object.
If an object is converted to an object, it is not modified. If a value of any other type is converted to an object, a new instance of the stdClass built-in class is created.
and here (starting with PHP 7.3.0, var_export() exports an object casting an array with (object) ):
However remember that empty($oVal) returns false, as @PaulP said:
Objects with no properties are no longer considered empty.
Regarding your example, if you write:
PHP key1 (an object itself)
Warning: Creating default object from empty value
PHP >= 8 creates the following Error:
Fatal error: Uncaught Error: Undefined constant «key1»
In my opinion your best option is:
I want to point out that in PHP there is no such thing like empty object in sense:
On other hand empty array mean empty in both cases
Quote from changelog function empty
Objects with no properties are no longer considered empty.
Short answer
Long answer
I love how easy is to create objects of anonymous type in JavaScript:
So I always try to write this kind of objects in PHP like javascript does:
But as this is basically an array you can’t do things like assign anonymous functions to a property like js does:
Well, you can do it, but IMO isn’t practical / clean:
Also, using this synthax you can find some funny surprises, but works fine for most cases.
php.net said it is best:
In addition to zombat’s answer if you keep forgetting stdClass
You can use new stdClass() (which is recommended):
Or you can convert an empty array to an object which produces a new empty instance of the stdClass built-in class:
Or you can convert the null value to an object which produces a new empty instance of the stdClass built-in class:
Use a generic object and map key value pairs to it.
Or cast an array into an object
to access data in a stdClass in similar fashion you do with an asociative array just use the <$var>syntax.
As others have pointed out, you can use stdClass. However I think it is cleaner without the (), like so:
However based on the question, it seems like what you really want is to be able to add properties to an object on the fly. You don’t need to use stdClass for that, although you can. Really you can use any class. Just create an object instance of any class and start setting properties. I like to create my own class whose name is simply o with some basic extended functionality that I like to use in these cases and is nice for extending from other classes. Basically it is my own base object class. I also like to have a function simply named o(). Like so:
This is a great start for a base «language» to build other language layers upon with the top layer being written in full internal DSLs. This is similar to the lisp style of development, and PHP supports it way better than most people realize. I realize this is a bit of a tangent for the question, but the question touches on what I think is the base for fully utilizing the power of PHP.