GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  MOJO::COLLECTION (3)

.ds Aq ’

NAME

Mojo::Collection - Collection

CONTENTS

SYNOPSIS



  use Mojo::Collection;

  # Manipulate collection
  my $collection = Mojo::Collection->new(qw(just works));
  unshift @$collection, it;
  say $collection->join("\n");

  # Chain methods
  $collection->map(sub { ucfirst })->shuffle->each(sub {
    my ($word, $num) = @_;
    say "$num: $word";
  });

  # Use the alternative constructor
  use Mojo::Collection c;
  c(qw(a b c))->join(/)->url_escape->say;



DESCRIPTION

Mojo::Collection is an array-based container for collections.



  # Access array directly to manipulate collection
  my $collection = Mojo::Collection->new(1 .. 25);
  $collection->[23] += 100;
  say for @$collection;



FUNCTIONS

Mojo::Collection implements the following functions, which can be imported individually.

    c



  my $collection = c(1, 2, 3);



Construct a new array-based Mojo::Collection object.

METHODS

Mojo::Collection implements the following methods.

    TO_JSON



  my $array = $collection->TO_JSON;



Alias for to_array.

    compact



  my $new = $collection->compact;



Create a new collection with all elements that are defined and not an empty string.



  # "0, 1, 2, 3"
  Mojo::Collection->new(0, 1, undef, 2, , 3)->compact->join(, );



    each



  my @elements = $collection->each;
  $collection  = $collection->each(sub {...});



Evaluate callback for each element in collection, or return all elements as a list if none has been provided. The element will be the first argument passed to the callback, and is also available as $_.



  # Make a numbered list
  $collection->each(sub {
    my ($e, $num) = @_;
    say "$num: $e";
  });



    first



  my $first = $collection->first;
  my $first = $collection->first(qr/foo/);
  my $first = $collection->first(sub {...});
  my $first = $collection->first($method);
  my $first = $collection->first($method, @args);



Evaluate regular expression/callback for, or call method on, each element in collection and return the first one that matched the regular expression, or for which the callback/method returned true. The element will be the first argument passed to the callback, and is also available as $_.



  # Longer version
  my $first = $collection->first(sub { $_->$method(@args) });

  # Find first value that contains the word "mojo"
  my $interesting = $collection->first(qr/mojo/i);

  # Find first value that is greater than 5
  my $greater = $collection->first(sub { $_ > 5 });



    flatten



  my $new = $collection->flatten;



Flatten nested collections/arrays recursively and create a new collection with all elements.



  # "1, 2, 3, 4, 5, 6, 7"
  Mojo::Collection->new(1, [2, [3, 4], 5, [6]], 7)->flatten->join(, );



    grep



  my $new = $collection->grep(qr/foo/);
  my $new = $collection->grep(sub {...});
  my $new = $collection->grep($method);
  my $new = $collection->grep($method, @args);



Evaluate regular expression/callback for, or call method on, each element in collection and create a new collection with all elements that matched the regular expression, or for which the callback/method returned true. The element will be the first argument passed to the callback, and is also available as $_.



  # Longer version
  my $new = $collection->grep(sub { $_->$method(@args) });

  # Find all values that contain the word "mojo"
  my $interesting = $collection->grep(qr/mojo/i);

  # Find all values that are greater than 5
  my $greater = $collection->grep(sub { $_ > 5 });



    join



  my $stream = $collection->join;
  my $stream = $collection->join("\n");



Turn collection into Mojo::ByteStream.



  # Join all values with commas
  $collection->join(, )->say;



    last



  my $last = $collection->last;



Return the last element in collection.

    map



  my $new = $collection->map(sub {...});
  my $new = $collection->map($method);
  my $new = $collection->map($method, @args);



Evaluate callback for, or call method on, each element in collection and create a new collection from the results. The element will be the first argument passed to the callback, and is also available as $_.



  # Longer version
  my $new = $collection->map(sub { $_->$method(@args) });

  # Append the word "mojo" to all values
  my $mojoified = $collection->map(sub { $_ . mojo });



    new



  my $collection = Mojo::Collection->new(1, 2, 3);



Construct a new array-based Mojo::Collection object.

    reduce



  my $result = $collection->reduce(sub {...});
  my $result = $collection->reduce(sub {...}, $initial);



Reduce elements in collection with callback, the first element will be used as initial value if none has been provided.



  # Calculate the sum of all values
  my $sum = $collection->reduce(sub { $a + $b });

  # Count how often each value occurs in collection
  my $hash = $collection->reduce(sub { $a->{$b}++; $a }, {});



    reverse



  my $new = $collection->reverse;



Create a new collection with all elements in reverse order.

    slice



  my $new = $collection->slice(4 .. 7);



Create a new collection with all selected elements.



  # "B C E"
  Mojo::Collection->new(A, B, C, D, E)->slice(1, 2, 4)->join( );



    shuffle



  my $new = $collection->shuffle;



Create a new collection with all elements in random order.

    size



  my $size = $collection->size;



Number of elements in collection.

    sort



  my $new = $collection->sort;
  my $new = $collection->sort(sub {...});



Sort elements based on return value of callback and create a new collection from the results.



  # Sort values case-insensitive
  my $case_insensitive = $collection->sort(sub { uc($a) cmp uc($b) });



    tap



  $collection = $collection->tap(sub {...});



Alias for tap in Mojo::Base.

    to_array



  my $array = $collection->to_array;



Turn collection into array reference.

    uniq



  my $new = $collection->uniq;
  my $new = $collection->uniq(sub {...});
  my $new = $collection->uniq($method);
  my $new = $collection->uniq($method, @args);



Create a new collection without duplicate elements, using the string representation of either the elements or the return value of the callback/method.



  # Longer version
  my $new = $collection->uniq(sub { $_->$method(@args) });

  # "foo bar baz"
  Mojo::Collection->new(foo, bar, bar, baz)->uniq->join( );

  # "[[1, 2], [2, 1]]"
  Mojo::Collection->new([1, 2], [2, 1], [3, 2])->uniq(sub{ $_->[1] })->to_array;



SEE ALSO

Mojolicious, Mojolicious::Guides, <http://mojolicious.org>.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MOJO::COLLECTION (3) 2016-03-15

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.