thinkphp5.x之Collection(集合)解析php集合

風來了發表於2016-10-03
PHP

國慶節放假了，出去了發現所有地方全是人。
怕你們了，還是找個咖啡廳，靜靜的看著你們玩耍。
TP5也出來一段時間了，Let’s Go 看看新框架優點。
註釋難免有不足之處，歡迎指正
thinkphp5.x之資料庫操作相關解析 Db類
http://blog.csdn.net/fenglailea/article/details/52728705
thinkphp5 資料庫 連結
http://blog.csdn.net/fenglailea/article/details/52728899
Collection 是集合的意思，也可以叫資料集/資料集合/物件
fox.風

//名稱空間 這沒什麼好說的
//如果你還不知道這是什麼，請先看 http://blog.csdn.net/fenglailea/article/details/52717646
namespace think;
// 陣列式訪問介面，php預定義介面 http://php.net/manual/zh/class.arrayaccess.php
use ArrayAccess;
// 陣列迭代器 http://php.net/manual/zh/class.arrayiterator.php
use ArrayIterator;
// 統計元素物件個數介面 http://php.net/manual/zh/class.countable.php
use Countable;
// 聚合式迭代器介面，php預定義介面  http://php.net/manual/zh/class.iteratoraggregate.php
use IteratorAggregate;
// JSON序列話介面 http://php.net/manual/zh/class.jsonserializable.php
use JsonSerializable;
// 類 Collection 實現了ArrayAccess, Countable, IteratorAggregate, JsonSerializable介面
class Collection implements ArrayAccess, Countable, IteratorAggregate, JsonSerializable
{
    // 資料儲存變數
    protected $items = [];
    // 建構函式
    public function __construct($items = [])
    {
        // 轉化成陣列，並賦值給變數items
        $this->items = $this->convertToArray($items);
    }
    // 裝載/生成/製作等等，怎麼叫法都可以，就是生成一個新結果集合
    public static function make($items = [])
    {
        // new static即是獲取最終呼叫時的類[後續有介紹]
        return new static($items);
    }

    /**
     * 是否為空
     * @return bool
     */
    public function isEmpty()
    {
        return empty($this->items);
    }
    // 返回陣列
    public function toArray()
    {
        // array_map ：陣列裡的每個元素都經過這個回撥函式處理
        return array_map(
            // 這是一個匿名回撥函式
            function ($value) {
            return (
            // instanceof 檢測變數$value是否屬於Model類的例項
            $value instanceof Model || 
            // instanceof 檢測變數$value是否屬於當前 Collection類的例項
            $value instanceof self) ? 
            // 返回陣列
            $value->toArray() : $value;
        }, $this->items);
    }
    // 返回變數 items 所有資料集
    public function all()
    {
        return $this->items;
    }

    /**
     * 合併陣列
     *
     * @param  mixed $items
     * @return static
     */
    public function merge($items)
    {
        // new static即是獲取最終呼叫時的類[後續有介紹]
        return new static(
        // array_merge 合併陣列
        array_merge($this->items, 
        // 轉換成陣列
        $this->convertToArray($items)));
    }

    /**
     * 比較陣列，返回差集
     *
     * @param  mixed $items
     * @return static
     */
    public function diff($items)
    {
        return new static(
        // 陣列之間的差集
        array_diff($this->items, $this->convertToArray($items)));
    }

    /**
     * 交換陣列中的鍵和值
     *
     * @return static
     */
    public function flip()
    {
        return new static(
        //  array_flip 交換陣列中的鍵和值
        array_flip($this->items));
    }

    /**
     * 比較陣列，返回交集
     *
     * @param  mixed $items
     * @return static
     */
    public function intersect($items)
    {
        return new static(
        // array_intersect 比較陣列，返回交集
        array_intersect($this->items, $this->convertToArray($items)));
    }

    /**
     * 返回陣列中所有的鍵名
     *
     * @return static
     */
    public function keys()
    {
        return new static(
        // array_keys 返回陣列中所有的鍵名
        array_keys($this->items));
    }

    /**
     * 刪除陣列的最後一個元素（出棧）
     *
     * @return mixed
     */
    public function pop()
    {
        // 刪除陣列的最後一個元素（出棧）
        return array_pop($this->items);
    }

    /**
     * 通過使用使用者自定義函式，以字串返回陣列
     *
     * @param  callable $callback
     * @param  mixed    $initial
     * @return mixed
     */
    public function reduce(callable $callback, $initial = null)
    {
        // array_reduce 用回撥函式迭代地將陣列簡化為單一的值
        return array_reduce($this->items, $callback, $initial);
    }

    /**
     * 以相反的順序返回陣列。
     *
     * @return static
     */
    public function reverse()
    {
        return new static(
        // array_reverse 以相反的順序返回陣列
        array_reverse($this->items));
    }

    /**
     * 刪除陣列中首個元素，並返回被刪除元素的值
     *
     * @return mixed
     */
    public function shift()
    {
        // array_shift 刪除陣列中首個元素，並返回被刪除元素的值
        return array_shift($this->items);
    }

    /**
     * 把一個陣列分割為新的陣列塊.
     *
     * @param  int  $size
     * @param  bool $preserveKeys
     * @return static
     */
    public function chunk($size, $preserveKeys = false)
    {
        $chunks = [];
        //array_chunk 把一個陣列分割為新的陣列塊.
        foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) {
            $chunks[] = new static($chunk);
        }

