1Mojo::Collection(3) User Contributed Perl Documentation Mojo::Collection(3)
2
6 Mojo::Collection - Collection
7
9 use Mojo::Collection;
10 # Manipulate collection
12 my $collection = Mojo::Collection->new(qw(just works));
13 unshift @$collection, 'it';
14 say $collection->join("\n");
15 # Chain methods
17 $collection->map(sub { ucfirst })->shuffle->each(sub {
18 my ($word, $num) = @_;
19 say "$num: $word";
20 });
21 # Use the alternative constructor
23 use Mojo::Collection 'c';
24 c(qw(a b c))->join('/')->url_escape->say;
25
27 Mojo::Collection is an array-based container for collections.
28 # Access array directly to manipulate collection
30 my $collection = Mojo::Collection->new(1 .. 25);
31 $collection->[23] += 100;
32 say for @$collection;
33
35 Mojo::Collection implements the following functions, which can be
36 imported individually.
37 c
39 my $collection = c(1, 2, 3);
40 Construct a new array-based Mojo::Collection object.
42
44 Mojo::Collection implements the following methods.
45 TO_JSON
47 my $array = $collection->TO_JSON;
48 Alias for "to_array".
50 compact
52 my $new = $collection->compact;
53 Create a new collection with all elements that are defined and not an
55 empty string.
56 # "0, 1, 2, 3"
58 c(0, 1, undef, 2, '', 3)->compact->join(', ');
59 each
61 my @elements = $collection->each;
62 $collection = $collection->each(sub {...});
63 Evaluate callback for each element in collection, or return all
65 elements as a list if none has been provided. The element will be the
66 first argument passed to the callback, and is also available as $_.
67 # Make a numbered list
69 $collection->each(sub {
70 my ($e, $num) = @_;
71 say "$num: $e";
72 });
73 first
75 my $first = $collection->first;
76 my $first = $collection->first(qr/foo/);
77 my $first = $collection->first(sub {...});
78 my $first = $collection->first('some_method');
79 my $first = $collection->first('some_method', @args);
80 Evaluate regular expression/callback for, or call method on, each
82 element in collection and return the first one that matched the regular
83 expression, or for which the callback/method returned true. The element
84 will be the first argument passed to the callback, and is also
85 available as $_.
86 # Longer version
88 my $first = $collection->first(sub { $_->some_method(@args) });
89 # Find first value that contains the word "mojo"
91 my $interesting = $collection->first(qr/mojo/i);
92 # Find first value that is greater than 5
94 my $greater = $collection->first(sub { $_ > 5 });
95 flatten
97 my $new = $collection->flatten;
98 Flatten nested collections/arrays recursively and create a new
100 collection with all elements.
101 # "1, 2, 3, 4, 5, 6, 7"
103 c(1, [2, [3, 4], 5, [6]], 7)->flatten->join(', ');
104 grep
106 my $new = $collection->grep(qr/foo/);
107 my $new = $collection->grep(sub {...});
108 my $new = $collection->grep('some_method');
109 my $new = $collection->grep('some_method', @args);
110 Evaluate regular expression/callback for, or call method on, each
112 element in collection and create a new collection with all elements
113 that matched the regular expression, or for which the callback/method
114 returned true. The element will be the first argument passed to the
115 callback, and is also available as $_.
116 # Longer version
118 my $new = $collection->grep(sub { $_->some_method(@args) });
119 # Find all values that contain the word "mojo"
121 my $interesting = $collection->grep(qr/mojo/i);
122 # Find all values that are greater than 5
124 my $greater = $collection->grep(sub { $_ > 5 });
125 join
127 my $stream = $collection->join;
128 my $stream = $collection->join("\n");
129 Turn collection into Mojo::ByteStream.
131 # Join all values with commas
133 $collection->join(', ')->say;
134 last
136 my $last = $collection->last;
137 Return the last element in collection.
139 map
141 my $new = $collection->map(sub {...});
142 my $new = $collection->map('some_method');
143 my $new = $collection->map('some_method', @args);
144 Evaluate callback for, or call method on, each element in collection
146 and create a new collection from the results. The element will be the
147 first argument passed to the callback, and is also available as $_.
148 # Longer version
150 my $new = $collection->map(sub { $_->some_method(@args) });
151 # Append the word "mojo" to all values
153 my $mojoified = $collection->map(sub { $_ . 'mojo' });
154 new
156 my $collection = Mojo::Collection->new(1, 2, 3);
157 Construct a new array-based Mojo::Collection object.
159 reduce
161 my $result = $collection->reduce(sub {...});
162 my $result = $collection->reduce(sub {...}, $initial);
163 Reduce elements in collection with a callback and return its final
165 result, setting $a and $b each time the callback is executed. The first
166 time $a will be set to an optional initial value or the first element
167 in the collection. And from then on $a will be set to the return value
168 of the callback, while $b will always be set to the next element in the
169 collection.
170 # Calculate the sum of all values
172 my $sum = $collection->reduce(sub { $a + $b });
173 # Count how often each value occurs in collection
175 my $hash = $collection->reduce(sub { $a->{$b}++; $a }, {});
176 reverse
178 my $new = $collection->reverse;
179 Create a new collection with all elements in reverse order.
181 shuffle
183 my $new = $collection->shuffle;
184 Create a new collection with all elements in random order.
186 size
188 my $size = $collection->size;
189 Number of elements in collection.
191 sort
193 my $new = $collection->sort;
194 my $new = $collection->sort(sub {...});
195 Sort elements based on return value of a callback and create a new
197 collection from the results, setting $a and $b to the elements being
198 compared, each time the callback is executed.
199 # Sort values case-insensitive
201 my $case_insensitive = $collection->sort(sub { uc($a) cmp uc($b) });
202 tap
204 $collection = $collection->tap(sub {...});
205 Alias for "tap" in Mojo::Base.
207 to_array
209 my $array = $collection->to_array;
210 Turn collection into array reference.
212 uniq
214 my $new = $collection->uniq;
215 my $new = $collection->uniq(sub {...});
216 my $new = $collection->uniq('some_method');
217 my $new = $collection->uniq('some_method', @args);
218 Create a new collection without duplicate elements, using the string
220 representation of either the elements or the return value of the
221 callback/method to decide uniqueness. Note that "undef" and empty
222 string are treated the same.
223 # Longer version
225 my $new = $collection->uniq(sub { $_->some_method(@args) });
226 # "foo bar baz"
228 c('foo', 'bar', 'bar', 'baz')->uniq->join(' ');
229 # "[[1, 2], [2, 1]]"
231 c([1, 2], [2, 1], [3, 2])->uniq(sub{ $_->[1] })->to_array;
232 with_roles
234 my $new_class = Mojo::Collection->with_roles('Mojo::Collection::Role::One');
235 my $new_class = Mojo::Collection->with_roles('+One', '+Two');
236 $collection = $collection->with_roles('+One', '+Two');
237 Alias for "with_roles" in Mojo::Base.
239
241 Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.
242perl v5.30.0 2019-07-26 Mojo::Collection(3)