think\Collection

Complexity

Total Complexity

105

Size/Duplication

Total Lines	598
Duplicated Lines	0 %

Importance

Changes

0

44 Methods

Rating	Name	Duplication	Size	Complexity
A	diff()	0	18	6
B	dictionary()	0	17	9
A	make()	0	3	1
A	intersect()	0	18	6
A	keys()	0	3	1
A	toArray()	0	5	3
A	merge()	0	3	1
A	__construct()	0	3	1
A	all()	0	3	1
A	flip()	0	3	1
A	isEmpty()	0	3	1
A	offsetSet()	0	6	2
A	__toString()	0	3	1
A	push()	0	6	2
A	shuffle()	0	7	1
A	column()	0	3	1
A	shift()	0	3	1
A	convertToArray()	0	7	2
A	map()	0	3	1
A	chunk()	0	9	2
A	whereLike()	0	3	1
A	whereNotLike()	0	3	1
A	whereNotBetween()	0	3	1
A	offsetUnset()	0	3	1
A	jsonSerialize()	0	3	1
A	filter()	0	7	2
A	toJson()	0	3	1
A	whereNotIn()	0	3	1
A	getIterator()	0	3	1
A	each()	0	13	4
D	where()	0	50	29
A	pop()	0	3	1
A	sort()	0	12	4
A	values()	0	3	1
A	count()	0	3	1
A	reduce()	0	3	1
A	offsetExists()	0	3	1
A	reverse()	0	3	1
A	whereIn()	0	3	1
A	whereBetween()	0	3	1
A	slice()	0	3	1
A	order()	0	7	2
A	unshift()	0	6	2
A	offsetGet()	0	3	1

<?php
// +----------------------------------------------------------------------

You must use "/**" style comments for a file comment

// | ThinkPHP [ WE CAN DO IT JUST THINK ]
// +----------------------------------------------------------------------
// | Copyright (c) 2006~2019 http://thinkphp.cn All rights reserved.
// +----------------------------------------------------------------------
// | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
// +----------------------------------------------------------------------
// | Author: zhangyajun <448901948@qq.com>
// +----------------------------------------------------------------------
declare (strict_types = 1);

namespace think;

use ArrayAccess;
use ArrayIterator;
use Countable;
use IteratorAggregate;
use JsonSerializable;

class Collection implements ArrayAccess, Countable, IteratorAggregate, JsonSerializable

Missing class doc comment

