blocks|key|1173245|text|我会坚持一个数组或散列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1173246|+@names+=+('Paul','Michael','Jessica','Megan');|code-block|syntax|javascript|1173247|和|1173248|my+%25petsounds+=+("cat"+=>+"meow",
+++++++++++++"dog"+=>+"woof",
+++++++++++++"snake"+=>+"hiss");|1173249|来源|offset|length|1173250|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikibooks.org/wiki/Programming:Perl_Hash_Variables^0|0|0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

i would stick with an ARRAY or a HASH.

<pre><code> @names = ('Paul','Michael','Jessica','Megan');
</code></pre>

and

<pre><code>my %petsounds = ("cat" =&gt; "meow",
 "dog" =&gt; "woof",
 "snake" =&gt; "hiss");
</code></pre>

<a href="http://en.wikibooks.org/wiki/Programming:Perl_Hash_Variables" rel="nofollow noreferrer">source</a>

blocks|key|849709|text|根据您需要如何访问对象来做出决定。如果将它们推入数组、索引到、弹出或移除它们，则使用数组。否则，按某个键散列它们，或将它们组织成一棵满足您需要的对象树。对象的散列是一种非常简单、强大和高度优化的在Perl中进行操作的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|849710|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Base your decision on how you need to access the objects. If pushing them onto an array, indexing into, popping/shifting them off works, then use an array. Otherwise hash them by some key or organize them into a tree of objects that meets your needs. A hash of objects is a very simple, powerful, and highly-optimized way of doing things in Perl.

blocks|key|174290|text|我通常会使用@数组或%25散列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|174291|你在寻找哪些不是由这些功能提供的功能？|174292|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I would normally use an @array or a %hash.

What features are you looking for that aren't provided by those?

blocks|key|849776|text|因为Perl数组可以很容易地附加、调整大小、排序等等，所以它们足以满足大多数“集合”需求。在您需要更高级的东西的情况下，通常可以使用散列。我不建议你去寻找一个收集模块，直到你真正需要它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|849777|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Since Perl arrays can easily be appended to, resized, sorted, etc., they are good enough for most "collection" needs. In cases where you need something more advanced, a hash will generally do. I wouldn't recommend that you go looking for a collection module until you actually need it.

blocks|key|1173411|text|数组或散列都可以存储对象的集合。如果您想以某种方式处理类，那么类可能会更好，但在我们提出任何好的建议之前，您必须告诉我们这些方法是什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1173412|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Either an array or a hash can store a collection of objects. A class might be better if you want to work with the class in certain ways but you'd have to tell us what those ways are before we could make any good recommendations.

blocks|key|174365|text|有些集合模块用于更复杂的结构，但在Perl中，对数组、堆栈和列表使用数组是常见的样式。Perl内置了用于将数组用作堆栈或列表的函数:+push/pop、shift/unshift、splice+(中间插入或删除)以及用于迭代的foreach表单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|174366|Perl还有一个名为hashmap的映射，它相当于Python中的字典--允许您在单个键和单个值之间进行关联。|174367|Perl开发人员经常组合这两种数据结构来构建他们所需要的，需要多个值吗？存储数组-哈希表(Map)的值部分中的引用。树可以以类似的方式构建如果您需要唯一的键，使用多个级别的hashmap，或者如果您不使用嵌套数组引用。|174368|Perl中的这两种原始集合类型没有面向对象的api，但它们仍然是集合。|174369|如果您查看CPAN，您可能会发现提供其他面向对象数据结构的模块，这实际上取决于您的需要。除了列表、堆栈或地图之外，您还需要特定的数据结构吗？如果你询问一个特定的数据结构，你可能会得到一个更精确的答案(比如一个特定的模块)。|174370|忘了提到，如果您正在寻找跨多种语言的小代码示例，PLEAC+(编程语言示例类似于Cookbook)是一个不错的资源。|offset|length|174371|entityMap|0|LINK|mutability|MUTABLE|url|http://pleac.sourceforge.net/^0|0|0|0|0|0|O|5|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@$L|11|M|12|1|13]]|A|$]]|$1|N|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

There are collection modules for more complex structures, but it is common style in Perl to use Arrays for arrays, stacks and lists. Perl has built in functions for using the array as a stack or list : push/pop, shift/unshift, splice (inserting or removing in the middle) and the foreach form for iteration.

Perl also has a map, called a hashmap which is the equivalent to a Dictionary in Python - allowing you to have an association between a single key and a single value.

