Morgengrauner Dokumentation

Dateipfad: /home/mud/mudlib/doc//efun/filter
SYNOPSIS
        mixed * filter(mixed *arg, string fun, string|object ob
                                             , mixed extra...)
        mixed * filter(mixed *arg, closure cl, mixed extra...)
        mixed * filter(mixed *arg, mapping map, mixed extra...)

        string  filter(string arg, string fun, string|object ob
                                          , mixed extra...)
        string  filter(string arg, closure cl, mixed extra...)
        string  filter(string arg, mapping map, mixed extra...)

        mapping filter(mapping arg, string func, string|object ob
                                               , mixed extra...)
        mapping filter(mapping arg, closure cl, mixed extra...)

DESCRIPTION
        Call the function ->() resp. the closure  for
        every element of the array, or mapping , and return a
        result made from those elements for which the function call
        returns TRUE.  The  arguments are passed as additional
        parameters to the function calls and must not be references of
        array of mapping elements (like &(i[1]) ).

        If  is omitted, or neither a string nor an object, it
        defaults to this_object().


        If  is an array or struct, the function will be called with
        each of the array/struct values as first parameter, followed by the
         arguments. If the result from the function call is true,
        the array element in question is included into the efun result.

        If the efun is used with a mapping  instead of a function,
        every array element which is key in  is included into the
        result.


        If  is a mapping, the function will be called with
        each of the mapping keys as first, and (if existing) the
        associated values as second parameter, followed by the 
        arguments. If the result is true, the mapping element in question
        is included into the result.

        Depending on the width of the mapping , the function
        call takes one of three forms:

            widthof(arg) == 0: ob->func(key, 0, extra...)
                         == 1: ob->func(key, arg[key], extra...)
                          > 1: ob->func( key
                                       , ({ arg[key,0] ...arg[key,width-1] })
                                       , extra...)

        The advantage of this approach is that the two types of
        multi-dimensional mappings (mappings with multiple values
        per key, and mappings of arrays) can be treated in the same way.

        If  is a string, the function will be called with each of the
        characters of the string. If the result is true, the character in
        question is included into the result.

NOTES

        Historical Note: filter() used with arrays behaves like
        filter_array(), but used with mappings is a generalisation of
        filter_indices().

HISTORY
        Introduced in LDMud 3.2.6, obsoletes filter_array().
        LDMud 3.3.439 added filtering of strings.

SEE ALSO
        filter(E), filter_indices(E), map(E), walk_mapping(E), member(E),
        m_contains(E)



zurück zur Übersicht