r2 - 07 Mar 2006 - IgorSutton

NOME

List::Util - Uma coleção de funções úteis para manipulação de listas

SINOPSE

    use List::Util qw(first max maxstr min minstr reduce shuffle sum);

voltar para o topo

DESCRIÇÃO

O módulo List::Util contém uma coleção de funções que diversas pessoas acham interessante existir no core do Perl, porém a utilização não é grande o suficiente para justificar o uso de uma palavra reservada (keyword), e seu tamanho é tão insignificante que também não justifica a existência de um módulo individual para cada uma delas. Por padrão, o módulo List::Util não exporta nenhuma função. As funções definidas em List::Util são:

first BLOCK LIST

É similar à função grep, onde é executado o bloco de código BLOCK atribuindo $_ para cada elemento da lista LIST, um de cada vez. A função first retorna o primeiro elemento onde o resultado de BLOCK seja um valor verdadeiro. Caso o bloco BLOCK nunca devolva um valor verdadeiro, ou a lista LIST esteja vazio então é devolvido undef.

    $foo = first { defined($_) } @list    # primeiro item com um valor definido de @list

    $foo = first { $_ > $value } @list    # primeiro valor de @list que seja maior que $value

Esta função poderia ser implementada utilizando a função reduce desta maneira:

    $foo = reduce { defined($a) ? $a : wanted($b) ? $b : undef } undef, @list

Por exemplo, wanted() poderia ser defined(), que neste caso devolveria o primeiro valor definido de @list.

max LIST

Devolve o item da lista que contenha o maior valor numérico. Caso a lista esteja vazia então undef é devolvido.

    $foo = max 1..10                # 10

    $foo = max 3,9,12               # 12

    $foo = max @bar, @baz           # o maior dos valores das duas listas

Esta função poderia ser implementada utilizando a função reduce desta maneira:

    $foo = reduce { $a > $b ? $a : $b } 1..10

maxstr LIST

Assemelha-se à função max, porém considera todos os itens como strings e devolve a maior string, como no operador gt. É devolvido undef caso a lista esteja vazia.

    $foo = maxstr 'A'..'Z'          # 'Z'

    $foo = maxstr "hello","world"   # "world"

    $foo = maxstr @bar, @baz        # o maior dos valores das duas listas

Esta função poderia ser implementada utilizando a função reduce desta maneira:

    $foo = reduce { $a gt $b ? $a : $b } 'A'..'Z'

min LIST

Assemelha-se à função max, porém devolve o item da lista com o menor valor numérico. Devolve undef caso a lista esteja vazia.

    $foo = min 1..10                # 1

    $foo = min 3,9,12               # 3

    $foo = min @bar, @baz           # o menor dos valores das duas listas

Esta função poderia ser implementada utilizando a função reduce desta maneira:

    $foo = reduce { $a < $b ? $a : $b } 1..10

minstr LIST

Assemelha-se à função min, porém considera todos os itens da lista como strings e retorna a menor string, como no operador lt. Devolve undef caso a lista esteja vazia.

    $foo = minstr 'A'..'Z'          # 'A'

    $foo = minstr "hello","world"   # "hello"

    $foo = minstr @bar, @baz        # o menor dos valores das duas listas

Esta função poderia ser implementada utilizando a função reduce desta maneira:

    $foo = reduce { $a lt $b ? $a : $b } 'A'..'Z'

reduce BLOCK LIST

Reduz a lista LIST, chamando o bloco de código BLOCK diversas vezes, atribuindo as variáveis $a e $b cada vez. Na primeira execução, são atribuídos a $a e $b os primeiros dois elementos da lista, e em cada execução subsequente, a $a é atribuido o resultado da execução anterior e $b o valor do próximo elemento da lista.

A função reduce devolve o resultado da última execução do bloco de código BLOCK. É devolvido undef caso a lista LIST esteja vazia. Se a lista LIST conter apenas um item, então este elemento é devolvido e o bloco de código BLOCK não é executado.

    $foo = reduce { $a < $b ? $a : $b } 1..10       # min

    $foo = reduce { $a lt $b ? $a : $b } 'aa'..'zz' # minstr

    $foo = reduce { $a + $b } 1 .. 10               # sum

    $foo = reduce { $a . $b } @bar                  # concat

shuffle LIST

Devolve os elementos da lista LIST em uma ordem randômica.

    @cards = shuffle 0..51      # 0..51 em uma ordem randômica

sum LIST

Devolve a soma de todos os elementos da lista LIST.

    $foo = sum 1..10                # 55

    $foo = sum 3,9,12               # 24

    $foo = sum @bar, @baz           # a soma dos elementos das duas listas

Esta função poderia ser implementada utilizando a função reduce desta maneira:

    $foo = reduce { $a + $b } 1..10

voltar para o topo

BUGS CONHECIDOS

Em versões de Perl anteriores à 5.005, existem alguns casos onde a função reduce devolverá um valor incorreto. Isto será informado caso o teste número 7 do arquivo reduce.t falhe.

voltar para o topo

SUGESTÕES DE FUNÇÕES

As seguintes funções foram sugeridas, porém relutei para adicioná-las pois eram muito simples de implementá-las em Perl.

  # Um item com valor verdadeiro

  sub any { $_ && return 1 for @_; 0 }

  # Todos itens com valores verdadeiros

  sub all { $_ || return 0 for @_; 1 }

  # Todos itens com valor falso

  sub none { $_ && return 0 for @_; 1 }

  # Um valor falso

  sub notall { $_ || return 1 for @_; 0 }

  # Número de elementos que possuem um valor verdadeiro

  sub true { scalar grep { $_ } @_ }

  # Número de elementos que possuem um valor falso

  sub false { scalar grep { !$_ } @_ }

voltar para o topo

COPYRIGHT

voltar para o topo

TRADUÇÃO

Igor Sutton <igor@izut.com>

voltar para o topo

Pesquisar

Documentação

Artigos

Planeta

Eventos

Comunidade

NOME

SINOPSE

DESCRIÇÃO

BUGS CONHECIDOS

SUGESTÕES DE FUNÇÕES

COPYRIGHT

TRADUÇÃO