Php как вывести класс

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

Объекты и классы

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

Ключевыми понятиями парадигмы ООП являются понятия «класс» и «объект». Описанием объекта является класс, а объект представляет экземпляр этого класса. Можно провести следующую аналогию: например, у каждого человека есть имя, определенный возраст, вес, какие-то другие параметры. То есть некоторый шаблон, который содержит набор параметров человека — этот шаблон можно назвать классом. А реально же существующий человек с конкретным именем, возрастом, весом и т.д. является объектом или экземпляром этого класса.

Для создания класса в PHP используется ключевое слово class , после которого идет название класса и фигурные скобки <> — блок кода класса. Например, новый класс, представляющий пользователя:

Чтобы создать объект класса Person, применяется ключевое слово new :

В данном случае переменная $person является объектом класса Person . С помощью функции print_r() можно вывести содержимое объекта, как и в случае с массивами.

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

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

Класс может содержать переменные, которые описывают какие-то признаки объекта, его состояние и которые еще назывют свойствами или атрибутам. И также класс класс может содержать функции, которые еще назвают методами и которые определяют его поведение.

Так, добавим в класс Person несколько свойств и методов:

Здесь класс Person содержит два свойства: $name и $age . Свойства объявляются как обычные переменные, перед которыми стоит модификатор доступа — в данном случае модификатор public .

Методы представляют обычные функции, которые выполняют определенные действия. Здесь функция hello() просто выводит приветствие.

После создания объекта класса Person:

Мы можем через имя переменной класса обращаться к его свойствам и методам. Чтобы обратиться к свойствам и методам объекта применяется оператор доступа -> . Например, установить значения свойств:

Или получить значение (например, присвоить его переменной):

Или вызвать методы объекта:

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

При этом свойствам можно задать в классе некоторые начальные значения:

Ключевое слово this

Для обращения к свойствам и методам объекта внутри его класса применяется ключевое слово this . Например, определим в классе метод для вывода информации об объекте:

Для обращения к полям и методам внутри класса также применяется оператор доступа -> , перед которым идет $this . Причем это $this указывает именно на текущий объект. Что это значит в практическом плане? Например:

$this фактически будет указывать на переменную $tom . Тогда как при вызове

$this будет указывать на переменную $bob .

Сравнение объектов

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

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

Рассмотрим на примере:

Здесь сравниваются две переменных — $tom и $tomas. Они представляют один и тот же класс Person, и их свойства имеют одни и те же значения. Однако они представляют разные объекты. Поэтому при сравнении оператор == возвратит true , а оператор === — false :

Возьмем другой пример, когда обе переменных представляют один и тот же объект:

Здесь объект класса Person создается только один раз: $person = new Person(); . И затем обе переменных $tom и $tomas будут указывать на этот объект. При этом не имеет значения, для какой именно переменной мы устанавливаем свойства. Так как в реальности это будет один и тот же объект. В итоге и оператор == , и оператор === при сравнении возвратят true

Источник

Объекты и классы в PHP

Объекты

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

Особенности объектов и их отличия от массивов

Давайте разберёмся, что такое PHP-объект. Как сказано выше, объекты похожи на массивы, но со своими особенностями. Объекты могут содержать отдельные значения, каждое под своим ключом. Эти значения называются свойствами объекта.
Также объекты могут иметь внутри себя функции — их называют методами объекта. Методы могут обращаться к любым свойствам объекта, читать и записывать туда данные.

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

Но самая большая особенность объектов — это то, как они создаются. Если массив создается либо пустым, либо сразу с набором значений, то объекты устроены иначе. Дело в том, что объекты не существуют сами по себе. Чтобы создать новый объект, вам придётся вначале создать его описание — класс.
Класс — это как бы чертёж объекта. Класс описывает то, из чего состоит объект. Мы разберёмся с классами чуть позже.

Анатомия объекта

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

Вторая группа — это методы объекта.
Набор методов также называется поведением объекта. Как и свойства, методы бывают публичными и скрытыми. Публичные методы объекта можно вызывать из внешнего кода, а скрытые только из самого объекта. Методы способны обращаться к свойствам объекта также просто, как если бы это были их внутренние переменные или аргументы.

Классы

Класс — это шаблон, по которому создаются объекты.

Напомню, что классы — это описания объектов. Мы не можем создать объект «на лету», как это происходит с массивами. Объект может быть создан только на основе своего описания — класса. Этим, кстати, реализация объектов в PHP отличается от JavaScript. В JS объектам не нужны никакие классы, и они могут быть созданы и модифицированы когда угодно и как угодно.

