archived-doc-pt-br/language/types/type-system.xml

<?xml version="1.0" encoding="utf-8"?><!-- EN-Revision: f908fff129bcd8ec1605658e06457cb04e5b2b51 Maintainer: leonardolara Status: ready --><!-- CREDITS: marcosmarcolin,ae,leonardolara -->
<sect1 xml:id="language.types.type-system">
 <title>Sistema de tipo</title>

 <para>
  O PHP usa um sistema de tipo nominal com uma forte relação de subtipagem comportamental.
  A relação de subtipagem é verificada em tempo de compilação, enquanto a verificação de
  tipos é verificada dinamicamente em tempo de execução.
 </para>

 <para>
  O sistema de tipos do PHP suporta vários tipos atômicos que podem ser compostos
  juntos para criar tipos mais complexos. Alguns desses tipos podem ser escritos como
  <link linkend="language.types.declarations">declarações de tipo</link>
 </para>

 <sect2 xml:id="language.types.type-system.atomic">
  <title>Tipos atômicos</title>
  <para>
   Tipos atômicos são tipos internos que são fortemente integrados com a linguagem e não
   podem ser reproduzidos com tipos definidos pelo usuário.
  </para>

  <para>
   A lista de tipos básicos é:
   <itemizedlist>
    <listitem>
     <simpara>Tipos integrados</simpara>
     <itemizedlist>
      <listitem>
       <simpara>
        Tipos escalares:
       </simpara>
       <itemizedlist>
        <listitem>
         <simpara>tipo <type>bool</type></simpara>
        </listitem>
        <listitem>
         <simpara>tipo <type>int</type></simpara>
        </listitem>
        <listitem>
         <simpara>tipo <type>float</type></simpara>
        </listitem>
        <listitem>
         <simpara>tipo <type>string</type></simpara>
        </listitem>
       </itemizedlist>
      </listitem>
      <listitem>
       <simpara>tipo <type>array</type></simpara>
      </listitem>
      <listitem>
       <simpara>tipo <type>object</type></simpara>
      </listitem>
      <listitem>
       <simpara>tipo <type>resource</type></simpara>
      </listitem>
      <listitem>
       <simpara>tipo <type>never</type></simpara>
      </listitem>
      <listitem>
       <simpara>tipo <type>void</type></simpara>
      </listitem>
      <listitem>
       <simpara>
        <link linkend="language.types.relative-class-types">Tipos de classes relativas:</link>
        <type>self</type>, <type>parent</type>, e <type>static</type>
       </simpara>
      </listitem>
      <listitem>
       <simpara>
        <link linkend="language.types.singleton">Tipos únicos</link>
       </simpara>
       <itemizedlist>
        <listitem>
         <simpara><type>false</type></simpara>
        </listitem>
        <listitem>
         <simpara><type>true</type></simpara>
        </listitem>
       </itemizedlist>
      </listitem>
      <listitem>
       <simpara>
        Tipos de unidade:
       </simpara>
       <itemizedlist>
        <listitem>
         <simpara><type>null</type></simpara>
        </listitem>
       </itemizedlist>
      </listitem>
     </itemizedlist>
    </listitem>
    <listitem>
     <simpara>
      Tipos definidos pelo usuário (geralmente chamados de tipos de classe)
     </simpara>
     <itemizedlist>
      <listitem>
       <simpara><link linkend="language.oop5.interfaces">Interfaces</link></simpara>
      </listitem>
      <listitem>
       <simpara><link linkend="language.oop5.basic.class">Classes</link></simpara>
      </listitem>
      <listitem>
       <simpara><link linkend="language.types.enumerations">Enumerações</link></simpara>
      </listitem>
     </itemizedlist>
    </listitem>
    <listitem>
     <simpara>tipo <type>callable</type></simpara>
    </listitem>
   </itemizedlist>
  </para>

  <sect3 xml:id="language.types.type-system.atomic.scalar">
   <title>Tipos escalares</title>
   <simpara>
    Um valor é considerado escalar se for do tipo <type>int</type>,
    <type>float</type>, <type>string</type> ou <type>bool</type>.
   </simpara>
  </sect3>

  <sect3 xml:id="language.types.type-system.atomic.user-defined">
   <title>Tipos definidos pelo usuário</title>
   <simpara>
    É possível definir tipos personalizados com
    <link linkend="language.oop5.interfaces">interfaces</link>,
    <link linkend="language.oop5.basic.class">classes</link> e
    <link linkend="language.types.enumerations">enumerações</link>.
    Essas são consideradas tipos definidos pelo usuário, ou tipos-classe.
    Por exemplo, uma classe chamada <literal>Elephant</literal> pode ser definida,
    em seguida objetos do tipo <literal>Elephant</literal> podem ser instanciados,
    e uma função pode requerer um parâmetro do tipo <literal>Elephant</literal>.
   </simpara>
  </sect3>
 </sect2>

 <sect2 xml:id="language.types.type-system.composite">
  <title>Tipos compostos</title>
  <para>
   É possível combinar vários tipos atômicos em tipos compostos.
   O PHP permite que os tipos sejam combinados das seguintes maneiras:
  </para>

  <itemizedlist>
   <listitem>
    <simpara>
     Interseção de tipos de classes (interfaces e nomes de classes).
    </simpara>
   </listitem>
   <listitem>
    <simpara>
     União de tipos.
    </simpara>
   </listitem>
  </itemizedlist>

  <sect3 xml:id="language.types.type-system.composite.intersection">
   <title>Tipos de interseção</title>
   <para>
    Um tipo de interseção aceita valores que satisfazem várias
    declarações de tipo de classe, em vez de uma única.
    Os tipos individuais que formam o tipo de interseção são unidos pelo símbolo
    <literal>&amp;</literal>. Portanto, um tipo de interseção composto pelos tipos
    <literal>T</literal>, <literal>U</literal>, e
    <literal>V</literal> será escrito como <literal>T&amp;U&amp;V</literal>.
   </para>
  </sect3>

  <sect3 xml:id="language.types.type-system.composite.union">
   <title>Tipos de união</title>
   <para>
    Um tipo de união aceita valores de vários tipos diferentes,
    em vez de um único.
    Tipos individuais que formam o tipo de união são unidos pelo
    <literal>|</literal> símbolo. Portanto, um tipo de união composto
    pelos tipos <literal>T</literal>, <literal>U</literal>, e
    <literal>V</literal> será escrito como <literal>T|U|V</literal>.
    Se um dos tipos for um tipo de interseção, ele precisa ser colocado entre
    parênteses para que seja escrito em <acronym>DNF</acronym>:
    <literal>T|(X&amp;Y)</literal>.
   </para>
  </sect3>
 </sect2>

 <sect2 xml:id="language.types.type-system.alias">
  <title>Alias de tipo</title>

  <para>
   O PHP suporta dois aliases de tipo: <type>mixed</type> e
   <type>iterable</type> que corresponde ao
   <link linkend="language.types.type-system.composite.union">tipo de união</link>
   de <literal>object|resource|array|string|float|int|bool|null</literal>
   e <literal>Traversable|array</literal>, respectivamente.
  </para>

  <note>
   <simpara>
    O PHP não suporta aliases de tipo definidos pelo usuário.
   </simpara>
  </note>
 </sect2>

</sect1>
<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->