我有一个数组，其中存储了对象。我想获取数组中名称为test-song-poll-02的对象。我知道我可以循环遍历它并执行一个条件来检查每个对象中的名称但我想知道是否有一个数组/对象php函数可以返回name = 'test-song-poll-03'的对象
Array
(
[0] => stdClass Object
(
[name] => test-song-poll-01
[description] => test-song-poll-01
[created_at] => 2014-05-02T23:07:59Z
[count] => stdClass Object
(
[approved] => 63787
[pending] => 341
[rejected] => 78962
[total] => 143090
)
[tpm] => 12
[approved_tpm] => 3
[pct] => 4
)
[1] => stdClass Object
(
[name] => test-song-poll-02
[description] => test-song-poll-02
[created_at] => 2014-05-02T23:17:20Z
[count] => stdClass Object
(
[approved] => 9587
[pending] => 0
[rejected] => 9780
[total] => 19367
)
[tpm] => 5
[approved_tpm] => 3
[pct] => 1
)
[2] => stdClass Object
(
[name] => test-song-poll-03
[description] => test-song-poll-03
[created_at] => 2014-05-02T23:19:06Z
[count] => stdClass Object
(
[approved] => 26442
[pending] => 0
[rejected] => 36242
[total] => 62684
)
[tpm] => 25
[approved_tpm] => 9
[pct] => 2
)
)
更新了我的代码，以显示我想如何传递一个变量:
function get_results()
{
$hashtag = "test-song-poll-03";
$this->load->model('artist_model');
$data['results'] = $this->artist_model->get_results();
$myobject = array_filter($data['results']->streams, function($e, $hashtag) {
return strcmp($e->name, $hashtag) == 0;
});
print_r($myobject);
}
可以使用array_filter
$myobjects = array_filter($objects, function($e) use($hashtag) {
return strcmp($e->name, "test-song-poll-03") == 0;
});
由于匿名函数的关系，这只能工作PHP>= 5.3
如果你有旧版本，可以使用你自己的函数
您从json格式的API获取数据的事实并不意味着您必须将其保持在给定的格式中。有几个策略会比你接受的答案更有效。
当前选择的答案的问题是，每次使用它时，它都会遍历整个数据集，即使在第一次迭代中找到匹配。我不知道你的数据集有多大，但我假设它很重要，否则你就不会问这个问题了。
我也不知道你想访问数据集多少次，你可能也不知道，但我认为这足够让你思考，或者，再次，你不会问这个问题。
让我们假设你有一个由1000个stdClass对象组成的数据集，并且你请求每个对象一次，所以你访问它1000次。
现在'array_filter()'方法已经被建议，你必须访问所有1000个元素(它是O(n))每次，这是总共1,000,000次迭代。
//Access every element once using array_filter()
$objectArray = [];
$objectNames = [];
for($i = 0; $i < 1000; $i ++){
$objName = 'object_name_' . ($i + 1);
$objectNames[] = $objName;
$obj = new stdClass();
$obj->name = $objName;
$obj->description = 'test description';
$obj->accessed = 0;
$objectArray[] = $obj;
}
$start = microtime(true);
foreach($objectNames as $name){
$iterations = getObjectWithArray_Filter($name, $objectArray);
}
$end = microtime(true);
$taken = $end - $start;
echo $iterations . " iterations using array_filter() in $taken seconds<br/>'n";
看到它在工作
想到的第一个备选方案是普通的旧式foreach()循环，这也是O(n)，但是可以将循环写入为一旦找到匹配项就退出。因此，假设我们访问数组的每个元素一次，我们将有500,500次迭代，节省了大约50%。这可能适用于也可能不适用于现实世界，你将是最好的判断。
//Access every element once using foreach(){}
$objectArray = [];
$objectNames = [];
for($i = 0; $i < 1000; $i ++){
$objName = 'object_name_' . ($i + 1);
$objectNames[] = $objName;
$obj = new stdClass();
$obj->name = $objName;
$obj->description = 'test description';
$obj->accessed = 0;
$objectArray[] = $obj;
}
$start = microtime(true);
foreach($objectNames as $name){
$iterations = getObjectWithForeach($name, $objectArray);
}
$end = microtime(true);
$taken = $end - $start;
echo $iterations . " iterations using foreach(){} in $taken seconds<br/>'n";
看到它在工作
我想到的第二种选择是遍历数组一次并将其写入关联数组。第一次遍历将是O(n)， 1000次迭代，之后我们将能够直接访问我们想要的元素，而不需要遍历数组，也就是O(1)。给我们2000次迭代来访问数组的每个元素一次。
//Access every element once using Associative array
$objectArray = [];
$objectNames = [];
for($i = 0; $i < 1000; $i ++){
$objName = 'object_name_' . ($i + 1);
$objectNames[] = $objName;
$obj = new stdClass();
$obj->name = $objName;
$obj->description = 'test description';
$obj->accessed = 0;
$objectArray[] = $obj;
}
$associativeArray = [];
$start = microtime(true);
foreach($objectArray as $object){
$associativeArray[$object->name] = $object;
$object->accessed ++;
}
foreach($objectNames as $name){
$iterations = getObjectFromAssociativeArray($objName, $associativeArray);
}
$end = microtime(true);
$taken = $end - $start;
echo $iterations . " iterations using associative array{} in $taken seconds<br/>'n";
看到它在工作
下面是我的测试代码:-//=================================================================
function getObjectWithArray_Filter($objectName, array $objectArray){
$myobjects = array_filter($objectArray, function($e) use($objectName) {
$e->accessed ++;
return strcmp($e->name, $objectName) == 0;
});
$iterations = 0;
foreach($objectArray as $object){
$iterations += $object->accessed;
}
return $iterations;
}
function getObjectWithForeach($objectName, array $objectArray){
$iterations = 0;
$found = false;
$count = 0;
while(!$found){
$objectArray[$count]->accessed ++;
if($objectArray[$count]->name === $objectName){
$found = true;
}
$count ++;
}
foreach($objectArray as $object){
$iterations += $object->accessed;
}
return $iterations;
}
function getObjectFromAssociativeArray($objectName, array $objectArray){
$iterations = 0;
if($objectName === $objectArray[$objectName]->name){
$objectArray[$objectName]->accessed ++;
}
foreach($objectArray as $object){
$iterations += $object->accessed;
}
return $iterations;
}
tl;博士
3v4l.org的输出:-
Accessing 1000 elements once took 1000000 iterations using array_filter() in 0.5374710559845 seconds
Accessing 1000 elements once took 500500 iterations using foreach(){} in 0.2077169418335 seconds
Accessing 1000 elements once took 2000 iterations using associative array{} in 0.1438410282135 seconds
看到它在工作
时间差异也很有趣。您可能需要也可能不需要像这样优化速度，但我建议这是对您的代码进行的值得更改。在任何情况下，我认为在第一次迭代之后没有迭代比1000次或每次平均500.5次要好得多。
我希望你认为这是一个有价值的练习，你的问题激起了我的兴趣，我确信你接受的答案不是最好的解决方案。你可能仍然认为它是，但我提供这个作为一个选择。
实现它的最简单的方法是使用某种对象存储/工厂:-
class ObjectStore
{
private $decoded;
private $asssocArray;
public function __construct($jsonEncodedObjects)
{
$this->decoded = json_decode($jsonEncodedObjects);
}
public function getObject($objectName)
{
if(!$this->asssocArray){
foreach($this->decoded as $object){
$this->asssocArray[$object->name] = $object;
}
}
return $this->asssocArray[$objectName];
}
}
这样，您对对象的第一次请求是O(n)，后续请求将是O(1)。
在你的代码中使用:-
$objectStore = new ObjectStore(getJsonEncodedData());
$hashtag = "test-song-poll-03";
$myObject = $objectStore->getObject($hashtag);