Класс как чертёж

Зачем же нужны классы, и почему объекты не могут существовать без них?

Здесь аналогия очень простая: класс – это чертёж, максимально подробное описание того, как должно выглядеть изделие. Сам по себе класс не является чем-то физическим и осязаемым, то есть мы не можем использовать его в коде непосредственно. Вместо этого класс является схемой, структурой, на основе которой будет создан объект.

Жизненный цикл объекта

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

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

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

Пример создания объекта на основе класса

Создание объекта на основе класса:

Разбор примера

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

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

Далее идёт перечисление методов. И начинается всё с метода, у которого особое имя и значение — __construct .

Что такое конструктор объекта

Методы объекта вызываются из внешнего кода, при явном обращении к ним с указанием имени. Но если назвать один метод __construct то он будет вызываться автоматически в момент создания объекта на основе класса.

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

Обращение к свойствам и методам объекта

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

Во-вторых, для обращения к методам и свойствам объекта нужен специальный синтаксис: «стрелочка». Такая стрелочка отделяет имя свойства или метода от имени объекта. Это аналог квадратных скобок при работе с массивами.

Метод с именем isCold() нужен, чтобы узнать было ли холодно в тот день, основываясь на показаниях температуры в градусах.
Метод setRainStatus() устанавливает логическое значение, которое показывает статус осадков в день наблюдения.
Метод getDayDescription() формирует текстовое описание погоды на заданную дату.

Создание объекта на основе класса

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

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

Источник

Функции работы с классами и объектами

Содержание

• __autoload — Попытка загрузить неопределённый класс
• class_alias — Создаёт псевдоним для указанного класса
• class_exists — Проверяет, был ли объявлен класс
• enum_exists — Проверяет, определено ли перечисление
• get_called_class — Имя класса, полученное с помощью позднего статического связывания
• get_class_methods — Возвращает массив имён методов класса
• get_class_vars — Возвращает объявленные по умолчанию свойства класса
• get_class — Возвращает имя класса, к которому принадлежит объект
• get_declared_classes — Возвращает массив с именами объявленных классов
• get_declared_interfaces — Возвращает массив всех объявленных интерфейсов
• get_declared_traits — Возвращает массив со всеми объявленными трейтами
• get_mangled_object_vars — Возвращает массив искажённых свойств объекта
• get_object_vars — Возвращает свойства указанного объекта
• get_parent_class — Возвращает имя родительского класса для объекта или класса
• interface_exists — Проверяет, определён ли интерфейс
• is_a — Проверяет, принадлежит ли объект к данному классу или является ли этот класс одним из его родителей
• is_subclass_of — Проверяет, содержит ли объект в своём дереве предков указанный класс либо прямо реализует его
• method_exists — Проверяет, существует ли метод в данном классе
• property_exists — Проверяет, содержит ли объект или класс указанный атрибут
• trait_exists — Проверяет, существует ли трейт

User Contributed Notes 19 notes

[Editor’s note: If you are trying to do overriding, then you can just interrogate (perhaps in the method itself) about what class (get_class()) the object belongs to, or if it is a subclass of a particular root class.

You can alway refer to the parent overriden method, see the «Classes and Objects» page of the manual and comments/editor’s notes therein.]

There is no function to determine if a member belongs to a base class or current class eg:

class foo <
function foo () < >
function a () < >
>

class bar extends foo <
function bar () < >
function a () < >
>

lala = new Bar ();
?>
——————
how do we find programmatically if member a now belongs to class Bar or Foo.

To pillepop2003 at yahoo dot de:

I have the same issue. I have a base class that manages database tasks for a number of child classes. One of the functions in the base class is a find() method that returns instances of the child classes. Since find() is usually called as a static method, it needs to know the name of the child class. As you’ve found, this appears to be impossible to get in an easy fashion.

The only way I’ve found to get the child class name is to use the debug_traceback() function. This requires me to have a find() method in every child class, but it does work.

Here’s an example:

class parentClass <
function find () <
$className = NULL ;
foreach ( debug_backtrace () as $bt ) <
if ( $bt [ ‘function’ ] == __FUNCTION__ ) <
$className = $bt [ ‘class’ ];
>
>

// here should be some code to find the proper id, let’s assume it was id 1
$id = 1 ;
return new $className ( $id );
>
>

class foo extends parentClass <
function __construct ( $id ) <
$this -> id = id ;
>

function find () <
return parent :: find ();
>
>

class bar extends parentClass <
function __construct ( $id ) <
$this -> id = id ;
>

