PHP 7中的类型提示-对象数组

77

也许我错过了一些东西，但是是否有任何选择来定义该函数应该具有参数或返回用户对象数组的示例？

考虑以下代码：

<?php

class User
{
    protected $name;

    protected $age;

    /**
     * User constructor.
     *
     * @param $name
     */
    public function __construct(string $name, int $age)
    {
        $this->name = $name;
        $this->age = $age;
    }

    /**
     * @return mixed
     */
    public function getName() : string
    {
        return $this->name;
    }

    public function getAge() : int
    {
        return $this->age;
    }
}

function findUserByAge(int $age, array $users) : array
{
    $result = [];
    foreach ($users as $user) {
        if ($user->getAge() == $age) {
            if ($user->getName() == 'John') {
                // complicated code here
                $result[] = $user->getName(); // bug
            } else {
                $result[] = $user;
            }
        }
    }

    return $result;
}

$users = [
    new User('John', 15),
    new User('Daniel', 25),
    new User('Michael', 15),
];

$matches = findUserByAge(15, $users);

foreach ($matches as $user) {
    echo $user->getName() . ' '.$user->getAge() . "\n";
}

PHP7中是否有任何选项可以告诉函数findUserByAge应返回用户数组？我希望添加类型提示时应该可以，但是我还没有找到对象数组类型提示的任何信息，因此它可能未包含在PHP 7中。如果不包含该信息，您是否知道为什么添加类型提示时不包括在内？

php  arrays  oop  type-hinting  php-7 
— 马尔辛·纳比亚列克（MarcinNabiałek）
source
8
仅按照惯例，例如@return User[]在DocBlock
— Gordon

Answers:

112

不包括在内。

如果不包含它，您有任何线索为什么添加类型提示时不包含它？

对于当前的数组实现，由于数组本身不包含任何类型信息，因此需要在运行时检查所有数组元素。

它实际上已经为PHP 5.6提出过，但是被拒绝：RFC“ arrayof” -有趣的是，并不是由于性能问题可忽略，而是因为在如何实现它方面没有达成共识。还有人反对没有标量类型提示的情况是不完整的。如果您对整个讨论感兴趣，请在邮件列表档案中阅读。

IMHO数组类型提示与带类型的数组一起将提供最大的好处，我很想看到它们的实现。

因此，也许是时候制定新的RFC并重新开始讨论了。

部分解决方法：

您可以键入提示可变参数，从而将签名写为

function findUserByAge(int $age, User ...$users) : array

用法：

findUserByAge(15, ...$userInput);

在此调用中，参数$userInput将“解包”为单个变量，并在方法本身中“打包”为数组$users。每个项目均已验证为类型User。$userInput也可以是迭代器，它将被转换为数组。

不幸的是，对于返回类型没有类似的解决方法，并且只能将其用于最后一个参数。

— 费边·施蒙格勒（Fabian Schmengler）
source
3
@RobertLimanto不，仍然看不到7.2，请查看wiki.php.net/rfc#php_next_72
— Fabian Schmengler
1
我希望看到一种指定返回数组中的类型的方法。我认为这对IDE来说是不错的选择，因为这将使它们能够理解类型，从而为自动补全等提供更好的支持。
— 伊卡洛斯
25
对于IDE，您可以使用phpDoc@return User[]
— Fabian Schmengler
4
当您以显示方式使用可变参数时，是否有人测量过性能的缺点？
— metamaker'9
1
@metamaker Variadic将大大降低3v4l.org/3hOfJ的速度，并且会严重影响大型集合的内存使用。由于这一事实，必须将集合作为单个参数解压缩，然后再次打包到变量数组中。不用说，但是集合中的对象越多，影响越大。仍然较慢是3v4l.org/JMrsq即使遍历整个集合进行任何业务逻辑之前验证类型
— 威尔B.
7

由于数组可以包含混合值，因此这是不可能的。

为此，您必须使用一个对象/类。

您可以创建一个类来管理自己的列表数组（私有/受保护的属性），并在确实需要时拒绝添加其他值作为此问题的解决方法。

但是，没有负责任的程序员会破坏预期的模式，尤其是如果您正确地注释了则不会。无论如何，它将在程序中发生错误时被识别。

透视图：

例如，您可以创建任何数组：

$myArray = array();

并添加一个数字：

$myArray[] = 1;

字符串：

$myArray[] = "abc123";

和一个对象

$myArray[] = new MyClass("some parameter", "and one more");

同样不要忘记，您可以拥有一个简单的数组，一个多维堆叠的数组以及具有混合模式的关联数组。

