PHP 语言最重要的特性之一便是数组了(特别是关联数组)。
PHP 为此也提供不少的函数和类接口方便于数组操作,但没有一个集大成的类专门用来操作数组。
如果数组操作不多的话,个别函数用起来会比较灵活,开销也小。
但是,如果经常操作数组,尤其是对数组进行各种操作如排序、入栈、出队列、翻转、迭代等,系统函数用起来可能就没有那么优雅了。
下面已实现的一个 Collection 类(数据集对象),来自 ThinkPHP5.0 的基础类 Collection,就是一个集大成的类。
1、 Collection源码
源码确实不错,也不是特别长,就全贴上了,方便阅读。跳到下面的 例子 结合看会比较好理解。
namespace think;use ArrayAccess;use ArrayIterator;use Countable;use IteratorAggregate;use JsonSerializable;class Collection implements ArrayAccess, Countable, IteratorAggregate, JsonSerializable{ protected $items = [];
public function __construct($items = [])
{ $this->items = $this->convertToArray($items);
} public static function make($items = [])
{ return new static($items);
} public function isEmpty()
{ return empty($this->items);
} public function toArray()
{ return array_map(function ($value) { return ($value instanceof Model || $value instanceof self) ? $value->toArray() : $value;
}, $this->items);
} public function all()
{ return $this->items;
} public function merge($items)
{ return new static(array_merge($this->items, $this->convertToArray($items)));
} /** * 比较数组,返回差集 */
public function diff($items)
{ return new static(array_diff($this->items, $this->convertToArray($items)));
} /** * 交换数组中的键和值 */
public function flip()
{ return new static(array_flip($this->items));
} /** * 比较数组,返回交集 */
public function intersect($items)
{ return new static(array_intersect($this->items, $this->convertToArray($items)));
} public function keys()
{ return new static(array_keys($this->items));
} /** * 删除数组的最后一个元素(出栈) */
public function pop()
{ return array_pop($this->items);
} /** * 通过使用用户自定义函数,以字符串返回数组 * * @param callable $callback * @param mixed $initial * @return mixed */
public function reduce(callable $callback, $initial = null)
{ return array_reduce($this->items, $callback, $initial);
} /** * 以相反的顺序返回数组。 */
public function reverse()
{ return new static(array_reverse($this->items));
} /** * 删除数组中首个元素,并返回被删除元素的值 */
public function shift()
{ return array_shift($this->items);
} /** * 把一个数组分割为新的数组块. */
public function chunk($size, $preserveKeys = false)
{ $chunks = [];
foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) { $chunks[] = new static($chunk);
} return new static($chunks);
} /** * 在数组开头插入一个元素 */
public function unshift($value, $key = null)
{ if (is_null($key)) { array_unshift($this->items, $value);
} else { $this->items = [$key => $value] + $this->items;
}
} /** * 给每个元素执行个回调 */
public function each(callable $callback)
{ foreach ($this->items as $key => $item) { if ($callback($item, $key) === false) { break;
}
} return $this;
} /** * 用回调函数过滤数组中的元素 */
public function filter(callable $callback = null)
{ if ($callback) { return new static(array_filter($this->items, $callback));
} return new static(array_filter($this->items));
} /** * 返回数组中指定的一列 */
public function column($column_key, $index_key = null)
{ if (function_exists('array_column')) { return array_column($this->items, $column_key, $index_key);
} $result = [];
foreach ($this->items as $row) { $key = $value = null;
$keySet = $valueSet = false;
if (null !== $index_key && array_key_exists($index_key, $row)) { $keySet = true;
$key = (string) $row[$index_key];
} if (null === $column_key) { $valueSet = true;
$value = $row;
} elseif (is_array($row) && array_key_exists($column_key, $row)) { $valueSet = true;
$value = $row[$column_key];
} if ($valueSet) { if ($keySet) { $result[$key] = $value;
} else { $result[] = $value;
}
}
} return $result;
} /** * 对数组排序 */
public function sort(callable $callback = null)
{ $items = $this->items;
$callback ? uasort($items, $callback) : uasort($items, function ($a, $b) { if ($a == $b) { return 0;
} return ($a < $b) ? -1 : 1;
});
return new static($items);
} /** * 将数组打乱 */
public function shuffle()
{ $items = $this->items;
shuffle($items);
return new static($items);
} /** * 截取数组 */
public function slice($offset, $length = null, $preserveKeys = false)
{ return new static(array_slice($this->items, $offset, $length, $preserveKeys));
} // ArrayAccess
public function offsetExists($offset)
{ return array_key_exists($offset, $this->items);
} public function offsetGet($offset)
{ return $this->items[$offset];
} public function offsetSet($offset, $value)
{ if (is_null($offset)) { $this->items[] = $value;
} else { $this->items[$offset] = $value;
}
} public function offsetUnset($offset)
{ unset($this->items[$offset]);
} //Countable
public function count()
{ return count($this->items);
} //IteratorAggregate
public function getIterator()
{ return new ArrayIterator($this->items);
} //JsonSerializable
public function jsonSerialize()
{ return $this->toArray();
} /** * 转换当前数据集为JSON字符串 */
public function toJson($options = JSON_UNESCAPED_UNICODE)
{ return json_encode($this->toArray(), $options);
} public function __toString()
{ return $this->toJson();
} /** * 转换成数组 */
protected function convertToArray($items)
{ if ($items instanceof self) { return $items->all();
} return (array) $items;
}
}
2、 讲解与例子
给出了例子有前后的关系,所以要结合所有例子来看。
Collection 的原理其实都是对 PHP 内置的函数和 SPL 的应用,如果要更加深入,看官方文档也是一个不错的选择。
ArrayAccess的使用
Collection 既然是个类,那要怎么才能像数组那样便利的操作呢?如 $a[‘key’] 。
答案是:继承接口类 ArrayAccess,并实现该类的几个接口,如下:
abstract public boolean offsetExists ( mixed
o
f
f
s
e
t
)
/
/
判
断
k
e
y
即
offset ) //判断key即
offset)//判断key即offset的数组元素是否存在,相当于 isset(
a
[
a[
a[offset])abstract public mixed offsetGet ( mixed $offset ) //数组元素获取,相当于 $value =
a
[
a[
a[offset]abstract public void offsetSet ( mixed $offset , mixed $value ) //数组元素设置 相当于
a
[
a[
a[offset] = $valueabstract public void offsetUnset ( mixed
o
f
f
s
e
t
)
/
/
删
除
数
组
元
素
,
相
当
于
u
n
s
e
t
(
offset ) //删除数组元素,相当于 unset(
offset)//删除数组元素,相当于unset(a[$offset]);
现在回头看看 Collection 的源码是怎么实现的。
如何使用,来个例子:
use think;
c
=
n
e
w
C
o
l
l
e
c
t
i
o
n
;
c = new Collection;
c=newCollection;c[‘a’] = ‘hello a’;$c[‘b’] = ‘you are b’;echo $c[‘a’] . ‘
’;echo
c
[
′
b
′
]
.
′
<
b
r
/
>
′
;
f
o
r
e
a
c
h
(
c['b'] . '<br/>';foreach (
c[′b′].′<br/>′;foreach(c as $k => $v) { echo "key: $k, val: $v
";}
结果输出:
hello a
you are bkey: a, val: hello akey: b, val: you are b
JsonSerializable的使用
如果对一个对象进行 json 编码的话,其实就是对该对象的 public 属性进行 json 化,那如何定制 json 化的内容和输出呢?
答案是:继承 JsonSerializable 接口类,并实现类中的接口:
abstract public mixed jsonSerialize ( void ) //定制json化的字符串输出
现在回头看看 Collection 的源码是怎么实现的。
如何使用,来个例子:
echo json_encode($c) . ‘
’;
结果输出:
{“a”:“hello a”,“b”:“you are b”}
Countable的使用
如果对一个对象进行 count() 操作的话,其实就是统计该对象的 public 属性的总数,那如何定制 count() 呢?
答案是:继承 Countable 接口类,并实现类中的接口:
abstract public int count ( void )
现在回头看看 Collection 的源码是怎么实现的。
如何使用,来个例子:
echo 'count: ’ .
c
−
>
c
o
u
n
t
(
)
.
′
<
b
r
/
>
′
;
/
/
或
者
e
c
h
o
′
c
o
u
n
t
:
′
.
c
o
u
n
t
(
c->count() . '<br/>';// 或者echo 'count: ' . count(
c−>count().′<br/>′;//或者echo′count:′.count(c) . ‘
’;
结果输出:
count: 2count: 2
IteratorAggregate、ArrayIterator的使用
如何实现迭代器的功能?如可进行 foreach 操作,提供迭代相关的函数等。
答案是:继承接口类 IteratorAggregate (聚合式迭代器),并实现类中的接口:
abstract public Traversable getIterator ( void )
如何实现该接口,调用生成一个 ArrayIterator 类,该类可提供迭代器的所有功能。
现在回头看看 Collection 的源码是怎么实现的。
如何使用,来个例子:
c
[
′
c
′
]
=
′
n
o
t
j
u
s
t
c
′
;
c['c'] = 'not just c';
c[′c′]=′notjustc′;iter =
c
−
>
g
e
t
I
t
e
r
a
t
o
r
(
)
;
/
/
获
取
迭
代
器
/
/
可
方
便
地
使
用
f
o
r
e
a
c
h
操
作
f
o
r
e
a
c
h
(
c->getIterator(); //获取迭代器// 可方便地使用foreach操作foreach (
c−>getIterator();//获取迭代器//可方便地使用foreach操作foreach(iter as $k => $v) { echo "key: $k, val: $v
";}echo 'count: ’ .
i
t
e
r
−
>
c
o
u
n
t
(
)
.
′
<
b
r
/
>
′
;
/
/
当
前
数
组
元
素
个
数
iter->count() . '<br/>'; // 当前数组元素个数
iter−>count().′<br/>′;//当前数组元素个数iter->rewind(); // 数组位置复位echo 'current: ’ . $iter->current() . ‘
’; // 当前位置数组元素的值
结果输出:
key: a, val: hello a
key: b, val: you are b
key: c, val: not just c
count: 3current: hello a
内置函数的使用
功能操作的一般使用内置函数,PHP 提供的内置函数功能已经很强大了,只需要简单地封装成一个类方法即可,函数其实使用不难,忘记怎么使用了去官网溜溜吧。
有些是为了兼容 PHP 低版本,所以还要另外实现一遍,如:
/** * 返回数组中指定的一列 */public function column($column_key, $index_key = null)
内置的 array_column() 需要 PHP5.5及以上版本才支持,而Collection类的应用目标是5.4及以上能使用,所以勉为其难地再实现了一遍。
http://mam.yisuping.com