function find () <
return parent :: find ();
>
>

$a = foo :: find ();
printf ( «Type for \$a: %s
\n» , get_class ( $a ));
$b = bar :: find ();
printf ( «Type for \$b: %s
\n» , get_class ( $b ));
?>

FYI: if you want to split your class into manageble chunks, what means different files for you, you can put you functoins into includes, and make include() have a return value. Like this:

class Some_class <
var $value = 3;
function add_value ($input_param) <
return include («path/some_file.php»);
>
>

And your included file:

$input_param += $this->value;
return $input_param;

Then your function call will be:

$instance = new Some_class ();
$instance->add_value (3);

And this will return
6
hopefully 😛

Keep in mind though, that the scope in the included file will be identical to the scope the function ‘add_value’ has.
And if you want to return the outcome, you should also have a return statement made in your include as well.

Something I found out just now that comes in very handy for my current project:

it is possible to have a class override itself in any method ( including the constructor ) like this:

..function ha ( ) <
. if ( $some_expr ) <
. $this = new b;
. return $this->ha ( );
. >
. return $something;
..>

in this case assuming that class b is already defined and also has the method ha ( )

note that the code after the statement to override itself is still executed but now applies to the new class

i did not find any information about this behaviour anywhere, so i have no clue wether this is supposed to be like this and if it might change. but it opens a few possibilities in flexible scripting!!

Re: Looking for an uninstantiated class

# Loads data from a table into a class object
class LFPDataFactory extends LFPObject <
var $object;
var $class;
var $table;
function LFPDataFactory($args) <
$this->unpackArgs($args); // assigns locals from $args
if (in_array(strtolower($this->class), get_declared_classes())) <
$this->object = new $this->class;
// assemble the columns in the table.
// select their values and put them in our new object.
> else < trigger_error("Class ".$this->class.» not found», E_USER_ERROR); >
>
>
$r = new LFPDataFactory(«class=LFPLayout,table=layout»);
$new_obj = $r->object; // this is a LFPLayout object.
print_r($new_obj);

This class looks to see if the class exists, then instantiates it — a declared class is not the same as an instantiated class. As long as LFPLayout exists somewhere in the scripts, get_declared_classes() will find it. Remember strtolower on compare, however.

Why would I do this? Because I have my class layouts the same as their respective tables; the factory then selects the data (making sure that the variables match) and plugs in the data. (I’ve left out the actual code to do the selection/insertion).

To pillepop2003 at yahoo dot de:

It seems to me if there really is no nice way to get the class name in an un-instanciated class, there is a workaround in PHP5 though using static/class variables.

class myFoo
<
static $__ClassName = __CLASS__ ;

static function getClassName ()
<
return myFoo :: $__ClassName ;
>
>;

class myFooExtended extends myFoo
<
function __construct ()
<
myFooExtended :: $__ClassName = __CLASS__ ;
>;
>;

?>

However, you’ll need to have at least instanciated an object of the class myFooExtended before calling getClassName or introduce some other initialization (the class variable will need to be set at some point to __CLASS__ in the sub-class).

If you want to be able to call an instance of a class from within another class, all you need to do is store a reference to the external class as a property of the local class (can use the constructor to pass this to the class), then call the external method like this:

or if the double ‘->’ is too freaky for you, how about:

This is handy if you write something like a general SQL class that you want member functions in other classes to be able to use, but want to keep namespaces separate. Hope that helps someone.

class class1 <
function test ( $var ) <
$result = $var + 2 ;
return $result ;
>
>

class class2 <
var $ref_to_class = » ; # to be pointer to other class

function class1 (& $ref ) < #constructor
$this -> ref_to_class = $ref ; #save ref to other class as property of this class
>

function test2 ( $var ) <
$val = $this -> ref_to_class -> test ( $var ); #call other class using ref
return $val ;
>
>

$obj1 =new class1 ;
# obj1 is instantiated.
$obj2 =new class2 ( $obj1 );
# pass ref to obj1 when instantiating obj2

$var = 5 ;
$result = obj2 -> test2 ( $var );
# call method in obj2, which calls method in obj1
echo ( $result );

I wanted to dynamically choose an extender for a class. This took awhile of playing with it but I came up with a solution. Note that I can’t verify how safe it is, but it appears to work for me. Perhaps someone else can shed light on the details:

// Uncomment which extender you want. You can use variables as well.
// define(‘__EXTENDER__’, ‘A’);
define ( ‘__EXTENDER__’ , ‘B’ );

// Use eval to create a wrapper class.
eval( ‘class EXTENDER extends ‘ . __EXTENDER__ . ‘ < >‘ );