很难甚至不可能找到一个解析器/符号来使所有版本都可以使用一个表达式来强制我认为的数组格式。

一方面，这很酷，但另一方面，您将失去一些在数组中混合数据的能力，这对于大量现有代码和PHP必须提供的灵活性至关重要。

由于我们不想在PHP 7中错过内容的混合功能，因此无法键入提示数组的确切内容，因为您可以将任何内容放入其中。

— Steini
source
1
目的恰恰是强制执行数组中所有条目的类型。如果我使用“ bar”方法获得了Foo类，并且我的函数在数组的每个元素上调用了“ bar”方法，那么我想将参数提示为“ Foo数组”
— Pierre-Olivier Vares
6

在我们的代码库中，我们有集合的概念。这些基于名为TypedArray的类，该类基于ArrayObject。

class ArrayObject extends \ArrayObject
{
    /**
     * Clone a collection by cloning all items.
     */
    public function __clone()
    {
        foreach ($this as $key => $value) {
            $this[$key] = is_object($value) ? clone $value : $value;
        }
    }

    /**
     * Inserting the provided element at the index. If index is negative, it will be calculated from the end of the Array Object
     *
     * @param int $index
     * @param mixed $element
     */
    public function insert(int $index, $element)
    {
        $data = $this->getArrayCopy();
        if ($index < 0) {
            $index = $this->count() + $index;
        }

        $data = array_merge(array_slice($data, 0, $index, true), [$element], array_slice($data, $index, null, true));
        $this->exchangeArray($data);
    }

    /**
     * Remove a portion of the array and optionally replace it with something else.
     *
     * @see array_splice()
     *
     * @param int $offset
     * @param int|null $length
     * @param null $replacement
     *
     * @return static
     */
    public function splice(int $offset, int $length = null, $replacement = null)
    {
        $data = $this->getArrayCopy();

        // A null $length AND a null $replacement is not the same as supplying null to the call.
        if (is_null($length) && is_null($replacement)) {
            $result = array_splice($data, $offset);
        } else {
            $result = array_splice($data, $offset, $length, $replacement);
        }
        $this->exchangeArray($data);

        return new static($result);
    }

    /**
     * Adding a new value at the beginning of the collection
     *
     * @param mixed $value
     *
     * @return int Returns the new number of elements in the Array
     */
    public function unshift($value): int
    {
        $data = $this->getArrayCopy();
        $result = array_unshift($data, $value);
        $this->exchangeArray($data);

        return $result;
    }

    /**
     * Extract a slice of the array.
     *
     * @see array_slice()
     *
     * @param int $offset
     * @param int|null $length
     * @param bool $preserveKeys
     *
     * @return static
     */
    public function slice(int $offset, int $length = null, bool $preserveKeys = false)
    {
        return new static(array_slice($this->getArrayCopy(), $offset, $length, $preserveKeys));
    }

    /**
     * Sort an array.
     *
     * @see sort()
     *
     * @param int $sortFlags
     *
     * @return bool
     */
    public function sort($sortFlags = SORT_REGULAR)
    {
        $data = $this->getArrayCopy();
        $result = sort($data, $sortFlags);
        $this->exchangeArray($data);

        return $result;
    }

    /**
     * Apply a user supplied function to every member of an array
     *
     * @see array_walk
     *
     * @param callable $callback
     * @param mixed|null $userData
     *
     * @return bool Returns true on success, otherwise false
     *
     * @see array_walk()
     */
    public function walk($callback, $userData = null)
    {
        $data = $this->getArrayCopy();
        $result = array_walk($data, $callback, $userData);
        $this->exchangeArray($data);

        return $result;
    }

    /**
     * Chunks the object into ArrayObject containing
     *
     * @param int $size
     * @param bool $preserveKeys
     *
     * @return ArrayObject
     */
    public function chunk(int $size, bool $preserveKeys = false): ArrayObject
    {
        $data = $this->getArrayCopy();
        $result = array_chunk($data, $size, $preserveKeys);

        return new ArrayObject($result);
    }

    /**
     * @see array_column
     *
     * @param mixed $columnKey
     *
     * @return array
     */
    public function column($columnKey): array
    {
        $data = $this->getArrayCopy();
        $result = array_column($data, $columnKey);

        return $result;
    }

    /**
     * @param callable $mapper Will be called as $mapper(mixed $item)
     *
     * @return ArrayObject A collection of the results of $mapper(mixed $item)
     */
    public function map(callable $mapper): ArrayObject
    {
        $data = $this->getArrayCopy();
        $result = array_map($mapper, $data);

        return new self($result);
    }