Perl developers often compose these two data-structures to build what they need - need multiple values? Store array-references in the value part of the hashtable (Map). Trees can be built in a similar manner - if you need unique keys, use multiple-levels of hashmaps, or if you don't use nested array references.

These two primitive collection types in Perl don't have an Object Oriented api, but they still are collections.

If you look on CPAN you'll likely find modules that provide other Object Oriented data structures, it really depends on your need. Is there a particular data structure you need besides a List, Stack or Map? You might get a more precise answer (eg a specific module) if you're asking about a particular data structure.

Forgot to mention, if you're looking for small code examples across a variety of languages, <a href="http://pleac.sourceforge.net/" rel="nofollow noreferrer">PLEAC</a> (Programming Language Examples Alike Cookbook) is a decent resource.

blocks|key|854005|text|它依赖于很多方面；有稀疏矩阵模块、一些形式的持久化、面向对象的新风格等等--大多数人只是用数据结构来回答他们的具体问题--+man+历法、佩洛尔、皮尔斯c。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|854006|entityMap|0|LINK|mutability|MUTABLE|url|http://search.cpan.org/~kesinger/Math-MatrixSparse-0.01/MatrixSparse.pm|1|http://search.cpan.org/~jprit/ObjStore-1.59/lib/ObjStore.pod|2|http://search.cpan.org/~drolsky/Moose-0.58/lib/Moose.pm|3|http://perldoc.perl.org/perldata.html|4|http://perldoc.perl.org/perllol.html|5|http://perldoc.perl.org/perldsc.html^0|A|4|0|M|3|1|Q|8|2|1U|2|3|1X|3|4|21|4|5|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]|$A|12|B|13|1|14]|$A|15|B|16|1|17]|$A|18|B|19|1|1A]|$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|-4|5|6|7|1E|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]|P|$5|G|H|I|C|$J|Q]]|R|$5|G|H|I|C|$J|S]]|T|$5|G|H|I|C|$J|U]]]]

It depends a lot; there's <a href="http://search.cpan.org/~kesinger/Math-MatrixSparse-0.01/MatrixSparse.pm" rel="nofollow noreferrer">Sparse Matrix</a> modules, some forms of <a href="http://search.cpan.org/~jprit/ObjStore-1.59/lib/ObjStore.pod" rel="nofollow noreferrer">persistence</a>, a <a href="http://search.cpan.org/~drolsky/Moose-0.58/lib/Moose.pm" rel="nofollow noreferrer">new style of OO</a> etc
Most people just man <a href="http://perldoc.perl.org/perldata.html" rel="nofollow noreferrer">perldata</a>, <a href="http://perldoc.perl.org/perllol.html" rel="nofollow noreferrer">perllol</a>, <a href="http://perldoc.perl.org/perldsc.html" rel="nofollow noreferrer">perldsc</a> to answer their specific issue with a data structure.

blocks|key|854033|text|我想再次听到Michael的评论:当您指的是散列或关联数组时，请不要使用术语"Hashmap“或"map”。特别是当Perl有一个map函数时，这只是混淆了一些事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|854034|话虽如此，凯尔·伯顿的反应从根本上说是健全的:要么是散列，要么是数组，要么是由两者混合而成的复杂结构，通常就足够了。Perl喜欢OO，但没有强制执行；松散定义的数据结构可能足以满足您的需要。|854035|否则，请更准确地定义“从每个元素计算集合级别属性”是什么意思。请记住，Perl有像map和grep这样的关键字，这些关键字允许您进行函数编程，比如。|854036|my+$record+=+get_complex_structure();
#+$record+=+{
#++++'widgets'+=>+{
#++++++++name+=>+'ACME+Widgets',
#++++++++skus+=>+[+'WIDG01',+'WIDG02',+'WIDG03'+],
#++++++++sales+=>+{
#++++++++++++WIDG01+=>+{+num+=>+25,+value+=>+105.24+},
#++++++++++++WIDG02+=>+{+num+=>+10,+value+=>+80.02+},
#++++++++++++WIDG03+=>+{+num+=>+8,++value+=>+205.80+},
#++++++++},
#++++},
#++++###+and+so+on+for+'grommets',+'nuts',+'bolts'+etc.
#+}