class C extends EXTENDER
<
function __construct ()
<
echo $this -> value ;
>
>

Practical application: I have a database abstraction system that has individual classes for mysql, pgsql, et al. I want to be able to create a global db class that extends one of the individual db classes depending on the application configuration.

I know that there are probably much better ways of doing this but I haven’t reached that level when it comes to classes.

to covertka at muohio dot edu and pillepop2003 at yahoo dot de:

There’s a much easier solution to getting a class’ name for working with a factory function. Let’s assume you’re doing something like this:

function FactoryFunction ( $whatever , $instancedata ) <

switch ( $whatever ) <
case ‘stuff’ : return new Stuff ( $instancedata );
case ‘otherstuff’ : return new Otherstuff ( $instancedata );
>

?>

Now, consider the named parameter idiom and remember that PHP uses hashes for everything; as a result make the following changes:

function FactoryFunction ( $whatever , $instancedata ) <

case ‘stuff’ : return array( ‘typeis’ => ‘stuff’ , ‘instance’ =>new Stuff ( $instancedata ));
case ‘otherstuff’ : return array( ‘typeis’ => ‘otherstuff’ , ‘instance’ =>new Otherstuff ( $instancedata ));

?>

Nice ‘n simple. It seems that what the original poster wanted was something like C++ static data members; unfortunately as PHP4 has no static variables at all, there would need to be significant language change to support static-like behavior. If you move to PHP5, the static keyword solves your problem cleanly.

To access an object member with an illegal character in the name, use this syntax:

This is particularly relevant with the dynamically-generated classes used by, for instance, database objects and the SoapClient class.

Subject: using «sql_calc_found_rows» in a MySQL query while exploiting result in a PHP db class object.

There is a nice function in MySQL that allows to know how many records would have been returned if no «where» clause were set : SQL_CALC_FOUND_ROWS.

If you have create a db object to collect the returned lines, you will be a little perplex when trying to call the result of this function.

Why ?
Simply because the returned field’s name is «found_rows()» and obviously it’s not possible to call something like :

-> found_rows () ?>

. as it will try to acces a method, not a property !

Then, the only way to get the right result seems to be the use of a class function, like :

-> query ( «select found_rows()» );
$count = current ( get_object_vars ( current ( $db -> result )));
?>

Of course, if somebody found an other way to solve it, like a special syntax (see the one used with curled arrays in a string), I’m really open to discuss.

A small function that allows finding all references to the object. Written in 3 minutes and may be buggy (for ex pass object as reference in some places?)

function find_ref_obj ( $object , $obj , $path ) <
if ( in_array ( $obj , $GLOBALS [ ‘__REF_CHECKED’ ], true ))
return false ;
$GLOBALS [ ‘__REF_CHECKED’ ][]= $obj ;
$r = array();
foreach ((array) $obj as $k => $v ) <
if ( $v === $object )
$r [] = $path . «-> $k » ;
if ( is_object ( $v )) <
$t = find_ref_obj ( $object , $v , $path . «-> $k » );
if ( $t !== false )
$r = array_merge ( $r , $t );
>
else if ( is_array ( $v )) <
$t = find_ref_arr ( $object , $v , $path . «-> $k » );
if ( $t !== false )
$r = array_merge ( $r , $t );
>
>
if (empty( $r ))
return false ;
else
return $r ;
>
function find_ref_arr ( $object , $arr , $path ) <
if ( in_array ( $arr , $GLOBALS [ ‘__REF_CHECKED’ ], true ))
return false ;
$GLOBALS [ ‘__REF_CHECKED’ ][]= $arr ;
$r = array();
foreach ( $arr as $k => $v ) <
if ( $v === $object )
$r [] = $path . «[‘ $k ‘]» ;
if ( is_object ( $v )) <
$t = find_ref_obj ( $object , $v , $path . «[‘ $k ‘]» );
if ( $t !== false )
$r = array_merge ( $r , $t );
>
else if ( is_array ( $v )) <
$t = find_ref_arr ( $object , $v , $path . «[‘ $k ‘]» );
if ( $t !== false )
$r = array_merge ( $r , $t );
>
>
if (empty( $r ))
return false ;
else
return $r ;
>
function find_references ( $object ) <
$r = array();
$GLOBALS [ ‘__REF_CHECKED’ ]=array();
foreach ( $GLOBALS as $n => $v )
if ( $n != ‘__REF_CHECKED’ )
if ( $n != ‘GLOBALS’ ) <
if ( $v === $object )
$r []= $n ;
if ( is_object ( $v )) <
$t = find_ref_obj ( $object , $v , $n );
if ( $t !== false )
$r = array_merge ( $r , $t );
>
else if ( is_array ( $v )) <
$t = find_ref_arr ( $object , $v , $n );
if ( $t !== false )
$r = array_merge ( $r , $t );
>
>
unset( $GLOBALS [ ‘__REF_CHECKED’ ]);
return $r ;
>