    /**
     * Applies the callback function $callable to each item in the collection.
     *
     * @param callable $callable
     */
    public function each(callable $callable)
    {
        foreach ($this as &$item) {
            $callable($item);
        }
        unset($item);
    }

    /**
     * Returns the item in the collection at $index.
     *
     * @param int $index
     *
     * @return mixed
     *
     * @throws InvalidArgumentException
     * @throws OutOfRangeException
     */
    public function at(int $index)
    {
        $this->validateIndex($index);

        return $this[$index];
    }

    /**
     * Validates a number to be used as an index
     *
     * @param int $index The number to be validated as an index
     *
     * @throws OutOfRangeException
     * @throws InvalidArgumentException
     */
    private function validateIndex(int $index)
    {
        $exists = $this->indexExists($index);

        if (!$exists) {
            throw new OutOfRangeException('Index out of bounds of collection');
        }
    }

    /**
     * Returns true if $index is within the collection's range and returns false
     * if it is not.
     *
     * @param int $index
     *
     * @return bool
     *
     * @throws InvalidArgumentException
     */
    public function indexExists(int $index)
    {
        if ($index < 0) {
            throw new InvalidArgumentException('Index must be a non-negative integer');
        }

        return $index < $this->count();
    }

    /**
     * Finding the first element in the Array, for which $callback returns true
     *
     * @param callable $callback
     *
     * @return mixed Element Found in the Array or null
     */
    public function find(callable $callback)
    {
        foreach ($this as $element) {
            if ($callback($element)) {
                return $element;
            }
        }

        return null;
    }

    /**
     * Filtering the array by retrieving only these elements for which callback returns true
     *
     * @param callable $callback
     * @param int $flag Use ARRAY_FILTER_USE_KEY to pass key as the only argument to $callback instead of value.
     *                  Use ARRAY_FILTER_USE_BOTH pass both value and key as arguments to $callback instead of value.
     *
     * @return static
     *
     * @see array_filter
     */
    public function filter(callable $callback, int $flag = 0)
    {
        $data = $this->getArrayCopy();
        $result = array_filter($data, $callback, $flag);

        return new static($result);
    }

    /**
     * Reset the array pointer to the first element and return the element.
     *
     * @return mixed
     *
     * @throws \OutOfBoundsException
     */
    public function first()
    {
        if ($this->count() === 0) {
            throw new \OutOfBoundsException('Cannot get first element of empty Collection');
        }

        return reset($this);
    }

    /**
     * Reset the array pointer to the last element and return the element.
     *
     * @return mixed
     *
     * @throws \OutOfBoundsException
     */
    public function last()
    {
        if ($this->count() === 0) {
            throw new \OutOfBoundsException('Cannot get last element of empty Collection');
        }

        return end($this);
    }

    /**
     * Apply a user supplied function to every member of an array
     *
     * @see array_reverse
     *
     * @param bool $preserveKeys
     *
     * @return static
     */
    public function reverse(bool $preserveKeys = false)
    {
        return new static(array_reverse($this->getArrayCopy(), $preserveKeys));
    }

    public function keys(): array
    {
        return array_keys($this->getArrayCopy());
    }

    /**
     * Use a user supplied callback to reduce the array to a single member and return it.
     *
     * @param callable $callback
     * @param mixed|null $initial
     *
     * @return mixed
     */
    public function reduce(callable $callback, $initial = null)
    {
        return array_reduce($this->getArrayCopy(), $callback, $initial);
    }
}

和

/**
 * Class TypedArray
 *
 * This is a typed array
 *
 * By enforcing the type, you can guarantee that the content is safe to simply iterate and call methods on.
 */
abstract class AbstractTypedArray extends ArrayObject
{
    use TypeValidator;

    /**
     * Define the class that will be used for all items in the array.
     * To be defined in each sub-class.
     */
    const ARRAY_TYPE = null;

    /**
     * Array Type
     *
     * Once set, this ArrayObject will only accept instances of that type.
     *
     * @var string $arrayType
     */
    private $arrayType = null;