my+@standouts+=
++++map+{+$_->[0]+}
++++sort+{
++++++++$b->[2]+<=>+$a->[2]+
+++++%7C%7C+$b->[1]+<=>+$a->[1]
+++++%7C%7C+$record->{$a->[0]}->{name}+cmp+$record->{$b->[0]}->{name}
++++}
++++map+{
++++++++my+($num,+$value);
++++++++for+my+$sku+(@{$record->{$_}{skus}})+{
++++++++++++$num+++%2B=+$record->{$_}{sales}{$sku}{num};
++++++++++++$value+%2B=+$record->{$_}{sales}{$sku}{value};
++++++++}
++++++++[+$_,+$num,+$value+];
++++}
++++keys+%25$record;|code-block|syntax|javascript|854037|从后面读到前面，这个特定的Schwarztian变换做了三件事：|offset|length|854038|3)它使用$record的一个键，遍历在这个任意结构中定义的SKU，并计算出事务的总数和总价值。它返回一个包含密钥、事务数和总价值的匿名数组。|854039|(+2)下一个块接受若干数组参，并对它们进行排序(+a)首先按降序对总价值进行比较；(+b)如果值相等，则按降序比较事务的数量；和(+c)如果不成功，则按与此顺序关联的名称进行排序。|854040|1)最后，我们从排序后的数据结构中获取$record的密钥，并将其返回。|854041|很可能你不需要设置一个单独的类来做你想做的事情。|854042|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Schwartzian_transform^0|0|0|0|0|D|D|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@$M|19|N|1A|1|1B]]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

I would second Michael Carman's comment: please do not use the term "Hashmap" or "map" when you mean a hash or associative array. Especially when Perl has a map function; that just confuses things.

Having said that, Kyle Burton's response is fundamentally sound: either a hash or an array, or a complex structure composed of a mixture of the two, is usually enough. Perl groks OO, but doesn't enforce it; chances are that a loosely-defined data structure may be good enough for what you need.

Failing that, please define more exactly what you mean by "compute collection level property from each element". And bear in mind that Perl has keywords like map and grep that let you do functional programming things like e.g.

<pre><code>my $record = get_complex_structure();
# $record = {
# 'widgets' =&gt; {
# name =&gt; 'ACME Widgets',
# skus =&gt; [ 'WIDG01', 'WIDG02', 'WIDG03' ],
# sales =&gt; {
# WIDG01 =&gt; { num =&gt; 25, value =&gt; 105.24 },
# WIDG02 =&gt; { num =&gt; 10, value =&gt; 80.02 },
# WIDG03 =&gt; { num =&gt; 8, value =&gt; 205.80 },
# },
# },
# ### and so on for 'grommets', 'nuts', 'bolts' etc.
# }

my @standouts =
 map { $_-&gt;[0] }
 sort {
 $b-&gt;[2] &lt;=&gt; $a-&gt;[2] 
 || $b-&gt;[1] &lt;=&gt; $a-&gt;[1]
 || $record-&gt;{$a-&gt;[0]}-&gt;{name} cmp $record-&gt;{$b-&gt;[0]}-&gt;{name}
 }
 map {
 my ($num, $value);
 for my $sku (@{$record-&gt;{$_}{skus}}) {
 $num += $record-&gt;{$_}{sales}{$sku}{num};
 $value += $record-&gt;{$_}{sales}{$sku}{value};
 }
 [ $_, $num, $value ];
 }
 keys %$record;
</code></pre>

Reading from back to front, this particular <a href="http://en.wikipedia.org/wiki/Schwartzian_transform" rel="nofollow noreferrer">Schwarztian transform</a> does three things:

3) It takes a key to $record, goes through the SKUs defined in this arbitrary structure, and works out the aggregate number and total value of transactions. It returns an anonymous array containing the key, the number of transactions and the total value.

2) The next block takes in a number of arrayrefs and sorts them a) first of all by comparing the total value, numerically, in descending orders; b) if the values are equal, by comparing the number of transactions, numerically in descending order; and c) if that fails, by sorting asciibetically on the name associated with this order.

1) Finally, we take the key to $record from the sorted data structure, and return that.

It may well be that you don't need to set up a separate class to do what you want.

Can someone suggest a good module in perl which can be used to store collection of objects?

Or is ARRAY a good enough substitute for most of the needs?

Update:
I am looking for a collections class because I want to be able to do an operation like compute collection level property from each element.

Since I need to perform many such operations, I might as well write a class which can be extended by individual objects. This class will obviously work with arrays (or may be hashes).

Any good collection module in perl?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

有人能建议在perl中建立一个好的模块来存储对象的集合吗？还是数组足够好地替代了大部分需求？更新：，我正在寻找一个集合类，因为我希望能够从每个元素执行像计算集合级别属性这样的操作。因为我需要执行许多这样的操作，所以我还不如编写一个类，它可以由单个对象进行扩展。这个类显然可以处理数组(或者可能是散列)。

问perl中有什么好的集合模块吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问perl中有什么好的集合模块吗？EN