{
    /**
     * 数据集数据
     * @var array
     */
    protected $items = [];

    public function __construct($items = [])

Missing function doc comment

    {
        $this->items = $this->convertToArray($items);
    }

    public static function make($items = [])

Missing function doc comment

    {
        return new static($items);
    }

    /**
     * 是否为空
     * @access public
     * @return bool
     */
    public function isEmpty(): bool
    {
        return empty($this->items);
    }

    public function toArray(): array

Missing function doc comment

    {
        return array_map(function ($value) {

The opening parenthesis of a multi-line function call should be the last content on the line.

            return ($value instanceof Model || $value instanceof self) ? $value->toArray() : $value;
        }, $this->items);

For multi-line function calls, the closing parenthesis should be on a new line.

    }

    public function all(): array

Missing function doc comment

    {
        return $this->items;
    }

    /**
     * 合并数组
     *
     * @access public
     * @param  mixed $items 数据
     * @return static
     */
    public function merge($items)
    {
        return new static(array_merge($this->items, $this->convertToArray($items)));
    }

    /**
     * 按指定键整理数据
     *
     * @access public
     * @param  mixed  $items    数据
     * @param  string $indexKey 键名
     * @return array
     */
    public function dictionary($items = null, string &$indexKey = null)
    {
        if ($items instanceof self || $items instanceof Paginator) {
            $items = $items->all();
        }

        $items = is_null($items) ? $this->items : $items;

        if ($items && empty($indexKey)) {
            $indexKey = is_array($items[0]) ? 'id' : $items[0]->getPk();
        }

        if (isset($indexKey) && is_string($indexKey)) {
            return array_column($items, null, $indexKey);
        }

        return $items;
    }

    /**
     * 比较数组，返回差集
     *
     * @access public
     * @param  mixed  $items    数据
     * @param  string $indexKey 指定比较的键名
     * @return static
     */
    public function diff($items, string $indexKey = null)
    {
        if ($this->isEmpty() || is_scalar($this->items[0])) {
            return new static(array_diff($this->items, $this->convertToArray($items)));
        }

        $diff       = [];
        $dictionary = $this->dictionary($items, $indexKey);

        if (is_string($indexKey)) {
            foreach ($this->items as $item) {
                if (!isset($dictionary[$item[$indexKey]])) {
                    $diff[] = $item;
                }
            }
        }

        return new static($diff);
    }

    /**
     * 比较数组，返回交集
     *
     * @access public
     * @param  mixed  $items    数据
     * @param  string $indexKey 指定比较的键名
     * @return static
     */
    public function intersect($items, string $indexKey = null)
    {
        if ($this->isEmpty() || is_scalar($this->items[0])) {
            return new static(array_diff($this->items, $this->convertToArray($items)));
        }

        $intersect  = [];
        $dictionary = $this->dictionary($items, $indexKey);

        if (is_string($indexKey)) {
            foreach ($this->items as $item) {
                if (isset($dictionary[$item[$indexKey]])) {
                    $intersect[] = $item;
                }
            }
        }

        return new static($intersect);
    }

    /**
     * 交换数组中的键和值
     *
     * @access public
     * @return static
     */
    public function flip()
    {
        return new static(array_flip($this->items));
    }

    /**
     * 返回数组中所有的键名
     *
     * @access public
     * @return static
     */
    public function keys()
    {
        return new static(array_keys($this->items));
    }

    /**
     * 返回数组中所有的值组成的新 Collection 实例
     * @access public
     * @return static
     */
    public function values()
    {
        return new static(array_values($this->items));
    }

    /**
     * 删除数组的最后一个元素（出栈）
     *
     * @access public
     * @return mixed
     */
    public function pop()
    {
        return array_pop($this->items);
    }

    /**
     * 通过使用用户自定义函数，以字符串返回数组
     *
     * @access public
     * @param  callable $callback 调用方法
     * @param  mixed    $initial

Missing parameter comment

     * @return mixed
     */
    public function reduce(callable $callback, $initial = null)
    {
        return array_reduce($this->items, $callback, $initial);
    }

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

    /**
     * 删除数组中首个元素，并返回被删除元素的值
     *
     * @access public
     * @return mixed
     */
    public function shift()
    {
        return array_shift($this->items);
    }

    /**
     * 在数组结尾插入一个元素
     * @access public
     * @param  mixed  $value 元素
     * @param  string $key KEY

Expected 3 spaces after parameter name; 1 found

     * @return void
     */
    public function push($value, string $key = null): void
    {
        if (is_null($key)) {
            $this->items[] = $value;
        } else {
            $this->items[$key] = $value;
        }
    }

    /**
     * 把一个数组分割为新的数组块.
     *
     * @access public
     * @param  int  $size 块大小

Expected 9 spaces after parameter name; 1 found

     * @param  bool $preserveKeys

Missing parameter comment

     * @return static
     */
    public function chunk(int $size, bool $preserveKeys = false)
    {
        $chunks = [];

        foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) {
            $chunks[] = new static($chunk);
        }

        return new static($chunks);
    }

    /**
     * 在数组开头插入一个元素
     * @access public
     * @param mixed  $value 元素

Tag value indented incorrectly; expected 2 spaces but found 1

     * @param string $key KEY

Expected 3 spaces after parameter name; 1 found

Tag value indented incorrectly; expected 2 spaces but found 1

     * @return void
     */
    public function unshift($value, string $key = null): void
    {
        if (is_null($key)) {
            array_unshift($this->items, $value);
        } else {
            $this->items = [$key => $value] + $this->items;
        }
    }

    /**
     * 给每个元素执行个回调
     *
     * @access public
     * @param  callable $callback 回调
     * @return $this
     */
    public function each(callable $callback)
    {
        foreach ($this->items as $key => $item) {
            $result = $callback($item, $key);

            if (false === $result) {
                break;
            } elseif (!is_object($item)) {
                $this->items[$key] = $result;
            }
        }

        return $this;
    }

    /**
     * 用回调函数处理数组中的元素
     * @access public
     * @param  callable|null $callback 回调
     * @return static
     */
    public function map(callable $callback)
    {
        return new static(array_map($callback, $this->items));
    }

    /**
     * 用回调函数过滤数组中的元素
     * @access public
     * @param  callable|null $callback 回调
     * @return static
     */
    public function filter(callable $callback = null)
    {
        if ($callback) {
            return new static(array_filter($this->items, $callback));
        }

        return new static(array_filter($this->items));
    }

    /**
     * 根据字段条件过滤数组中的元素
     * @access public
     * @param  string $field 字段名

Expected 4 spaces after parameter name; 1 found

     * @param  mixed  $operator 操作符
     * @param  mixed  $value 数据

Expected 4 spaces after parameter name; 1 found

     * @return static
     */
    public function where(string $field, $operator, $value = null)
    {
        if (is_null($value)) {
            $value    = $operator;
            $operator = '=';
        }

        return $this->filter(function ($data) use ($field, $operator, $value) {

The opening parenthesis of a multi-line function call should be the last content on the line.

            if (strpos($field, '.')) {
                list($field, $relation) = explode('.', $field);

                $result = $data[$field][$relation] ?? null;
            } else {
                $result = $data[$field] ?? null;
            }

            switch ($operator) {
                case '===':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result === $value;
                case '!==':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result !== $value;
                case '!=':

Line indented incorrectly; expected 12 spaces, found 16

                case '<>':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result != $value;
                case '>':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result > $value;
                case '>=':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result >= $value;
                case '<':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result < $value;
                case '<=':

Line indented incorrectly; expected 12 spaces, found 16

                    return $result <= $value;
                case 'like':

Line indented incorrectly; expected 12 spaces, found 16

                    return is_string($result) && false !== strpos($result, $value);
                case 'not like':

Line indented incorrectly; expected 12 spaces, found 16

                    return is_string($result) && false === strpos($result, $value);
                case 'in':

Line indented incorrectly; expected 12 spaces, found 16

                    return is_scalar($result) && in_array($result, $value, true);
                case 'not in':

Line indented incorrectly; expected 12 spaces, found 16

                    return is_scalar($result) && !in_array($result, $value, true);
                case 'between':

Line indented incorrectly; expected 12 spaces, found 16

                    list($min, $max) = is_string($value) ? explode(',', $value) : $value;
                    return is_scalar($result) && $result >= $min && $result <= $max;
                case 'not between':

Line indented incorrectly; expected 12 spaces, found 16

                    list($min, $max) = is_string($value) ? explode(',', $value) : $value;
                    return is_scalar($result) && $result > $max || $result < $min;
                case '==':

Line indented incorrectly; expected 12 spaces, found 16

                case '=':

Line indented incorrectly; expected 12 spaces, found 16

                default:

Line indented incorrectly; expected 12 spaces, found 16

                    return $result == $value;
            }
        });

For multi-line function calls, the closing parenthesis should be on a new line.

    }

    /**
     * LIKE过滤
     * @access public
     * @param  string $field 字段名
     * @param  string $value 数据
     * @return static
     */
    public function whereLike(string $field, string $value)
    {
        return $this->where($field, 'like', $value);
    }

    /**
     * NOT LIKE过滤
     * @access public
     * @param  string $field 字段名
     * @param  string $value 数据
     * @return static
     */
    public function whereNotLike(string $field, string $value)
    {
        return $this->where($field, 'not like', $value);
    }

    /**
     * IN过滤
     * @access public
     * @param  string $field 字段名
     * @param  array  $value 数据
     * @return static
     */
    public function whereIn(string $field, array $value)
    {
        return $this->where($field, 'in', $value);
    }

    /**
     * NOT IN过滤
     * @access public
     * @param  string $field 字段名
     * @param  array  $value 数据
     * @return static
     */
    public function whereNotIn(string $field, array $value)
    {
        return $this->where($field, 'not in', $value);
    }

    /**
     * BETWEEN 过滤
     * @access public
     * @param  string $field 字段名
     * @param  mixed  $value 数据
     * @return static
     */
    public function whereBetween(string $field, $value)
    {
        return $this->where($field, 'between', $value);
    }

    /**
     * NOT BETWEEN 过滤
     * @access public
     * @param  string $field 字段名
     * @param  mixed  $value 数据
     * @return static
     */
    public function whereNotBetween(string $field, $value)
    {
        return $this->where($field, 'not between', $value);
    }

    /**
     * 返回数据中指定的一列
     * @access public
     * @param string $columnKey 键名

Tag value indented incorrectly; expected 2 spaces but found 1

     * @param string $indexKey  作为索引值的列

Tag value indented incorrectly; expected 2 spaces but found 1

     * @return array
     */
    public function column(string $columnKey, string $indexKey = null)
    {
        return array_column($this->items, $columnKey, $indexKey);
    }

    /**
     * 对数组排序
     *
     * @access public
     * @param  callable|null $callback 回调
     * @return static
     */
    public function sort(callable $callback = null)
    {
        $items = $this->items;

        $callback = $callback ?: function ($a, $b) {
            return $a == $b ? 0 : (($a < $b) ? -1 : 1);

        };

        uasort($items, $callback);

        return new static($items);
    }

    /**
     * 指定字段排序
     * @access public
     * @param  string $field 排序字段
     * @param  string $order 排序
     * @return $this
     */
    public function order(string $field, string $order = null)
    {
        return $this->sort(function ($a, $b) use ($field, $order) {

The opening parenthesis of a multi-line function call should be the last content on the line.

            $fieldA = $a[$field] ?? null;
            $fieldB = $b[$field] ?? null;

            return 'desc' == strtolower($order) ? strcmp($fieldB, $fieldA) : strcmp($fieldA, $fieldB);
        });

For multi-line function calls, the closing parenthesis should be on a new line.

    }

    /**
     * 将数组打乱
     *
     * @access public
     * @return static
     */
    public function shuffle()
    {
        $items = $this->items;

        shuffle($items);

        return new static($items);
    }

    /**
     * 截取数组
     *
     * @access public
     * @param  int  $offset 起始位置

Expected 7 spaces after parameter name; 1 found

     * @param  int  $length 截取长度

Expected 7 spaces after parameter name; 1 found

     * @param  bool $preserveKeys preserveKeys
     * @return static
     */
    public function slice(int $offset, int $length = null, bool $preserveKeys = false)
    {
        return new static(array_slice($this->items, $offset, $length, $preserveKeys));
    }

    // ArrayAccess
    public function offsetExists($offset)