    /**
     * Constructor
     *
     * Store the required array type prior to parental construction.
     *
     * @param mixed[] $input Any data to preset the array to.
     * @param int $flags The flags to control the behaviour of the ArrayObject.
     * @param string $iteratorClass Specify the class that will be used for iteration of the ArrayObject object. ArrayIterator is the default class used.
     *
     * @throws InvalidArgumentException
     */
    public function __construct($input = [], $flags = 0, $iteratorClass = ArrayIterator::class)
    {
        // ARRAY_TYPE must be defined.
        if (empty(static::ARRAY_TYPE)) {
            throw new \RuntimeException(
                sprintf(
                    '%s::ARRAY_TYPE must be set to an allowable type.',
                    get_called_class()
                )
            );
        }

        // Validate that the ARRAY_TYPE is appropriate.
        try {
            $this->arrayType = $this->determineType(static::ARRAY_TYPE);
        } catch (\Collections\Exceptions\InvalidArgumentException $e) {
            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
        }

        // Validate that the input is an array or an object with an Traversable interface.
        if (!(is_array($input) || (is_object($input) && in_array(Traversable::class, class_implements($input))))) {
            throw new InvalidArgumentException('$input must be an array or an object that implements \Traversable.');
        }

        // Create an empty array.
        parent::__construct([], $flags, $iteratorClass);

        // Append each item so to validate it's type.
        foreach ($input as $key => $value) {
            $this[$key] = $value;
        }
    }

    /**
     * Adding a new value at the beginning of the collection
     *
     * @param mixed $value
     *
     * @return int Returns the new number of elements in the Array
     *
     * @throws InvalidArgumentException
     */
    public function unshift($value): int
    {
        try {
            $this->validateItem($value, $this->arrayType);
        } catch (\Collections\Exceptions\InvalidArgumentException $e) {
            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
        }

        return parent::unshift($value);
    }

    /**
     * Check the type and then store the value.
     *
     * @param mixed $offset The offset to store the value at or null to append the value.
     * @param mixed $value The value to store.
     *
     * @throws InvalidArgumentException
     */
    public function offsetSet($offset, $value)
    {
        try {
            $this->validateItem($value, $this->arrayType);
        } catch (\Collections\Exceptions\InvalidArgumentException $e) {
            throw new InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
        }

        parent::offsetSet($offset, $value);
    }

    /**
     * Sort an array, taking into account objects being able to represent their sortable value.
     *
     * {@inheritdoc}
     */
    public function sort($sortFlags = SORT_REGULAR)
    {
        if (!in_array(SortableInterface::class, class_implements($this->arrayType))) {
            throw new \RuntimeException(
                sprintf(
                    "Cannot sort an array of '%s' as that class does not implement '%s'.",
                    $this->arrayType,
                    SortableInterface::class
                )
            );
        }
        // Get the data from
        $originalData = $this->getArrayCopy();
        $sortableData = array_map(
            function (SortableInterface $item) {
                return $item->getSortValue();
            },
            $originalData
        );

        $result = asort($sortableData, $sortFlags);

        $order = array_keys($sortableData);
        uksort(
            $originalData,
            function ($key1, $key2) use ($order) {
                return array_search($key1, $order) <=> array_search($key2, $order);
            }
        );

        $this->exchangeArray($originalData);

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function filter(callable $callback, int $flag = 0)
    {
        if ($flag == ARRAY_FILTER_USE_KEY) {
            throw new InvalidArgumentException('Cannot filter solely by key. Use ARRAY_FILTER_USE_BOTH and amend your callback to receive $value and $key.');
        }

        return parent::filter($callback, $flag);
    }
}

一个例子使用。

class PaymentChannelCollection extends AbstractTypedArray
{
    const ARRAY_TYPE = PaymentChannel::class;
}

您现在可以输入提示 PaymentChannelCollection并确保您有一个PaymentChannels集合（例如）。

一些代码可能会在我们的命名空间中调用异常。我认为danielgsims / php-collections中也有一个类型验证器（我们最初使用这些集合，但是围绕它们的灵活性存在一些问题-它们很好，但对我们而言不是-所以无论如何都可以看看它们！）。

— 理查德四重奏
source
6

我给一般的答案有关数组的类型提示。

我对所选答案进行了修改。主要区别在于参数是一个数组，而不是被检查类的许多实例。

/**
 * @param $_foos Foo[]
 */
function doFoo(array $_foos)
{return (function(Foo ...$_foos){

    // Do whatever you want with the $_foos array

})(...$_foos);}

看起来有点模糊，但很容易理解。并非总是在每次调用时都手动解压缩数组，而是调用函数内部的闭包，并将数组解压缩为参数。

function doFoo(array $_foos)
{
    return (function(Foo ...$_foos){ // Closure

    // Do whatever you want with the $_foos array

    })(...$_foos); //Main function's parameter $_foos unpacked
}

我觉得这很酷，因为您可以像使用具有ArrayOfType参数的任何其他语言函数一样使用该函数。另外，该错误的处理方式与其余PHP类型提示错误相同。此外，您不会混淆其他程序员，他们会使用您的函数，并且不得不拆开它们的数组，这总是让人感到有些棘手。

您确实需要一些编程经验才能理解其工作原理。如果您需要多个参数，则可以始终在闭包的“使用”部分添加它们。

您还可以使用文档注释来公开类型提示。

/**
 * @param $_foos Foo[] <- An array of type Foo
 */

这是一个OO示例：

class Foo{}

class NotFoo{}

class Bar{
    /**
     * @param $_foos Foo[]
     */
    public function doFoo(array $_foos, $_param2)
    {return (function(Foo ...$_foos) use($_param2){

        return $_param2;

    })(...$_foos);}
}

$myBar = new Bar();
$arrayOfFoo = array(new Foo(), new Foo(), new Foo());
$notArrayOfFoo = array(new Foo(), new NotFoo(), new Foo());

echo $myBar->doFoo($arrayOfFoo, 'Success');
// Success

echo $myBar->doFoo($notArrayOfFoo, 'Success');
// Uncaught TypeError: Argument 2 passed to Bar::{closure}() must be an instance of Foo, instance of NotFoo given...

注意：这也适用于非对象类型（int，字符串等）

— Stefmachine
source
4

加上Steini回答的内容。

您可以创建一个类ObjectNIterator来管理您的ObjectN并实现一个Iterator：http ://php.net/manual/en/class.iterator.php

从methodN调用classMethodM，它返回一个已填充的ObjectNIterator，然后将此数据传递给需要ObjectNIterator的methodO：

public function methodO(ObjectNIterator $objectNCollection)

— visualex
source
是的，我在PHP 5.x上也做完全相同的操作，但是在那里使用了PHPDoc类型提示，该提示由PhpStorm IDE使用（很好地显示了所有可能的问题）。我有一个对象关系映射器，它可以从声明性XML规范（以及模型）生成这些类型化的迭代器类（数组），因此我可以很快地创建它们。将来将PHP转换为强类型语言会很好。
— 蹲着的小猫，
0

一种相当简单的方法是创建自己的数组类型，该数组类型可与PHP的内置函数（如foreach，count，unset，indexing等）一起使用。这是一个示例：

class DataRowCollection implements \ArrayAccess, \Iterator, \Countable
{
    private $rows = array();
    private $idx = 0;