        return new static($chunks);
    }

    /**
     * 在陣列開頭插入一個元素
     * @param mixed $value
     * @param null  $key
     * @return int
     */
    public function unshift($value, $key = null)
    {
        // 檢測 $key 是否為null
        if (is_null($key)) {
            // array_unshift 在陣列開頭插入一個元素
            array_unshift($this->items, $value);
        } else {
            //兩個陣列組合成為新的陣列，並賦值給items
            $this->items = [$key => $value] + $this->items;
        }
    }

    /**
     * 給每個元素執行個回撥
     *
     * @param  callable $callback
     * @return $this
     */
    public function each(callable $callback)
    {
        //陣列迴圈
        foreach ($this->items as $key => $item) {
            // 陣列回撥，如果不明白的，看PHP基礎吧
            if ($callback($item, $key) === false) {
                break;
            }
        }
        //返回 當前物件
        return $this;
    }

    /**
     * 用回撥函式過濾陣列中的元素
     * @param callable|null $callback
     * @return static
     */
    public function filter(callable $callback = null)
    {
        if ($callback) {
            return new static(
            // array_filter用回撥函式過濾陣列中的元素
            array_filter($this->items, $callback));
        }

        return new static(
        // array_filter用回撥函式過濾陣列中的元素
        array_filter($this->items));
    }

    /**
     * 返回陣列中指定的一列
     * @param      $column_key
     * @param null $index_key
     * @return array
     */
    public function column($column_key, $index_key = null)
    {
        // 檢測函式是否存在,如果存在，則使用PHP內建函式處理，不存在則使用我們自己實現的方法
        if (function_exists(`array_column`)) {
            // array_column 返回陣列中指定的列
            return array_column($this->items, $column_key, $index_key);
        }

        $result = [];
        foreach ($this->items as $row) {
            $key    = $value = null;
            $keySet = $valueSet = false;
            // array_key_exists 檢查給定的鍵名或索引$index_key是否存在於陣列$row中
            if (null !== $index_key && array_key_exists($index_key, $row)) {
                //如果存在，設定變數$keySet值為真
                $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;
    }

    /**
     * 對陣列排序
     *
     * @param  callable|null $callback
     * @return static
     */
    public function sort(callable $callback = null)
    {
        $items = $this->items;

        $callback ? 
        // uasort 使用使用者自定義的$callback比較函式對$items陣列中的值進行排序並保持索引關聯
        uasort($items, $callback) : uasort($items, 
            // 這是個匿名函式
            function ($a, $b) {
            // 檢測兩個變數的值是否相等，相等返回0
            if ($a == $b) {
                return 0;
            }
            // 如果變數$a小於$b時，返回-1，否則都返回1
            return ($a < $b) ? -1 : 1;
        });

        return new static($items);
    }

    /**
     * 將陣列打亂
     *
     * @return static
     */
    public function shuffle()
    {
        $items = $this->items;
        // 將陣列打亂
        shuffle($items);

        return new static($items);
    }

    /**
     * 擷取陣列
     *
     * @param  int  $offset
     * @param  int  $length
     * @param  bool $preserveKeys
     * @return static
     */
    public function slice($offset, $length = null, $preserveKeys = false)
    {
        return new static(
        // array_slice 擷取  $this->items 陣列中 $offset 和 $length 之間的陣列
        // $preserveKeys 預設會重新排序並重置陣列的數字索引
        array_slice($this->items, $offset, $length, $preserveKeys));
    }

    // ArrayAccess
    public function offsetExists($offset)
    {
        // 檢查給定的$offset鍵名或索引是否存在於$this->items陣列中
        return array_key_exists($offset, $this->items);
    }

    public function offsetGet($offset)
    {
        //返回 $this->items陣列中指定 $offset鍵名或索引 的資料或者物件
        return $this->items[$offset];
    }
    // 陣列 中增加一條新資料或者物件
    public function offsetSet($offset, $value)
    {
        if (is_null($offset)) {
            $this->items[] = $value;
        } else {
            $this->items[$offset] = $value;
        }
    }
    // 刪除指定 $offset鍵名或索引 的資料或者物件
    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字串
     * @access public
     * @param integer $options json引數
     * @return string
     */
    public function toJson($options = JSON_UNESCAPED_UNICODE)
    {
        // 返回JSON 格式資料
        return json_encode($this->toArray(), $options);
    }

    public function __toString()
    {
        // 返回JSON 格式資料
        return $this->toJson();
    }

    /**
     * 轉換成陣列
     *
     * @param  mixed $items
     * @return array
     */
    protected function convertToArray($items)
    {
        // instanceof 檢測變數$items是否屬於當前類Collection的例項
        if ($items instanceof self) {
            // 執行all方法，返回所有
            return $items->all();
        }
        // 強制轉換為陣列
        return (array)$items;
    }
}

new self 和 new static（後期靜態繫結 ）

self 取決於當前方法定義的類
static 即是獲取最終呼叫時的類（即當前例項化的那個類）

class A{
    public static function testSelf() {
        return new self();
    }
    public static function testStatic() {
        return new static();
    }
}
class B extends A{}
echo get_class(B::testSelf());  /* A */
echo get_class(B::testStatic());  /* B  */

輸出
A
B

製作自己的 PHP Collection類

看看上面的原始碼，只要刪除2處（$value instanceof Model ），名稱空間名字再改一下，就是自己 PHP Collection集合類，是不是非常棒~
使用方式

$data 就是資料庫取出的資料
$result=new Collection($data);


相關文章