Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (Debian-5.0)
Apropos / Subsearch:
optional field

MIME::Type(3pm)       User Contributed Perl Documentation      MIME::Type(3pm)

       MIME::Type - Definition of one MIME type

        use MIME::Types;
        my $mimetypes = MIME::Types->new;
        my MIME::Type $plaintext = $mimetypes->type('text/plain');
        print $plaintext->mediaType;   # text
        print $plaintext->subType;     # plain

        my @ext = $plaintext->extensions;
        print "@ext"                   # txt asc c cc h hh cpp

        print $plaintext->encoding     # 8bit
        if($plaintext->isBinary)       # false
        if($plaintext->isAscii)        # true
        if($plaintext->equals('text/plain') {...}
        if($plaintext eq 'text/plain') # same

        print MIME::Type->simplified('x-appl/x-zip') #  'appl/zip'

       MIME types are used in MIME entities, for instance as part of e-mail
       and HTTP traffic.  Sometimes real knowledge about a mime-type is need.
       Objects of "MIME::Type" store the information on one such type.

       This module is built to conform to the MIME types of RFC's 2045 and
       2231.  It follows the official IANA registry at
       http://www.iana.org/assignments/media-types/ and the collection kept at

       overload: string comparison

           When a MIME::Type object is compared to either a string or an other
           MIME::TYpe, the equals() method is called.  Comparison is smart,
           which means that it extends common string comparison with some
           features which are defined in the related RFCs.

       overload: stringification

           The stringification (use of the object in a place where a string is
           required) will result in the type name, the same as type() returns.

           example: use of stringification

            my $mime = MIME::Type->new('text/html');
            print "$mime\n";   # explicit stringification
            print $mime;       # implicit stringification



           Create (instantiate) a new MIME::Type object which manages one mime

            Option    --Default
            encoding    <depends on type>
            extensions  []
            simplified  <derived from type>
            system      undef
            type        <required>

           . encoding => '7bit'|'8bit'|'base64'|'quoted-printable'

               How must this data be encoded to be transported safely.  The
               default depends on the type: mimes with as main type "text/"
               will default to "quoted-printable" and all other to "base64".

           . extensions => REF-ARRAY

               An array of extensions which are using this mime.

           . simplified => STRING

               The mime types main- and sub-label can both start with "x-", to
               indicate that is a non-registered name.  Of course, after
               registration this flag can disappear which adds to the
               confusion.  The simplified string has the "x-" thingies removed
               and are translated to lower-case.

           . system => REGEX

               Regular expression which defines for which systems this rule is
               valid.  The REGEX is matched on $^O.

           . type => STRING

               The type which is defined here.  It consists of a type and a
               sub-type, both case-insensitive.  This module will return
               lower-case, but accept upper-case.



           Returns the type of encoding which is required to transport data of
           this type safely.


           Returns a list of extensions which are known to be used for this
           mime type.



           Returns the simplified mime type for this object or the specified
           STRING.  Mime type names can get officially registered.  Until
           then, they have to carry an "x-" preamble to indicate that.  Of
           course, after recognition, the "x-" can disappear.  In many cases,
           we prefer the simplified version of the type.

           example: results of simplified()

            my $mime = MIME::Type->new(type => 'x-appl/x-zip');
            print $mime->simplified;                     # 'appl/zip'
            print $mime->simplified('text/plain');       # 'text/plain'
            print MIME::Type->simplified('x-xyz/x-abc'); # 'xyz/abc'


           Returns the regular expression which can be used to determine
           whether this type is active on the system where you are working on.


           Returns the long type of this object, for instance 'text/plain'



           Compare this mime-type object with a STRING or other object.  In
           case of a STRING, simplification will take place.


           Returns false when the encoding is base64, and true otherwise.  All
           encodings except base64 are text encodings.


           Returns true when the encoding is base64.


           Mime-types which are not registered by IANA nor defined in RFCs
           shall start with an "x-".  This counts for as well the media-type
           as the sub-type.  In case either one of the types starts with "x-"
           this method will return false.


           Returns true when the type is in the list of known signatures.


           The media type of the simplified mime.  For 'text/plain' it will
           return 'text'.

           For historical reasons, the 'mainType' method still can be used to
           retreive the same value.  However, that method is deprecated.


           The sub type of the simplified mime.  For 'text/plain' it will
           return 'plain'.

       Error: Type parameter is obligatory.

           When a MIME::Type object is created, the type itself must be
           specified with the "type" option flag.

       This module is part of MIME-Types distribution version 1.24, built on
       May 23, 2008. Website: http://perl.overmeer.net/mimetypes/

       Copyrights 1999,2001-2008 by Mark Overmeer. For other contributors see

       This program is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself.  See

perl v5.10.0                      2008-05-23                   MIME::Type(3pm)