Shulou(Shulou.com)06/03 Report--

This article mainly introduces "what are the interfaces of the PHP SPL standard library". In the daily operation, I believe that many people have doubts about the interface of the PHP SPL standard library. The editor consulted all kinds of materials and sorted out the simple and easy-to-use operation methods. I hope it will be helpful to answer the questions of "what are the interfaces of the PHP SPL standard library?" Next, please follow the editor to study!

The PHP SPL standard library has a total of 6 APIs, as follows:

1.Countable

2.OuterIterator

3.RecursiveIterator

4.SeekableIterator

5.SplObserver

6.SplSubject

OuterIterator, RecursiveIterator and SeekableIterator all inherit the Iterator class. The function and use of each API are described in detail below.

Coutable interface:

Objects that implement the Countable interface can be used to count the count () function.

The copy code is as follows:

Class Mycount implements Countable

{

Public function count ()

{

Static $count = 0

$count++

Return $count

}

}

$count = new Mycount ()

$count- > count ()

$count- > count ()

Echo count ($count); / / 3

Echo count ($count); / / 4

Description:

When the count () function is called, the Mycount::count () method is called

The second argument of the count () function will have no effect

OuterIterator interface:

Customize or modify the iterative process.

The copy code is as follows:

/ / IteratorIterator is an implementation class of OuterIterator

Class MyOuterIterator extends IteratorIterator {

Public function current ()

{

Return parent::current (). 'TEST'

}

}

Foreach (new MyOuterIterator (new ArrayIterator (['baked dagger ([' baked cinematic])) as $key = > $value) {

Echo "$key- > $value" .PHP _ EOL

}

/ *

Results:

0-> bTEST

1-> aTEST

2-> cTEST

, /

In practice, OuterIterator is extremely useful:

The copy code is as follows:

$db = new PDO ('mysql:host=localhost;dbname=test',' root', 'mckee')

$db- > query ('set names utf8')

$pdoStatement = $db- > query ('SELECT * FROM test1', PDO::FETCH_ASSOC)

$iterator = new IteratorIterator ($pdoStatement)

$tenRecordArray = iterator_to_array ($iterator)

Print_r ($tenRecordArray)

RecursiveIterator interface:

For iterating through multi-tier data, RecursiveIterator provides two additional methods:

RecursiveIterator::getChildren gets the child iterator under the current element

RecursiveIterator::hasChildren determines whether there is an iterator under the current element

The copy code is as follows:

Class MyRecursiveIterator implements RecursiveIterator

{

Private $_ data

Private $_ position = 0

Public function _ _ construct (array $data) {

$this- > _ data = $data

}

Public function valid () {

Return isset ($this- > _ data [$this- > _ position])

}

Public function hasChildren () {

Return is_array ($this- > _ data [$this- > _ position])

}

Public function next () {

$this- > _ position++

}

Public function current () {

Return $this- > _ data [$this- > _ position]

}

Public function getChildren () {

Print_r ($this- > _ data [$this- > _ position])

}

Public function rewind () {

$this- > _ position = 0

}

Public function key () {

Return $this- > _ position

}

}

$arr = array (0,1 = > array (10,20), 2,3 = > array (1,2))

$mri = new MyRecursiveIterator ($arr)

Foreach ($mri as $c = > $v) {

If ($mri- > hasChildren ()) {

Echo "$c has children:" .PHP _ EOL

$mri- > getChildren ()

} else {

Echo "$v" .PHP _ EOL

}

}

/ *

Results:

0

1 has children:

Array

(

[0] = > 10

[1] = > 20

)

two

3 has children:

Array

(

[0] = > 1

[1] = > 2

)

, /

SeekableIterator interface:

Implement a searchable iterator through the seek () method, which is used to search for elements under a certain location.

The copy code is as follows:

Class MySeekableIterator implements SeekableIterator {

Private $position = 0

Private $array = array (

"first element"

"second element"

"third element"

"fourth element"

);

Public function seek ($position) {

If (! isset ($this-> array [$position])) {

Throw new OutOfBoundsException ("invalid seek position ($position)")

}

$this-> position = $position

}

Public function rewind () {

$this-> position = 0

}

Public function current () {

Return $this-> array [$this-> position]

}

Public function key () {

Return $this-> position

}

Public function next () {

+ + $this-> position

}

Public function valid () {

Return isset ($this-> array [$this-> position])

}

}

Try {

$it = new MySeekableIterator

Echo $it-> current (), "\ n"

$it-> seek (2)

Echo $it-> current (), "\ n"

$it-> seek (1)

Echo $it-> current (), "\ n"

$it-> seek (10)

} catch (OutOfBoundsException $e) {

Echo $e-> getMessage ()

}

/ *

Results:

First element

Third element

Second element

Invalid seek position (10)

, /

SplObserver and SplSubject interfaces:

The SplObserver and SplSubject interfaces are used to implement the Observer Design pattern, which means that when the state of a class changes, objects that depend on it are notified and updated. The use of scenarios is very widespread, for example, when an event occurs, multiple logic operations need to be updated. The traditional way is to write logic after the event is added. This kind of code is coupled and difficult to maintain. Observer mode can implement low-coupling notification and update mechanism.

Look at the interface structure between SplObserver and SplSubject:

The copy code is as follows:

/ / the object whose SplSubject structure is observed

Interface SplSubject {

Public function attach (SplObserver $observer); / / add an observer

Public function detach (SplObserver $observer); / / eliminate observers

Public function notify (); / / notify the observer

}

/ / the SplObserver structure represents the observer

Interface SplObserver {

Public function update (SplSubject $subject); / / update operation

}

Take a look at the following example of implementing an observer:

The copy code is as follows:

Class Subject implements SplSubject

{

Private $observers = array ()

Public function attach (SplObserver $observer)

{

$this- > observers [] = $observer

}

Public function detach (SplObserver $observer)

{

If ($index = array_search ($observer, $this- > observers, true)) {

Unset ($this- > observers [$index])

}

}

Public function notify ()

{

Foreach ($this- > observers as $observer) {

$observer- > update ($this)

}

}

}

Class Observer1 implements SplObserver

{

Public function update (SplSubject $subject)

{

Echo "Logic 1 Code" .PHP _ EOL

}

}

Class Observer2 implements SplObserver

{

Public function update (SplSubject $subject)

{

Echo "Logic 2 Code" .PHP _ EOL

}

}

$subject = new Subject ()

$subject- > attach (new Observer1 ())

$subject- > attach (new Observer2 ())

$subject- > notify ()

/ *

Results:

Logic 1 code

Logic 2 code

, /

At this point, the study of "what are the interfaces of the PHP SPL standard library" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.