You must use "/**" style comments for a function comment

    {
        return array_key_exists($offset, $this->items);
    }

    public function offsetGet($offset)

Missing function doc comment

    {
        return $this->items[$offset];
    }

    public function offsetSet($offset, $value)

Missing function doc comment

    {
        if (is_null($offset)) {
            $this->items[] = $value;
        } else {
            $this->items[$offset] = $value;
        }
    }

    public function offsetUnset($offset)

Missing function doc comment

    {
        unset($this->items[$offset]);
    }

    //Countable
    public function count()

You must use "/**" style comments for a function comment

    {
        return count($this->items);
    }

    //IteratorAggregate
    public function getIterator()

You must use "/**" style comments for a function comment

    {
        return new ArrayIterator($this->items);
    }

    //JsonSerializable
    public function jsonSerialize()

You must use "/**" style comments for a function comment

    {
        return $this->toArray();
    }

    /**
     * 转换当前数据集为JSON字符串
     * @access public
     * @param  integer $options json参数
     * @return string
     */
    public function toJson(int $options = JSON_UNESCAPED_UNICODE)
    {
        return json_encode($this->toArray(), $options);
    }

    public function __toString()

Missing function doc comment

    {
        return $this->toJson();
    }

    /**
     * 转换成数组
     *
     * @access public
     * @param  mixed $items 数据
     * @return array
     */
    protected function convertToArray($items): array
    {
        if ($items instanceof self) {
            return $items->all();
        }

        return (array) $items;
    }
}