function find_refs ( $object ) <
return implode ( ‘, ‘ , find_references ( $object ));
>
?>

Why do u want to know the classname of an non-existant object?

The only possible explanation for this question seems to me u want to know the class before u instantiate the object. Well, this is of no use since u always instantiate a class of ur choice.

When the class is instantiated into an object u can find the class of the object by means of get_class(). This is all u need. In case of inheritance u can use get_class($this) to get the class of the instantiated object. Now u can differentiate according to which class the object belongs to.

class A <
function A () <
$class_of_this = get_class ( $this );
echo ‘Object is an instance of class ‘ . $class_of_this . ‘ which is the ‘ ;
if( strcmp ( $class_of_this , ‘A’ )== 0 )
echo ‘parent-class’ ;
else if( strcmp ( $class_of_this , ‘B’ )== 0 )
echo ‘child-class’ ;
echo «.\n» ;
>
>

class B extends A <
function B () <
$this -> A ();
>
>

$object1 = new A ();
$object2 = new B ();
?>

When u run this code-snippet the output will be:

Object is an instance of class A which is the parent-class.
Object is an instance of class B which is the child-class.

We have an array with many objects in a style like

= new StepModel ( 1 ); // if the StepModel id is «1»
$demand = $step -> getDemand (); // returns DemandModel
$step2 = $demand -> getCustomer (); // returns StepModel
$demand2 = $step2 -> getDemand (); // returns DemandModel

?>

$step and $step2 can be the same objects. So we have an recursive array. Now we need to know if $step == $step2 or $step === $step2. In other words: We need to know the php internal resource ids.

Because there is no function in php api, we made the following function.

Be careful: In our case, all objects have as first attribute [«id»:protected]. If your objects are different from this, you need to edit $pattern.

Warning: function is very slow and should only be called if it’s necessary for debugging reasons:

/**
* returns resource- and object-ids of all objects in an array
*
* @param array $array
* @return array
*/
function getObjectInformation (Array $array )
<
// start output-buffering
ob_start ();

// create an var_dump of $array
var_dump ( $array );

// save the dump in var $dump
$dump = ob_get_contents ();

// clean the output-buffer
ob_end_clean ();

// delete white-spaces
$dump = str_replace ( ‘ ‘ , » , $dump );

// define the regex-pattern
// in our case, all objects look like this:
//
// object(ClassName)#1(1) <
// [«id»:protected]=>
// string(1)»1″
$pattern = ‘/object\(([a-zA-Z0-9]+)\)#(5+)\(1+\) <\\n' ;
$pattern .= ‘\[«id»:protected\]=>\\n’ ;
$pattern .= ‘string\(9+\)»([v]?3+)»/im’ ;

// search for all matches
preg_match_all ( $pattern , $dump , $regs );

// sort all mathes by class name, object id and then resource id
array_multisort ( $regs [ 1 ], SORT_ASC , SORT_STRING ,
$regs [ 3 ], SORT_ASC , SORT_NUMERIC ,
$regs [ 2 ], SORT_ASC , SORT_NUMERIC );

// cache the last match
$lastMatch = array();

// the return value
$return = array();

// loop through the matches
for ( $i = 0 ; $i sizeof ( $regs [ 0 ]); $i ++) <

// check if the current match was not visited before
if ( 0 == sizeof ( $lastMatch ) ||
$regs [ 1 ][ $i ] != $lastMatch [ 1 ] ||
$regs [ 2 ][ $i ] != $lastMatch [ 2 ] ||
$regs [ 3 ][ $i ] != $lastMatch [ 3 ]) <

// save the match in return value
array_push ( $return , array( $regs [ 1 ][ $i ],
$regs [ 2 ][ $i ],
$regs [ 3 ][ $i ]));
>

// save match in last match cache
$lastMatch [ 1 ] = $regs [ 1 ][ $i ];
$lastMatch [ 2 ] = $regs [ 2 ][ $i ];
$lastMatch [ 3 ] = $regs [ 3 ][ $i ];
>

// return all matches
return $return ;
>

?>

I know, it’s not that elegant but I hope it’s useful for a few people.

Источник