    public function __construct()
    {
    }

    // ArrayAccess interface

    // Used when adding or updating an array value
    public function offsetSet($offset, $value)
    {
        if ($offset === null)
        {
            $this->rows[] = $value;
        }
        else
        {
            $this->rows[$offset] = $value;
        }
    }

    // Used when isset() is called
    public function offsetExists($offset)
    {
        return isset($this->rows[$offset]);
    }

    // Used when unset() is called
    public function offsetUnset($offset)
    {
        unset($this->rows[$offset]);
    }

    // Used to retrieve a value using indexing
    public function offsetGet($offset)
    {
        return $this->rows[$offset];
    }

    // Iterator interface

    public function rewind()
    {
        $this->idx = 0;
    }

    public function valid()
    {
        return $this->idx < count($this->rows);
    }

    public function current()
    {
        return $this->rows[$this->idx];
    }

    public function key()
    {
        return $this->idx;
    }

    public function next()
    {
        $this->idx++;
    }

    // Countable interface

    public function count()
    {
        return count($this->rows);
    }
}

用法示例：

$data = new DataRowCollection(); // = array();
$data[] = new DataRow("person");
$data[] = new DataRow("animal");

它的工作方式与传统数组类似，但是键入的类型与您想要的一样。非常简单有效。

— 吉米·汤姆森
source
问题的关键是关于强制数组元素的类型。
— miken32 '19
当然可以实现这一目标。只需使用运行时类型检查扩展offsetSet（..）。类型提示将不起作用，因为PHP需要实现与接口函数相同，但是运行时检查将起作用。也许是这样的：if（get_class（$ value）！==“ DataRow”）{抛出新的Exception（“预期的DataRow实例”）; }
— Jimmy Thomsen，
0

目前，尚无办法在对象数组的函数签名上对其进行定义。但是您可以在功能文档中对其进行定义。如果您传递混合值，它不会产生PHP错误/警告，但是大多数IDE会给出提示。这是示例：

/**
 * @param int $age
 * @param User[] $users
 * @return User[]
 */
function findUserByAge(int $age, array $users) : array {
    $results = [];
    //
    //
    return $result;
}
— 伊扎里（Izhari Ishak Aksa）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.