PHP 7 中的类型提示 - 对象数组
Posted
技术标签:
【中文标题】PHP 7 中的类型提示 - 对象数组【英文标题】：Type hinting in PHP 7 - array of objects 【发布时间】：2016-03-20 07:23:00 【问题描述】：也许我遗漏了一些东西，但是否有任何选项来定义该函数应该有参数或返回例如用户对象数组？
考虑以下代码：
<?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 中。如果不包含，你有任何线索为什么它是添加类型提示时不包括在内？
【问题讨论】：
仅按惯例，例如在 DocBlock 中使用@return User[]
【参考方案1】：
由于数组可以包含混合值，这是不可能的。
您必须为此目的使用对象/类。
您可以创建一个类来管理自己的列表数组（私有/受保护属性），如果确实需要，则拒绝添加其他值作为解决此问题的方法。
但是，任何负责任的程序员都不会破坏预期的模式，尤其是在您正确注释时。无论如何，它都会在程序中发生错误时被识别出来。
解释：
例如，您可以创建任何数组：
$myArray = array();
并添加一个数字：
$myArray[] = 1;
一个字符串：
$myArray[] = "abc123";
和一个对象
$myArray[] = new MyClass("some parameter", "and one more");
另外不要忘记，您可以有一个简单的数组、一个多维堆叠数组以及可以有混合模式的关联数组。
很难找到一个解析器/符号来使所有版本都可以使用强制格式为我认为的数组的表达式。
一方面这很酷，但另一方面，你会失去一些在数组中混合数据的能力，这可能对许多现有代码和 PHP 必须提供的灵活性至关重要。
由于 PHP 7 中我们不想错过的混合内容功能，因此无法键入提示数组的确切内容，因为您可以将其放入任何内容中。
【讨论】：
目的正是在数组中强制执行 all 条目的类型。如果我有一个带有“bar”方法的类 Foo，并且我的函数在数组的每个元素上调用“bar”方法，我想要将我的参数提示为“Foo 数组” 【参考方案2】：不包括在内。
如果不包括在内，您是否知道为什么在添加类型提示时不包括在内？
使用当前的数组实现，需要在运行时检查所有数组元素，因为数组本身不包含类型信息。
它实际上已经被提议用于 PHP 5.6，但被拒绝了：RFC "arrayof" - 有趣的不是因为性能问题被证明可以忽略不计，而是因为对于应该如何实现它没有达成一致意见。也有人反对，如果没有标量类型提示，它是不完整的。如果您对整个讨论感兴趣，请阅读in the mailing list archive。
恕我直言，数组类型提示将与类型化数组一起提供最大的好处，我很乐意看到它们实现。
所以也许是时候制定一个新的 RFC 并重新开始讨论了。
部分解决方法：
您可以键入提示可变参数，从而将签名写为
function findUserByAge(int $age, User ...$users) : array
用法：
findUserByAge(15, ...$userInput);
在此调用中，参数$userInput 将被“解包”为单个变量，并在方法本身中“打包”回数组$users。每个项目都被验证为User 类型。 $userInput 也可以是一个迭代器，它会被转换成一个数组。
很遗憾，对于返回类型没有类似的解决方法，您只能将其用于最后一个参数。
【讨论】：
@RobertLimanto 没有，而且仍然看不到 7.2，看看wiki.php.net/rfc#php_next_72 我很想看到一种方法来指定返回数组中的类型。我认为这对 IDE 来说会很好，因为这应该让他们能够理解类型，从而为自动完成等提供更好的支持。此外，更强大的类型提示，同时可以不指定类型，我觉得这是一个很好的组合。 对于 IDE，您可以使用 phpDoc@return User[]
当您以显示的方式使用可变参数时，有人测量过性能缺陷吗？
@metamaker Variadic 会明显变慢3v4l.org/3hOfJ，并且会极大地影响大型集合的内存使用。由于必须将集合解压缩为单独的参数，然后再次打包到变量数组中。不言而喻，但集合中的对象越多，影响就越大。即使在迭代整个集合以在执行任何业务逻辑之前验证类型时，3v4l.org/JMrsq 仍然较慢【参考方案3】：
补充 Steini 的回答。
您可以创建一个 ObjectNIterator 类来管理您的 ObjectN 并实现一个 Iterator：http://php.net/manual/en/class.iterator.php
从 methodN 调用返回填充的 ObjectNIterator 的 classMethodM，然后将此数据传递给期望 ObjectNIterator 的 methodO：
public function methodO(ObjectNIterator $objectNCollection)
【讨论】：
是的，我在 PHP 5.x 上也做了同样的事情，但是使用了 PHPDoc 类型提示，它被 PhpStorm IDE 使用（它很好地显示了所有可能的问题）。我有一个对象关系映射器，它从声明性 XML 规范（以及模型）生成这些类型化的迭代器类（数组），所以我可以快速创建它们。如果将来能将 PHP 转换为强类型语言，那就太好了。【参考方案4】：在我们的代码库中，我们有集合的概念。它们基于一个名为 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 也有一个类型验证器（我们最初使用了这些集合，但在它们的灵活性方面存在问题——它们很好，只是不适合我们——所以还是看看它们吧！）。
【讨论】：
这太棒了。我会试试的！【参考方案5】：我给出了一个关于数组类型提示的通用答案。
我对所选答案进行了修改。主要区别在于参数是一个数组，而不是被检查类的许多实例。
/**
* @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 类型提示错误相同。此外，您不会让其他将使用您的函数并且必须解包他们的数组的程序员感到困惑，这总是感觉有点hacky。
您确实需要一些编程经验才能理解其工作原理。如果您需要多个参数，您可以随时将它们添加到闭包的“使用”部分。
您也可以使用 doc cmets 来公开类型提示。
/**
* @param $_foos Foo[] <- An array of type Foo
*/
这是一个面向对象的示例：
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、string 等）
【讨论】：
【参考方案6】：一个相当简单的方法是创建自己的数组类型，它可以与 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");
它就像一个传统的数组一样工作，但它的类型是你想要的。非常简单有效。
【讨论】：
问题的关键在于强制数组的元素的类型。 当然可以做到这一点。只需使用运行时类型检查扩展 offsetSet(..)。类型提示不起作用，因为 PHP 需要实现与接口函数相同，但运行时检查会起作用。也许是这样的： if (get_class($value) !== "DataRow") throw new Exception("Instance of DataRow expected"); 【参考方案7】：目前无法在对象数组的函数签名中定义它。但是您可以在函数文档中定义它。如果您传递混合值，它不会生成 PHP 错误/警告，但大多数 IDE 会给出提示。示例如下：
/**
* @param int $age
* @param User[] $users
* @return User[]
*/
function findUserByAge(int $age, array $users) : array
$results = [];
//
//
return $result;
【讨论】：
以上是关于PHP 7 中的类型提示 - 对象数组的主要内容，如果未能解决你的问题，请参考以下文章