mirror of
https://github.com/php/doc-es.git
synced 2026-03-23 23:12:09 +01:00
feat(translation): add and revision doc EN (#271)
This commit is contained in:
39
appendices/examples.xml
Normal file
39
appendices/examples.xml
Normal file
@@ -0,0 +1,39 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<appendix xml:id="examples" xmlns="http://docbook.org/ns/docbook">
|
||||
<title>Acerca de los ejemplos del manual</title>
|
||||
<simpara>
|
||||
Debe tenerse en cuenta que muchos ejemplos en la documentación de PHP omiten
|
||||
el manejo de errores y excepciones por claridad y brevedad.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Esto no significa que el manejo de errores deba omitirse en el código de producción,
|
||||
ya que puede llevar a que se lancen excepciones <exceptionname>TypeError</exceptionname>,
|
||||
valores de fallo sean forzados, como &false; a un string vacío,
|
||||
o supuestos sean violados, lo que podría causar errores difíciles de rastrear.
|
||||
Algunas extensiones proporcionan ejemplos completos donde se incluye el manejo de errores
|
||||
para demostrar el uso correcto de las diversas funciones y métodos proporcionados
|
||||
por la extensión.
|
||||
</simpara>
|
||||
</appendix>
|
||||
<!-- 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
|
||||
-->
|
||||
175
install/pecl.xml
175
install/pecl.xml
@@ -15,30 +15,30 @@
|
||||
</simpara>
|
||||
<simpara>
|
||||
Estas instrucciones asumen que <literal>/path/to/php/src/dir/</literal> es la
|
||||
ruta a la distribución de código fuente de PHP y que <literal>extname</literal> es
|
||||
ruta a la distribución del código fuente de PHP y que <literal>extname</literal> es
|
||||
el nombre de la extensión PECL. Ajuste según corresponda.
|
||||
Estas instrucciones también asumen familiaridad con el
|
||||
<link xlink:href="&url.php.pear.cli;">comando pear</link>.
|
||||
La información en el manual PEAR para el
|
||||
La información en el manual de PEAR para el
|
||||
comando <command>pear</command>
|
||||
también se aplica al
|
||||
comando <command>pecl</command>.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Una extensión compartida debe ser construida, instalada y cargada para ser útil.
|
||||
Los métodos descritos a continuación proporcionan varias instrucciones sobre cómo construir e
|
||||
Una extensión compartida debe ser compilada, instalada y cargada para ser útil.
|
||||
Los métodos descritos a continuación proporcionan varias instrucciones sobre cómo compilar e
|
||||
instalar las extensiones, pero no las cargan automáticamente.
|
||||
Las extensiones pueden ser cargadas añadiendo una
|
||||
Las extensiones pueden cargarse añadiendo una
|
||||
directiva <link linkend="ini.extension">extension</link>
|
||||
al archivo &php.ini; o a través del uso de la
|
||||
al fichero &php.ini; o mediante el uso de la
|
||||
función <function>dl</function>.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Al construir módulos PHP, es importante tener versiones conocidas y buenas de las
|
||||
Al compilar módulos PHP, es importante tener versiones conocidas y buenas de las
|
||||
herramientas requeridas (autoconf, automake, libtool, etc.).
|
||||
Consulte las
|
||||
<link xlink:href="&url.php.anongit;">Instrucciones de Git Anónimo</link>
|
||||
para detalles sobre las herramientas requeridas y las versiones necesarias.
|
||||
para obtener detalles sobre las herramientas requeridas y las versiones necesarias.
|
||||
</simpara>
|
||||
</sect1>
|
||||
|
||||
@@ -46,7 +46,7 @@
|
||||
<title>Descarga de extensiones PECL</title>
|
||||
&pecl.moving.to.pie;
|
||||
<simpara>
|
||||
Hay varias opciones para descargar extensiones PECL, tales como:
|
||||
Hay varias opciones para descargar extensiones PECL, como:
|
||||
</simpara>
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
@@ -62,8 +62,8 @@
|
||||
</simpara>
|
||||
<simpara>
|
||||
El sitio web de PECL contiene información sobre las diferentes extensiones que
|
||||
son ofrecidas por el Equipo de Desarrollo de PHP.
|
||||
La información disponible aquí incluye: registro de cambios, notas de lanzamiento,
|
||||
ofrece el Equipo de Desarrollo de PHP.
|
||||
La información disponible aquí incluye: registro de cambios, notas de la versión,
|
||||
requisitos y otros detalles similares.
|
||||
</simpara>
|
||||
</listitem>
|
||||
@@ -72,10 +72,10 @@
|
||||
<command>pecl download extname</command>
|
||||
</simpara>
|
||||
<simpara>
|
||||
Las extensiones PECL que tienen lanzamientos listados en el sitio web de PECL están disponibles
|
||||
Las extensiones PECL que tienen versiones publicadas en el sitio web de PECL están disponibles
|
||||
para descarga e instalación usando el
|
||||
<link xlink:href="&url.php.pear.cli;">comando pecl</link>.
|
||||
También se pueden especificar revisiones específicas.
|
||||
También pueden especificarse revisiones específicas.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
@@ -96,7 +96,7 @@
|
||||
Una vista basada en web puede verse en
|
||||
<link xlink:href="&url.php.svn;pecl/">&url.php.svn;pecl/</link>.
|
||||
Para descargar directamente desde <acronym>SVN</acronym>,
|
||||
la siguiente secuencia de comandos puede ser usada:
|
||||
puede usarse la siguiente secuencia de comandos:
|
||||
</simpara>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
@@ -125,45 +125,45 @@ $ svn checkout https://svn.php.net/repository/pecl/extname/trunk extname
|
||||
</para>
|
||||
<para>
|
||||
Para cargar una extensión, debe estar disponible como un
|
||||
archivo <filename>.dll</filename>
|
||||
fichero <filename>.dll</filename>
|
||||
en el sistema.
|
||||
Todas las extensiones son compiladas automáticamente y periódicamente por el Grupo PHP
|
||||
(ver la siguiente sección para la descarga).
|
||||
(consulte la siguiente sección para la descarga).
|
||||
</para>
|
||||
<para>
|
||||
Para compilar una extensión en PHP, consulte la
|
||||
documentación <link linkend="install.windows.building">compilación desde el código fuente</link>.
|
||||
documentación de <link linkend="install.windows.building">compilación desde el código fuente</link>.
|
||||
</para>
|
||||
<para>
|
||||
Para compilar una extensión independiente (también conocida como un archivo DLL), consulte la
|
||||
documentación <link linkend="install.windows.building">compilación desde el código fuente</link>.
|
||||
Si el archivo DLL no está disponible ni con la distribución de PHP ni en PECL,
|
||||
puede ser necesario compilarlo antes de que la extensión pueda ser usada.
|
||||
Para compilar una extensión independiente (también conocida como un fichero DLL), consulte la
|
||||
documentación de <link linkend="install.windows.building">compilación desde el código fuente</link>.
|
||||
Si el fichero DLL no está disponible ni con la distribución de PHP ni en PECL,
|
||||
puede ser necesario compilarlo antes de que la extensión pueda usarse.
|
||||
</para>
|
||||
<sect2 xml:id="install.pecl.windows.find">
|
||||
<title>¿Dónde encontrar una extensión?</title>
|
||||
<para>
|
||||
Las extensiones PHP suelen llamarse <filename>php_*.dll</filename> (donde el
|
||||
asterisco representa el nombre de la extensión), y están ubicadas en la
|
||||
asterisco representa el nombre de la extensión), y se encuentran en la
|
||||
carpeta <filename>PHP\ext</filename>.
|
||||
</para>
|
||||
<para>
|
||||
PHP se distribuye con las extensiones más útiles para la mayoría de los desarrolladores.
|
||||
PHP incluye las extensiones más útiles para la mayoría de los desarrolladores.
|
||||
Se llaman extensiones <emphasis>incluidas</emphasis>.
|
||||
</para>
|
||||
<para>
|
||||
Sin embargo, si las extensiones incluidas no proporcionan la funcionalidad necesaria,
|
||||
aún se puede encontrar una extensión que sí lo haga en &link.pecl;.
|
||||
La Biblioteca Comunitaria de Extensiones PHP (PECL) es un repositorio para
|
||||
Extensiones PHP, proporcionando un directorio de todas las extensiones conocidas y alojando
|
||||
facilidades para descargar y desarrollar extensiones PHP.
|
||||
aún puede encontrarse una extensión que lo haga en &link.pecl;.
|
||||
La Biblioteca de Extensiones de la Comunidad PHP (PECL) es un repositorio para
|
||||
Extensiones PHP, que proporciona un directorio de todas las extensiones conocidas y ofrece
|
||||
instalaciones para descargar y desarrollar extensiones PHP.
|
||||
</para>
|
||||
<para>
|
||||
Si una extensión ha sido desarrollada para usos particulares, puede estar alojada en
|
||||
PECL para que otros con las mismas necesidades puedan beneficiarse de ella.
|
||||
Un buen efecto secundario es que es una buena oportunidad para recibir comentarios,
|
||||
(con suerte) agradecimientos, informes de errores e incluso correcciones/parches.
|
||||
Antes de enviar una extensión para alojamiento en PECL, por favor lea
|
||||
Antes de enviar una extensión para alojarla en PECL, lea
|
||||
<link xlink:href="&url.pecl.submit;">PECL submit</link>.
|
||||
</para>
|
||||
</sect2>
|
||||
@@ -182,12 +182,12 @@ $ svn checkout https://svn.php.net/repository/pecl/extname/trunk extname
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Diferentes configuraciones de seguridad de subprocesos
|
||||
Diferentes configuraciones de seguridad de hilos
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Diferente arquitectura de procesador (x86, x64, ...)
|
||||
Diferentes arquitecturas de procesador (x86, x64, ...)
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
@@ -204,8 +204,8 @@ $ svn checkout https://svn.php.net/repository/pecl/extname/trunk extname
|
||||
</para>
|
||||
<para>
|
||||
Tenga en cuenta que la configuración de la extensión debe coincidir con todas las configuraciones de
|
||||
el ejecutable PHP que se está utilizando.
|
||||
El siguiente script PHP dirá <emphasis>todo</emphasis> sobre la configuración de PHP:
|
||||
el ejecutable de PHP que se está utilizando.
|
||||
El siguiente script PHP informará <emphasis>todo</emphasis> sobre la configuración de PHP:
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
@@ -234,17 +234,17 @@ drive:\path\to\php\executable\php.exe -i
|
||||
<sect2 xml:id="install.pecl.windows.loading">
|
||||
<title>Carga de una extensión</title>
|
||||
<para>
|
||||
La forma más común de cargar una extensión PHP es incluirla en
|
||||
el archivo de configuración &php.ini;.
|
||||
La forma más común de cargar una extensión PHP es incluirla en el
|
||||
fichero de configuración &php.ini;.
|
||||
Tenga en cuenta que muchas extensiones ya están presentes en el &php.ini; y
|
||||
que solo es necesario eliminar el punto y coma para activarlas.
|
||||
</para>
|
||||
<para>
|
||||
Tenga en cuenta que, a partir de PHP 7.2.0, se puede usar el
|
||||
nombre de la extensión en lugar del nombre del archivo de la extensión.
|
||||
Como esto es independiente del sistema operativo y más fácil, especialmente para principiantes, se convierte
|
||||
en la forma recomendada de especificar extensiones para cargar.
|
||||
Los nombres de archivos siguen siendo compatibles con versiones anteriores.
|
||||
Tenga en cuenta que, a partir de PHP 7.2.0, puede usarse el nombre de la extensión
|
||||
en lugar del nombre del fichero de la extensión.
|
||||
Al ser independiente del sistema operativo y más fácil, especialmente para los recién llegados, se convierte
|
||||
en la forma recomendada de especificar las extensiones a cargar.
|
||||
Los nombres de fichero siguen siendo compatibles con versiones anteriores.
|
||||
</para>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
@@ -258,7 +258,7 @@ extension=php_extname.dll
|
||||
</screen>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
; A partir de PHP 7.2.0, prefiera:
|
||||
; A partir de PHP 7.2.0, se prefiere:
|
||||
extension=extname
|
||||
zend_extension=another_extension
|
||||
]]>
|
||||
@@ -290,7 +290,7 @@ Loaded Configuration File C:\Program Files\PHP\8.2\php.ini
|
||||
<title>Resolución de problemas</title>
|
||||
<para>
|
||||
Si la extensión no aparece en <function>phpinfo</function>,
|
||||
los registros deben ser verificados para saber de dónde viene el problema.
|
||||
deben revisarse los registros para saber de dónde proviene el problema.
|
||||
</para>
|
||||
<para>
|
||||
Si PHP se está utilizando desde la línea de comandos (CLI), el error de carga de la extensión
|
||||
@@ -298,17 +298,17 @@ Loaded Configuration File C:\Program Files\PHP\8.2\php.ini
|
||||
</para>
|
||||
<para>
|
||||
Si PHP se está utilizando con un servidor web, la ubicación y el formato de los registros
|
||||
varían dependiendo del software.
|
||||
Por favor lea la documentación del servidor web para localizar los registros, ya que
|
||||
no tiene nada que ver con PHP en sí.
|
||||
varían según el software.
|
||||
Lea la documentación del servidor web para localizar los registros, ya que no tiene
|
||||
nada que ver con PHP en sí.
|
||||
</para>
|
||||
<para>
|
||||
Los problemas comunes son la ubicación de la DLL y las DLLs de las que depende, el
|
||||
valor de la configuración "<link linkend="ini.extension-dir">extension_dir</link>"
|
||||
dentro de &php.ini; y las discrepancias en la configuración de tiempo de compilación.
|
||||
dentro de &php.ini; y las incompatibilidades en la configuración de compilación.
|
||||
</para>
|
||||
<para>
|
||||
Si el problema radica en una discrepancia en la configuración de tiempo de compilación, probablemente la DLL
|
||||
Si el problema radica en una incompatibilidad en la configuración de compilación, probablemente la DLL
|
||||
descargada no es la correcta.
|
||||
Intente descargar la extensión nuevamente con la configuración adecuada.
|
||||
Nuevamente, <function>phpinfo</function> puede ser de gran ayuda.
|
||||
@@ -331,18 +331,18 @@ $ pecl install extname
|
||||
]]>
|
||||
</screen>
|
||||
<simpara>
|
||||
Esto descargará el código fuente para <emphasis>extname</emphasis>,
|
||||
compilará e instalará <filename>extname.so</filename> en el
|
||||
Esto descargará el código fuente de <emphasis>extname</emphasis>,
|
||||
lo compilará e instalará <filename>extname.so</filename> en el
|
||||
<link linkend="ini.extension-dir">extension_dir</link>.
|
||||
<filename>extname.so</filename>
|
||||
puede entonces ser cargado a través de &php.ini;.
|
||||
luego puede cargarse a través de &php.ini;.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Por defecto, el comando <command>pecl</command> no instalará paquetes
|
||||
Por omisión, el comando <command>pecl</command> no instalará paquetes
|
||||
que estén marcados con el estado <literal>alpha</literal> o
|
||||
<literal>beta</literal>.
|
||||
Si no hay paquetes <literal>estable</literal> disponibles,
|
||||
un paquete <literal>beta</literal> puede ser instalado usando el siguiente
|
||||
Si no hay paquetes <literal>stable</literal> disponibles,
|
||||
puede instalarse un paquete <literal>beta</literal> usando el siguiente
|
||||
comando:
|
||||
</simpara>
|
||||
<screen>
|
||||
@@ -351,7 +351,7 @@ $ pecl install extname-beta
|
||||
]]>
|
||||
</screen>
|
||||
<para>
|
||||
También se puede instalar una versión específica usando esta variante:
|
||||
También puede instalarse una versión específica usando esta variante:
|
||||
</para>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
@@ -361,7 +361,7 @@ $ pecl install extname-0.1
|
||||
<note>
|
||||
<para>
|
||||
Después de habilitar la extensión en &php.ini;, es necesario reiniciar el servicio web para que
|
||||
los cambios sean aplicados.
|
||||
los cambios surtan efecto.
|
||||
</para>
|
||||
</note>
|
||||
</sect1>
|
||||
@@ -371,15 +371,15 @@ $ pecl install extname-0.1
|
||||
<simpara>
|
||||
A veces, usar el instalador <command>pecl</command> no es una opción.
|
||||
Esto podría deberse a que hay un firewall o porque la extensión que se está
|
||||
instalando no está disponible como un paquete compatible con PECL, como extensiones no lanzadas
|
||||
desde git.
|
||||
Si tal extensión necesita ser construida, se pueden usar las herramientas de construcción de bajo nivel para
|
||||
realizar la construcción manualmente.
|
||||
instalando no está disponible como un paquete compatible con PECL, como extensiones no publicadas
|
||||
de git.
|
||||
Si es necesario compilar dicha extensión, se pueden usar las herramientas de compilación de bajo nivel para
|
||||
realizar la compilación manualmente.
|
||||
</simpara>
|
||||
<simpara>
|
||||
El comando <command>phpize</command> se usa para preparar el entorno de construcción
|
||||
El comando <command>phpize</command> se utiliza para preparar el entorno de compilación
|
||||
para una extensión PHP.
|
||||
En el siguiente ejemplo, los fuentes para una extensión están en un directorio
|
||||
En el siguiente ejemplo, los fuentes de una extensión están en un directorio
|
||||
llamado <filename>extname</filename>:
|
||||
</simpara>
|
||||
<para>
|
||||
@@ -395,18 +395,18 @@ $ make
|
||||
</para>
|
||||
<simpara>
|
||||
Una instalación exitosa habrá creado <filename>extname.so</filename> y
|
||||
lo habrá puesto en el directorio de extensiones PHP
|
||||
lo habrá colocado en el directorio de extensiones de PHP
|
||||
<link linkend="ini.extension-dir">extensions directory</link>.
|
||||
El archivo &php.ini; necesitará ser ajustado, y una
|
||||
El &php.ini; deberá ajustarse y se deberá añadir una
|
||||
línea <literal>extension=extname.so</literal>
|
||||
necesitará ser añadida antes de que la extensión pueda ser usada.
|
||||
antes de que la extensión pueda usarse.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Si el sistema carece del comando <command>phpize</command>, y
|
||||
Si el sistema no tiene el comando <command>phpize</command>, y
|
||||
se usan paquetes precompilados (como RPMs), asegúrese de instalar también la
|
||||
versión de desarrollo adecuada del paquete PHP ya que a menudo incluyen el
|
||||
versión de desarrollo adecuada del paquete PHP, ya que a menudo incluyen el
|
||||
comando <command>phpize</command>
|
||||
junto con los archivos de cabecera adecuados para construir PHP y sus extensiones.
|
||||
junto con los ficheros de cabecera adecuados para compilar PHP y sus extensiones.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Ejecute <command>phpize --help</command> para mostrar información adicional de uso.
|
||||
@@ -420,23 +420,22 @@ $ make
|
||||
|
||||
<para>
|
||||
<command>php-config</command>
|
||||
es un simple script de shell para obtener información sobre la configuración instalada de PHP.
|
||||
es un script de shell simple para obtener información sobre la configuración instalada de PHP.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Cuando las extensiones están siendo compiladas, si hay múltiples versiones de PHP instaladas, la instalación
|
||||
para la cual construir puede ser especificada usando la opción
|
||||
Cuando las extensiones se están compilando, si hay varias versiones de PHP instaladas, la instalación para la cual
|
||||
se va a compilar puede especificarse usando la opción
|
||||
<option role="configure">--with-php-config</option>
|
||||
durante la configuración, estableciendo la ruta del respectivo script
|
||||
durante la configuración, estableciendo la ruta del script respectivo
|
||||
<command>php-config</command>.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
La lista de opciones de línea de comandos proporcionadas por el script
|
||||
La lista de opciones de línea de comandos proporcionadas por el
|
||||
script <command>php-config</command> puede consultarse en cualquier momento ejecutando
|
||||
<command>php-config</command>
|
||||
puede ser consultada en cualquier momento ejecutando
|
||||
<command>php-config</command>
|
||||
con el interruptor <option>-h</option>:
|
||||
con el modificador <option>-h</option>:
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Usage: /usr/local/bin/php-config [OPTION]
|
||||
@@ -469,33 +468,33 @@ Options:
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>--prefix</entry>
|
||||
<entry>Prefijo de directorio donde PHP está instalado, p. ej. /usr/local</entry>
|
||||
<entry>Prefijo del directorio donde está instalado PHP, p. ej. /usr/local</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>--includes</entry>
|
||||
<entry>
|
||||
Lista de opciones <literal>-I</literal> con todos los archivos de inclusión
|
||||
Lista de opciones <literal>-I</literal> con todos los ficheros de inclusión
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>--ldflags</entry>
|
||||
<entry>
|
||||
<literal>LD</literal>
|
||||
flags con los que PHP fue compilado
|
||||
flags con los que se compiló PHP
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>--libs</entry>
|
||||
<entry>Librerías adicionales con las que PHP fue compilado</entry>
|
||||
<entry>Bibliotecas adicionales con las que se compiló PHP</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>--extension-dir</entry>
|
||||
<entry>Directorio donde las extensiones son buscadas por defecto</entry>
|
||||
<entry>Directorio donde se buscan las extensiones por omisión</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>--include-dir</entry>
|
||||
<entry>
|
||||
Prefijo de directorio donde los archivos de cabecera son instalados por defecto
|
||||
Prefijo del directorio donde se instalan los ficheros de cabecera por omisión
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -529,10 +528,10 @@ Options:
|
||||
<sect1 xml:id="install.pecl.static">
|
||||
<title>Compilación de extensiones PECL estáticamente en PHP</title>
|
||||
<simpara>
|
||||
Puede ser necesario construir una extensión PECL estáticamente en el binario PHP.
|
||||
Para hacer esto, el código fuente de la extensión necesitará ser colocado bajo el
|
||||
Puede ser necesario compilar una extensión PECL estáticamente en el binario de PHP.
|
||||
Para hacerlo, el código fuente de la extensión deberá colocarse bajo el
|
||||
directorio <filename>/path/to/php/src/dir/ext/</filename>,
|
||||
y el sistema de construcción de PHP necesitará regenerar su script de configuración.
|
||||
y el sistema de compilación de PHP deberá regenerar su script de configuración.
|
||||
</simpara>
|
||||
<para>
|
||||
<screen>
|
||||
@@ -545,7 +544,7 @@ $ mv extname-x.x.x extname
|
||||
</screen>
|
||||
</para>
|
||||
<simpara>
|
||||
Esto resultará en el siguiente directorio:
|
||||
Esto dará como resultado el siguiente directorio:
|
||||
</simpara>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
@@ -554,7 +553,7 @@ $ mv extname-x.x.x extname
|
||||
</screen>
|
||||
<simpara>
|
||||
Desde aquí, PHP necesita ser forzado a reconstruir el script de configuración, y luego
|
||||
puede ser construido normalmente:
|
||||
puede ser compilado normalmente:
|
||||
</simpara>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
@@ -575,8 +574,8 @@ $ make install
|
||||
y
|
||||
<command>automake</command>
|
||||
<literal>1.4+</literal>.
|
||||
Versiones más nuevas de <command>autoconf</command> pueden funcionar pero no son
|
||||
compatibles.
|
||||
Versiones más recientes de <command>autoconf</command> pueden funcionar pero no están
|
||||
soportadas.
|
||||
</simpara>
|
||||
</note>
|
||||
<simpara>
|
||||
@@ -585,7 +584,7 @@ $ make install
|
||||
o
|
||||
<option role="configure">--with-extname</option>
|
||||
depende de la extensión.
|
||||
Típicamente, una extensión que no requiere librerías externas usa
|
||||
Normalmente, una extensión que no requiere bibliotecas externas usa
|
||||
<option role="configure">--enable</option>.
|
||||
Para estar seguro, ejecute lo siguiente después de <command>buildconf</command>:
|
||||
</simpara>
|
||||
|
||||
37
install/pie.xml
Normal file
37
install/pie.xml
Normal file
@@ -0,0 +1,37 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 3bc709a20a52a12d7e0e4736a8f332517acb199c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<chapter xml:id="install.pie" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" annotations="chunk:false">
|
||||
<title>Instalación de PIE y extensiones de terceros</title>
|
||||
|
||||
<sect1 xml:id="install.pie.intro">
|
||||
<title>Introducción a PIE</title>
|
||||
<simpara>
|
||||
&link.pie; es un instalador para PHP que permite instalar
|
||||
extensiones PHP de terceros, que luego pueden ser fácilmente instaladas y actualizadas.
|
||||
Aprovecha el repositorio de extensiones PHP de
|
||||
<link xlink:href="&url.packagist;">Packagist</link> para encontrar el código fuente
|
||||
para compilar la extensión, o un binario de Windows para descargar, si existe. Si
|
||||
descarga el código fuente, también sabe cómo compilarlo e instalarlo.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Tras <link xlink:href="&url.pie;?tab=readme-ov-file#what-do-i-need-to-get-started">instalar
|
||||
los requisitos y PIE en sí</link>, puede instalar la
|
||||
<link linkend="mongodb.mongodb">extensión MongoDB</link> ejecutando
|
||||
el siguiente comando en la línea de comandos.
|
||||
</simpara>
|
||||
<example>
|
||||
<title>Instalación de la extensión MongoDB con PIE</title>
|
||||
<programlisting role="shell">
|
||||
<![CDATA[
|
||||
pie install mongodb/mongodb-extension
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<simpara>
|
||||
La documentación de <link xlink:href="&url.pie;/blob/main/docs/usage.md">"Uso de PIE"</link>
|
||||
profundiza más en este tema.
|
||||
</simpara>
|
||||
|
||||
</sect1>
|
||||
</chapter>
|
||||
@@ -1,5 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: cb6d65ebe2412bbaef6d1edd076911539f1aceda Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: dd4d6c1217c4bc53eeadc65b5b67bf29ba429993 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
|
||||
<!ENTITY installation.enabled.disable 'Esta extensión está activada por omisión. Puede ser desactivada utilizando la opción de configuración: '>
|
||||
@@ -689,6 +689,10 @@ Se recomienda evitar su uso.</simpara></warning>
|
||||
|
||||
<!ENTITY example.outputs.84.similar '<para xmlns="http://docbook.org/ns/docbook">La salida del ejemplo anterior en PHP 8.4 es similar a :</para>'>
|
||||
|
||||
<!ENTITY example.outputs.85 '<para xmlns="http://docbook.org/ns/docbook">Output of the above example in PHP 8.5:</para>'>
|
||||
|
||||
<!ENTITY example.outputs.85.similar '<para xmlns="http://docbook.org/ns/docbook">Output of the above example in PHP 8.5 is similar to:</para>'>
|
||||
|
||||
<!ENTITY example.outputs.32bit '<para xmlns="http://docbook.org/ns/docbook">Resultado del ejemplo anterior en una máquina de 32 bits :</para>'>
|
||||
|
||||
<!ENTITY example.outputs.64bit '<para xmlns="http://docbook.org/ns/docbook">Resultado del ejemplo anterior en una máquina de 64 bits :</para>'>
|
||||
|
||||
@@ -1,19 +1,17 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 53a400680d0cb2ddabd4493fb9846533c422e90d Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: yes -->
|
||||
|
||||
<!-- EN-Revision: ba7093cf7f30dbcd301c62536ac7ef8664d891f4 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<sect1 xml:id="control-structures.foreach" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<title>foreach</title>
|
||||
<?phpdoc print-version-for="foreach"?>
|
||||
<para>
|
||||
La estructura de lenguaje <literal>foreach</literal> proporciona una forma sencilla de
|
||||
recorrer <type>array</type> y objetos <interfacename>Traversable</interfacename>.
|
||||
La estructura <literal>foreach</literal> proporciona una forma sencilla de
|
||||
iterar sobre <type>array</type>s y objetos <interfacename>Traversable</interfacename>.
|
||||
<literal>foreach</literal> generará un error cuando se utilice con
|
||||
una variable que contenga un tipo de datos diferente o con una variable no inicializada.
|
||||
una variable que contenga un tipo de dato diferente o con una variable no inicializada.
|
||||
<informalexample>
|
||||
<simpara>
|
||||
<literal>foreach</literal> puede eventualmente obtener la <literal>clave</literal> de cada elemento:
|
||||
<literal>foreach</literal> puede obtener opcionalmente la <literal>key</literal> de cada elemento:
|
||||
</simpara>
|
||||
<programlisting>
|
||||
<![CDATA[
|
||||
@@ -29,22 +27,22 @@ foreach (iterable_expression as $key => $value) {
|
||||
</informalexample>
|
||||
</para>
|
||||
<simpara>
|
||||
La primera forma revisa el array
|
||||
La primera forma recorre el iterable dado por
|
||||
<literal>iterable_expression</literal>. En cada iteración, el valor del
|
||||
elemento actual se asigna a <literal>$value</literal>.
|
||||
</simpara>
|
||||
<simpara>
|
||||
La segunda forma asignará además la clave del elemento actual
|
||||
a la variable <literal>$key</literal> en cada iteración.
|
||||
La segunda forma asignará adicionalmente la clave del elemento actual a
|
||||
la variable <literal>$key</literal> en cada iteración.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Es importante señalar que <literal>foreach</literal> no modifica el puntero
|
||||
interno del array, que es utilizado por funciones como
|
||||
<function>current</function> y <function>key</function>.
|
||||
Tenga en cuenta que <literal>foreach</literal> no modifica el puntero interno del array,
|
||||
que es utilizado por funciones como <function>current</function>
|
||||
y <function>key</function>.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Es posible personalizar
|
||||
<link linkend="language.oop5.iterations">la iteración sobre objetos</link>.
|
||||
Es posible
|
||||
<link linkend="language.oop5.iterations">personalizar la iteración de objetos</link>.
|
||||
</simpara>
|
||||
|
||||
<example>
|
||||
@@ -53,28 +51,26 @@ foreach (iterable_expression as $key => $value) {
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
/* Ejemplo: valor únicamente */
|
||||
|
||||
/* Ejemplo: solo valor */
|
||||
$array = [1, 2, 3, 17];
|
||||
|
||||
foreach ($array as $value) {
|
||||
echo "Valor actual de \$array: $value.\n";
|
||||
echo "Elemento actual de \$array: $value.\n";
|
||||
}
|
||||
|
||||
/* Ejemplo: clave y valor */
|
||||
|
||||
$array = [
|
||||
"uno" => 1,
|
||||
"dos" => 2,
|
||||
"tres" => 3,
|
||||
"diecisiete" => 17
|
||||
"one" => 1,
|
||||
"two" => 2,
|
||||
"three" => 3,
|
||||
"seventeen" => 17
|
||||
];
|
||||
|
||||
foreach ($array as $key => $value) {
|
||||
echo "\$array[$key] => $value.\n";
|
||||
echo "Clave: $key => Valor: $value\n";
|
||||
}
|
||||
|
||||
/* Ejemplo: arrays clave-valor multidimensionales */
|
||||
/* Ejemplo: arrays multidimensionales clave-valor */
|
||||
$grid = [];
|
||||
$grid[0][0] = "a";
|
||||
$grid[0][1] = "b";
|
||||
@@ -83,12 +79,11 @@ $grid[1][1] = "z";
|
||||
|
||||
foreach ($grid as $y => $row) {
|
||||
foreach ($row as $x => $value) {
|
||||
echo "Valor en la posición x=$x y y=$y: $value\n";
|
||||
echo "Valor en posición x=$x y y=$y: $value\n";
|
||||
}
|
||||
}
|
||||
|
||||
/* Ejemplo: arrays dinámicos */
|
||||
|
||||
foreach (range(1, 5) as $value) {
|
||||
echo "$value\n";
|
||||
}
|
||||
@@ -98,25 +93,26 @@ foreach (range(1, 5) as $value) {
|
||||
</example>
|
||||
<note>
|
||||
<para>
|
||||
<literal>foreach</literal> no soporta la posibilidad de
|
||||
suprimir los mensajes de error utilizando el
|
||||
<literal>foreach</literal> no admite la capacidad de
|
||||
suprimir mensajes de error utilizando
|
||||
<link linkend="language.operators.errorcontrol"><literal>@</literal></link>.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
<sect2 xml:id="control-structures.foreach.list">
|
||||
<title>Extracción de arrays internos</title>
|
||||
<title>Desempaquetar arrays anidados</title>
|
||||
<?phpdoc print-version-for="foreach.list"?>
|
||||
<para>
|
||||
Es posible iterar sobre un array de arrays y descomponer el array anidado
|
||||
en variables de bucle utilizando la
|
||||
<link linkend="language.types.array.syntax.destructuring">desestructuración de array</link>
|
||||
mediante <literal>[]</literal> o utilizando el constructor de lenguaje <function>list</function> como valor.
|
||||
Es posible iterar sobre un array de arrays y desempaquetar el array anidado
|
||||
en variables de bucle utilizando ya sea
|
||||
<link linkend="language.types.array.syntax.destructuring">destructuración de arrays</link>
|
||||
mediante <literal>[]</literal> o utilizando la estructura de lenguaje
|
||||
<function>list</function> como valor.
|
||||
|
||||
<note>
|
||||
<simpara>
|
||||
Es importante señalar que
|
||||
<link linkend="language.types.array.syntax.destructuring">la desestructuración de array</link>
|
||||
Tenga en cuenta que
|
||||
<link linkend="language.types.array.syntax.destructuring">destructuración de arrays</link>
|
||||
mediante <literal>[]</literal> solo es posible a partir de PHP 7.1.0
|
||||
</simpara>
|
||||
</note>
|
||||
@@ -125,13 +121,13 @@ foreach (range(1, 5) as $value) {
|
||||
<para>
|
||||
<informalexample>
|
||||
<simpara>
|
||||
En los dos ejemplos siguientes, <literal>$a</literal> será definido sobre
|
||||
En ambos ejemplos siguientes, <literal>$a</literal> se establecerá con
|
||||
el primer elemento del array anidado y <literal>$b</literal> contendrá
|
||||
el segundo elemento:
|
||||
</simpara>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
<![CDATA[
|
||||
<?php
|
||||
$array = [
|
||||
[1, 2],
|
||||
[3, 4],
|
||||
@@ -158,16 +154,15 @@ A: 3; B: 4
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Cuando hay menos variables que elementos en el array,
|
||||
Cuando se proporcionan menos variables que elementos en el array,
|
||||
los elementos restantes serán ignorados.
|
||||
De manera similar, los elementos pueden ser ignorados utilizando una coma:
|
||||
|
||||
De manera similar, los elementos pueden omitirse utilizando una coma:
|
||||
<informalexample>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$array = [
|
||||
[1, 2, 3],
|
||||
[1, 2, 5],
|
||||
[3, 4, 6],
|
||||
];
|
||||
|
||||
@@ -177,10 +172,9 @@ foreach ($array as [$a, $b]) {
|
||||
}
|
||||
|
||||
foreach ($array as [, , $c]) {
|
||||
// Ignorar $a y $b
|
||||
// Omitiendo $a y $b
|
||||
echo "$c\n";
|
||||
}
|
||||
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
@@ -197,8 +191,8 @@ foreach ($array as [, , $c]) {
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Se generará una notificación si no hay suficientes elementos en el array
|
||||
para llenar la función <function>list</function>:
|
||||
Se generará un aviso si no hay suficientes elementos en el array para llenar
|
||||
el <function>list</function>:
|
||||
|
||||
<informalexample>
|
||||
<programlisting role="php">
|
||||
@@ -232,9 +226,9 @@ A: 3; B: 4; C:
|
||||
<sect2 xml:id="control-structures.foreach.reference">
|
||||
<title>foreach y referencias</title>
|
||||
<para>
|
||||
Es posible modificar directamente los elementos del array en un bucle precediendo
|
||||
Es posible modificar directamente elementos de array dentro de un bucle precediendo
|
||||
<literal>$value</literal> con <literal>&</literal>.
|
||||
En este caso, el valor será asignado por
|
||||
En ese caso el valor será asignado por
|
||||
<link linkend="language.references">referencia</link>.
|
||||
<informalexample>
|
||||
<programlisting role="php">
|
||||
@@ -244,7 +238,7 @@ $arr = [1, 2, 3, 4];
|
||||
foreach ($arr as &$value) {
|
||||
$value = $value * 2;
|
||||
}
|
||||
// $arr ahora es [2, 4, 6, 8]
|
||||
// $arr es ahora [2, 4, 6, 8]
|
||||
unset($value); // romper la referencia con el último elemento
|
||||
?>
|
||||
]]>
|
||||
@@ -253,10 +247,10 @@ unset($value); // romper la referencia con el último elemento
|
||||
</para>
|
||||
<warning>
|
||||
<simpara>
|
||||
La referencia a <literal>$value</literal> del último elemento del array
|
||||
La referencia a un <literal>$value</literal> del último elemento del array
|
||||
permanece incluso después del bucle <literal>foreach</literal>. Se recomienda
|
||||
destruir estas referencias utilizando <function>unset</function>.
|
||||
De lo contrario, se producirá el siguiente comportamiento:
|
||||
De lo contrario, ocurrirá el siguiente comportamiento:
|
||||
</simpara>
|
||||
<informalexample>
|
||||
<programlisting role="php">
|
||||
@@ -266,16 +260,16 @@ $arr = [1, 2, 3, 4];
|
||||
foreach ($arr as &$value) {
|
||||
$value = $value * 2;
|
||||
}
|
||||
// $arr ahora es [2, 4, 6, 8]
|
||||
// $arr es ahora [2, 4, 6, 8]
|
||||
|
||||
// sin unset($value), $value sigue siendo una referencia al último elemento: $arr[3]
|
||||
// sin un unset($value), $value sigue siendo una referencia al último elemento: $arr[3]
|
||||
|
||||
foreach ($arr as $key => $value) {
|
||||
// $arr[3] será actualizado con cada valor de $arr...
|
||||
// $arr[3] se actualizará con cada valor de $arr...
|
||||
echo "{$key} => {$value} ";
|
||||
print_r($arr);
|
||||
}
|
||||
// ...hasta que finalmente el penúltimo valor sea copiado en el último valor
|
||||
// ...hasta que finalmente el penúltimo valor se copie sobre el último valor
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
@@ -291,7 +285,7 @@ foreach ($arr as $key => $value) {
|
||||
</informalexample>
|
||||
</warning>
|
||||
<example>
|
||||
<title>Iterar sobre los valores de un array constante por referencia</title>
|
||||
<title>Iterar los valores de un array constante por referencia</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
@@ -1,42 +1,40 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 3bc8fc7b9785c335e55d83986e6cd8968498dcfb Maintainer: Marqitos Status: ready -->
|
||||
<!-- EN-Revision: 2e5f2910f3a2a95dcbdaf580ba57a0b60b072c2a Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<chapter xml:id="language.enumerations" xmlns="http://docbook.org/ns/docbook">
|
||||
<title>Enumerations</title>
|
||||
<chapter xml:id="language.enumerations" xmlns="http://docbook.org/ns/docbook">
|
||||
<title>Enumeraciones</title>
|
||||
<sect1 xml:id="language.enumerations.overview">
|
||||
<title>Descripción general de las enumeraciónes</title>
|
||||
<title>Visión general de las enumeraciones</title>
|
||||
<?phpdoc print-version-for="enumerations"?>
|
||||
|
||||
<para>
|
||||
Las enumeraciónes, o "Enums", permiten a un desarrollador definir un tipo personalizado que está limitado a uno
|
||||
Las enumeraciones, o "Enums", permiten a un desarrollador definir un tipo personalizado que se limita a uno
|
||||
de un número discreto de valores posibles. Esto puede ser especialmente útil al definir un
|
||||
modelo de dominio, ya que permite "hacer que los estados inválidos sean irrepresentables".
|
||||
modelo de dominio, ya que permite "hacer que los estados no válidos sean irrepresentables".
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Enums aparecen en muchos lenguajes con una variedad de características diferentes. En PHP,
|
||||
Enums son un tipo especial de objeto. El Enum en sí es una clase, y sus posibles
|
||||
casos son todos una instancia de esa clase. Eso significa que los casos de
|
||||
Enum son objetos válidos y pueden usarse en cualquier lugar donde se pueda usar un objeto, incluidas las comprobaciones de tipo.
|
||||
Las enumeraciones aparecen en muchos lenguajes con una variedad de características diferentes. En PHP,
|
||||
las enumeraciones son un tipo especial de objeto. La enumeración en sí es una clase, y sus posibles
|
||||
casos son todos objetos de instancia única de esa clase. Eso significa que los casos de enumeración son
|
||||
objetos válidos y pueden usarse dondequiera que se pueda usar un objeto, incluyendo comprobaciones de tipo.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
El ejemplo más popular de enumeraciónes es el tipo booleano incorporado, que es un
|
||||
El ejemplo más popular de enumeraciones es el tipo booleano integrado, que es un
|
||||
tipo enumerado con valores legales &true; y &false;.
|
||||
Los Enums permiten a los desarrolladores definir sus propias enumeraciónes arbitrariamente robustas.
|
||||
Las enumeraciones permiten a los desarrolladores definir sus propias enumeraciones arbitrariamente robustas.
|
||||
</para>
|
||||
</sect1>
|
||||
<sect1 xml:id="language.enumerations.basics">
|
||||
<title>Enumeraciónes básicas</title>
|
||||
<title>Enumeraciones básicas</title>
|
||||
|
||||
<para>
|
||||
Enums son similares a las clases, y comparten los mismos espacios de nombres que las clases, interfaces y rasgos (traits).
|
||||
También se pueden cargar automáticamente de la misma manera. Un Enum define un nuevo tipo, que tiene un número fijo
|
||||
y limitado de valores válidos.
|
||||
Las enumeraciones son similares a las clases y comparten los mismos espacios de nombres que las clases,
|
||||
interfaces y traits. También son autocargables de la misma manera. Una enumeración define un nuevo tipo,
|
||||
que tiene un número fijo y limitado de valores legales posibles.
|
||||
</para>
|
||||
|
||||
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -54,9 +52,9 @@ enum Suit
|
||||
|
||||
<para>
|
||||
Esta declaración crea un nuevo tipo enumerado llamado <literal>Suit</literal>, que tiene
|
||||
cuatro y solo cuatro valores válidos: <literal>Suit::Hearts</literal>, <literal>Suit::Diamonds</literal>,
|
||||
<literal>Suit::Clubs</literal> y <literal>Suit::Spades</literal>. Las variables pueden asignarse
|
||||
a uno de esos valores válidos. Una función puede ser comprobada por tipo contra un tipo enumerado,
|
||||
cuatro y solo cuatro valores legales: <literal>Suit::Hearts</literal>, <literal>Suit::Diamonds</literal>,
|
||||
<literal>Suit::Clubs</literal>, y <literal>Suit::Spades</literal>. Las variables pueden ser asignadas
|
||||
a uno de esos valores legales. Una función puede ser comprobada de tipo contra un tipo enumerado,
|
||||
en cuyo caso solo se pueden pasar valores de ese tipo.
|
||||
</para>
|
||||
|
||||
@@ -84,17 +82,17 @@ pick_a_card('Spades');
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Una enumeración puede tener cero o más definiciones de <literal>case</literal>, sin un máximo.
|
||||
Una enumeración de cero casos es sintácticamente válida, aunque bastante inútil.
|
||||
Una enumeración puede tener cero o más definiciones de <literal>case</literal>, sin máximo.
|
||||
Una enumeración sin casos es sintácticamente válida, aunque bastante inútil.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Para casos de enumeración, se aplican las mismas reglas de sintaxis que a cualquier etiqueta en PHP, consulte
|
||||
Para los casos de enumeración, se aplican las mismas reglas sintácticas que a cualquier etiqueta en PHP, ver
|
||||
<link linkend="language.constants">Constantes</link>.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Por omisión, los casos no están intrínsecamente respaldados por un valor escalar. Es decir, <literal>Suit::Hearts</literal>
|
||||
Por omisión, los casos no están respaldados intrínsecamente por un valor escalar. Es decir, <literal>Suit::Hearts</literal>
|
||||
no es igual a <literal>"0"</literal>. En su lugar, cada caso está respaldado por un objeto singleton de ese nombre. Eso significa que:
|
||||
</para>
|
||||
|
||||
@@ -113,24 +111,23 @@ $a instanceof Suit; // true
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Esto también significa que los valores de enumeración nunca son <literal><</literal> o <literal>></literal> entre sí,
|
||||
ya que esas comparaciones no tienen sentido en objetos. Esas comparaciones siempre devolverán
|
||||
También significa que los valores de enumeración nunca son <literal><</literal> o <literal>></literal> entre sí,
|
||||
ya que esas comparaciones no tienen significado en los objetos. Esas comparaciones siempre devolverán
|
||||
&false; al trabajar con valores de enumeración.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Estos tipos de casos, sin datos relacionados, se llaman "Casos Puros". Un Enum que contiene
|
||||
solo Casos Puros se llama un Pure Enum.
|
||||
Este tipo de caso, sin datos relacionados, se denomina "Caso Puro". Una enumeración que contiene
|
||||
solo Casos Puros se denomina Enumeración Pura.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Todos los Casos Puros se implementan como instancias de su tipo de enumeración. El tipo de enumeración
|
||||
se representa internamente como una clase.
|
||||
Todos los Casos Puros se implementan como instancias de su tipo de enumeración. El tipo de enumeración está representado internamente como una clase.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Todos los Casos tienen una propiedad de solo lectura, <literal>name</literal>, que es el nombre
|
||||
con distinción de mayúsculas y minúsculas del caso en sí.
|
||||
Todos los Casos tienen una propiedad de solo lectura, <literal>name</literal>, que es el nombre sensible a mayúsculas y minúsculas
|
||||
del caso en sí.
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -138,31 +135,31 @@ $a instanceof Suit; // true
|
||||
<?php
|
||||
|
||||
print Suit::Spades->name;
|
||||
// Imprime "Spades"
|
||||
// imprime "Spades"
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Esto también hace posible utilizar la función <function>defined</function> y <function>constant</function>
|
||||
para comprobar la existencia o leer un caso de enumeración si el nombre se obtiene dinámicamente.
|
||||
Esto es, sin embargo, desaconsejado, ya que el uso de <link linkend="language.enumerations.backed">Enumeraciónes respaldadas</link>
|
||||
También es posible usar las funciones <function>defined</function> y <function>constant</function>
|
||||
para verificar la existencia o leer un caso de enumeración si el nombre se obtiene dinámicamente.
|
||||
Sin embargo, esto se desaconseja ya que el uso de <link linkend="language.enumerations.backed">Enumeraciones respaldadas</link>
|
||||
debería funcionar para la mayoría de los casos de uso.
|
||||
</para>
|
||||
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.backed">
|
||||
<title>Enumeraciónes respaldadas</title>
|
||||
<title>Enumeraciones respaldadas</title>
|
||||
|
||||
<para>
|
||||
Por omisión, los Casos Enumerados no tienen un equivalente escalar. Son simplemente objetos singleton. Sin embargo,
|
||||
hay muchos casos en los que un Caso Enumerado necesita poder viajar de ida y vuelta a una base de datos o
|
||||
almacenamiento de datos similar, por lo que tener un equivalente escalar (y por lo tanto trivialmente serializable)
|
||||
incorporado definido intrínsecamente es útil.
|
||||
Por omisión, los Casos Enumerados no tienen equivalente escalar. Son simplemente objetos singleton. Sin embargo,
|
||||
hay amplios casos en los que un Caso Enumerado necesita poder hacer un viaje de ida y vuelta a una base de datos o
|
||||
un almacén de datos similar, por lo que tener un equivalente escalar integrado (y por lo tanto trivialmente serializable) definido
|
||||
intrínsecamente es útil.
|
||||
</para>
|
||||
|
||||
<para>Para definir un escalar equivalente para una Enumeración, la sintaxis es la siguiente:</para>
|
||||
<para>Para definir un equivalente escalar para una Enumeración, la sintaxis es la siguiente:</para>
|
||||
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
@@ -180,31 +177,30 @@ enum Suit: string
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Un caso que tiene un equivalente escalar se llama un Caso Respaldado, ya que está "respaldado"
|
||||
por un valor más simple. Una Enumeración que contiene todos los Casos Respaldados se llama una "Enum Respaldada".
|
||||
Una Enum Respaldada solo puede contener Casos Respaldados. Una Enum Pura solo puede contener Casos Puros.
|
||||
Un caso que tiene un equivalente escalar se denomina Caso Respaldado, ya que está "respaldado"
|
||||
por un valor más simple. Una enumeración que contiene todos los Casos Respaldados se denomina "Enumeración Respaldada".
|
||||
Una Enumeración Respaldada solo puede contener Casos Respaldados. Una Enumeración Pura solo puede contener Casos Puros.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Una Enum Respaldada puede estar respaldada por tipos de <literal>int</literal> o <literal>string</literal>,
|
||||
y una enumeración dada solo admite un solo tipo a la vez (es decir, no hay unión de <literal>int|string</literal>).
|
||||
Si una enumeración se marca como teniendo un equivalente escalar, entonces todos los casos deben tener un equivalente escalar único
|
||||
definido explícitamente. No hay equivalentes escalares generados automáticamente
|
||||
(por ejemplo, enteros secuenciales). Los Casos Respaldados deben ser únicos; dos casos de enum respaldados
|
||||
no pueden tener el mismo equivalente escalar. Sin embargo, una constante puede hacer referencia a un caso,
|
||||
creando efectivamente un alias. Consulte <link linkend="language.enumerations.constants">Constantes de enumeración</link>.
|
||||
Una Enumeración Respaldada puede estar respaldada por tipos de <literal>int</literal> o <literal>string</literal>,
|
||||
y una enumeración dada admite solo un tipo a la vez (es decir, no hay unión de <literal>int|string</literal>).
|
||||
Si una enumeración está marcada como que tiene un equivalente escalar, entonces todos los casos deben tener un equivalente
|
||||
escalar único definido explícitamente. No hay equivalentes escalares generados automáticamente
|
||||
(por ejemplo, enteros secuenciales). Los casos respaldados deben ser únicos; dos casos de enumeración respaldados no pueden
|
||||
tener el mismo equivalente escalar. Sin embargo, una constante puede referirse a un caso, creando efectivamente
|
||||
un alias. Ver <link linkend="language.enumerations.constants">Constantes de enumeración</link>.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Los valores equivalentes pueden ser una expresión escalar constante.
|
||||
Antes de PHP 8.2.0, los valores equivalentes debían ser literales o expresiones literales.
|
||||
Esto significa que las constantes y expresiones constantes no eran compatibles.
|
||||
Es decir, <code>1 + 1</code> era aceptable, pero no <code>1 + SOME_CONST</code>
|
||||
no lo es.
|
||||
Esto significa que las constantes y expresiones constantes no estaban admitidas.
|
||||
Es decir, <code>1 + 1</code> estaba permitido, pero <code>1 + SOME_CONST</code> no.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Casos Respaldados tienen una propiedad adicional de solo lectura, <literal>value</literal>, que es el valor
|
||||
Los Casos Respaldados tienen una propiedad adicional de solo lectura, <literal>value</literal>, que es el valor
|
||||
especificado en la definición.
|
||||
</para>
|
||||
|
||||
@@ -220,7 +216,7 @@ print Suit::Clubs->value;
|
||||
|
||||
<para>
|
||||
Para hacer cumplir la propiedad <literal>value</literal> como de solo lectura, una variable no puede
|
||||
asignarse como una referencia a ella. Es decir, lo siguiente arroja un error:
|
||||
ser asignada como referencia a ella. Es decir, lo siguiente genera un error:
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -229,37 +225,38 @@ print Suit::Clubs->value;
|
||||
|
||||
$suit = Suit::Clubs;
|
||||
$ref = &$suit->value;
|
||||
// Error: Cannot acquire reference to property Suit::$value
|
||||
// Error: No se puede obtener una referencia a la propiedad Suit::$value
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Las enumeraciónes respaldadas implementan una interfaz interna <interfacename>BackedEnum</interfacename>,
|
||||
Las enumeraciones respaldadas implementan una interfaz interna <interfacename>BackedEnum</interfacename>,
|
||||
que expone dos métodos adicionales:
|
||||
</para>
|
||||
|
||||
<simplelist>
|
||||
<member>
|
||||
<literal>from(int|string): self</literal> tomará un escalar y devolverá el Caso Enum correspondiente.
|
||||
Si no se encuentra uno, lanzará un <classname>ValueError</classname>. Esto es útil principalmente
|
||||
en casos en los que el escalar de entrada es de confianza y un valor de enumeración faltante debería ser
|
||||
<literal>from(int|string): self</literal> tomará un escalar y devolverá el Caso de Enumeración correspondiente.
|
||||
Si no se encuentra ninguno, lanzará un <classname>ValueError</classname>. Esto es principalmente
|
||||
útil en casos donde el escalar de entrada es confiable y un valor de enumeración faltante debería ser
|
||||
considerado un error que detiene la aplicación.
|
||||
</member>
|
||||
<member>
|
||||
<literal>tryFrom(int|string): ?self</literal> tomará un escalar y devolverá el Caso Enum correspondiente.
|
||||
Si no se encuentra uno, devolverá <literal>null</literal>. Esto es útil principalmente en casos en los que
|
||||
el escalar de entrada no es de confianza y el llamante desea implementar su propia lógica de manejo de errores
|
||||
o de valor predeterminado.
|
||||
<literal>tryFrom(int|string): ?self</literal> tomará un escalar y devolverá el
|
||||
Caso de Enumeración correspondiente. Si no se encuentra ninguno, devolverá <literal>null</literal>.
|
||||
Esto es principalmente útil en casos donde el escalar de entrada no es confiable y el llamador quiere
|
||||
implementar su propia lógica de manejo de errores o valores por omisión.
|
||||
</member>
|
||||
</simplelist>
|
||||
|
||||
<para>
|
||||
Los métodos <literal>from()</literal> y <literal>tryFrom()</literal> siguen las reglas estándar de tipado débil/fuerte.
|
||||
En modo de tipado débil, pasar un entero o una cadena es aceptable y el sistema convertirá el valor en consecuencia.
|
||||
Pasar un flotante también funcionará y se convertirá. En modo de tipado estricto, pasar un entero a <literal>from()</literal> en un
|
||||
enum respaldado por una cadena (o viceversa) resultará en un <classname>TypeError</classname>,
|
||||
al igual que un flotante en todas las circunstancias. Todos los demás tipos de parámetros lanzarán un TypeError
|
||||
Los métodos <literal>from()</literal> y <literal>tryFrom()</literal> siguen las reglas estándar
|
||||
de tipado débil/fuerte. En modo de tipado débil, pasar un entero o string es admisible
|
||||
y el sistema coercionará el valor en consecuencia. Pasar un float también funcionará y será
|
||||
coercionado. En modo de tipado estricto, pasar un entero a <literal>from()</literal> en una
|
||||
enumeración respaldada por string (o viceversa) resultará en un <classname>TypeError</classname>,
|
||||
al igual que un float en todas las circunstancias. Todos los demás tipos de parámetros lanzarán un TypeError
|
||||
en ambos modos.
|
||||
</para>
|
||||
|
||||
@@ -271,27 +268,27 @@ $record = get_stuff_from_database($id);
|
||||
print $record['suit'];
|
||||
|
||||
$suit = Suit::from($record['suit']);
|
||||
// Dato no válido lanzará un ValueError: "X" is not a valid scalar value for enum "Suit"
|
||||
// Datos no válidos lanzan un ValueError: "X" no es un valor escalar válido para la enumeración "Suit"
|
||||
print $suit->value;
|
||||
|
||||
$suit = Suit::tryFrom('A') ?? Suit::Spades;
|
||||
// Dato no válido devolverá null, por lo tanto será usado Suit::Spades en su lugar.
|
||||
// Datos no válidos devuelven null, por lo que se usa Suit::Spades en su lugar.
|
||||
print $suit->value;
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
|
||||
<para>Definir manualmente un método <literal>from()</literal> o <literal>tryFrom()</literal> en un Enum Respaldado devolverá en un error fatal.</para>
|
||||
<para>Definir manualmente un método <literal>from()</literal> o <literal>tryFrom()</literal> en una Enumeración Respaldada resultará en un error fatal.</para>
|
||||
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.methods">
|
||||
<title>Métodos de enumeraciónes</title>
|
||||
<title>Métodos de enumeración</title>
|
||||
|
||||
<para>
|
||||
Enums (tanto Enums Puros como Enums Respaldados) pueden contener métodos, y pueden implementar interfaces.
|
||||
Si un Enum implementa una interfaz, entonces cualquier comprobación de tipo para esa interfaz también aceptará
|
||||
todos los casos de ese Enum.
|
||||
Las enumeraciones (tanto Enumeraciones Puras como Enumeraciones Respaldadas) pueden contener métodos y pueden implementar interfaces.
|
||||
Si una enumeración implementa una interfaz, entonces cualquier comprobación de tipo para esa interfaz también aceptará
|
||||
todos los casos de esa enumeración.
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -310,7 +307,7 @@ enum Suit implements Colorful
|
||||
case Clubs;
|
||||
case Spades;
|
||||
|
||||
// Rellenando el contrato de la interface.
|
||||
// Cumple con el contrato de la interfaz.
|
||||
public function color(): string
|
||||
{
|
||||
return match($this) {
|
||||
@@ -319,7 +316,7 @@ enum Suit implements Colorful
|
||||
};
|
||||
}
|
||||
|
||||
// No es parte de una interfaz; eso está bien.
|
||||
// No forma parte de una interfaz; eso está bien.
|
||||
public function shape(): string
|
||||
{
|
||||
return "Rectangle";
|
||||
@@ -333,19 +330,19 @@ function paint(Colorful $c)
|
||||
|
||||
paint(Suit::Clubs); // Funciona
|
||||
|
||||
print Suit::Diamonds->shape(); // Imprime "Rectangle"
|
||||
print Suit::Diamonds->shape(); // imprime "Rectangle"
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
En este ejemplo, las cuatro instancias de <literal>Suit</literal> tienen dos métodos,
|
||||
<literal>color()</literal> y <literal>shape()</literal>. En lo que respecta al código de llamada
|
||||
y a las comprobaciones de tipo, se comportan exactamente igual que cualquier otra instancia de objeto.
|
||||
<literal>color()</literal> y <literal>shape()</literal>. En cuanto al código de llamada
|
||||
y las comprobaciones de tipo, se comportan exactamente igual que cualquier otra instancia de objeto.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
En un Enum Respaldado, la declaración de interfaz va después de la declaración del tipo de respaldo.
|
||||
En una Enumeración Respaldada, la declaración de interfaz va después de la declaración del tipo de respaldo.
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -364,7 +361,7 @@ enum Suit: string implements Colorful
|
||||
case Clubs = 'C';
|
||||
case Spades = 'S';
|
||||
|
||||
// Rellenando el contrato de la interface.
|
||||
// Cumple con el contrato de la interfaz.
|
||||
public function color(): string
|
||||
{
|
||||
return match($this) {
|
||||
@@ -378,18 +375,18 @@ enum Suit: string implements Colorful
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Dentro de un método, la variable <literal>$this</literal> está definida y se refiere a la instancia de Caso.
|
||||
Dentro de un método, la variable <literal>$this</literal> está definida y se refiere a la instancia del Caso.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Los métodos pueden ser arbitrariamente complejos, pero en la práctica generalmente devolverán un valor estático o
|
||||
Los métodos pueden ser arbitrariamente complejos, pero en la práctica suelen devolver un valor estático o
|
||||
&match; en <literal>$this</literal> para proporcionar
|
||||
diferentes resultados para diferentes casos.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Tenga en cuenta que en este caso sería una mejor práctica de modelado de datos definir también un
|
||||
Tipo Enum <literal>SuitColor</literal> con valores Rojo y Negro y devolver eso en su lugar.
|
||||
Tenga en cuenta que en este caso sería una mejor práctica de modelado de datos también definir un
|
||||
tipo de enumeración <literal>SuitColor</literal> con valores Red y Black y devolver eso en su lugar.
|
||||
Sin embargo, eso complicaría este ejemplo.
|
||||
</para>
|
||||
|
||||
@@ -431,8 +428,8 @@ final class Suit implements UnitEnum, Colorful
|
||||
|
||||
public static function cases(): array
|
||||
{
|
||||
// Método no válido, porque definir manualmente un método cases() en un Enum está prohibido.
|
||||
// Vea también la sección "Listado de valores".
|
||||
// Método ilegal, porque definir manualmente un método cases() en una Enumeración no está permitido.
|
||||
// Ver también la sección "Listado de valores".
|
||||
}
|
||||
}
|
||||
?>
|
||||
@@ -440,17 +437,17 @@ final class Suit implements UnitEnum, Colorful
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Los métodos pueden ser public, privados o protegidos, aunque en la práctica privado y
|
||||
protegido son equivalentes ya que no se permite la herencia.
|
||||
Los métodos pueden ser públicos, privados o protegidos, aunque en la práctica privado y
|
||||
protegido son equivalentes ya que la herencia no está permitida.
|
||||
</para>
|
||||
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.static-methods">
|
||||
<title>Métodos estáticos de enumeraciónes</title>
|
||||
<title>Métodos estáticos de enumeración</title>
|
||||
|
||||
<para>
|
||||
Las enumeraciónes también pueden tener métodos estáticos. El uso de métodos estáticos en la
|
||||
Las enumeraciones también pueden tener métodos estáticos. El uso de métodos estáticos en la
|
||||
enumeración en sí es principalmente para constructores alternativos. Por ejemplo:
|
||||
</para>
|
||||
|
||||
@@ -479,20 +476,20 @@ enum Size
|
||||
|
||||
<para>
|
||||
Los métodos estáticos pueden ser públicos, privados o protegidos, aunque en la práctica privado
|
||||
y protegido son equivalentes ya que no se permite la herencia.
|
||||
y protegido son equivalentes ya que la herencia no está permitida.
|
||||
</para>
|
||||
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.constants">
|
||||
<title>Enumeraciónes constantes</title>
|
||||
<title>Constantes de enumeración</title>
|
||||
|
||||
<para>
|
||||
Enumeraciónes pueden incluir constantes, que pueden ser públicas, privadas o protegidas,
|
||||
aunque en la práctica privado y protegido son equivalentes ya que no se permite la herencia.
|
||||
Las enumeraciones pueden incluir constantes, que pueden ser públicas, privadas o protegidas,
|
||||
aunque en la práctica privada y protegida son equivalentes ya que la herencia no está permitida.
|
||||
</para>
|
||||
|
||||
<para>Una constante puede referirse a un caso de enumeración:</para>
|
||||
<para>Una constante de enumeración puede referirse a un caso de enumeración:</para>
|
||||
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
@@ -512,12 +509,11 @@ enum Size
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.traits">
|
||||
<title>Rasgos (Traits)</title>
|
||||
<title>Traits</title>
|
||||
|
||||
<para>Las enumeraciónes pueden aprovechar los rasgos, que se comportarán igual que en las clases.
|
||||
La advertencia es que los rasgos <literal>use</literal> (usados) en una enumeración no deben contener propiedades.
|
||||
Solo pueden incluir métodos, métodos estáticos y constantes. Un rasgo con propiedades resultará en
|
||||
un error fatal.
|
||||
<para>Las enumeraciones pueden aprovechar los traits, que se comportarán igual que en las clases.
|
||||
La salvedad es que los traits <literal>use</literal>ados en una enumeración no deben contener propiedades.
|
||||
Solo pueden incluir métodos, métodos estáticos y constantes. Un trait con propiedades resultará en un error fatal.
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -562,24 +558,24 @@ enum Suit implements Colorful
|
||||
<title>Valores de enumeración en expresiones constantes</title>
|
||||
|
||||
<para>
|
||||
Por que los casos son representados como constantes en la enumeración misma, pueden ser usados como valores
|
||||
estáticos en la mayoría de las expresiones constantes: valores predeterminados de propiedades, valores predeterminados de variables estáticas,
|
||||
valores predeterminados de parámetros, valores constantes globales y de clase. No pueden ser usados en otros valores de casos de enumeración,
|
||||
Debido a que los casos están representados como constantes en la enumeración en sí, pueden usarse como valores estáticos
|
||||
en la mayoría de las expresiones constantes: valores por omisión de propiedades, valores por omisión de variables estáticas,
|
||||
valores por omisión de parámetros, valores de constantes globales y de clase. No pueden usarse en otros valores de casos de enumeración,
|
||||
pero las constantes normales pueden referirse a un caso de enumeración.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Sin embargo, las llamadas a métodos mágicos implícitos como <classname>ArrayAccess</classname> en enumeraciones no están permitidas en definiciones estáticas
|
||||
o constantes ya que no podemos garantizar absolutamente que el valor resultante sea determinista
|
||||
o que la invocación del método esté libre de efectos secundarios. Llamadas a funciones, llamadas a métodos y
|
||||
acceso a propiedades siguen siendo operaciones no válidas en expresiones constantes.
|
||||
Sin embargo, las llamadas implícitas a métodos mágicos como <classname>ArrayAccess</classname> en enumeraciones no están permitidas
|
||||
en definiciones estáticas o constantes, ya que no podemos garantizar absolutamente que el valor resultante sea determinista
|
||||
o que la invocación del método esté libre de efectos secundarios. Las llamadas a funciones, llamadas a métodos y
|
||||
el acceso a propiedades continúan siendo operaciones no válidas en expresiones constantes.
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
// Esta es una definición de Enum completamente válida.
|
||||
// Esta es una definición de Enumeración completamente legal.
|
||||
enum Direction implements ArrayAccess
|
||||
{
|
||||
case Up;
|
||||
@@ -613,10 +609,10 @@ class Foo
|
||||
|
||||
// Esto no está permitido, ya que puede no ser determinista.
|
||||
const UP = Direction::Up['short'];
|
||||
// Fatal error: Cannot use [] on enums in constant expression
|
||||
// Error fatal: No se puede usar [] en enumeraciones en expresión constante
|
||||
}
|
||||
|
||||
// Esto es completamente válido, ya que no es una expresión constante.
|
||||
// Esto es completamente legal, porque no es una expresión constante.
|
||||
$x = Direction::Up['short'];
|
||||
var_dump("\$x is " . var_export($x, true));
|
||||
|
||||
@@ -627,50 +623,51 @@ $foo = new Foo();
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.object-differences">
|
||||
<title>Difencias de objetos</title>
|
||||
<title>Diferencias con los objetos</title>
|
||||
|
||||
<para>
|
||||
Aunque las enumeraciónes están construidas sobre clases y objetos, no admiten toda la funcionalidad relacionada con objetos.
|
||||
En particular, los casos de Enum tienen prohibido tener estado.
|
||||
Aunque las enumeraciones están construidas sobre clases y objetos, no admiten toda la funcionalidad relacionada con objetos.
|
||||
En particular, los casos de enumeración tienen prohibido tener estado.
|
||||
</para>
|
||||
|
||||
<simplelist>
|
||||
<member>Constructores y Destructores están prohibidos.</member>
|
||||
<member>No soporta herencia. Las enumeraciónes no pueden heredarse ni ser heredadas.</member>
|
||||
<member>Propiedades estáticas o de objeto no están permitidas.</member>
|
||||
<member>Clonar un caso de Enum no está soportado, ya que los casos deben ser instancias singleton.</member>
|
||||
<member><link linkend="language.oop5.magic">Métodos mágicos</link>, excepto los listados a continuación, están prohibidos.</member>
|
||||
<member>Las enumeraciónes deben declararse siempre antes de ser usadas.</member>
|
||||
<member>Los constructores y destructores están prohibidos.</member>
|
||||
<member>La herencia no está admitida. Las enumeraciones no pueden extender ni ser extendidas.</member>
|
||||
<member>No se permiten propiedades estáticas u objetuales.</member>
|
||||
<member>Clonar un caso de enumeración no está admitido, ya que los casos deben ser instancias singleton.</member>
|
||||
<member><link linkend="language.oop5.magic">Métodos mágicos</link>, excepto los listados a continuación, no están permitidos.</member>
|
||||
<member>Las enumeraciones siempre deben declararse antes de ser usadas.</member>
|
||||
</simplelist>
|
||||
|
||||
<para>Las siguientes funcionalidades de objetos están disponibles y se comportan igual que en cualquier otro objeto:</para>
|
||||
<para>La siguiente funcionalidad de objetos está disponible y se comporta igual que en cualquier otro objeto:</para>
|
||||
|
||||
<simplelist>
|
||||
<member>Métodos públicos, privados y protegidos.</member>
|
||||
<member>Métodos estáticos públicos, privados y protegidos.</member>
|
||||
<member>Constantes públicas, privadas y protegidas.</member>
|
||||
<member>Las enumeraciónes pueden implementar cualquier número de interfaces.</member>
|
||||
<member>Las enumeraciones pueden implementar cualquier número de interfaces.</member>
|
||||
<member>
|
||||
<link linkend="language.attributes">Atributos</link> pueden ser adjuntados a enumeraciónes y casos.
|
||||
El filtro de destino <constant>TARGET_CLASS</constant> incluye las enumeraciónes en sí.
|
||||
El filtro de destino <constant>TARGET_CLASS_CONST</constant> incluye los Casos de Enum.
|
||||
Las enumeraciones y los casos pueden tener <link linkend="language.attributes">atributos</link>
|
||||
adjuntos a ellos. El filtro de destino <constant>TARGET_CLASS</constant>
|
||||
incluye las enumeraciones en sí. El filtro de destino <constant>TARGET_CLASS_CONST</constant>
|
||||
incluye los Casos de Enumeración.
|
||||
</member>
|
||||
<member>
|
||||
Los métodos mágicos <link linkend="object.call">__call</link>, <link linkend="object.callstatic">__callStatic</link>,
|
||||
e <link linkend="object.invoke">__invoke</link>.
|
||||
<link linkend="object.call">__call</link>, <link linkend="object.callstatic">__callStatic</link>,
|
||||
y <link linkend="object.invoke">__invoke</link> métodos mágicos
|
||||
</member>
|
||||
<member>Las constantes <constant>__CLASS__</constant> y <constant>__FUNCTION__</constant> se comportan como normalmente.</member>
|
||||
<member>Las constantes <constant>__CLASS__</constant> y <constant>__FUNCTION__</constant> se comportan normalmente</member>
|
||||
</simplelist>
|
||||
|
||||
<para>
|
||||
El literal <literal>::class</literal> mágico en un tipo Enum se evalúa al nombre del tipo
|
||||
incluyendo cualquier espacio de nombres, exactamente igual que un objeto. El literal <literal>::class</literal>
|
||||
mágico en una instancia de Caso también se evalúa al tipo Enum, ya que es una
|
||||
La constante mágica <literal>::class</literal> en un tipo de enumeración se evalúa al nombre
|
||||
del tipo incluyendo cualquier espacio de nombres, exactamente igual que un objeto. La constante mágica <literal>::class</literal>
|
||||
en una instancia de Caso también se evalúa al tipo de enumeración, ya que es una
|
||||
instancia de ese tipo.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Además, los casos de Enum no pueden ser instanciados directamente con <literal>new</literal>, ni con
|
||||
Además, los casos de enumeración no pueden ser instanciados directamente con <literal>new</literal>, ni con
|
||||
<methodname>ReflectionClass::newInstanceWithoutConstructor</methodname> en reflexión. Ambos resultarán en un error.
|
||||
</para>
|
||||
|
||||
@@ -679,22 +676,22 @@ $foo = new Foo();
|
||||
<?php
|
||||
|
||||
$clovers = new Suit();
|
||||
// Error: Cannot instantiate enum Suit
|
||||
// Error: No se puede instanciar la enumeración Suit
|
||||
|
||||
$horseshoes = (new ReflectionClass(Suit::class))->newInstanceWithoutConstructor()
|
||||
// Error: Cannot instantiate enum Suit
|
||||
// Error: No se puede instanciar la enumeración Suit
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.listing">
|
||||
<title>Listando valores</title>
|
||||
<title>Listado de valores</title>
|
||||
|
||||
<para>
|
||||
Tanto los Enums Puros como los Enums Respaldados implementan una interfaz interna llamada
|
||||
Tanto las Enumeraciones Puras como las Enumeraciones Respaldadas implementan una interfaz interna llamada
|
||||
<interfacename>UnitEnum</interfacename>. <literal>UnitEnum</literal> incluye un método estático
|
||||
<literal>cases()</literal>. <literal>cases()</literal> devuelve un array empaquetado de
|
||||
<literal>cases()</literal>. <literal>cases()</literal> devuelve un array compacto de
|
||||
todos los Casos definidos en el orden de declaración.
|
||||
</para>
|
||||
|
||||
@@ -703,21 +700,21 @@ $horseshoes = (new ReflectionClass(Suit::class))->newInstanceWithoutConstructor(
|
||||
<?php
|
||||
|
||||
Suit::cases();
|
||||
// Devuelve: [Suit::Hearts, Suit::Diamonds, Suit::Clubs, Suit::Spades]
|
||||
// Produce: [Suit::Hearts, Suit::Diamonds, Suit::Clubs, Suit::Spades]
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
|
||||
<para>Definiar manualmente el método <literal>cases()</literal> en una enumeración causará en un error fatal.</para>
|
||||
<para>Definir manualmente un método <literal>cases()</literal> en una Enumeración resultará en un error fatal.</para>
|
||||
</sect1>
|
||||
|
||||
<sect1 xml:id="language.enumerations.serialization">
|
||||
<title>Serialización</title>
|
||||
|
||||
<para>
|
||||
Las enumeraciónes se serializan de manera diferente a los objetos. Específicamente, tienen un nuevo código de serialización,
|
||||
<literal>"E"</literal>, que especifica el nombre del caso de la enumeración. El rutina de deserialización es capaz de
|
||||
usar eso para establecer una variable en el valor singleton existente. Eso asegura que:
|
||||
Las enumeraciones se serializan de manera diferente a los objetos. Específicamente, tienen un nuevo código de serialización,
|
||||
<literal>"E"</literal>, que especifica el nombre del caso de enumeración. La rutina de deserialización puede entonces
|
||||
usar eso para establecer una variable al valor singleton existente. Eso asegura que:
|
||||
</para>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -733,19 +730,18 @@ print serialize(Suit::Hearts);
|
||||
</programlisting>
|
||||
|
||||
<para>
|
||||
Durante la deserialización, si no se puede encontrar un caso de enumeración que coincida con un valor serializado,
|
||||
Al deserializar, si no se puede encontrar una enumeración y un caso para coincidir con un valor serializado,
|
||||
se emitirá una advertencia y se devolverá &false;.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Si un Enum Puro se serializa a JSON, se lanzará un error. Si un Enum Respaldado
|
||||
se serializa a JSON, se representará solo por su valor escalar, en el
|
||||
tipo apropiado. El comportamiento de ambos puede ser anulado implementando
|
||||
Si una Enumeración Pura se serializa a JSON, se lanzará un error. Si una Enumeración Respaldada
|
||||
se serializa a JSON, estará representada solo por su valor escalar, en el
|
||||
tipo apropiado. El comportamiento de ambas puede ser sobrescrito implementando
|
||||
<classname>JsonSerializable</classname>.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Para <function>print_r</function>, la salida de un caso de enumeración es ligeramente diferente
|
||||
<para>Para <function>print_r</function>, la salida de un caso de enumeración es ligeramente diferente
|
||||
de los objetos para minimizar la confusión.
|
||||
</para>
|
||||
|
||||
@@ -764,7 +760,7 @@ enum Baz: int {
|
||||
print_r(Foo::Bar);
|
||||
print_r(Baz::Beep);
|
||||
|
||||
/* Imprime:
|
||||
/* Produce
|
||||
|
||||
Foo Enum (
|
||||
[name] => Bar
|
||||
@@ -781,7 +777,7 @@ Baz Enum:int {
|
||||
|
||||
<sect1 xml:id="language.enumerations.object-differences.inheritance">
|
||||
|
||||
<title>Porque las enumeraciónes no pueden ser heredadas</title>
|
||||
<title>Por qué las enumeraciones no son extensibles</title>
|
||||
|
||||
<simpara>
|
||||
Las clases tienen contratos en sus métodos:
|
||||
@@ -805,12 +801,12 @@ function bar(B $b) {
|
||||
|
||||
<simpara>
|
||||
Este código es seguro en cuanto a tipos, ya que B sigue el contrato de A, y a través de la magia de
|
||||
co/contra-varianza, cualquier expectativa que uno pueda tener de los métodos
|
||||
se mantendrá, expecto excepciones.
|
||||
la co/contravariancia, cualquier expectativa que uno pueda tener de los métodos será
|
||||
preservada, exceptuando las excepciones.
|
||||
</simpara>
|
||||
|
||||
<simpara>
|
||||
Enums tienen contratos en sus casos, no en sus métodos:
|
||||
Las enumeraciones tienen contratos en sus casos, no en sus métodos:
|
||||
</simpara>
|
||||
|
||||
<programlisting role="php">
|
||||
@@ -823,7 +819,7 @@ enum ErrorCode {
|
||||
|
||||
function quux(ErrorCode $errorCode)
|
||||
{
|
||||
// Cuando escribimos, este código parece cubrir todos los casos
|
||||
// Cuando se escribe, este código parece cubrir todos los casos
|
||||
match ($errorCode) {
|
||||
ErrorCode::SOMETHING_BROKE => true,
|
||||
};
|
||||
@@ -839,16 +835,15 @@ function quux(ErrorCode $errorCode)
|
||||
</simpara>
|
||||
|
||||
<simpara>
|
||||
But imagine it was allowed to extend enums:
|
||||
Pero imagina que estuviera permitido extender enumeraciones:
|
||||
</simpara>
|
||||
|
||||
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
// Código de experimento mental donde las enumeraciones no son finales.
|
||||
// Nota, esto no funcionará realmente en PHP.
|
||||
// Nota: esto no funcionará realmente en PHP.
|
||||
enum MoreErrorCode extends ErrorCode {
|
||||
case PEBKAC;
|
||||
}
|
||||
@@ -864,17 +859,17 @@ fot(MoreErrorCode::PEBKAC);
|
||||
</programlisting>
|
||||
|
||||
<simpara>
|
||||
Bajo reglas de herencia normales, una clase que extiende otra pasará
|
||||
Bajo las reglas normales de herencia, una clase que extiende a otra pasará
|
||||
la comprobación de tipo.
|
||||
</simpara>
|
||||
|
||||
<simpara>
|
||||
El problema sería que la sentencia &match; en <code>quux()</code> ya no cubre todos
|
||||
los casos. Porque no sabe sobre <code>MoreErrorCode::PEBKAC</code> la sentencia &match; lanzará una excepción.
|
||||
El problema sería que la sentencia &match; en <code>quux()</code> ya no cubriría todos
|
||||
los casos. Debido a que no sabe acerca de <code>MoreErrorCode::PEBKAC</code>, el match lanzará una excepción.
|
||||
</simpara>
|
||||
|
||||
<simpara>
|
||||
Por esta razón, las enumeraciónes son finales y no pueden ser extendidas.
|
||||
Debido a esto, las enumeraciones son finales y no pueden ser extendidas.
|
||||
</simpara>
|
||||
</sect1>
|
||||
|
||||
@@ -902,10 +897,10 @@ function query($fields, $filter, SortOrder $order = SortOrder::Asc)
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
La función <literal>query()</literal> acepta un parámetro <literal>$order</literal> que
|
||||
debe ser de tipo <literal>SortOrder</literal> que garantiza que solo puede ser <literal>SortOrder::Asc</literal>
|
||||
o <literal>SortOrder::Desc</literal>. Cualquier otro valor resultará en un
|
||||
<classname>TypeError</classname>, por lo que no se necesita más comprobación o prueba de errores.
|
||||
La función <literal>query()</literal> ahora puede proceder con la seguridad de que
|
||||
<literal>$order</literal> está garantizado que sea <literal>SortOrder::Asc</literal>
|
||||
o <literal>SortOrder::Desc</literal>. Cualquier otro valor habría resultado en un
|
||||
<classname>TypeError</classname>, por lo que no se necesita ninguna comprobación o prueba de errores adicional.
|
||||
</para>
|
||||
</example>
|
||||
</para>
|
||||
@@ -943,13 +938,13 @@ enum UserStatus: string
|
||||
<para>
|
||||
En este ejemplo, el estado de un usuario puede ser uno de, y exclusivamente, <literal>UserStatus::Pending</literal>,
|
||||
<literal>UserStatus::Active</literal>, <literal>UserStatus::Suspended</literal>, o
|
||||
<literal>UserStatus::CanceledByUser</literal>. Una función puede tipar un parámetro con
|
||||
<literal>UserStatus::CanceledByUser</literal>. Una función puede tipar un parámetro contra
|
||||
<literal>UserStatus</literal> y luego solo aceptar esos cuatro valores, punto.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Todos los valores tienen un método <literal>label()</literal>, que devuelve una cadena legible por humanos.
|
||||
Esa cadena es independiente de la cadena equivalente escalar "nombre de máquina", que se puede usar en,
|
||||
Los cuatro valores tienen un método <literal>label()</literal>, que devuelve un string legible por humanos.
|
||||
Ese string es independiente del string equivalente escalar de "nombre de máquina", que puede usarse en,
|
||||
por ejemplo, un campo de base de datos o un cuadro de selección HTML.
|
||||
</para>
|
||||
|
||||
@@ -968,7 +963,7 @@ foreach (UserStatus::cases() as $case) {
|
||||
|
||||
</sect1>
|
||||
|
||||
</chapter>
|
||||
</chapter>
|
||||
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: e8600fec147c06a6f4dcfb02f0f0e95b2f89d1e3 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: eaec4ab10a65c4515ee2fb899d06e89bae3754b0 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<sect1 xml:id="language.types.array">
|
||||
<title>Arrays</title>
|
||||
@@ -10,8 +10,8 @@
|
||||
está optimizado para varios usos diferentes; puede ser tratado como un array,
|
||||
lista (vector), tabla hash (una implementación de un mapa), diccionario,
|
||||
colección, pila, cola, y probablemente más. Como los valores <type>array</type> pueden
|
||||
ser otros <type>array</type>s, árboles y arrays <type>array</type>s
|
||||
multidimensionales también son posibles.
|
||||
ser otros <type>array</type>s, también son posibles árboles y <type>array</type>s
|
||||
multidimensionales.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
@@ -27,9 +27,9 @@
|
||||
<title>Especificación con <function>array</function></title>
|
||||
|
||||
<para>
|
||||
Un <type>array</type> puede ser creado usando la construcción de lenguaje <function>array</function>. Toma cualquier número de pares
|
||||
<literal><replaceable>clave</replaceable> => <replaceable>valor</replaceable></literal> separados por comas
|
||||
como argumentos.
|
||||
Un <type>array</type> puede ser creado usando la construcción del lenguaje <function>array</function>.
|
||||
Acepta cualquier número de pares <literal><replaceable>clave</replaceable> => <replaceable>valor</replaceable></literal>
|
||||
separados por comas como argumentos.
|
||||
</para>
|
||||
|
||||
<synopsis>
|
||||
@@ -42,7 +42,7 @@ array(
|
||||
<!-- Do not fix the whitespace for the synopsis end element. A limitation of PhD prevents proper trimming -->
|
||||
|
||||
<para>
|
||||
La coma después del último elemento del array es opcional y puede ser omitida. Esto se hace usualmente
|
||||
La coma después del último elemento del array es opcional y puede ser omitida. Esto se suele hacer
|
||||
para arrays de una sola línea, es decir, <literal>array(1, 2)</literal> es preferido sobre
|
||||
<literal>array(1, 2, )</literal>. Para arrays de múltiples líneas, por otro lado, la coma final
|
||||
es comúnmente usada, ya que permite una adición más fácil de nuevos elementos al final.
|
||||
@@ -84,32 +84,33 @@ var_dump($array1, $array2);
|
||||
</para>
|
||||
|
||||
<para xml:id="language.types.array.key-casts">
|
||||
Además, las siguientes conversiones de <replaceable>clave</replaceable> ocurrirán:
|
||||
Además, se producirán las siguientes conversiones de <replaceable>clave</replaceable>:
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<simpara>
|
||||
<type>String</type>s que contienen <type>int</type>s decimales válidos, a menos que el número esté precedido por un signo <literal>+</literal>, serán convertidos al
|
||||
tipo <type>int</type>. Por ejemplo, la clave <literal>"8"</literal> será almacenada bajo <literal>8</literal>. Por otro lado, <literal>"08"</literal> no
|
||||
tipo <type>int</type>. Por ejemplo, la clave <literal>"8"</literal> se almacenará realmente bajo <literal>8</literal>. Por otro lado, <literal>"08"</literal> no
|
||||
será convertido, ya que no es un entero decimal válido.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Los <type>float</type>s también son convertidos a <type>int</type>s, lo que significa que la
|
||||
parte fraccional será truncada. Por ejemplo, la clave <literal>8.7</literal> será almacenada bajo <literal>8</literal>.
|
||||
Los <type>float</type>s también se convierten a <type>int</type>s, lo que significa que la
|
||||
parte fraccionaria será truncada. Por ejemplo, la clave <literal>8.7</literal> se almacenará realmente bajo
|
||||
<literal>8</literal>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Los <type>bool</type>s son convertidos a <type>int</type>s también, es decir, la clave
|
||||
&true; será almacenada bajo <literal>1</literal>
|
||||
Los <type>bool</type>s se convierten a <type>int</type>s también, es decir, la clave
|
||||
&true; se almacenará realmente bajo <literal>1</literal>
|
||||
y la clave &false; bajo <literal>0</literal>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
<type>Null</type> será convertido a una cadena vacía, es decir, la clave
|
||||
<literal>null</literal> será almacenada bajo <literal>""</literal>.
|
||||
<type>Null</type> se convertirá en una cadena vacía, es decir, la clave
|
||||
<literal>null</literal> se almacenará realmente bajo <literal>""</literal>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
@@ -122,8 +123,8 @@ var_dump($array1, $array2);
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Si múltiples elementos en la declaración del array usan la misma clave, solo el último será
|
||||
usado ya que todos los demás son sobrescritos.
|
||||
Si múltiples elementos en la declaración del array usan la misma clave, solo el último
|
||||
será usado, ya que todos los demás son sobrescritos.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
@@ -151,7 +152,7 @@ array(1) {
|
||||
]]>
|
||||
</screen>
|
||||
<para>
|
||||
Como todas las claves en el ejemplo anterior son convertidas a <literal>1</literal>, el valor será sobrescrito
|
||||
Como todas las claves en el ejemplo anterior se convierten a <literal>1</literal>, el valor será sobrescrito
|
||||
en cada nuevo elemento y el último valor asignado <literal>"d"</literal> es el único que queda.
|
||||
</para>
|
||||
</example>
|
||||
@@ -260,7 +261,7 @@ array(4) {
|
||||
]]>
|
||||
</screen>
|
||||
<para>
|
||||
Como puede ver, el último valor <literal>"d"</literal> fue asignado con la clave
|
||||
Como puede ver, el último valor <literal>"d"</literal> fue asignado a la clave
|
||||
<literal>7</literal>. Esto es porque la clave entera más grande antes de eso
|
||||
era <literal>6</literal>.
|
||||
</para>
|
||||
@@ -280,13 +281,13 @@ $array = array(
|
||||
'1' => 'b', // el valor "a" será sobrescrito por "b"
|
||||
1.5 => 'c', // el valor "b" será sobrescrito por "c"
|
||||
-1 => 'd',
|
||||
'01' => 'e', // como esto no es una cadena entera, NO sobrescribirá la clave para 1
|
||||
'1.5' => 'f', // como esto no es una cadena entera, NO sobrescribirá la clave para 1
|
||||
'01' => 'e', // como esto no es una cadena entera no sobrescribirá la clave para 1
|
||||
'1.5' => 'f', // como esto no es una cadena entera no sobrescribirá la clave para 1
|
||||
true => 'g', // el valor "c" será sobrescrito por "g"
|
||||
false => 'h',
|
||||
'' => 'i',
|
||||
null => 'j', // el valor "i" será sobrescrito por "j"
|
||||
'k', // el valor "k" es asignado con la clave 2. Esto es porque la clave entera más grande antes de eso era 1
|
||||
'k', // el valor "k" se asigna a la clave 2. Esto es porque la clave entera más grande antes de eso era 1
|
||||
2 => 'l', // el valor "k" será sobrescrito por "l"
|
||||
);
|
||||
|
||||
@@ -350,8 +351,7 @@ array(2) {
|
||||
<warning>
|
||||
<simpara>
|
||||
Antes de PHP 8.3.0, asignar una clave entera negativa <literal>n</literal> asignaría
|
||||
la siguiente clave a <literal>0</literal>, el ejemplo anterior produciría
|
||||
por lo tanto:
|
||||
la siguiente clave a <literal>0</literal>, el ejemplo anterior produciría por lo tanto:
|
||||
</simpara>
|
||||
<informalexample>
|
||||
<screen>
|
||||
@@ -370,14 +370,14 @@ array(2) {
|
||||
</sect3>
|
||||
|
||||
<sect3 xml:id="language.types.array.syntax.accessing">
|
||||
<title>Accediendo a elementos de array con sintaxis de corchetes</title>
|
||||
<title>Acceso a elementos de array con sintaxis de corchetes</title>
|
||||
|
||||
<para>
|
||||
Los elementos de array pueden ser accedidos usando la sintaxis <literal>array[clave]</literal>.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Accediendo a elementos de array</title>
|
||||
<title>Acceso a elementos de array</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -409,7 +409,7 @@ string(3) "foo"
|
||||
|
||||
<note>
|
||||
<para>
|
||||
Antes de PHP 8.0.0, los corchetes y las llaves podían ser usados indistintamente
|
||||
Antes de PHP 8.0.0, los corchetes y las llaves podían usarse indistintamente
|
||||
para acceder a elementos de array (por ejemplo, <literal>$array[42]</literal> y <literal>$array{42}</literal>
|
||||
harían lo mismo en el ejemplo anterior).
|
||||
La sintaxis de llaves fue deprecada a partir de PHP 7.4.0 y ya no es soportada a partir de PHP 8.0.0.
|
||||
@@ -438,12 +438,13 @@ var_dump($secondElement);
|
||||
Intentar acceder a una clave de array que no ha sido definida es
|
||||
lo mismo que acceder a cualquier otra variable no definida:
|
||||
se emitirá un mensaje de error de nivel <constant>E_WARNING</constant>
|
||||
(nivel <constant>E_NOTICE</constant> antes de PHP 8.0.0) y el resultado será &null;.
|
||||
(nivel <constant>E_NOTICE</constant> antes de PHP 8.0.0) y el
|
||||
resultado será &null;.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
La desreferenciación de array de un valor escalar que no es un <type>string</type>
|
||||
Desreferenciar un valor escalar que no es un <type>string</type>
|
||||
produce &null;. Antes de PHP 7.4.0, esto no emitía un mensaje de error.
|
||||
A partir de PHP 7.4.0, esto emite <constant>E_NOTICE</constant>;
|
||||
a partir de PHP 8.0.0, esto emite <constant>E_WARNING</constant>.
|
||||
@@ -452,17 +453,17 @@ var_dump($secondElement);
|
||||
</sect3>
|
||||
|
||||
<sect3 xml:id="language.types.array.syntax.modifying">
|
||||
<title>Creando/modificando con sintaxis de corchetes</title>
|
||||
<title>Creación/modificación con sintaxis de corchetes</title>
|
||||
|
||||
<para>
|
||||
Un <type>array</type> existente puede ser modificado asignando explícitamente valores
|
||||
en él.
|
||||
Un <type>array</type> existente puede ser modificado asignando valores
|
||||
explícitamente en él.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Esto se hace asignando valores al <type>array</type>, especificando
|
||||
la clave entre corchetes. La clave también puede ser omitida, resultando en un par vacío de
|
||||
corchetes (<literal>[]</literal>).
|
||||
Esto se hace asignando valores al <type>array</type>, especificando la
|
||||
clave entre corchetes. La clave también puede ser omitida, resultando en un par de
|
||||
corchetes vacíos (<literal>[]</literal>).
|
||||
</para>
|
||||
|
||||
<synopsis>
|
||||
@@ -473,22 +474,23 @@ $arr[] = <replaceable>valor</replaceable>;
|
||||
|
||||
<para>
|
||||
Si <varname>$arr</varname> no existe aún o está establecido a &null; o &false;, será creado, por lo que esto es
|
||||
también una forma alternativa de crear un <type>array</type>. Sin embargo, esta práctica es
|
||||
desaconsejada porque si <varname>$arr</varname> ya contiene
|
||||
algún valor (por ejemplo, <type>string</type> de una variable de solicitud) entonces este
|
||||
valor permanecerá en su lugar y <literal>[]</literal> puede en realidad representar
|
||||
el <link linkend="language.types.string.substr">operador de acceso a string</link>. Siempre es mejor inicializar una variable mediante una asignación directa.
|
||||
también una forma alternativa de crear un <type>array</type>. Sin embargo, esta práctica
|
||||
está desaconsejada porque si <varname>$arr</varname> ya contiene
|
||||
algún valor (por ejemplo, <type>string</type> de una variable de petición) entonces este
|
||||
valor permanecerá en su lugar y <literal>[]</literal> podría en realidad representar
|
||||
el <link linkend="language.types.string.substr">operador de acceso a string</link>. Siempre es mejor inicializar una variable mediante una
|
||||
asignación directa.
|
||||
</para>
|
||||
<note>
|
||||
<simpara>
|
||||
A partir de PHP 7.1.0, aplicar el operador de índice vacío en un string lanza un error fatal.
|
||||
Anteriormente, el string era convertido silenciosamente a un array.
|
||||
Anteriormente, el string se convertía silenciosamente a un array.
|
||||
</simpara>
|
||||
</note>
|
||||
<note>
|
||||
<simpara>
|
||||
A partir de PHP 8.1.0, crear un nuevo array a partir de un valor &false; está deprecado.
|
||||
Crear un nuevo array a partir de valores &null; y no definidos sigue estando permitido.
|
||||
Crear un nuevo array a partir de &null; y valores no definidos sigue estando permitido.
|
||||
</simpara>
|
||||
</note>
|
||||
|
||||
@@ -499,7 +501,7 @@ $arr[] = <replaceable>valor</replaceable>;
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Usando corchetes con arrays</title>
|
||||
<title>Uso de corchetes con arrays</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -525,14 +527,15 @@ var_dump($arr);
|
||||
|
||||
<note>
|
||||
<para>
|
||||
Como se mencionó anteriormente, si no se especifica una clave, se toma el máximo de los índices
|
||||
<type>int</type> existentes, y la nueva clave será ese valor máximo más 1 (pero al menos 0). Si no existen índices
|
||||
<type>int</type> aún, la clave será <literal>0</literal> (cero).
|
||||
Como se mencionó anteriormente, si no se especifica ninguna clave, se toma el máximo de los
|
||||
índices <type>int</type> existentes, y la nueva clave será ese valor máximo
|
||||
más 1 (pero al menos 0). Si no existen índices <type>int</type> aún, la clave será
|
||||
<literal>0</literal> (cero).
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Tenga en cuenta que el índice entero máximo usado para esto <emphasis>no necesita
|
||||
existir actualmente en el <type>array</type></emphasis>. Solo necesita haber
|
||||
Tenga en cuenta que el índice entero máximo usado para esto <emphasis>no
|
||||
necesita existir actualmente en el <type>array</type></emphasis>. Solo necesita haber
|
||||
existido en el <type>array</type> en algún momento desde la última vez que el
|
||||
<type>array</type> fue reindexado. El siguiente ejemplo lo ilustra:
|
||||
</para>
|
||||
@@ -603,7 +606,7 @@ Array
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Desestructuración de arrays</title>
|
||||
<title>Desestructuración de array</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -625,7 +628,7 @@ echo $baz, PHP_EOL; // imprime "baz"
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Desestructuración de arrays en foreach</title>
|
||||
<title>Desestructuración de array en foreach</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -643,12 +646,12 @@ foreach ($source_array as [$id, $name]) {
|
||||
</example>
|
||||
|
||||
<para>
|
||||
Los elementos del array serán ignorados si la variable no es proporcionada. La desestructuración de arrays
|
||||
siempre comienza en el índice <literal>0</literal>.
|
||||
Los elementos del array serán ignorados si la variable no está proporcionada. La
|
||||
desestructuración de array siempre comienza en el índice <literal>0</literal>.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Ignorando elementos</title>
|
||||
<title>Ignorar elementos</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -665,7 +668,7 @@ echo $baz; // imprime "baz"
|
||||
|
||||
<para>
|
||||
A partir de PHP 7.1.0, los arrays asociativos también pueden ser desestructurados. Esto también
|
||||
permite una selección más fácil del elemento correcto en arrays indexados numéricamente ya que el índice puede ser especificado explícitamente.
|
||||
permite una selección más fácil del elemento correcto en arrays indexados numéricamente, ya que el índice puede ser especificado explícitamente.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
@@ -692,11 +695,11 @@ echo $baz, PHP_EOL; // imprime "baz"
|
||||
</example>
|
||||
|
||||
<para>
|
||||
La desestructuración de arrays puede ser usada para un intercambio fácil de dos variables.
|
||||
La desestructuración de arrays puede ser usada para intercambiar fácilmente dos variables.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Intercambiando dos variables</title>
|
||||
<title>Intercambio de dos variables</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -714,7 +717,7 @@ echo $b, PHP_EOL; // imprime 1
|
||||
|
||||
<note>
|
||||
<para>
|
||||
El operador de propagación (<literal>...</literal>) no es soportado en asignaciones.
|
||||
El operador de propagación (<literal>...</literal>) no está soportado en asignaciones.
|
||||
</para>
|
||||
</note>
|
||||
|
||||
@@ -723,7 +726,13 @@ echo $b, PHP_EOL; // imprime 1
|
||||
Intentar acceder a una clave de array que no ha sido definida es
|
||||
lo mismo que acceder a cualquier otra variable no definida:
|
||||
se emitirá un mensaje de error de nivel <constant>E_WARNING</constant>
|
||||
(nivel <constant>E_NOTICE</constant> antes de PHP 8.0.0) y el resultado será &null;.
|
||||
(nivel <constant>E_NOTICE</constant> antes de PHP 8.0.0) y el
|
||||
resultado será &null;.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Desestructurar un valor escalar asigna &null; a todas las variables.
|
||||
</para>
|
||||
</note>
|
||||
</sect3>
|
||||
@@ -748,7 +757,7 @@ echo $b, PHP_EOL; // imprime 1
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Eliminando elementos intermedios</title>
|
||||
<title>Eliminación de elementos intermedios</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -779,7 +788,7 @@ var_dump($b);
|
||||
</sect2>
|
||||
|
||||
<sect2 xml:id="language.types.array.donts">
|
||||
<title>Qué hacer y qué no hacer con arrays</title>
|
||||
<title>Lo que se debe y no se debe hacer con arrays</title>
|
||||
|
||||
<sect3 xml:id="language.types.array.foo-bar">
|
||||
<title>¿Por qué <literal>$foo[bar]</literal> está mal?</title>
|
||||
@@ -787,7 +796,7 @@ var_dump($b);
|
||||
<para>
|
||||
Siempre use comillas alrededor de un índice de array literal de cadena. Por ejemplo,
|
||||
<literal>$foo['bar']</literal> es correcto, mientras que
|
||||
<literal>$foo[bar]</literal> no lo es. Pero, ¿por qué? Es común encontrar este
|
||||
<literal>$foo[bar]</literal> no lo es. Pero ¿por qué? Es común encontrar este
|
||||
tipo de sintaxis en scripts antiguos:
|
||||
</para>
|
||||
|
||||
@@ -805,15 +814,17 @@ echo $foo[bar];
|
||||
|
||||
<para>
|
||||
Esto está mal, pero funciona. La razón es que este código tiene una constante no definida (<literal>bar</literal>)
|
||||
en lugar de un <type>string</type> (<literal>'bar'</literal> - note las comillas). Funciona porque PHP
|
||||
convierte automáticamente una <emphasis>cadena sin comillas</emphasis> (una cadena sin comillas que no
|
||||
corresponde a ningún símbolo conocido) en un <type>string</type> que contiene la cadena sin comillas.
|
||||
Por ejemplo, si no hay una constante definida llamada <constant>bar</constant>, entonces PHP
|
||||
sustituirá la cadena <literal>'bar'</literal> y la usará.
|
||||
en lugar de un <type>string</type> (<literal>'bar'</literal> - note las
|
||||
comillas). Funciona porque PHP convierte automáticamente una
|
||||
<emphasis>cadena desnuda</emphasis> (una <type>string</type> sin comillas que no
|
||||
corresponde a ningún símbolo conocido) en un <type>string</type> que
|
||||
contiene la <type>string</type> desnuda. Por ejemplo, si no hay una constante
|
||||
definida llamada <constant>bar</constant>, entonces PHP sustituirá la
|
||||
<type>string</type> <literal>'bar'</literal> y la usará.
|
||||
</para>
|
||||
<warning>
|
||||
<simpara>
|
||||
La opción de tratar una constante no definida como una cadena sin comillas emite un error
|
||||
La retrocompatibilidad para tratar una constante no definida como cadena desnuda emite un error
|
||||
de nivel <constant>E_NOTICE</constant>.
|
||||
Esto ha sido deprecado a partir de PHP 7.2.0, y emite un error
|
||||
de nivel <constant>E_WARNING</constant>.
|
||||
@@ -823,14 +834,14 @@ echo $foo[bar];
|
||||
</warning>
|
||||
|
||||
<simpara>
|
||||
Esto no significa que <emphasis>siempre</emphasis> se deban poner comillas a la clave. No
|
||||
ponga comillas a las claves que son <link linkend="language.constants">constantes</link> o
|
||||
Esto no significa que <emphasis>siempre</emphasis> deba poner comillas a la clave. No
|
||||
ponga comillas a claves que son <link linkend="language.constants">constantes</link> o
|
||||
<link linkend="language.variables">variables</link>, ya que esto evitará
|
||||
que PHP las interprete.
|
||||
</simpara>
|
||||
|
||||
<example>
|
||||
<title>Claves con comillas</title>
|
||||
<title>Comillas en claves</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -843,7 +854,7 @@ $array = array(1, 2);
|
||||
$count = count($array);
|
||||
|
||||
for ($i = 0; $i < $count; $i++) {
|
||||
echo "\nRevisando $i: \n";
|
||||
echo "\nComprobando $i: \n";
|
||||
echo "Incorrecto: " . $array['$i'] . "\n";
|
||||
echo "Correcto: " . $array[$i] . "\n";
|
||||
echo "Incorrecto: {$array['$i']}\n";
|
||||
@@ -856,19 +867,19 @@ for ($i = 0; $i < $count; $i++) {
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Revisando 0:
|
||||
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 9
|
||||
Comprobando 0:
|
||||
Notice: Undefined index: $i in /path/to/script.html on line 9
|
||||
Incorrecto:
|
||||
Correcto: 1
|
||||
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 11
|
||||
Notice: Undefined index: $i in /path/to/script.html on line 11
|
||||
Incorrecto:
|
||||
Correcto: 1
|
||||
|
||||
Revisando 1:
|
||||
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 9
|
||||
Comprobando 1:
|
||||
Notice: Undefined index: $i in /path/to/script.html on line 9
|
||||
Incorrecto:
|
||||
Correcto: 2
|
||||
Notice: Índice no definido: $i en /ruta/al/script.html en la línea 11
|
||||
Notice: Undefined index: $i in /path/to/script.html on line 11
|
||||
Incorrecto:
|
||||
Correcto: 2
|
||||
]]>
|
||||
@@ -895,7 +906,7 @@ echo $arr['veggie'], PHP_EOL; // carrot
|
||||
// Incorrecto. Esto funciona pero también lanza un error de PHP debido a
|
||||
// una constante no definida llamada fruit
|
||||
//
|
||||
// Error: Constante no definida "fruit"
|
||||
// Error: Undefined constant "fruit"
|
||||
try {
|
||||
echo $arr[fruit]; // apple
|
||||
} catch (Error $e) {
|
||||
@@ -910,8 +921,8 @@ define('fruit', 'veggie');
|
||||
echo $arr['fruit'], PHP_EOL; // apple
|
||||
echo $arr[fruit], PHP_EOL; // carrot
|
||||
|
||||
// Lo siguiente está bien, ya que está dentro de una cadena. Las constantes no son buscadas
|
||||
// dentro de cadenas, por lo que no ocurre E_NOTICE aquí
|
||||
// Lo siguiente está bien, ya que está dentro de una cadena. Las constantes no se buscan
|
||||
// dentro de cadenas, por lo que no ocurre ningún E_NOTICE aquí
|
||||
echo "Hello $arr[fruit]", PHP_EOL; // Hello apple
|
||||
|
||||
// Con una excepción: las llaves que rodean arrays dentro de cadenas permiten que las constantes
|
||||
@@ -931,7 +942,7 @@ echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple
|
||||
<![CDATA[
|
||||
<?php
|
||||
// Esto no funcionará, y resultará en un error de análisis, como:
|
||||
// Error de análisis: error de análisis, esperando T_STRING o T_VARIABLE o T_NUM_STRING'
|
||||
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
|
||||
// Esto, por supuesto, también se aplica al usar superglobals en cadenas
|
||||
print "Hello $arr['fruit']";
|
||||
print "Hello $_GET['foo']";
|
||||
@@ -942,15 +953,15 @@ print "Hello $_GET['foo']";
|
||||
|
||||
<para>
|
||||
Cuando <link linkend="ini.error-reporting">error_reporting</link> está configurado para
|
||||
mostrar errores de nivel <constant>E_NOTICE</constant> (configurándolo a
|
||||
<constant>E_ALL</constant>, por ejemplo), tales usos se harán inmediatamente
|
||||
mostrar errores de nivel <constant>E_NOTICE</constant> (estableciéndolo en
|
||||
<constant>E_ALL</constant>, por ejemplo), estos usos se harán inmediatamente
|
||||
visibles. Por defecto,
|
||||
<link linkend="ini.error-reporting">error_reporting</link> está configurado para no
|
||||
mostrar notificaciones.
|
||||
mostrar avisos.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Como se establece en la sección de <link linkend="language.types.array.syntax">sintaxis</link>,
|
||||
Como se indica en la sección de <link linkend="language.types.array.syntax">sintaxis</link>,
|
||||
lo que está dentro de los corchetes ('<literal>[</literal>' y
|
||||
'<literal>]</literal>') debe ser una expresión. Esto significa que el código como
|
||||
este funciona:
|
||||
@@ -967,7 +978,7 @@ echo $arr[somefunc($bar)];
|
||||
</informalexample>
|
||||
|
||||
<para>
|
||||
Este es un ejemplo de usar el valor de retorno de una función como índice del array. PHP
|
||||
Este es un ejemplo de uso del valor de retorno de una función como índice del array. PHP
|
||||
también conoce las constantes:
|
||||
</para>
|
||||
|
||||
@@ -977,15 +988,15 @@ echo $arr[somefunc($bar)];
|
||||
<?php
|
||||
$error_descriptions[E_ERROR] = "Ha ocurrido un error fatal";
|
||||
$error_descriptions[E_WARNING] = "PHP emitió una advertencia";
|
||||
$error_descriptions[E_NOTICE] = "Esto es solo una notificación informal";
|
||||
$error_descriptions[E_NOTICE] = "Esto es solo un aviso informal";
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</informalexample>
|
||||
|
||||
<para>
|
||||
Note que <constant>E_ERROR</constant> también es un identificador válido, al igual que
|
||||
<literal>bar</literal> en el primer ejemplo. Pero el último ejemplo es de hecho
|
||||
Tenga en cuenta que <constant>E_ERROR</constant> también es un identificador válido, al igual que
|
||||
<literal>bar</literal> en el primer ejemplo. Pero el último ejemplo es en realidad
|
||||
lo mismo que escribir:
|
||||
</para>
|
||||
|
||||
@@ -995,7 +1006,7 @@ $error_descriptions[E_NOTICE] = "Esto es solo una notificación informal";
|
||||
<?php
|
||||
$error_descriptions[1] = "Ha ocurrido un error fatal";
|
||||
$error_descriptions[2] = "PHP emitió una advertencia";
|
||||
$error_descriptions[8] = "Esto es solo una notificación informal";
|
||||
$error_descriptions[8] = "Esto es solo un aviso informal";
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
@@ -1018,9 +1029,9 @@ $error_descriptions[8] = "Esto es solo una notificación informal";
|
||||
|
||||
<note>
|
||||
<simpara>
|
||||
Para reiterar, dentro de una cadena entre comillas dobles, es válido
|
||||
no rodear los índices de array con comillas, por lo que <literal>"$foo[bar]"</literal>
|
||||
es válido. Vea los ejemplos anteriores para más detalles sobre por qué, así como la sección
|
||||
Para reiterar, dentro de una <type>string</type> entre comillas dobles, es válido no
|
||||
rodear los índices de array con comillas, por lo que <literal>"$foo[bar]"</literal>
|
||||
es válido. Consulte los ejemplos anteriores para más detalles, así como la sección
|
||||
sobre <link linkend="language.types.string.parsing">análisis de variables en
|
||||
cadenas</link>.
|
||||
</simpara>
|
||||
@@ -1044,13 +1055,14 @@ $error_descriptions[8] = "Esto es solo una notificación informal";
|
||||
|
||||
<para>
|
||||
Si un <type>object</type> es convertido a un <type>array</type>, el resultado
|
||||
es un <type>array</type> cuyos elementos son las propiedades del <type>object</type>.
|
||||
es un <type>array</type> cuyos elementos son las
|
||||
propiedades del <type>object</type>.
|
||||
Las claves son los nombres de las variables miembro, con algunas excepciones notables: las propiedades enteras son inaccesibles;
|
||||
las variables privadas tienen el nombre de la clase antepuesto al nombre de la variable;
|
||||
las variables protegidas tienen un '*' antepuesto al nombre de la variable. Estos
|
||||
valores antepuestos tienen bytes <literal>NUL</literal> en ambos lados.
|
||||
las variables privadas tienen el nombre de la clase antepuesto al nombre de la
|
||||
variable; las variables protegidas tienen un '*' antepuesto al nombre de la variable. Estos
|
||||
valores antepuestos tienen bytes <literal>NUL</literal> a ambos lados.
|
||||
Las <link linkend="language.oop5.properties.typed-properties">propiedades tipadas</link>
|
||||
no inicializadas son descartadas silenciosamente.
|
||||
no inicializadas se descartan silenciosamente.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
@@ -1108,10 +1120,10 @@ class B extends A {
|
||||
var_dump((array) new B());
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
</programlisting>
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
array(3) {
|
||||
["BA"]=>
|
||||
NULL
|
||||
@@ -1121,12 +1133,12 @@ array(3) {
|
||||
NULL
|
||||
}
|
||||
]]>
|
||||
</screen>
|
||||
</screen>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
Lo anterior parecerá tener dos claves llamadas 'AA', aunque una de ellas está
|
||||
realmente llamada '\0A\0A'.
|
||||
Lo anterior parecerá tener dos claves llamadas 'AA', aunque una de ellas
|
||||
en realidad se llama '\0A\0A'.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
@@ -1140,7 +1152,7 @@ array(3) {
|
||||
|
||||
<para>
|
||||
Es posible comparar arrays con la función <function>array_diff</function>
|
||||
y con los
|
||||
y con
|
||||
<link linkend="language.operators.array">operadores de array</link>.
|
||||
</para>
|
||||
</sect2>
|
||||
@@ -1159,7 +1171,7 @@ array(3) {
|
||||
Es posible expandir múltiples veces, y añadir elementos normales antes o después del operador <code>...</code>:
|
||||
|
||||
<example>
|
||||
<title>Desempaquetado simple de arrays</title>
|
||||
<title>Desempaquetado de array simple</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -1184,11 +1196,11 @@ var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6);
|
||||
</para>
|
||||
|
||||
<para>
|
||||
El desempaquetado de un array con el operador <code>...</code> sigue la semántica de la función <function>array_merge</function>.
|
||||
Es decir, las claves de cadena posteriores sobrescriben las anteriores y las claves enteras son renumeradas:
|
||||
Desempaquetar un array con el operador <code>...</code> sigue la semántica de la función <function>array_merge</function>.
|
||||
Es decir, las claves de cadena posteriores sobrescriben las anteriores y las claves enteras se renumeran:
|
||||
|
||||
<example>
|
||||
<title>Desempaquetado de arrays con clave duplicada</title>
|
||||
<title>Desempaquetado de array con clave duplicada</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -1204,7 +1216,7 @@ $arr5 = [4, 5, 6];
|
||||
$arr6 = [...$arr4, ...$arr5];
|
||||
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
|
||||
// Que es [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
|
||||
// donde las claves enteras originales no han sido retenidas.
|
||||
// donde las claves enteras originales no se han conservado.
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
@@ -1213,13 +1225,13 @@ var_dump($arr6); // [1, 2, 3, 4, 5, 6]
|
||||
|
||||
<note>
|
||||
<para>
|
||||
Las claves que no son ni enteras ni cadenas lanzan un <classname>TypeError</classname>.
|
||||
Las claves que no son ni enteros ni cadenas lanzan un <classname>TypeError</classname>.
|
||||
Tales claves solo pueden ser generadas por un objeto <interfacename>Traversable</interfacename>.
|
||||
</para>
|
||||
</note>
|
||||
<note>
|
||||
<para>
|
||||
Antes de PHP 8.1, el desempaquetado de un array que tiene una clave de cadena no es soportado:
|
||||
Antes de PHP 8.1, el desempaquetado de un array que tiene una clave de cadena no está soportado:
|
||||
</para>
|
||||
<informalexample>
|
||||
<programlisting role="php">
|
||||
@@ -1229,7 +1241,7 @@ var_dump($arr6); // [1, 2, 3, 4, 5, 6]
|
||||
$arr1 = [1, 2, 3];
|
||||
$arr2 = ['a' => 4];
|
||||
$arr3 = [...$arr1, ...$arr2];
|
||||
// Error fatal: Error no capturado: No se puede desempaquetar un array con claves de cadena en example.php:5
|
||||
// Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5
|
||||
|
||||
$arr4 = [1, 2, 3];
|
||||
$arr5 = [4, 5];
|
||||
@@ -1250,7 +1262,7 @@ $arr6 = [...$arr4, ...$arr5]; // funciona. [1, 2, 3, 4, 5]
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Versatilidad de arrays</title>
|
||||
<title>Versatilidad de los arrays</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -1266,7 +1278,7 @@ $b = array('a', 'b', 'c');
|
||||
|
||||
var_dump($a, $b);
|
||||
|
||||
// . . .es completamente equivalente a esto:
|
||||
// ...es completamente equivalente a esto:
|
||||
$a = array();
|
||||
$a['color'] = 'red';
|
||||
$a['taste'] = 'sweet';
|
||||
@@ -1279,7 +1291,7 @@ $b[] = 'a';
|
||||
$b[] = 'b';
|
||||
$b[] = 'c';
|
||||
|
||||
// Después de que el código anterior sea ejecutado, $a será el array
|
||||
// Después de que el código anterior se ejecute, $a será el array
|
||||
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
|
||||
// 'name' => 'apple', 0 => 4), y $b será el array
|
||||
// array(0 => 'a', 1 => 'b', 2 => 'c'), o simplemente array('a', 'b', 'c').
|
||||
@@ -1291,11 +1303,11 @@ var_dump($a, $b);
|
||||
</example>
|
||||
|
||||
<example>
|
||||
<title>Usando array()</title>
|
||||
<title>Uso de array()</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
// Array como (mapa de propiedades)
|
||||
// Array como (propiedad-)mapa
|
||||
$map = array( 'version' => 4,
|
||||
'OS' => 'Linux',
|
||||
'lang' => 'english',
|
||||
@@ -1377,15 +1389,15 @@ $colors = array('red', 'blue', 'green', 'yellow');
|
||||
foreach ($colors as &$color) {
|
||||
$color = mb_strtoupper($color);
|
||||
}
|
||||
unset($color); /* asegurar que las siguientes escrituras a
|
||||
unset($color); /* asegúrese de que las escrituras siguientes a
|
||||
$color no modificarán el último elemento del array */
|
||||
|
||||
print_r($colors);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
&example.outputs;
|
||||
<screen>
|
||||
</programlisting>
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Array
|
||||
(
|
||||
@@ -1395,7 +1407,7 @@ Array
|
||||
[3] => YELLOW
|
||||
)
|
||||
]]>
|
||||
</screen>
|
||||
</screen>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
@@ -1411,9 +1423,9 @@ $firstquarter = array(1 => 'January', 'February', 'March');
|
||||
print_r($firstquarter);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
&example.outputs;
|
||||
<screen>
|
||||
</programlisting>
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Array
|
||||
(
|
||||
@@ -1422,11 +1434,11 @@ Array
|
||||
[3] => March
|
||||
)
|
||||
]]>
|
||||
</screen>
|
||||
</screen>
|
||||
</example>
|
||||
|
||||
<example>
|
||||
<title>Llenando un array</title>
|
||||
<title>Llenar un array</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -1440,18 +1452,18 @@ closedir($handle);
|
||||
var_dump($files);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
Los <type>array</type>s están ordenados. El orden puede ser cambiado usando varias
|
||||
funciones de ordenamiento. Vea la sección de <link linkend="ref.array">funciones de array</link>
|
||||
funciones de ordenación. Vea la sección de <link linkend="ref.array">funciones de array</link>
|
||||
para más información. La función <function>count</function> puede ser
|
||||
usada para contar el número de elementos en un <type>array</type>.
|
||||
</para>
|
||||
|
||||
<example>
|
||||
<title>Ordenando un array</title>
|
||||
<title>Ordenar un array</title>
|
||||
<programlisting role="php" annotations="non-interactive">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -1459,7 +1471,7 @@ sort($files);
|
||||
print_r($files);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
@@ -1501,11 +1513,11 @@ $juices["apple"]["green"] = "good";
|
||||
var_dump($juices);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</programlisting>
|
||||
</example>
|
||||
|
||||
<para>
|
||||
La asignación de <type>array</type> siempre implica la copia de valores. Use el
|
||||
La asignación de <type>array</type> siempre implica una copia de valores. Use el
|
||||
<link linkend="language.operators">operador de referencia</link> para copiar un
|
||||
<type>array</type> por referencia.
|
||||
</para>
|
||||
@@ -1521,12 +1533,12 @@ $arr2[] = 4; // $arr2 es cambiado,
|
||||
// $arr1 sigue siendo array(2, 3)
|
||||
|
||||
$arr3 = &$arr1;
|
||||
$arr3[] = 4; // ahora $arr1 y $arr3 son los mismos
|
||||
$arr3[] = 4; // ahora $arr1 y $arr3 son iguales
|
||||
|
||||
var_dump($arr1, $arr2, $arr3);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</programlisting>
|
||||
</example>
|
||||
|
||||
</sect2>
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
<refnamediv>
|
||||
<refname>apcu_entry</refname>
|
||||
<refpurpose>
|
||||
Recupera o genera de forma atómica una entrada en caché
|
||||
Recupera o genera de forma atómica una entrada de caché
|
||||
</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
@@ -17,20 +17,21 @@
|
||||
<methodparam choice="opt"><type>int</type><parameter>ttl</parameter><initializer>0</initializer></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Intenta de forma atómica encontrar <parameter>key</parameter> en la caché, si no se puede encontrar se llama a <parameter>callback</parameter>,
|
||||
pasando <parameter>key</parameter> como único argumento. El valor de retorno de la llamada se almacena en caché con el <parameter>ttl</parameter> opcionalmente especificado,
|
||||
y se devuelve.
|
||||
Intenta de forma atómica encontrar <parameter>key</parameter> en la caché; si no se encuentra, se llama a <parameter>callback</parameter>,
|
||||
pasando <parameter>key</parameter> como único argumento. El valor de retorno de la llamada se almacena en caché con el <parameter>ttl</parameter>
|
||||
especificado opcionalmente y se devuelve.
|
||||
</para>
|
||||
<note>
|
||||
<simpara>
|
||||
Cuando el control entra en <function>apcu_entry</function> se adquiere el bloqueo para la caché de forma exclusiva, se libera cuando el control sale de <function>apcu_entry</function>:
|
||||
En efecto, esto convierte el cuerpo de <parameter>callback</parameter> en una sección crítica, impidiendo que dos procesos ejecuten las mismas rutas de código concurrentemente.
|
||||
Además, prohíbe la ejecución concurrente de cualquier otra función de APCu, ya que adquirirán el mismo bloqueo.
|
||||
Cuando el control entra en <function>apcu_entry</function>, se adquiere de forma exclusiva el bloqueo de la caché, que se libera cuando el control
|
||||
sale de <function>apcu_entry</function>. En efecto, esto convierte el cuerpo de <parameter>callback</parameter> en una sección crítica, impidiendo que
|
||||
dos procesos ejecuten las mismas rutas de código concurrentemente. Además, prohíbe la ejecución concurrente de cualquier otra función de APCu,
|
||||
ya que adquirirán el mismo bloqueo.
|
||||
</simpara>
|
||||
</note>
|
||||
<warning>
|
||||
<simpara>
|
||||
La única función de APCu que puede ser llamada de forma segura por <parameter>callback</parameter> es <function>apcu_entry</function>.
|
||||
La única función de APCu que puede llamarse de forma segura desde <parameter>callback</parameter> es <function>apcu_entry</function>.
|
||||
</simpara>
|
||||
</warning>
|
||||
</refsect1>
|
||||
@@ -42,7 +43,7 @@
|
||||
<term><parameter>key</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Identidad de la entrada en caché
|
||||
Identificador de la entrada de caché
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -58,13 +59,13 @@
|
||||
<term><parameter>ttl</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Tiempo de Vida; almacena <parameter>var</parameter> en la caché durante
|
||||
Tiempo de vida; almacena <parameter>var</parameter> en la caché durante
|
||||
<parameter>ttl</parameter> segundos. Después de que
|
||||
<parameter>ttl</parameter> haya pasado, la variable almacenada será
|
||||
<parameter>ttl</parameter> haya transcurrido, la variable almacenada será
|
||||
eliminada de la caché (en la siguiente petición). Si no se proporciona <parameter>ttl</parameter>
|
||||
(o si el <parameter>ttl</parameter> es
|
||||
<literal>0</literal>), el valor persistirá hasta que sea eliminado de
|
||||
la caché manualmente, o deje de existir en la caché (limpieza,
|
||||
<literal>0</literal>), el valor persistirá hasta que se elimine manualmente de
|
||||
la caché, o deje de existir en la caché (limpieza,
|
||||
reinicio, etc.).
|
||||
</para>
|
||||
</listitem>
|
||||
|
||||
@@ -1,12 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: d58ee8eaaa7f716c51f66f5f1058ab3c42376d98 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: f53ab502a11a52e82baca372c37d64e3f298b17c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<!-- CREDITS: DavidA. -->
|
||||
<refentry xml:id="function.extract" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>extract</refname>
|
||||
<refpurpose>Importa las variables en la tabla de símbolos</refpurpose>
|
||||
<refpurpose>Importa variables al símbolo actual desde un array</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -17,18 +15,16 @@
|
||||
<methodparam choice="opt"><type>string</type><parameter>prefix</parameter><initializer>""</initializer></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Importa las variables en la
|
||||
<link linkend="features.gc.refcounting-basics">tabla de símbolos</link>.
|
||||
Importa variables desde un array a la tabla de símbolos actual.
|
||||
</para>
|
||||
<para>
|
||||
<function>extract</function> verifica cada clave para controlar si tiene un nombre
|
||||
de variable válido. También verifica las colisiones con variables
|
||||
existentes en la tabla de símbolos.
|
||||
Verifica cada clave para determinar si tiene un nombre de variable válido.
|
||||
También verifica colisiones con variables existentes en la tabla de símbolos.
|
||||
</para>
|
||||
<warning>
|
||||
<para>
|
||||
No utilice <function>extract</function> en datos no seguros como las entradas de usuario
|
||||
(ex. <varname>$_GET</varname>, <varname>$_FILES</varname>).
|
||||
No utilice <function>extract</function> con datos no confiables, como entrada de usuario
|
||||
(ej. <varname>$_GET</varname>, <varname>$_FILES</varname>).
|
||||
</para>
|
||||
</warning>
|
||||
</refsect1>
|
||||
@@ -40,16 +36,15 @@
|
||||
<term><parameter>array</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Un array asociativo. Esta función crea las variables cuyos
|
||||
nombres son los índices de este array, y les asigna el valor asociado.
|
||||
Para cada par clave/valor, <function>extract</function> crea
|
||||
una variable, con los parámetros <parameter>flags</parameter>
|
||||
y <parameter>prefix</parameter>.
|
||||
Un array asociativo. Esta función trata las claves como nombres de variables y
|
||||
los valores como valores de variables. Para cada par clave/valor creará
|
||||
una variable en la tabla de símbolos actual, sujeto a los parámetros
|
||||
<parameter>flags</parameter> y <parameter>prefix</parameter>.
|
||||
</para>
|
||||
<para>
|
||||
Debe utilizar un array asociativo. Un array indexado numéricamente
|
||||
no producirá ningún resultado, a menos que se utilice la opción
|
||||
<constant>EXTR_PREFIX_ALL</constant> o <constant>EXTR_PREFIX_INVALID</constant>.
|
||||
Debe usar un array asociativo; un array indexado numéricamente
|
||||
no producirá resultados a menos que use <constant>EXTR_PREFIX_ALL</constant> o
|
||||
<constant>EXTR_PREFIX_INVALID</constant>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -57,15 +52,15 @@
|
||||
<term><parameter>flags</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El tratamiento de las colisiones es
|
||||
determinado por <parameter>flags</parameter>.
|
||||
Este parámetro puede tomar uno de los siguientes valores:
|
||||
La forma en que se tratan las claves inválidas/numéricas y las colisiones se determina
|
||||
por los <parameter>flags</parameter> de extracción. Puede ser uno de los
|
||||
siguientes valores:
|
||||
<variablelist>
|
||||
<varlistentry>
|
||||
<term><constant>EXTR_OVERWRITE</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
En caso de colisión, sobrescribir la variable existente.
|
||||
Si hay una colisión, sobrescribe la variable existente.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -73,16 +68,16 @@
|
||||
<term><constant>EXTR_SKIP</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
En caso de colisión, no sobrescribir la variable existente.
|
||||
Si hay una colisión, no sobrescribe la variable
|
||||
existente.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
<varlistentry>
|
||||
<term><constant>EXTR_PREFIX_SAME</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
En caso de colisión, añadir el prefijo <parameter>prefix</parameter>,
|
||||
y crear una nueva variable.
|
||||
<simpara>Si hay una colisión, antepone el nombre de la variable con
|
||||
<parameter>prefix</parameter>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -90,7 +85,8 @@
|
||||
<term><constant>EXTR_PREFIX_ALL</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Añadir el prefijo <parameter>prefix</parameter> para todas las variables.
|
||||
Antepone todos los nombres de variables con
|
||||
<parameter>prefix</parameter>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -98,8 +94,8 @@
|
||||
<term><constant>EXTR_PREFIX_INVALID</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Prefijar únicamente las variables con nombres inválidos o numéricos
|
||||
con el prefijo <parameter>prefix</parameter>.
|
||||
Solo antepone nombres de variables inválidas/numéricas con
|
||||
<parameter>prefix</parameter>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -107,11 +103,11 @@
|
||||
<term><constant>EXTR_IF_EXISTS</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Sobrescribir la variable únicamente si ya existe en la
|
||||
tabla de símbolos, y, de lo contrario, no hacer nada. Esto es
|
||||
práctico para definir una lista de variables válidas, y luego
|
||||
extraer del array los valores que ya se han definido
|
||||
gracias a <varname>$_REQUEST</varname>, por ejemplo.
|
||||
Solo sobrescribe la variable si ya existe en la
|
||||
tabla de símbolos actual, de lo contrario no hace nada. Esto es útil
|
||||
para definir una lista de variables válidas y luego extraer
|
||||
solo esas variables que ha definido de
|
||||
<varname>$_REQUEST</varname>, por ejemplo.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -119,7 +115,7 @@
|
||||
<term><constant>EXTR_PREFIX_IF_EXISTS</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Crear solo variables prefijadas, si la versión no prefijada
|
||||
Solo crea nombres de variables con prefijo si la versión sin prefijo
|
||||
de la misma variable existe en la tabla de símbolos actual.
|
||||
</simpara>
|
||||
</listitem>
|
||||
@@ -128,20 +124,19 @@
|
||||
<term><constant>EXTR_REFS</constant></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Extraer las variables como referencias. Esto significa que
|
||||
los valores de las variables importadas siempre hacen referencia a los
|
||||
valores de las variables originales en el parámetro
|
||||
<parameter>array</parameter>. Se puede utilizar esta
|
||||
opción sola, o bien combinarla con otras opciones con
|
||||
el operador OR, en el parámetro <parameter>flags</parameter>.
|
||||
Extrae variables como referencias. Esto significa efectivamente que
|
||||
los valores de las variables importadas aún hacen referencia a los valores del
|
||||
parámetro <parameter>array</parameter>. Puede usar este flag
|
||||
por sí solo o combinarlo con cualquier otro flag mediante OR con los
|
||||
<parameter>flags</parameter>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
</variablelist>
|
||||
</para>
|
||||
<para>
|
||||
Si <parameter>flags</parameter> se omite, <function>extract</function>
|
||||
utilizará <constant>EXTR_OVERWRITE</constant> por omisión.
|
||||
Si <parameter>flags</parameter> no está especificado, se
|
||||
asume que es <constant>EXTR_OVERWRITE</constant>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -149,13 +144,13 @@
|
||||
<term><parameter>prefix</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Tenga en cuenta que <parameter>prefix</parameter> solo es necesario para
|
||||
los siguientes valores de <parameter>flags</parameter>:
|
||||
<constant>EXTR_PREFIX_SAME</constant>, <constant>EXTR_PREFIX_ALL</constant>,
|
||||
<constant>EXTR_PREFIX_INVALID</constant> o <constant>EXTR_PREFIX_IF_EXISTS</constant>.
|
||||
Si el resultado prefijado no es un nombre de variable válido,
|
||||
no se importará en la tabla de símbolos. Los prefijos se separan automáticamente
|
||||
del índice del array por un carácter de subrayado.
|
||||
Tenga en cuenta que <parameter>prefix</parameter> solo es requerido si
|
||||
<parameter>flags</parameter> es <constant>EXTR_PREFIX_SAME</constant>,
|
||||
<constant>EXTR_PREFIX_ALL</constant>, <constant>EXTR_PREFIX_INVALID</constant>
|
||||
o <constant>EXTR_PREFIX_IF_EXISTS</constant>. Si
|
||||
el resultado con prefijo no es un nombre de variable válido, no se
|
||||
importará a la tabla de símbolos. Los prefijos se separan automáticamente de
|
||||
la clave del array por un carácter de guión bajo.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -165,28 +160,17 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Devuelve el número de variables importadas con éxito en la tabla
|
||||
de símbolos.
|
||||
Devuelve el número de variables importadas con éxito a la tabla de símbolos.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>extract</function></title>
|
||||
<para>
|
||||
Un uso posible de la función <function>extract</function> es la exportación
|
||||
a la tabla de símbolos de arrays de variables devueltos
|
||||
por <function>wddx_deserialize</function>.
|
||||
</para>
|
||||
<title>Ejemplo de <function>extract</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
/* Supongamos que $var_array es un array devuelto por
|
||||
wddx_deserialize */
|
||||
|
||||
$size = "large";
|
||||
$var_array = array(
|
||||
"color" => "blue",
|
||||
@@ -208,14 +192,15 @@ blue, large, sphere, medium
|
||||
]]>
|
||||
</screen>
|
||||
<para>
|
||||
La variable <varname>$size</varname> no fue sobrescrita, ya que se había especificado el parámetro <constant>EXTR_PREFIX_SAME</constant>,
|
||||
que permitió la creación de <varname>$wddx_size</varname>. Si
|
||||
<constant>EXTR_SKIP</constant> hubiera sido utilizado, entonces
|
||||
<varname>$wddx_size</varname> no habría sido creado.
|
||||
Con <constant>EXTR_OVERWRITE</constant>, <varname>$size</varname>
|
||||
habría tomado el valor "medium", y con <constant>EXTR_PREFIX_ALL</constant>,
|
||||
las variables creadas habrían sido <varname>$wddx_color</varname>,
|
||||
<varname>$wddx_size</varname> y <varname>$wddx_shape</varname>.
|
||||
La variable <varname>$size</varname> no fue sobrescrita porque especificamos
|
||||
<constant>EXTR_PREFIX_SAME</constant>, lo que resultó en la creación de
|
||||
<varname>$wddx_size</varname>. Si se hubiera especificado <constant>EXTR_SKIP</constant>,
|
||||
entonces <varname>$wddx_size</varname> ni siquiera se habría creado.
|
||||
<constant>EXTR_OVERWRITE</constant> habría hecho que <varname>$size</varname> tuviera
|
||||
el valor "medium", y <constant>EXTR_PREFIX_ALL</constant> habría resultado en nuevas variables
|
||||
llamadas <varname>$wddx_color</varname>,
|
||||
<varname>$wddx_size</varname>, y
|
||||
<varname>$wddx_shape</varname>.
|
||||
</para>
|
||||
</example>
|
||||
</para>
|
||||
@@ -224,15 +209,15 @@ blue, large, sphere, medium
|
||||
&reftitle.notes;
|
||||
<warning>
|
||||
<para>
|
||||
No utilice <function>extract</function> en datos desconocidos, como
|
||||
los datos de usuario (i.e. <varname>$_GET</varname>,
|
||||
<varname>$_FILES</varname>, etc.).
|
||||
Si lo hace, asegúrese de utilizar una de las constantes
|
||||
<parameter>flags</parameter> que no sobrescriban los valores, como
|
||||
<constant>EXTR_SKIP</constant>. Tenga en cuenta también que ahora
|
||||
debe extraer en el mismo orden que el definido en <link
|
||||
linkend="ini.variables-order">variables_order</link> del <link
|
||||
linkend="ini">&php.ini;</link>.
|
||||
No utilice <function>extract</function> con datos no confiables, como
|
||||
entrada de usuario
|
||||
(ej. <varname>$_GET</varname>, <varname>$_FILES</varname>, etc.).
|
||||
Si lo hace, asegúrese de usar uno de los valores de
|
||||
<parameter>flags</parameter> que no sobrescriban, como
|
||||
<constant>EXTR_SKIP</constant> y tenga en cuenta que debe extraer
|
||||
en el mismo orden que está definido en
|
||||
<link linkend="ini.variables-order">variables_order</link> dentro del
|
||||
<link linkend="ini">&php.ini;</link>.
|
||||
</para>
|
||||
</warning>
|
||||
</refsect1>
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 2e60c5134e7a847c99f81eb3f7ecee1f5efeeace Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: eaec4ab10a65c4515ee2fb899d06e89bae3754b0 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<!-- CREDITS: DavidA. -->
|
||||
|
||||
<refentry xml:id="function.list" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>list</refname>
|
||||
@@ -16,24 +14,36 @@
|
||||
<methodparam rep="repeat" choice="opt"><type>mixed</type><parameter>vars</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Al igual que <function>array</function>, <function>list</function> no es una
|
||||
función real, sino un elemento de lenguaje, que permite agrupar
|
||||
las variables <parameter>varname</parameter>, <parameter>...</parameter>
|
||||
en forma de array, para asignarlas en una sola línea.
|
||||
Las strings no pueden ser desestructuradas y las expresiones
|
||||
<function>list</function> no pueden estar completamente vacías.
|
||||
Al igual que <function>array</function>, esto no es realmente una función,
|
||||
sino una construcción del lenguaje. <function>list</function> se utiliza para
|
||||
asignar una lista de variables en una sola operación.
|
||||
Solo se pueden desempaquetar arrays y objetos que implementen <link linkend="class.arrayaccess">ArrayAccess</link>.
|
||||
Las expresiones <function>list</function> no pueden estar completamente vacías.
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
Antes de PHP 7.1.0, <function>list</function> solo funciona con arrays
|
||||
de índices numéricos y asume que el índice numérico comienza en 0.
|
||||
Antes de PHP 7.1.0, <function>list</function> solo funcionaba con arrays numéricos y asumía
|
||||
que los índices numéricos comenzaban en 0.
|
||||
</para>
|
||||
</note>
|
||||
<para>
|
||||
A partir de PHP 7.1.0, <function>list</function> también puede contener claves explícitas, permitiendo así la
|
||||
desestructuración de arrays con claves no enteras o no secuenciales. Para más detalles sobre
|
||||
la desestructuración de arrays, ver la <link linkend="language.types.array.syntax.destructuring">sección sobre la desestructuración de arrays</link>.
|
||||
A partir de PHP 7.1.0, <function>list</function> también puede contener claves explícitas, permitiendo
|
||||
la desestructuración de arrays con claves no enteras o no secuenciales. Para más detalles sobre
|
||||
la desestructuración de arrays, consulte la <link linkend="language.types.array.syntax.destructuring">sección de desestructuración de arrays</link>.
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
Intentar acceder a una clave de array que no ha sido definida es
|
||||
lo mismo que acceder a cualquier otra variable no definida:
|
||||
se emitirá un mensaje de error de nivel <constant>E_WARNING</constant>
|
||||
(nivel <constant>E_NOTICE</constant> antes de PHP 8.0.0) y
|
||||
el resultado será &null;.
|
||||
</para>
|
||||
<para>
|
||||
Intentar desempaquetar un escalar asigna &null; a todas las variables.
|
||||
Intentar desempaquetar un objeto que no implementa ArrayAccess es un error fatal.
|
||||
</para>
|
||||
</note>
|
||||
</refsect1>
|
||||
<refsect1 role="parameters">
|
||||
&reftitle.parameters;
|
||||
@@ -81,16 +91,14 @@
|
||||
<row>
|
||||
<entry>7.3.0</entry>
|
||||
<entry>
|
||||
Se añadió el soporte para la asignación por referencia en la desestructuración
|
||||
de arrays.
|
||||
Se añadió soporte para asignaciones por referencia en la desestructuración de arrays.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>7.1.0</entry>
|
||||
<entry>
|
||||
Ahora es posible especificar claves en
|
||||
<function>list</function>. Esto permite desestructurar arrays
|
||||
con claves no enteras o no secuenciales.
|
||||
Ahora es posible especificar claves en <function>list</function>. Esto
|
||||
permite la desestructuración de arrays con claves no enteras o no secuenciales.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -102,22 +110,22 @@
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>list</function></title>
|
||||
<title>Ejemplos de <function>list</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
$info = array('coffee', 'brown', 'caffeine');
|
||||
|
||||
// Lista todas las variables
|
||||
// Listando todas las variables
|
||||
list($drink, $color, $power) = $info;
|
||||
echo "$drink is $color and $power makes it special.\n";
|
||||
|
||||
// Lista algunas variables
|
||||
// Listando algunas de ellas
|
||||
list($drink, , $power) = $info;
|
||||
echo "$drink has $power.\n";
|
||||
|
||||
// O bien, solo usamos el tercero
|
||||
// O saltemos solo a la tercera
|
||||
list( , , $power) = $info;
|
||||
echo "I need $power!\n";
|
||||
|
||||
@@ -131,7 +139,7 @@ var_dump($bar); // NULL
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo de uso de <function>list</function></title>
|
||||
<title>Un ejemplo de uso de <function>list</function></title>
|
||||
<programlisting role="php" annotations="non-interactive">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -146,7 +154,7 @@ while (list($id, $name) = $result->fetch(PDO::FETCH_NUM)) {
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
<title>Uso de un sub-<function>list</function></title>
|
||||
<title>Uso de <function>list</function> anidado</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -169,12 +177,12 @@ int(3)
|
||||
</example>
|
||||
</para>
|
||||
<para>
|
||||
El orden en el que se definen los índices de un array a procesar por
|
||||
<function>list</function> no es relevante.
|
||||
El orden en el que se definen los índices del array a ser consumido por
|
||||
<function>list</function> es irrelevante.
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
<title><function>list</function> y el orden de definición de los índices</title>
|
||||
<title><function>list</function> y el orden de las definiciones de índices</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -185,9 +193,8 @@ var_dump($foo, $x, $y, $z);
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
Dado el siguiente resultado (note el orden de los elementos comparados
|
||||
y en qué orden se escribieron en la sintaxis
|
||||
de la <function>list</function>) :
|
||||
Produce la siguiente salida (note el orden de los elementos comparado con
|
||||
el orden en que fueron escritos en la sintaxis <function>list</function>):
|
||||
</para>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
@@ -214,8 +221,8 @@ string(1) "a"
|
||||
<simpara>
|
||||
A partir de PHP 7.1.0 <function>list</function> ahora también puede contener
|
||||
claves explícitas, que pueden ser dadas como expresiones arbitrarias.
|
||||
La mezcla de claves &integer; y &string; está permitida; Sin embargo, los elementos
|
||||
con y sin claves no pueden mezclarse.
|
||||
Se permite mezclar claves enteras y string; sin embargo, no se pueden mezclar
|
||||
elementos con y sin claves.
|
||||
</simpara>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
@@ -244,6 +251,7 @@ id: 2, name: Fred
|
||||
</example>
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="seealso">
|
||||
&reftitle.seealso;
|
||||
<para>
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 96c9d88bad9a7d7d44bfb7f26c226df7ee9ddf26 Maintainer: chuso Status: ready -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.dio-tcsetattr" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>dio_tcsetattr</refname>
|
||||
<refpurpose>
|
||||
Establece los atributos terminales y la tasa de baudios del puerto serie
|
||||
Establece los atributos de terminal y la velocidad de transmisión para un puerto serie
|
||||
</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
@@ -16,8 +16,8 @@
|
||||
<methodparam><type>array</type><parameter>options</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
<function>dio_tcsetattr</function> establece los atributos terminales y la
|
||||
tasa de baudios del fichero <parameter>fd</parameter>.
|
||||
<function>dio_tcsetattr</function> establece los atributos de terminal y la velocidad de
|
||||
transmisión del <parameter>fd</parameter> abierto.
|
||||
</para>
|
||||
</refsect1>
|
||||
<refsect1 role="parameters">
|
||||
@@ -28,7 +28,7 @@
|
||||
<term><parameter>fd</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Descriptor de fichero devuelto por <function>dio_open</function>.
|
||||
El descriptor de fichero devuelto por <function>dio_open</function>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -36,11 +36,11 @@
|
||||
<term><parameter>options</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Las siguientes opciones están disponibles:
|
||||
Las opciones disponibles actualmente son:
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<para>
|
||||
'baud' - tasa de baudios del puerto - puede ser 38400,19200,9600,4800,2400,1800,
|
||||
'baud' - velocidad de transmisión del puerto - puede ser 38400,19200,9600,4800,2400,1800,
|
||||
1200,600,300,200,150,134,110,75 o 50, el valor por omisión es 9600.
|
||||
</para>
|
||||
</listitem>
|
||||
@@ -56,7 +56,7 @@
|
||||
</listitem>
|
||||
<listitem>
|
||||
<para>
|
||||
'parity' - paridad - puede ser 0,1 o 2. El valor por omisión es 0.
|
||||
'parity' - puede ser 0,1 o 2. El valor por omisión es 0.
|
||||
</para>
|
||||
</listitem>
|
||||
</itemizedlist>
|
||||
@@ -74,10 +74,9 @@
|
||||
</refsect1>
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Asignando la tasa de baudios del puerto serie</title>
|
||||
<programlisting role="php">
|
||||
<example>
|
||||
<title>Establecer la velocidad de transmisión en un puerto serie</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
@@ -86,26 +85,23 @@ $fd = dio_open('/dev/ttyS0', O_RDWR | O_NOCTTY | O_NONBLOCK);
|
||||
dio_fcntl($fd, F_SETFL, O_SYNC);
|
||||
|
||||
dio_tcsetattr($fd, array(
|
||||
'baud' => 9600,
|
||||
'bits' => 8,
|
||||
'stop' => 1,
|
||||
'parity' => 0
|
||||
));
|
||||
'baud' => 9600,
|
||||
'bits' => 8,
|
||||
'stop' => 1,
|
||||
'parity' => 0
|
||||
));
|
||||
|
||||
while (1) {
|
||||
|
||||
$data = dio_read($fd, 256);
|
||||
|
||||
if ($data) {
|
||||
echo $data;
|
||||
}
|
||||
}
|
||||
while (true) {
|
||||
$data = dio_read($fd, 256);
|
||||
if ($data !== null && $date !== '') {
|
||||
echo $data;
|
||||
}
|
||||
}
|
||||
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</para>
|
||||
</programlisting>
|
||||
</example>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="notes">
|
||||
@@ -113,7 +109,6 @@ while (1) {
|
||||
¬e.no-windows;
|
||||
</refsect1>
|
||||
</refentry>
|
||||
|
||||
<!-- Keep this comment at the end of the file
|
||||
Local variables:
|
||||
mode: sgml
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 6fa29283c5861ccb1f9da74fb252f80e01d27668 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.enchant-broker-request-dict" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>enchant_broker_request_dict</refname>
|
||||
<refpurpose>Crea un nuevo diccionario</refpurpose>
|
||||
<refpurpose>Crear un nuevo diccionario usando una etiqueta</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -15,9 +14,8 @@
|
||||
<methodparam><type>string</type><parameter>tag</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Crea un nuevo diccionario utilizando el argumento <parameter>tag</parameter>,
|
||||
que representa el idioma para el cual se desea asociar el diccionario
|
||||
("en_US", "de_DE", ...).
|
||||
crea un nuevo diccionario usando una etiqueta, la etiqueta de idioma no vacía que
|
||||
desea solicitar para un diccionario ("en_US", "de_DE", ...)
|
||||
</para>
|
||||
</refsect1>
|
||||
<refsect1 role="parameters">
|
||||
@@ -29,7 +27,7 @@
|
||||
<term><parameter>tag</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Una etiqueta que describe el idioma, por ejemplo, en_US, de_DE
|
||||
Una etiqueta que describe la configuración local, por ejemplo en_US, de_DE
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -59,8 +57,8 @@
|
||||
<row>
|
||||
<entry>8.0.0</entry>
|
||||
<entry>
|
||||
En caso de éxito, esta función devuelve ahora una instancia de <classname>EnchantDictionary</classname> ;
|
||||
anteriormente se devolvía un &resource;.
|
||||
En caso de éxito, esta función devuelve ahora una instancia de <classname>EnchantDictionary</classname>;
|
||||
anteriormente, se devolvía un &resource;.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -70,26 +68,25 @@
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>enchant_broker_request_dict</function></title>
|
||||
<para>
|
||||
Verifica si existe un diccionario utilizando la función
|
||||
<function>enchant_broker_dict_exists</function> y lo solicita.
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
<example>
|
||||
<title>Un ejemplo de <function>enchant_broker_request_dict</function></title>
|
||||
<para>
|
||||
Comprueba si existe un diccionario usando
|
||||
<function>enchant_broker_dict_exists</function> y solicítalo.
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$tag = 'en_US';
|
||||
$broker = enchant_broker_init();
|
||||
if (enchant_broker_dict_exists($broker,$tag)) {
|
||||
$dict = enchant_broker_request_dict($r, $tag);
|
||||
$dict = enchant_broker_request_dict($broker, $tag);
|
||||
var_dump($dict);
|
||||
}
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</para>
|
||||
</programlisting>
|
||||
</example>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="seealso">
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 62126c55f1c6ed444043e7272c4f9e233818a44b Maintainer: julionc Status: ready -->
|
||||
<!-- Reviewed: yes -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.enchant-dict-add" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>enchant_dict_add</refname>
|
||||
<refpurpose>Add a word to personal word list</refpurpose>
|
||||
<refpurpose>Añadir una palabra a la lista personal de palabras</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -15,7 +14,7 @@
|
||||
<methodparam><type>string</type><parameter>word</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Añadir una palabra a la lista de palabras personalizadas del diccionario dado.
|
||||
Añade una palabra a la lista personal de palabras del diccionario dado.
|
||||
</para>
|
||||
</refsect1>
|
||||
<refsect1 role="parameters">
|
||||
@@ -40,7 +39,7 @@
|
||||
&return.success;
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
|
||||
<refsect1 role="changelog">
|
||||
&reftitle.changelog;
|
||||
<informaltable>
|
||||
@@ -61,7 +60,7 @@
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<example>
|
||||
<title>Agregar una palabra a una PWL</title>
|
||||
<title>Añadir una palabra a una PWL</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -74,8 +73,6 @@ $dict = enchant_broker_request_pwl_dict($broker, $filename);
|
||||
|
||||
enchant_dict_add($dict, $word);
|
||||
|
||||
enchant_broker_free($broker);
|
||||
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 6fa29283c5861ccb1f9da74fb252f80e01d27668 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.enchant-dict-describe" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>enchant_dict_describe</refname>
|
||||
<refpurpose>Describe un diccionario</refpurpose>
|
||||
<refpurpose>Describe un diccionario individual</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -14,7 +13,7 @@
|
||||
<methodparam><type>EnchantDictionary</type><parameter>dictionary</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Devuelve los detalles de un diccionario.
|
||||
Devuelve los detalles del diccionario.
|
||||
</para>
|
||||
|
||||
</refsect1>
|
||||
@@ -49,7 +48,7 @@
|
||||
<row>
|
||||
<entry>8.0.0</entry>
|
||||
<entry>
|
||||
Antes de esta versión, esta función devolvía &false; en caso de fallo.
|
||||
Antes de esta versión, la función devolvía &false; en caso de error.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -59,40 +58,38 @@
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>enchant_dict_describe</function></title>
|
||||
<para>
|
||||
Verifica si un diccionario existe utilizando la función
|
||||
<function>enchant_broker_dict_exists</function> y muestra todos los detalles concernientes a este diccionario.
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
<example>
|
||||
<title>Ejemplo de <function>enchant_dict_describe</function></title>
|
||||
<para>
|
||||
Comprueba si existe un diccionario usando
|
||||
<function>enchant_broker_dict_exists</function> y muestra sus detalles.
|
||||
</para>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$tag = 'en_US';
|
||||
$broker = enchant_broker_init();
|
||||
if (enchant_broker_dict_exists($broker,$tag)) {
|
||||
$dict = enchant_broker_request_dict($r, $tag);
|
||||
if (enchant_broker_dict_exists($broker, $tag)) {
|
||||
$dict = enchant_broker_request_dict($broker, $tag);
|
||||
$dict_details = enchant_dict_describe($dict);
|
||||
print_r($dict_details);
|
||||
}
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
&example.outputs.similar;
|
||||
<screen>
|
||||
</programlisting>
|
||||
&example.outputs.similar;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
Array
|
||||
(
|
||||
[lang] => en_US
|
||||
[name] => aspell
|
||||
[desc] => Aspell Provider
|
||||
[desc] => Proveedor Aspell
|
||||
[file] => /usr/lib/enchant/libenchant_aspell.so
|
||||
)
|
||||
]]>
|
||||
</screen>
|
||||
</example>
|
||||
</para>
|
||||
</screen>
|
||||
</example>
|
||||
</refsect1>
|
||||
</refentry>
|
||||
<!-- Keep this comment at the end of the file
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 6fa29283c5861ccb1f9da74fb252f80e01d27668 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.enchant-dict-suggest" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>enchant_dict_suggest</refname>
|
||||
<refpurpose>Retorna una lista de valores si ninguna de las condiciones se cumple</refpurpose>
|
||||
<refpurpose>Devolverá una lista de valores si no se cumplen alguna de las precondiciones</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -26,7 +25,7 @@
|
||||
<term><parameter>word</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Palabra a utilizar para las sugerencias
|
||||
Palabra para la que se generarán sugerencias.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -36,7 +35,7 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Retorna un array de sugerencias si la palabra está mal escrita.
|
||||
Devuelve un array de sugerencias si la palabra está mal escrita.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -59,10 +58,9 @@
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>enchant_dict_suggest</function></title>
|
||||
<programlisting role="php">
|
||||
<example>
|
||||
<title>Ejemplo de uso de <function>enchant_dict_suggest</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$tag = 'en_US';
|
||||
@@ -73,17 +71,14 @@ if (enchant_broker_dict_exists($r,$tag)) {
|
||||
$wordcorrect = enchant_dict_check($d, "soong");
|
||||
if (!$wordcorrect) {
|
||||
$suggs = enchant_dict_suggest($d, "soong");
|
||||
echo "Sugerencias para 'soong' : ";
|
||||
echo "Sugerencias para 'soong':";
|
||||
print_r($suggs);
|
||||
}
|
||||
enchant_broker_free_dict($d);
|
||||
}
|
||||
enchant_broker_free($r);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
</para>
|
||||
</programlisting>
|
||||
</example>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="seealso">
|
||||
|
||||
@@ -1,16 +1,15 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 3cb239e6e98fc2b7353fca4149f08902d08b8100 Maintainer: Marqitos Status: ready -->
|
||||
<!-- Reviewed: no Maintainer: seros -->
|
||||
<!-- EN-Revision: edb34f53e1d711a5bd968d1fe1b9b41e58ed38cb Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<!-- Generated by xml_proto.php v2.4. Found in /scripts directory of phpdoc. -->
|
||||
<appendix xml:id="filter.constants" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
&reftitle.constants;
|
||||
&extension.constants;
|
||||
|
||||
<variablelist>
|
||||
<title>Constantes de Input</title>
|
||||
<title>Constantes de entrada</title>
|
||||
<simpara>
|
||||
Estas constantes son usadas por
|
||||
Estas constantes son utilizadas por
|
||||
<function>filter_input</function> y
|
||||
<function>filter_input_array</function>.
|
||||
</simpara>
|
||||
@@ -96,7 +95,7 @@
|
||||
</variablelist>
|
||||
|
||||
<variablelist xml:id="filter.constants.flags.generic">
|
||||
<title>Flags de filtros genéricos</title>
|
||||
<title>Flags genéricos de filtro</title>
|
||||
<varlistentry xml:id="constant.filter-flag-none">
|
||||
<term>
|
||||
<constant>FILTER_FLAG_NONE</constant>
|
||||
@@ -115,7 +114,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Flag usado para requerir un escalar como entrada.
|
||||
Flag utilizado para requerir que la entrada del filtro sea un escalar.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -126,7 +125,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Flag usado para requerir ru la entrada sea un <type>array</type>.
|
||||
Flag utilizado para requerir que la entrada del filtro sea un <type>array</type>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -137,8 +136,8 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Este flag envuelve las entradas escalares en un <type>array</type> de un solo elemento
|
||||
para los filtros que operan en <type>arrays</type>.
|
||||
Este flag envuelve las entradas escalares en un <type>array</type> de un elemento
|
||||
para filtros que operan sobre arrays.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -149,7 +148,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Devuelve &null; en vez de &false; en caso de fallo.
|
||||
Usar &null; en lugar de &false; en caso de fallo.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Utilizable con cualquier filtro de validación
|
||||
@@ -160,7 +159,7 @@
|
||||
</variablelist>
|
||||
|
||||
<variablelist xml:id="filter.constants.flags.sanitization">
|
||||
<title>Flags para filtros de saneamiento</title>
|
||||
<title>Flags de filtro de saneamiento</title>
|
||||
<varlistentry xml:id="constant.filter-flag-strip-low">
|
||||
<term>
|
||||
<constant>FILTER_FLAG_STRIP_LOW</constant>
|
||||
@@ -168,7 +167,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Elimina caracteres con un valor ASCII inferior a 32.
|
||||
Elimina caracteres con valor ASCII menor que 32.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -179,7 +178,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Elimina caracteres con un valor ASCII superior a 127.
|
||||
Elimina caracteres con valor ASCII mayor que 127.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -190,7 +189,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Elimina los caracteres de acento grave (<literal>`</literal>).
|
||||
Elimina caracteres de comilla invertida (<literal>`</literal>).
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -201,7 +200,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Codifica caracteres con un valor ASCII inferior a 32.
|
||||
Codifica caracteres con valor ASCII menor que 32.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -212,7 +211,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Codifica caracteres con un valor ASCII superior a 127.
|
||||
Codifica caracteres con valor ASCII mayor que 127.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -235,7 +234,7 @@
|
||||
<listitem>
|
||||
<simpara>
|
||||
Las comillas simples y dobles (<literal>'</literal> y <literal>"</literal>)
|
||||
no se codificarán.
|
||||
no serán codificadas.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -248,14 +247,14 @@
|
||||
<simpara>
|
||||
<!-- TODO Document/check which filters accept this flag (FILTER_UNSAFE_RAW and FILTER_SANITIZE_STRING only) -->
|
||||
Si el saneamiento de un string resulta en un string vacío,
|
||||
convierte el valor a &null;.
|
||||
convierte el valor a &null;
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
</variablelist>
|
||||
|
||||
<variablelist xml:id="filter.constants.validation">
|
||||
<title>Filtros de Validación</title>
|
||||
<title>Filtros de validación</title>
|
||||
|
||||
<varlistentry xml:id="constant.filter-validate-bool">
|
||||
<term>
|
||||
@@ -277,9 +276,9 @@
|
||||
<literal>""</literal>.
|
||||
</simpara>
|
||||
<simpara>
|
||||
El valor devuelto para valores no booleanos depende de
|
||||
El valor de retorno para valores no booleanos depende de
|
||||
<constant>FILTER_NULL_ON_FAILURE</constant>.
|
||||
Si está establecido, se devolverá &null;, de lo contrario se devolverá &false;.
|
||||
Si está configurado, se devuelve &null;, de lo contrario se devuelve &false;.
|
||||
</simpara>
|
||||
<variablelist xml:id="filter.constants.validation.bool.options">
|
||||
<title>Opciones disponibles</title>
|
||||
@@ -287,7 +286,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -306,8 +305,8 @@
|
||||
<listitem>
|
||||
<simpara>
|
||||
&Alias; <constant>FILTER_VALIDATE_BOOL</constant>.
|
||||
El alias estaba disponible antes de la introducción de su nombre
|
||||
canónico en PHP 8.0.0.
|
||||
El alias estaba disponible antes de la introducción de su nombre canónico
|
||||
en PHP 8.0.0.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -319,8 +318,8 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valida cuando el valor es un entero,
|
||||
en caso de éxito es convertido al tipo <type>int</type>.
|
||||
Valida si el valor es un entero,
|
||||
en caso de éxito se convierte al tipo <type>int</type>.
|
||||
</simpara>
|
||||
|
||||
<note>
|
||||
@@ -336,7 +335,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -344,7 +343,7 @@
|
||||
<term><literal>min_range</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
El valor es válido solo si es mayor o igual al valor proporcionado.
|
||||
El valor solo es válido si es mayor o igual que el valor proporcionado.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -352,7 +351,7 @@
|
||||
<term><literal>max_range</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
El valor es válido solo si es menor o igual al valor proporcionado.
|
||||
El valor solo es válido si es menor o igual que el valor proporcionado.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -395,8 +394,8 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valida cuando un valor es un float,
|
||||
en caso de éxito es convertido al tipo <type>float</type>.
|
||||
Valida si el valor es un float,
|
||||
en caso de éxito se convierte al tipo <type>float</type>.
|
||||
</simpara>
|
||||
|
||||
<note>
|
||||
@@ -412,7 +411,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -428,7 +427,7 @@
|
||||
<term><literal>min_range</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
El valor es válido solo si es mayor o igual al valor proporcionado.
|
||||
El valor solo es válido si es mayor o igual que el valor proporcionado.
|
||||
Disponible a partir de PHP 7.4.0.
|
||||
</simpara>
|
||||
</listitem>
|
||||
@@ -437,7 +436,7 @@
|
||||
<term><literal>max_range</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
El valor es válido solo si es menor o igual al valor proporcionado.
|
||||
El valor solo es válido si es menor o igual que el valor proporcionado.
|
||||
Disponible a partir de PHP 7.4.0.
|
||||
</simpara>
|
||||
</listitem>
|
||||
@@ -452,8 +451,8 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Acepta commas (<literal>,</literal>),
|
||||
que usualmente representan el separador de miles.
|
||||
Acepta comas (<literal>,</literal>),
|
||||
que normalmente representan el separador de miles.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -467,7 +466,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valida un valor contra la expresión regular proporcionada por la
|
||||
Valida el valor contra la expresión regular proporcionada por la
|
||||
opción <literal>regexp</literal>.
|
||||
</simpara>
|
||||
|
||||
@@ -477,7 +476,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -485,7 +484,7 @@
|
||||
<term><literal>regexp</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Expresión regular <link linkend="book.pcre">compatible con Perl</link>
|
||||
Expresión regular <link linkend="book.pcre">compatible con Perl</link>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -500,7 +499,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valida si el valor es una <acronym>URL</acronym> válida según
|
||||
Valida si el nombre de <acronym>URL</acronym> es válido según
|
||||
<link xlink:href="&url.rfc;2396">RFC 2396</link>.
|
||||
</simpara>
|
||||
<variablelist xml:id="filter.constants.validation.url.options">
|
||||
@@ -509,13 +508,13 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
</variablelist>
|
||||
<variablelist xml:id="filter.constants.validation.url.flags">
|
||||
<title>Optional Flags</title>
|
||||
<title>Flags opcionales</title>
|
||||
<varlistentry xml:id="constant.filter-flag-scheme-required">
|
||||
<term>
|
||||
<constant>FILTER_FLAG_SCHEME_REQUIRED</constant>
|
||||
@@ -523,14 +522,14 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Requiere que la <acronym>URL</acronym> contenga una parte de esquema (scheme).
|
||||
Requiere que la <acronym>URL</acronym> contenga una parte de esquema.
|
||||
</simpara>
|
||||
<warning>
|
||||
<simpara>
|
||||
<emphasis>OBSOLETO</emphasis> a partir de PHP 7.3.0 y
|
||||
<emphasis>ELIMINADO</emphasis> a partir de PHP 8.0.0.
|
||||
Esto es porque siempre es implícito por el filtro
|
||||
<constant>FILTER_VALIDATE_URL</constant>.
|
||||
Esto se debe a que siempre está implícito por el
|
||||
filtro <constant>FILTER_VALIDATE_URL</constant>.
|
||||
</simpara>
|
||||
</warning>
|
||||
</listitem>
|
||||
@@ -548,8 +547,8 @@
|
||||
<simpara>
|
||||
<emphasis>OBSOLETO</emphasis> a partir de PHP 7.3.0 y
|
||||
<emphasis>ELIMINADO</emphasis> a partir de PHP 8.0.0.
|
||||
Esto es porque siempre es implícito por el filtro
|
||||
<constant>FILTER_VALIDATE_URL</constant>.
|
||||
Esto se debe a que siempre está implícito por el
|
||||
filtro <constant>FILTER_VALIDATE_URL</constant>.
|
||||
</simpara>
|
||||
</warning>
|
||||
</listitem>
|
||||
@@ -572,23 +571,23 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Requiere que la <acronym>URL</acronym> contenga una parte de consulta (query).
|
||||
Requiere que la <acronym>URL</acronym> contenga una parte de consulta.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
</variablelist>
|
||||
<warning>
|
||||
<simpara>
|
||||
Una <acronym>URL</acronym> válida no puede especificar el
|
||||
Una <acronym>URL</acronym> válida puede no especificar el
|
||||
protocolo <acronym>HTTP</acronym> (<literal>http://</literal>).
|
||||
Por lo tanto, se puede requerir una validación adicional para determinar si la
|
||||
Por lo tanto, puede ser necesaria una validación adicional para determinar si la
|
||||
<acronym>URL</acronym> usa un protocolo esperado,
|
||||
por ejemplo <literal>ssh://</literal> o <literal>mailto:</literal>.
|
||||
por ejemplo, <literal>ssh://</literal> o <literal>mailto:</literal>.
|
||||
</simpara>
|
||||
</warning>
|
||||
<warning>
|
||||
<simpara>
|
||||
Este filtro solo funciona en <acronym>URL</acronym>s <acronym>ASCII</acronym>.
|
||||
Este filtro solo funciona con <acronym>URL</acronym>s <acronym>ASCII</acronym>.
|
||||
Esto significa que los Nombres de Dominio Internacionalizados (IDN) siempre serán rechazados.
|
||||
</simpara>
|
||||
</warning>
|
||||
@@ -606,7 +605,8 @@
|
||||
<link xlink:href="&url.rfc;1034">RFC 1034</link>,
|
||||
<link xlink:href="&url.rfc;1035">RFC 1035</link>,
|
||||
<link xlink:href="&url.rfc;1034">RFC 1123</link>,
|
||||
<link xlink:href="&url.rfc;1034">RFC 2732</link> y
|
||||
<link xlink:href="&url.rfc;1034">RFC 2732</link>,
|
||||
y
|
||||
<link xlink:href="&url.rfc;2181">RFC 2181</link>.
|
||||
</simpara>
|
||||
<variablelist xml:id="filter.constants.validation.domain.options">
|
||||
@@ -615,7 +615,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -630,7 +630,7 @@
|
||||
<listitem>
|
||||
<simpara>
|
||||
Requiere que los nombres de host comiencen con un carácter alfanumérico y contengan
|
||||
solo alfanuméricos o guiones.
|
||||
solo caracteres alfanuméricos o guiones.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -649,9 +649,10 @@
|
||||
|
||||
<simpara>
|
||||
La validación se realiza contra la sintaxis <literal>addr-spec</literal>
|
||||
en <link xlink:href="&url.rfc;822">RFC 822</link>.
|
||||
en
|
||||
<link xlink:href="&url.rfc;822">RFC 822</link>.
|
||||
Sin embargo, los comentarios, el plegado de espacios en blanco y los nombres de dominio sin puntos
|
||||
no son compatibles, y por lo tanto serán rechazados.
|
||||
no están soportados, y por lo tanto serán rechazados.
|
||||
</simpara>
|
||||
|
||||
<variablelist xml:id="filter.constants.validation.email.options">
|
||||
@@ -660,7 +661,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -683,8 +684,8 @@
|
||||
|
||||
<warning>
|
||||
<simpara>
|
||||
La validación de correo electrónico es compleja y la única forma real de confirmar
|
||||
que un correo electrónico es válido y existe es enviar un correo electrónico a la dirección.
|
||||
La validación de correo electrónico es compleja y la única forma verdadera de confirmar que un correo electrónico
|
||||
es válido y existe es enviar un correo electrónico a la dirección.
|
||||
</simpara>
|
||||
</warning>
|
||||
</listitem>
|
||||
@@ -697,7 +698,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<para>
|
||||
Valida si el valor es una dirección IP válida.
|
||||
Valida el valor como dirección IP.
|
||||
</para>
|
||||
<variablelist xml:id="filter.constants.validation.ip.options">
|
||||
<title>Opciones disponibles</title>
|
||||
@@ -705,13 +706,13 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
</variablelist>
|
||||
<variablelist xml:id="filter.constants.validation.ip.flags">
|
||||
<title>Optional Flags</title>
|
||||
<title>Flags opcionales</title>
|
||||
<varlistentry xml:id="constant.filter-flag-ipv4">
|
||||
<term>
|
||||
<constant>FILTER_FLAG_IPV4</constant>
|
||||
@@ -744,12 +745,12 @@
|
||||
Deniega direcciones reservadas.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Estas son las rangos marcados como
|
||||
Estos son los rangos que están marcados como
|
||||
<literal>Reserved-By-Protocol</literal> en
|
||||
<link xlink:href="&url.rfc;6890">RFC 6890</link>.
|
||||
</simpara>
|
||||
<para>
|
||||
En caso de IPv4 corresponde a los siguientes rangos:
|
||||
Que para IPv4 corresponden a los siguientes rangos:
|
||||
<simplelist type="inline">
|
||||
<member><literal>0.0.0.0/8</literal></member>
|
||||
<member><literal>169.254.0.0/16</literal></member>
|
||||
@@ -758,7 +759,7 @@
|
||||
</simplelist>.
|
||||
</para>
|
||||
<para>
|
||||
Y para IPv6 corresponde a los siguientes rangos:
|
||||
Y para IPv6 corresponden a los siguientes rangos:
|
||||
<simplelist type="inline">
|
||||
<member><literal>::1/128</literal></member>
|
||||
<member><literal>::/128</literal></member>
|
||||
@@ -778,7 +779,7 @@
|
||||
Deniega direcciones privadas.
|
||||
</simpara>
|
||||
<para>
|
||||
En caso de IPv4 corresponde a los siguientes rangos:
|
||||
Estas son direcciones IPv4 que están en los siguientes rangos:
|
||||
<simplelist type="inline">
|
||||
<member><literal>10.0.0.0/8</literal></member>
|
||||
<member><literal>172.16.0.0/12</literal></member>
|
||||
@@ -799,9 +800,9 @@
|
||||
<listitem>
|
||||
<simpara>
|
||||
Solo permite direcciones globales.
|
||||
Estas pueden ser encontradas en
|
||||
Estas se pueden encontrar en
|
||||
<link xlink:href="&url.rfc;6890">RFC 6890</link>
|
||||
cuando el atributo <literal>Global</literal> es <literal>True</literal>.
|
||||
donde el atributo <literal>Global</literal> es <literal>True</literal>.
|
||||
Disponible a partir de PHP 8.2.0.
|
||||
</simpara>
|
||||
</listitem>
|
||||
@@ -817,7 +818,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valida cuando el valor es una dirección MAC.
|
||||
Valida si el valor es una dirección MAC.
|
||||
</simpara>
|
||||
|
||||
<variablelist xml:id="filter.constants.validation.mac.options">
|
||||
@@ -826,7 +827,7 @@
|
||||
<term><literal>default</literal></term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Valor a devolver en caso de fallo del filtro.
|
||||
Valor a devolver en caso de que el filtro falle.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -848,8 +849,7 @@
|
||||
</simpara>
|
||||
<simpara>
|
||||
Sin embargo, puede eliminar o codificar caracteres especiales si se usa junto con
|
||||
los flags de saneamiento de filtro
|
||||
<constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>
|
||||
los flags de saneamiento de filtro <constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>
|
||||
y <constant>FILTER_FLAG_ENCODE_<replaceable>*</replaceable></constant>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
@@ -872,27 +872,26 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Este filtro elimina las etiquetas y codifica en HTML las comillas dobles y simples.
|
||||
Este filtro elimina etiquetas y codifica en HTML comillas dobles y simples.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Opcionalmente puede eliminar o codificar caracteres especificados si se usa junto con
|
||||
los flags de saneamiento de filtro
|
||||
<constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>
|
||||
los flags de saneamiento de filtro <constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>
|
||||
y <constant>FILTER_FLAG_ENCODE_<replaceable>*</replaceable></constant>.
|
||||
</simpara>
|
||||
<simpara>
|
||||
El comportamiento de codificación de comillas puede deshabilitarse usando el
|
||||
El comportamiento de codificación de comillas puede desactivarse usando el
|
||||
flag de filtro <constant>FILTER_FLAG_NO_ENCODE_QUOTES</constant>.
|
||||
</simpara>
|
||||
<warning>
|
||||
<simpara>
|
||||
<emphasis>OBSOLETO</emphasis> a partir de PHP 8.1.0,
|
||||
<emphasis>Obsoleto</emphasis> a partir de PHP 8.1.0,
|
||||
use <function>htmlspecialchars</function> en su lugar.
|
||||
</simpara>
|
||||
</warning>
|
||||
<warning>
|
||||
<simpara>
|
||||
La forma en que este filtro elimina las etiquetas no es equivalente a
|
||||
La forma en que este filtro elimina etiquetas no es equivalente a
|
||||
<function>strip_tags</function>.
|
||||
</simpara>
|
||||
</warning>
|
||||
@@ -909,7 +908,7 @@
|
||||
</simpara>
|
||||
<warning>
|
||||
<simpara>
|
||||
<emphasis>OBSOLETO</emphasis> a partir de PHP 8.1.0,
|
||||
<emphasis>Obsoleto</emphasis> a partir de PHP 8.1.0,
|
||||
use <function>htmlspecialchars</function> en su lugar.
|
||||
</simpara>
|
||||
</warning>
|
||||
@@ -922,17 +921,15 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Este filtro codifica en URL un string.
|
||||
Este filtro codifica una cadena en URL.
|
||||
</simpara>
|
||||
<simpara>
|
||||
Opcionalmente puede eliminar o codificar caracteres especificados si se usa junto con
|
||||
los flags de saneamiento de filtro
|
||||
<constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>
|
||||
los flags de saneamiento de filtro <constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>
|
||||
y <constant>FILTER_FLAG_ENCODE_<replaceable>*</replaceable></constant>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
|
||||
<varlistentry xml:id="constant.filter-sanitize-special-chars">
|
||||
<term>
|
||||
<constant>FILTER_SANITIZE_SPECIAL_CHARS</constant>
|
||||
@@ -948,14 +945,13 @@
|
||||
<member><literal>></literal></member>
|
||||
<member><literal>&</literal></member>
|
||||
</simplelist>
|
||||
y los caracteres con un valor ASCII menor a 32.
|
||||
y caracteres con un valor ASCII menor que 32.
|
||||
</para>
|
||||
<simpara>
|
||||
Opcionalmente puede eliminar o codificar caracteres especificados si se usa junto con
|
||||
los flags de saneamiento de filtro
|
||||
<constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>,
|
||||
y puede codificar caracteres con un valor ASCII mayor a 127 usando
|
||||
<constant>FILTER_FLAG_ENCODE_HIGH</constant>.
|
||||
Opcionalmente puede eliminar caracteres especificados si se usa junto con
|
||||
los flags de saneamiento de filtro <constant>FILTER_FLAG_STRIP_<replaceable>*</replaceable></constant>,
|
||||
y puede codificar caracteres con valor ASCII
|
||||
mayor que 127 usando <constant>FILTER_FLAG_ENCODE_HIGH</constant>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -967,19 +963,19 @@
|
||||
<listitem>
|
||||
<simpara>
|
||||
Este filtro es equivalente a llamar a <function>htmlspecialchars</function>
|
||||
con <constant>ENT_QUOTES</constant> establecido.
|
||||
con <constant>ENT_QUOTES</constant> configurado.
|
||||
</simpara>
|
||||
<simpara>
|
||||
El comportamiento de codificación de comillas puede deshabilitarse usando el
|
||||
El comportamiento de codificación de comillas puede desactivarse usando el
|
||||
flag de filtro <constant>FILTER_FLAG_NO_ENCODE_QUOTES</constant>.
|
||||
</simpara>
|
||||
<warning>
|
||||
<simpara>
|
||||
Igual que <function>htmlspecialchars</function>, este filtro es consciente de la
|
||||
Al igual que <function>htmlspecialchars</function>, este filtro es consciente de la
|
||||
configuración INI <link linkend="ini.default-charset">default_charset</link>.
|
||||
Si se detecta una secuencia de bytes que compone un carácter inválido en el
|
||||
conjunto de caracteres actual, se rechaza toda la cadena
|
||||
devolviendo como resultado en una cadena vacía.
|
||||
Si se detecta una secuencia de bytes que forma un carácter no válido
|
||||
en el juego de caracteres actual, entonces toda la cadena es rechazada
|
||||
resultando en que se devuelva una cadena vacía.
|
||||
</simpara>
|
||||
</warning>
|
||||
</listitem>
|
||||
@@ -991,7 +987,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Sanea una cadena eliminando todo los caracteres excepto
|
||||
Sanea la cadena eliminando todos los caracteres excepto
|
||||
letras latinas (<literal>[a-zA-Z]</literal>),
|
||||
dígitos (<literal>[0-9]</literal>),
|
||||
y los caracteres especiales
|
||||
@@ -1006,7 +1002,7 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Sanea un string eliminando todos los caracteres excepto
|
||||
Sanea la cadena eliminando todos los caracteres excepto
|
||||
letras latinas (<literal>[a-zA-Z]</literal>),
|
||||
dígitos (<literal>[0-9]</literal>),
|
||||
y los caracteres especiales
|
||||
@@ -1021,9 +1017,9 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Sanea una cadena eliminando todo los caracteres excepto dígitos
|
||||
(<literal>[0-9]</literal>), y los signos de más (<literal>+</literal>),
|
||||
y menos (<literal>-</literal>).
|
||||
Sanea la cadena eliminando todos los caracteres excepto dígitos
|
||||
(<literal>[0-9]</literal>), signo más (<literal>+</literal>),
|
||||
y signo menos (<literal>-</literal>).
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -1034,13 +1030,13 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Sanea una cadena eliminando todo los caracteres excepto dígitos
|
||||
(<literal>[0-9]</literal>), signos de más (<literal>+</literal>),
|
||||
y menos (<literal>-</literal>).
|
||||
Sanea la cadena eliminando todos los caracteres excepto dígitos
|
||||
(<literal>[0-9]</literal>), signo más (<literal>+</literal>),
|
||||
y signo menos (<literal>-</literal>).
|
||||
</simpara>
|
||||
|
||||
<variablelist xml:id="filter.constants.sanitization.float.flags">
|
||||
<title>Optional Flags</title>
|
||||
<title>Flags opcionales</title>
|
||||
<varlistentry xml:id="constant.filter-flag-allow-fraction">
|
||||
<term>
|
||||
<constant>FILTER_FLAG_ALLOW_FRACTION</constant>
|
||||
@@ -1048,9 +1044,9 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Acepta el carácter de punto <literal>.</literal>,
|
||||
que usualmente representa el separador entre la parte entera
|
||||
y fraccionaria.
|
||||
Acepta el carácter punto (<literal>.</literal>),
|
||||
que normalmente representa el separador entre las partes entera y
|
||||
fraccionaria.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -1061,8 +1057,8 @@
|
||||
</term>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Acepta el carácter de coma <literal>,</literal>,
|
||||
que usualmente representa el separador de miles.
|
||||
Acepta el carácter coma (<literal>,</literal>),
|
||||
que normalmente representa el separador de miles.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -1078,12 +1074,10 @@
|
||||
</simpara>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
|
||||
</variablelist>
|
||||
|
||||
<warning>
|
||||
<simpara>
|
||||
Si la <constant>FILTER_FLAG_ALLOW_FRACTION</constant> no es usada,
|
||||
Si no se usa el flag <constant>FILTER_FLAG_ALLOW_FRACTION</constant>,
|
||||
entonces el separador decimal es eliminado, alterando el valor recibido.
|
||||
</simpara>
|
||||
<informalexample>
|
||||
@@ -1142,7 +1136,7 @@ string(5) "12.34"
|
||||
</variablelist>
|
||||
|
||||
<variablelist>
|
||||
<title>Filtros definidos por el usuario</title>
|
||||
<title>Filtro definido por el usuario</title>
|
||||
<varlistentry xml:id="constant.filter-callback">
|
||||
<term>
|
||||
<constant>FILTER_CALLBACK</constant>
|
||||
@@ -1151,12 +1145,12 @@ string(5) "12.34"
|
||||
<listitem>
|
||||
<simpara>
|
||||
Este filtro delega el filtrado a una función definida por el usuario.
|
||||
El <type>callable</type> es pasado a través del
|
||||
El <type>callable</type> se pasa a través del
|
||||
parámetro <parameter>options</parameter> como el valor asociado a
|
||||
la clave <literal>'options'</literal>.
|
||||
</simpara>
|
||||
<para>
|
||||
La función de filtrado debe tener la siguiente firma:
|
||||
La retrollamada debe tener la siguiente firma:
|
||||
<methodsynopsis>
|
||||
<type>mixed</type><methodname><replaceable>callback</replaceable></methodname>
|
||||
<methodparam><type>string</type><parameter>value</parameter></methodparam>
|
||||
@@ -1174,19 +1168,19 @@ string(5) "12.34"
|
||||
</para>
|
||||
<note>
|
||||
<simpara>
|
||||
El valor devuelto por la función de filtrado será el valor devuelto por
|
||||
El valor devuelto por la retrollamada será el valor devuelto por
|
||||
la función de filtro invocada.
|
||||
</simpara>
|
||||
</note>
|
||||
<example>
|
||||
<title>
|
||||
Ejemplo de uso de <constant>FILTER_CALLBACK</constant> para validar
|
||||
un nombre de usuario
|
||||
un nombre de inicio de sesión
|
||||
</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
function validate_login($value): ?string
|
||||
function validate_login(string $value): ?string
|
||||
{
|
||||
if (strlen($value) >= 5 && ctype_alnum($value)) {
|
||||
return $value;
|
||||
@@ -1194,11 +1188,11 @@ function validate_login($value): ?string
|
||||
return null;
|
||||
}
|
||||
|
||||
$login = "Inic1oDeSesi0nValido";
|
||||
$login = "val1dL0gin";
|
||||
$filtered_login = filter_var($login, FILTER_CALLBACK, ['options' => 'validate_login']);
|
||||
var_dump($filtered_login);
|
||||
|
||||
$login = "Inic1o de sesión fa4lso";
|
||||
$login = "f&ke login";
|
||||
$filtered_login = filter_var($login, FILTER_CALLBACK, ['options' => 'validate_login']);
|
||||
var_dump($filtered_login);
|
||||
?>
|
||||
@@ -1207,15 +1201,15 @@ var_dump($filtered_login);
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
string(20) "Inic1oDeSesi0nValido"
|
||||
string(10) "val1dL0gin"
|
||||
NULL
|
||||
]]>
|
||||
</screen>
|
||||
</example>
|
||||
<warning>
|
||||
<simpara>
|
||||
Este filtro no puede ser usado con ningún otro flag de filtro,
|
||||
e.g. <constant>FILTER_NULL_ON_FAILURE</constant>.
|
||||
Este filtro no puede usarse con ningún otro flag de filtro, por ejemplo,
|
||||
<constant>FILTER_NULL_ON_FAILURE</constant>.
|
||||
</simpara>
|
||||
</warning>
|
||||
</listitem>
|
||||
|
||||
@@ -1,63 +1,63 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 0904e1f4db189dfd2873a126bf72fe34fa9c50f8 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: a19139232af73a3c2054fcf5a687640ade63a393 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
|
||||
<book xml:id="book.hash" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<book xml:id="book.hash" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" annotations="interactive">
|
||||
<?phpdoc extension-membership="core" ?>
|
||||
<title>HASH</title>
|
||||
<title>HASH Message Digest Framework</title>
|
||||
<titleabbrev>Hash</titleabbrev>
|
||||
|
||||
<!-- {{{ preface -->
|
||||
<preface xml:id="intro.hash">
|
||||
&reftitle.intro;
|
||||
<para>
|
||||
Esta extensión proporciona funciones que pueden ser utilizadas para el tratamiento directo o
|
||||
incremental de mensajes de longitud arbitraria utilizando una variedad de algoritmos de hachado,
|
||||
incluyendo la generación de valores <acronym>HMAC</acronym> y derivaciones de claves
|
||||
incluyendo <acronym>HKDF</acronym> y <acronym>PBKDF2</acronym>.
|
||||
Esta extensión proporciona funciones que pueden usarse para el procesamiento directo o
|
||||
incremental de mensajes de longitud arbitraria utilizando una variedad de
|
||||
algoritmos de hash, incluyendo la generación de valores <acronym>HMAC</acronym>
|
||||
y derivaciones de claves incluyendo <acronym>HKDF</acronym> y
|
||||
<acronym>PBKDF2</acronym>.
|
||||
</para>
|
||||
<para>
|
||||
Existen grosso modo tres categorías de algoritmos de hachado, y una lista completa de
|
||||
los algoritmos puede ser encontrada en la documentación para <function>hash_algos</function>.
|
||||
Existen aproximadamente tres categorías de algoritmos de hash, y una lista completa de
|
||||
algoritmos puede encontrarse en la documentación de <function>hash_algos</function>.
|
||||
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Algoritmos de suma de control (tales como <literal>"crc32b"</literal> o <literal>"adler32"</literal>) :
|
||||
Estos son utilizados para calcular sumas de control, útiles en situaciones tales como
|
||||
la detección de errores de transmisión. Son frecuentemente muy rápidos. Estos
|
||||
algoritmos generan frecuentemente valores fácilmente "adivinables" o pueden ser manipulados
|
||||
para crear colisiones, por lo que son totalmente inadecuados para un uso criptográfico.
|
||||
Algoritmos de suma de verificación (como <literal>"crc32b"</literal> o <literal>"adler32"</literal>):
|
||||
Estos se utilizan para calcular sumas de verificación, útiles en situaciones como cuando
|
||||
se deben detectar errores de transmisión. Suelen ser muy rápidos. Estos
|
||||
algoritmos a menudo generan valores que son fácilmente "adivinables" o pueden ser manipulados
|
||||
para crear colisiones, por lo que son completamente inadecuados para uso criptográfico.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Algoritmos no criptográficos (como la familia xxHash) :
|
||||
Estos son frecuentemente utilizados para calcular valores de hachado para tablas de hachado,
|
||||
ya que están diseñados para producir una buena distribución sobre entradas de string arbitrarias.
|
||||
Son también generalmente rápidos, pero también inadecuados para un uso criptográfico.
|
||||
Algoritmos no criptográficos (como la familia xxHash):
|
||||
Estos se utilizan a menudo para calcular valores hash para tablas hash, ya que están
|
||||
diseñados para ofrecer una buena distribución sobre entradas de string arbitrarias. También
|
||||
suelen ser rápidos, pero no son adecuados para uso criptográfico.
|
||||
</simpara>
|
||||
</listitem>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Algoritmos criptográficos (como la familia SHA-2) :
|
||||
Estos están diseñados para producir valores de hachado representativos de sus
|
||||
entradas pero que no puedan ser adivinados ni sujetos a colisiones. El rendimiento es a menudo
|
||||
una preocupación secundaria, pero el hardware moderno soporta frecuentemente un manejo especial
|
||||
Algoritmos criptográficos (como la familia SHA-2):
|
||||
Estos están diseñados para generar valores hash que sean representativos de sus
|
||||
entradas pero que no sean adivinables ni propensos a colisiones. El rendimiento suele
|
||||
ser una preocupación secundaria, pero el hardware moderno a menudo admite un manejo especial
|
||||
para estos algoritmos que PHP intenta utilizar cuando está disponible.
|
||||
</simpara>
|
||||
<simpara>
|
||||
El Centro de Recursos para la Seguridad Informática del <acronym>NIST</acronym> tiene
|
||||
El Centro de Recursos de Seguridad Informática del <acronym>NIST</acronym> tiene
|
||||
<link xlink:href="&url.hash.nist-hash-functions;">una explicación de los algoritmos
|
||||
actualmente aprobados por los Estándares Federales de Procesamiento de Información de los Estados Unidos</link>.
|
||||
actualmente aprobados por los Estándares Federales de Procesamiento de Información
|
||||
de los Estados Unidos</link>.
|
||||
</simpara>
|
||||
<caution>
|
||||
<para>
|
||||
Algunos de los primeros algoritmos criptográficos, tales como <literal>"md4"</literal>,
|
||||
<literal>"md5"</literal>, y <literal>"sha1"</literal>, se han demostrado
|
||||
ser sujetos a ataques por colisión y generalmente se recomienda no utilizarlos más
|
||||
para aplicaciones criptográficas.
|
||||
Algunos de los primeros algoritmos criptográficos, como <literal>"md4"</literal>,
|
||||
<literal>"md5"</literal> y <literal>"sha1"</literal>, han demostrado
|
||||
ser propensos a ataques de colisión y generalmente se recomienda no
|
||||
utilizarlos más para aplicaciones criptográficas.
|
||||
</para>
|
||||
</caution>
|
||||
</listitem>
|
||||
@@ -65,11 +65,10 @@
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Ver también la <link linkend="faq.passwords">FAQ sobre el hachado seguro de contraseñas</link>
|
||||
para información sobre las mejores prácticas de utilización de las funciones de hachado en la gestión
|
||||
Consulte también las <link linkend="faq.passwords">preguntas frecuentes sobre el Hashing Seguro de Contraseñas</link>
|
||||
para obtener información sobre las mejores prácticas para el uso de funciones hash en el manejo
|
||||
de contraseñas.
|
||||
</para>
|
||||
|
||||
</preface>
|
||||
<!-- }}} -->
|
||||
|
||||
|
||||
@@ -1,11 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 539a9823a805ac29cab7fa4baf3ae3a28116a2f5 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: a19139232af73a3c2054fcf5a687640ade63a393 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.hash-hkdf" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<refnamediv>
|
||||
<refname>hash_hkdf</refname>
|
||||
<refpurpose>Genera una derivación de clave HKDF desde una clave proporcionada</refpurpose>
|
||||
<refpurpose>Genera una derivación de clave HKDF a partir de una clave de entrada proporcionada</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -27,11 +26,11 @@
|
||||
<term><parameter>algo</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Nombre del algoritmo de hash seleccionado (por ejemplo: <literal>"sha256"</literal>).
|
||||
Para una lista de los algoritmos soportados ver <function>hash_hmac_algos</function>.
|
||||
Nombre del algoritmo hash seleccionado (por ejemplo, <literal>"sha256"</literal>).
|
||||
Para ver una lista de algoritmos soportados, consulte <function>hash_hmac_algos</function>.
|
||||
<note>
|
||||
<para>
|
||||
Las funciones de hash no criptográficas no están permitidas.
|
||||
No se permiten funciones hash no criptográficas.
|
||||
</para>
|
||||
</note>
|
||||
</para>
|
||||
@@ -41,8 +40,7 @@
|
||||
<term><parameter>key</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Datos (Input keying material) en binario que servirán para el clavetage.
|
||||
No puede estar vacío.
|
||||
Material de clave de entrada (binario sin tratar). No puede estar vacío.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -50,12 +48,12 @@
|
||||
<term><parameter>length</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Longitud deseada de los datos de salida en octetos.
|
||||
No puede ser mayor que 255 veces el tamaño de la función de hash.
|
||||
Longitud deseada de la salida en bytes.
|
||||
No puede ser mayor que 255 veces el tamaño de la función hash elegida.
|
||||
</para>
|
||||
<para>
|
||||
Si <parameter>length</parameter> vale <literal>0</literal>, la longitud de los
|
||||
datos de salida será por defecto el tamaño de la función de hash elegida.
|
||||
Si <parameter>length</parameter> es <literal>0</literal>, la longitud de salida
|
||||
será por omisión el tamaño de la función hash elegida.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -63,7 +61,7 @@
|
||||
<term><parameter>info</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Información en forma de &string; específica de la aplicación/contexto.
|
||||
String de información específica de la aplicación/contexto.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -71,11 +69,10 @@
|
||||
<term><parameter>salt</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Sal a utilizar durante la derivación.
|
||||
Salt a utilizar durante la derivación.
|
||||
</para>
|
||||
<para>
|
||||
Aunque opcional, añadir una sal aleatoria aumenta significativamente la
|
||||
robustez de HKDF.
|
||||
Aunque es opcional, añadir un salt aleatorio mejora significativamente la robustez de HKDF.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -86,8 +83,8 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Devuelve un &string; que contiene una representación binaria en bruto de la clave derivada
|
||||
(también conocida como output keying material - OKM).
|
||||
Devuelve un string que contiene una representación binaria sin tratar de la clave derivada
|
||||
(también conocida como material de clave de salida - OKM).
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -97,12 +94,12 @@
|
||||
Lanza una excepción <classname>ValueError</classname> si <parameter>key</parameter>
|
||||
está vacío, <parameter>algo</parameter> es desconocido/no criptográfico,
|
||||
<parameter>length</parameter> es menor que <literal>0</literal> o demasiado grande
|
||||
(mayor que 255 veces el tamaño de la función de hash).
|
||||
(mayor que 255 veces el tamaño de la función hash).
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="changelog">
|
||||
&reftitle.changelog;
|
||||
&reftitle.changelog;
|
||||
<para>
|
||||
<informaltable>
|
||||
<tgroup cols="2">
|
||||
@@ -116,8 +113,9 @@
|
||||
<row>
|
||||
<entry>8.0.0</entry>
|
||||
<entry>
|
||||
Lanza una excepción <classname>ValueError</classname> en caso de error a partir de ahora.
|
||||
Anteriormente, se devolvía &false; y se emitía un mensaje <constant>E_WARNING</constant>.
|
||||
Ahora lanza una excepción <classname>ValueError</classname> en caso de error.
|
||||
Anteriormente, se devolvía &false; y se emitía un mensaje
|
||||
<constant>E_WARNING</constant>.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -128,17 +126,22 @@
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
El ejemplo siguiente produce un par de claves separadas, adecuadas para crear
|
||||
una construcción de tipo encrypt-then-HMAC, utilizando AES-256 y SHA-256 para
|
||||
cifrado y autenticación respectivamente.
|
||||
</para>
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>hash_hkdf</function></title>
|
||||
<title>Ejemplo de <function>hash_hkdf</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
// Genera una clave aleatoria y una sal para reforzarla durante la derivación.
|
||||
// Generar una clave aleatoria y un salt para fortalecerla durante la derivación.
|
||||
$inputKey = random_bytes(32);
|
||||
$salt = random_bytes(16);
|
||||
|
||||
// Deriva un par de claves separadas, utilizando los mismos datos creados anteriormente.
|
||||
// Derivar un par de claves separadas, utilizando la misma entrada creada arriba.
|
||||
$encryptionKey = hash_hkdf('sha256', $inputKey, 32, 'aes-256-encryption', $salt);
|
||||
$authenticationKey = hash_hkdf('sha256', $inputKey, 32, 'sha-256-authentication', $salt);
|
||||
|
||||
@@ -146,11 +149,6 @@ var_dump($encryptionKey !== $authenticationKey); // bool(true)
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
<para>
|
||||
El ejemplo anterior produce un par de claves separadas, que es adecuado para crear
|
||||
una construcción cifrar-entonces-HMAC (encrypt-then-HMAC), utilizando AES-256
|
||||
y SHA-256 para el cifrado y la autenticación respectivamente.
|
||||
</para>
|
||||
</example>
|
||||
</para>
|
||||
</refsect1>
|
||||
@@ -161,7 +159,7 @@ var_dump($encryptionKey !== $authenticationKey); // bool(true)
|
||||
<simplelist>
|
||||
<member><function>hash_pbkdf2</function></member>
|
||||
<member><link xlink:href="&url.rfc;5869">RFC 5869</link></member>
|
||||
<member><link xlink:href="&url.git.hub;narfbg/hash_hkdf_compat">implementación en userland</link></member>
|
||||
<member><link xlink:href="&url.git.hub;narfbg/hash_hkdf_compat">implementación en espacio de usuario</link></member>
|
||||
</simplelist>
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 71e12e2df7b0bcf0dc2743681b73790ac0d45ccc Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: yes -->
|
||||
<!-- EN-Revision: a19139232af73a3c2054fcf5a687640ade63a393 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.hash-update-stream" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>hash_update_stream</refname>
|
||||
<refpurpose>Añade datos en un contexto de hash activo de un flujo abierto</refpurpose>
|
||||
<refpurpose>Introduce datos en un contexto de hash activo desde un flujo abierto</refpurpose>
|
||||
</refnamediv>
|
||||
<refsect1 role="description">
|
||||
&reftitle.description;
|
||||
@@ -32,8 +32,7 @@
|
||||
<term><parameter>stream</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Identificador de fichero abierto como devuelto por cualquier
|
||||
función de creación de flujo.
|
||||
Gestor de fichero abierto como el devuelto por cualquier función de creación de flujos.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -41,8 +40,8 @@
|
||||
<term><parameter>length</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Tamaño máximo de caracteres a copiar de <parameter>stream</parameter>
|
||||
en el contexto de hash.
|
||||
Número máximo de caracteres a copiar desde <parameter>stream</parameter>
|
||||
al contexto de hash.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -53,8 +52,7 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Número actual de bytes añadidos al contexto de hash de
|
||||
<parameter>stream</parameter>.
|
||||
Número real de bytes añadidos al contexto de hash desde <parameter>stream</parameter>.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -73,7 +71,7 @@
|
||||
<row>
|
||||
<entry>7.2.0</entry>
|
||||
<entry>
|
||||
Acepta una <classname>HashContext</classname> en lugar de un recurso.
|
||||
Acepta <classname>HashContext</classname> en lugar de resource.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -86,7 +84,7 @@
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>hash_update_stream</function></title>
|
||||
<title>Ejemplo de <function>hash_update_stream</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -117,7 +115,6 @@ echo hash_final($ctx);
|
||||
<simplelist>
|
||||
<member><function>hash_init</function></member>
|
||||
<member><function>hash_update</function></member>
|
||||
<member><function>hash_update_stream</function></member>
|
||||
<member><function>hash_final</function></member>
|
||||
</simplelist>
|
||||
</para>
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 1976eae0d815797af97a1e16c5cd90ffc2868395 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: yes -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="intlcalendar.fromdatetime" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<refnamediv>
|
||||
<refname>IntlCalendar::fromDateTime</refname>
|
||||
<refpurpose>Crear un IntlCalendar desde un objeto DateTime o una cadena de caracteres</refpurpose>
|
||||
<refpurpose>Crea un IntlCalendar a partir de un objeto DateTime o string</refpurpose>
|
||||
</refnamediv>
|
||||
|
||||
<refsect1 role="description">
|
||||
@@ -26,16 +26,16 @@
|
||||
<methodparam choice="opt"><type class="union"><type>string</type><type>null</type></type><parameter>locale</parameter><initializer>&null;</initializer></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Crear un objeto <classname>IntlCalendar</classname> desde un objeto
|
||||
<classname>DateTime</classname> o desde una cadena de caracteres que
|
||||
puede ser utilizada para construir un objeto <classname>DateTime</classname>.
|
||||
Crea un objeto <classname>IntlCalendar</classname> ya sea a partir de un
|
||||
objeto <classname>DateTime</classname> o a partir de un string del cual se
|
||||
puede construir un objeto <classname>DateTime</classname>.
|
||||
</para>
|
||||
<para>
|
||||
El nuevo calendario representará no solo el mismo instante que el
|
||||
<classname>DateTime</classname> dado (sujeto a la pérdida de precisión
|
||||
para fechas muy antiguas o futuras), sino también la misma zona horaria
|
||||
(sujeto a la advertencia de que diferentes bases de datos de zonas horarias
|
||||
serán utilizadas, y por lo tanto los resultados pueden diferir).
|
||||
<classname>DateTime</classname> dado (sujeto a pérdida de precisión para fechas
|
||||
muy lejanas en el pasado o futuro), sino también la misma zona horaria (sujeto
|
||||
a la salvedad de que se usarán diferentes bases de datos de zonas horarias, y
|
||||
por lo tanto los resultados pueden diferir).
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -46,8 +46,8 @@
|
||||
<term><parameter>datetime</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Un objeto <classname>DateTime</classname> o una <type>string</type> que
|
||||
puede ser pasado a <function>DateTime::__construct</function>.
|
||||
Un objeto <classname>DateTime</classname> o un <type>string</type> que
|
||||
puede pasarse a <function>DateTime::__construct</function>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -57,9 +57,9 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
El objeto <classname>IntlCalendar</classname> creado o &null; en caso de fallo.
|
||||
Si una <type>string</type> es pasada, cualquier excepción que ocurra
|
||||
dentro del constructor <classname>DateTime</classname> es propagada.
|
||||
El objeto <classname>IntlCalendar</classname> creado o &null; en caso de
|
||||
error. Si se pasa un <type>string</type>, cualquier excepción que ocurra
|
||||
dentro del constructor de <classname>DateTime</classname> se propaga.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -73,10 +73,10 @@
|
||||
<?php
|
||||
ini_set('date.timezone', 'Europe/Lisbon');
|
||||
|
||||
//como IntlCalendar::fromDateTime(new DateTime(...))
|
||||
$cal1 = IntlCalendar::fromDateTime('2013-02-28 00:01:02 Europe/Berlin');
|
||||
//igual que IntlCalendar::fromDateTime(new DateTime(...))
|
||||
$cal1 = IntlCalendar::fromDateTime('2013-02-28 00:01:02 Europe/Berlin', 'de_DE');
|
||||
|
||||
//Nota que la zona horaria es Europe/Berlin, no la predeterminada Europe/Lisbon
|
||||
//Nota: la zona horaria es Europe/Berlin, no la predeterminada Europe/Lisbon
|
||||
echo IntlDateFormatter::formatObject($cal1, 'yyyy MMMM d HH:mm:ss VVVV', 'de_DE'), "\n";
|
||||
|
||||
]]>
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 1976eae0d815797af97a1e16c5cd90ffc2868395 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="numberformatter.format" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<refnamediv>
|
||||
<refname>NumberFormatter::format</refname>
|
||||
<refname>numfmt_format</refname>
|
||||
<refpurpose>Formatea un número</refpurpose>
|
||||
<refpurpose>Formatear un número</refpurpose>
|
||||
</refnamediv>
|
||||
|
||||
<refsect1 role="description">
|
||||
@@ -28,7 +28,7 @@
|
||||
<methodparam choice="opt"><type>int</type><parameter>type</parameter><initializer>NumberFormatter::TYPE_DEFAULT</initializer></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Formatea un valor numérico, según las reglas del formateador.
|
||||
Formatea un valor numérico según las reglas del formateador.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -40,7 +40,7 @@
|
||||
<term><parameter>formatter</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El objeto <classname>NumberFormatter</classname>.
|
||||
Objeto <classname>NumberFormatter</classname>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -48,9 +48,8 @@
|
||||
<term><parameter>num</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El valor a formatear. Puede ser un <type>int</type> o
|
||||
un <type>float</type>. Otros valores serán convertidos a
|
||||
valor numérico antes del formateo.
|
||||
El valor a formatear. Puede ser <type>int</type> o <type>float</type>,
|
||||
otros valores serán convertidos a un valor numérico.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -58,9 +57,11 @@
|
||||
<term><parameter>type</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El <link linkend="intl.numberformatter-constants.types">tipo de formato</link>.
|
||||
Tenga en cuenta que <constant>NumberFormatter::TYPE_CURRENCY</constant> no es soportado;
|
||||
utilice <methodname>NumberFormatter::formatCurrency</methodname> en su lugar.
|
||||
El
|
||||
<link linkend="intl.numberformatter-constants.types">
|
||||
tipo de formato</link> a usar.
|
||||
Tenga en cuenta que <constant>NumberFormatter::TYPE_CURRENCY</constant> no está soportado;
|
||||
use <methodname>NumberFormatter::formatCurrency</methodname> en su lugar.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -71,36 +72,32 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Devuelve la cadena que contiene el valor formateado, o &false; en caso de error.
|
||||
Devuelve el string que contiene el valor formateado, o &false; en caso de error.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<example>
|
||||
<title>Ejemplo con <function>numfmt_format</function>, &style.procedural;</title>
|
||||
<title>Ejemplo de <function>numfmt_format</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$fmt = numfmt_create( 'de_DE', NumberFormatter::DECIMAL );
|
||||
$data = numfmt_format($fmt, 1234567.891234567890000);
|
||||
if(intl_is_failure(numfmt_format($fmt))) {
|
||||
report_error("Error de formateador");
|
||||
}
|
||||
var_dump($data);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<example>
|
||||
<title>Ejemplo con <function>numfmt_format</function>, estilo POO</title>
|
||||
<title>Ejemplo POO</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$fmt = new NumberFormatter( 'de_DE', NumberFormatter::DECIMAL );
|
||||
$fmt->format(1234567.891234567890000);
|
||||
if(intl_is_failure($fmt->getErrorCode())) {
|
||||
report_error("Error de formateador");
|
||||
}
|
||||
$data = $fmt->format(1234567.891234567890000);
|
||||
var_dump($data);
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
@@ -108,7 +105,7 @@ if(intl_is_failure($fmt->getErrorCode())) {
|
||||
&example.outputs;
|
||||
<screen>
|
||||
<![CDATA[
|
||||
1.234.567,891
|
||||
string(13) "1.234.567,891"
|
||||
]]>
|
||||
</screen>
|
||||
</refsect1>
|
||||
@@ -117,11 +114,11 @@ if(intl_is_failure($fmt->getErrorCode())) {
|
||||
&reftitle.notes;
|
||||
<note>
|
||||
<para>
|
||||
Los formatos realizables por este método de formateo no pueden utilizar plenamente las posibilidades de
|
||||
la biblioteca ICU subyacente, como por ejemplo el formateo de moneda con un símbolo monetario corto.
|
||||
Los formatos alcanzables por este método de formateo no pueden utilizar completamente las posibilidades de la biblioteca ICU subyacente,
|
||||
como por ejemplo formatear moneda con símbolo de moneda estrecho.
|
||||
</para>
|
||||
<para>
|
||||
Para utilizarlas plenamente, utilice <function>msgfmt_format_message</function>.
|
||||
Para utilizarlas completamente use <function>msgfmt_format_message</function>.
|
||||
</para>
|
||||
</note>
|
||||
</refsect1>
|
||||
|
||||
@@ -1,12 +1,11 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 1976eae0d815797af97a1e16c5cd90ffc2868395 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: bce2cb849721c70737eb32ce958131e22677770c Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<!-- CREDITS: DAnnebicque -->
|
||||
<refentry xml:id="numberformatter.geterrorcode" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<refnamediv>
|
||||
<refname>NumberFormatter::getErrorCode</refname>
|
||||
<refname>numfmt_get_error_code</refname>
|
||||
<refpurpose>Lee el último código de error del formateador</refpurpose>
|
||||
<refpurpose>Obtener el último código de error del formateador</refpurpose>
|
||||
</refnamediv>
|
||||
|
||||
<refsect1 role="description">
|
||||
@@ -26,7 +25,7 @@
|
||||
<methodparam><type>NumberFormatter</type><parameter>formatter</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
Lee el código de error generado por la última función del formateador.
|
||||
Obtiene el código de error de la última función ejecutada por el formateador.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -38,7 +37,7 @@
|
||||
<term><parameter>formatter</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El objeto <classname>NumberFormatter</classname>.
|
||||
Objeto <classname>NumberFormatter</classname>.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -56,28 +55,28 @@
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<example>
|
||||
<title>Ejemplo con <function>numfmt_get_error_code</function>, &style.procedural;</title>
|
||||
<title>Ejemplo de <function>numfmt_get_error_code</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$fmt = numfmt_create( 'de_DE', NumberFormatter::DECIMAL );
|
||||
$data = numfmt_format($fmt, 1234567.891234567890000);
|
||||
if(intl_is_failure(numfmt_get_error_code($fmt))) {
|
||||
report_error("Error de formateador");
|
||||
if (intl_is_failure(numfmt_get_error_code($fmt))) {
|
||||
echo 'Error del formateador';
|
||||
}
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
</example>
|
||||
<example>
|
||||
<title>Ejemplo con <function>numfmt_get_error_code</function>, estilo POO</title>
|
||||
<title>Ejemplo OO</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$fmt = new NumberFormatter( 'de_DE', NumberFormatter::DECIMAL );
|
||||
$fmt->format(1234567.891234567890000);
|
||||
if(intl_is_failure($fmt->getErrorCode())) {
|
||||
report_error("Error de formateador");
|
||||
if (intl_is_failure($fmt->getErrorCode())) {
|
||||
echo 'Error del formateador';
|
||||
}
|
||||
?>
|
||||
]]>
|
||||
|
||||
@@ -1,12 +1,11 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: d0ae617680e58bde494f9d58d9c553e0a6944418 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="function.pg-lo-import" xmlns="http://docbook.org/ns/docbook">
|
||||
<!-- splitted from ./en/functions/pgsql.xml, last change in rev 1.6 -->
|
||||
<refentry xmlns="http://docbook.org/ns/docbook" xml:id="function.pg-lo-import">
|
||||
<refnamediv>
|
||||
<refname>pg_lo_import</refname>
|
||||
<refpurpose>
|
||||
Importa un objeto de gran tamaño desde un fichero
|
||||
</refpurpose>
|
||||
<refpurpose>Importa un objeto grande desde un fichero</refpurpose>
|
||||
</refnamediv>
|
||||
|
||||
<refsect1 role="description">
|
||||
@@ -18,17 +17,17 @@
|
||||
<methodparam choice="opt"><type>mixed</type><parameter>object_id</parameter></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
<function>pg_lo_import</function> crea un nuevo objeto de gran tamaño
|
||||
en la base de datos utilizando un fichero en el sistema de ficheros
|
||||
como datos de origen.
|
||||
<function>pg_lo_import</function> crea un nuevo objeto grande
|
||||
en la base de datos usando un fichero en el sistema de ficheros como
|
||||
fuente de datos.
|
||||
</para>
|
||||
<para>
|
||||
Para utilizar un objeto de gran tamaño (<literal>lo</literal>), es
|
||||
necesario hacerlo dentro de una transacción.
|
||||
Para usar la interfaz de objetos grandes, es necesario
|
||||
encerrarla dentro de un bloque de transacción.
|
||||
</para>
|
||||
<note>
|
||||
<para>
|
||||
Anteriormente, esta función se llamaba <function>pg_loimport</function>.
|
||||
Esta función antes se llamaba <function>pg_loimport</function>.
|
||||
</para>
|
||||
</note>
|
||||
</refsect1>
|
||||
@@ -47,8 +46,8 @@
|
||||
<term><parameter>pathname</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
La ruta de acceso completa y el fichero desde el cual se leerá
|
||||
el objeto de gran tamaño en el sistema del cliente.
|
||||
La ruta completa y nombre del fichero en el sistema de ficheros del cliente
|
||||
desde el cual leer los datos del objeto grande.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -56,10 +55,10 @@
|
||||
<term><parameter>object_id</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Si el argumento <parameter>object_id</parameter> es proporcionado, la función
|
||||
intentará crear un objeto grande con este identificador, de lo contrario, un
|
||||
identificador de objeto disponible será asignado por el servidor.
|
||||
Este argumento depende de una funcionalidad que apareció con PostgreSQL 8.1.
|
||||
Si se proporciona un <parameter>object_id</parameter>, la función
|
||||
intentará crear un objeto grande con este ID, de lo contrario, el servidor
|
||||
asignará un ID de objeto libre. Este parámetro depende de funcionalidad que
|
||||
apareció por primera vez en PostgreSQL 8.1.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -70,7 +69,7 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
El <varname>OID</varname> del nuevo objeto de gran tamaño creado, &return.falseforfailure;.
|
||||
El <varname>OID</varname> del objeto grande recién creado, &return.falseforfailure;.
|
||||
</para>
|
||||
</refsect1>
|
||||
|
||||
@@ -95,7 +94,7 @@
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>pg_lo_import</function></title>
|
||||
<title>Ejemplo de <function>pg_lo_import</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- $Revision$ -->
|
||||
<!-- EN-Revision: 9c166423255b3d5e02f74232f2d05fd3b59d5d62 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: 55d731ec5cdf9961bd6085525316af91e32c8006 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
|
||||
<refentry xml:id="function.posix-getrlimit" xmlns="http://docbook.org/ns/docbook">
|
||||
<refnamediv>
|
||||
<refname>posix_getrlimit</refname>
|
||||
@@ -16,8 +14,8 @@
|
||||
<methodparam choice="opt"><type class="union"><type>int</type><type>null</type></type><parameter>resource</parameter><initializer>&null;</initializer></methodparam>
|
||||
</methodsynopsis>
|
||||
<para>
|
||||
<function>posix_getrlimit</function> devuelve un &array; de información
|
||||
sobre los límites soft y hard del recurso actual.
|
||||
<function>posix_getrlimit</function> devuelve un <type>array</type>
|
||||
con información sobre los límites actuales blandos y duros del recurso.
|
||||
</para>
|
||||
&posix.rlimits;
|
||||
</refsect1>
|
||||
@@ -30,8 +28,10 @@
|
||||
<term><parameter>resource</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
Si &null;, se recuperan todos los límites de recursos.
|
||||
De lo contrario, solo se devuelven los límites del tipo de recurso proporcionado.
|
||||
Si es &null;, se devolverán todos los límites de recursos actuales.
|
||||
De lo contrario, especifique la
|
||||
<link linkend="posix.constants.setrlimit">constante de límite de recurso</link>
|
||||
para recuperar un límite específico.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -42,8 +42,8 @@
|
||||
<refsect1 role="returnvalues">
|
||||
&reftitle.returnvalues;
|
||||
<para>
|
||||
Devuelve un &array; asociativo con elementos para cada límite definido.
|
||||
Cada límite tiene un límite soft y hard.
|
||||
Devuelve un <type>array</type> asociativo de elementos para cada
|
||||
límite que esté definido. Cada límite tiene un límite blando y uno duro.
|
||||
<table>
|
||||
<title>Lista de límites posibles devueltos</title>
|
||||
<tgroup cols="2">
|
||||
@@ -57,21 +57,20 @@
|
||||
<row>
|
||||
<entry>core</entry>
|
||||
<entry>
|
||||
El tamaño máximo del archivo de núcleo. Cuando es 0,
|
||||
no se crea ningún archivo de núcleo. Cuando el núcleo del archivo
|
||||
es más grande que su tamaño, será truncado a este tamaño.
|
||||
El tamaño máximo del fichero de memoria. Cuando es 0, no se crean ficheros de memoria.
|
||||
Cuando los ficheros de memoria son más grandes que este tamaño, se truncarán a este tamaño.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>totalmem</entry>
|
||||
<entry>
|
||||
El tamaño máximo de memoria del proceso, en bytes.
|
||||
El tamaño máximo de la memoria del proceso, en bytes.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>virtualmem</entry>
|
||||
<entry>
|
||||
El tamaño máximo de memoria virtual del proceso, en bytes.
|
||||
El tamaño máximo de la memoria virtual para el proceso, en bytes.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -89,14 +88,14 @@
|
||||
<row>
|
||||
<entry>rss</entry>
|
||||
<entry>
|
||||
El número máximo de páginas virtuales residentes en RAM.
|
||||
El número máximo de páginas virtuales residentes en RAM
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
<entry>maxproc</entry>
|
||||
<entry>
|
||||
El número máximo de procesos que pueden ser creados para el ID
|
||||
de usuario real del proceso llamado.
|
||||
El número máximo de procesos que pueden ser creados para el
|
||||
ID de usuario real del proceso llamante.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -108,7 +107,7 @@
|
||||
<row>
|
||||
<entry>cpu</entry>
|
||||
<entry>
|
||||
El tiempo que el proceso está autorizado a usar la CPU.
|
||||
La cantidad de tiempo que se permite al proceso usar la CPU.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -120,7 +119,7 @@
|
||||
<row>
|
||||
<entry>openfiles</entry>
|
||||
<entry>
|
||||
El número máximo de punteros de archivos abiertos.
|
||||
Uno más que el número máximo de descriptores de fichero abiertos.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -128,35 +127,35 @@
|
||||
</table>
|
||||
La función devuelve &false; en caso de error.
|
||||
</para>
|
||||
</refsect1>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="changelog">
|
||||
<refsect1 role="changelog">
|
||||
&reftitle.changelog;
|
||||
<informaltable>
|
||||
<tgroup cols="2">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>&Version;</entry>
|
||||
<entry>&Description;</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>8.3.0</entry>
|
||||
<entry>
|
||||
Se añadió el parámetro opcional <parameter>resource</parameter>.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
<tgroup cols="2">
|
||||
<thead>
|
||||
<row>
|
||||
<entry>&Version;</entry>
|
||||
<entry>&Description;</entry>
|
||||
</row>
|
||||
</thead>
|
||||
<tbody>
|
||||
<row>
|
||||
<entry>8.3.0</entry>
|
||||
<entry>
|
||||
Se ha añadido el parámetro opcional <parameter>resource</parameter>.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
</tgroup>
|
||||
</informaltable>
|
||||
</refsect1>
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<para>
|
||||
<example>
|
||||
<title>Ejemplo con <function>posix_getrlimit</function></title>
|
||||
<title>Ejemplo de uso de <function>posix_getrlimit</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
@@ -203,7 +202,7 @@ Array
|
||||
&reftitle.seealso;
|
||||
<para>
|
||||
<simplelist>
|
||||
<member>página de manual GETRLIMIT(2)</member>
|
||||
<member>página del manual GETRLIMIT(2)</member>
|
||||
<member><function>posix_setrlimit</function></member>
|
||||
</simplelist>
|
||||
</para>
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 550b9c3c31a66c18c9303794c12260bf5c684fed Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: 1bcc40f8134305cbebf6c8378ee7e5fc8c569674 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<book xml:id="book.random" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<book xml:id="book.random" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" annotations="interactive">
|
||||
<?phpdoc extension-membership="core" ?>
|
||||
<title>Generadores de números aleatorios y funciones relacionadas con la aleatoriedad.</title>
|
||||
<title>Generadores de Números Aleatorios y Funciones Relacionadas con la Aleatoriedad</title>
|
||||
<titleabbrev>Random</titleabbrev>
|
||||
|
||||
<preface xml:id="intro.random">
|
||||
|
||||
@@ -1,23 +1,45 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 2166824858a40ea664c558f2930b63b8f4fd89c6 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- EN-Revision: 1bcc40f8134305cbebf6c8378ee7e5fc8c569674 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<chapter xml:id="random.examples" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
&reftitle.examples;
|
||||
<example>
|
||||
<title>Ejemplo Random</title>
|
||||
<programlisting role="php">
|
||||
<title>Ejemplo de aleatoriedad</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$r = new \Random\Randomizer();
|
||||
|
||||
/* ... */
|
||||
// Generar un nombre de dominio aleatorio
|
||||
printf(
|
||||
"%s.example.com\n",
|
||||
$r->getBytesFromString('abcdefghijklmnopqrstuvwxyz0123456789', 16)
|
||||
);
|
||||
|
||||
// Mezclar array:
|
||||
$fruits = [ 'red' => '🍎', 'green' => '🥝', 'yellow' => '🍌', 'pink' => '🍑', 'purple' => '🍇' ];
|
||||
echo "Ensalada: ", implode(', ', $r->shuffleArray($fruits)), "\n";
|
||||
|
||||
// Mezclar claves de array
|
||||
$fruits = [ 'red' => '🍎', 'green' => '🥝', 'yellow' => '🍌', 'pink' => '🍑', 'purple' => '🍇' ];
|
||||
|
||||
$keys = $r->pickArrayKeys($fruits, 2);
|
||||
// Buscar los valores para las claves seleccionadas
|
||||
$selection = array_map(
|
||||
static fn ($key) => $fruits[$key],
|
||||
$keys
|
||||
);
|
||||
|
||||
echo "Valores: ", implode(', ', $selection), "\n";
|
||||
?>
|
||||
]]>
|
||||
</programlisting>
|
||||
&example.outputs.similar;
|
||||
<screen>
|
||||
<screen>
|
||||
<![CDATA[
|
||||
...
|
||||
j87fzv1p0daiwmlo.example.com
|
||||
Ensalada: 🥝, 🍇, 🍎, 🍌, 🍑
|
||||
Valores: 🍌, 🍑
|
||||
]]>
|
||||
</screen>
|
||||
</example>
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: c4f24e2eef1a3c970c491c0ee8cbc1f290ff023a Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: yes -->
|
||||
<!-- EN-Revision: 1bcc40f8134305cbebf6c8378ee7e5fc8c569674 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="random-engine-mt19937.construct" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<refnamediv>
|
||||
<refname>Random\Engine\Mt19937::__construct</refname>
|
||||
@@ -19,9 +19,6 @@
|
||||
</para>
|
||||
|
||||
&caution.mt19937-tiny-seed;
|
||||
|
||||
&warn.undocumented.func;
|
||||
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="parameters">
|
||||
@@ -32,13 +29,13 @@
|
||||
<listitem>
|
||||
<para>
|
||||
Rellena el estado con valores generados con un generador congruencial lineal
|
||||
que ha sido inicializado con <parameter>seed</parameter> interpretado como un entero
|
||||
sin signo de 32 bits.
|
||||
que fue inicializado con <parameter>seed</parameter> interpretado como un
|
||||
entero sin signo de 32 bits.
|
||||
</para>
|
||||
|
||||
<para>
|
||||
Si <parameter>seed</parameter> es omitido o &null;, se utilizará un entero sin signo aleatorio
|
||||
de 32 bits.
|
||||
Si <parameter>seed</parameter> se omite o es &null;, se utilizará un entero
|
||||
sin signo de 32 bits aleatorio.
|
||||
</para>
|
||||
</listitem>
|
||||
</varlistentry>
|
||||
@@ -46,7 +43,8 @@
|
||||
<term><parameter>mode</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El uso de una de las constantes siguientes para especificar la implementación del algoritmo a utilizar.
|
||||
Utilice una de las siguientes constantes para especificar la implementación
|
||||
del algoritmo a usar.
|
||||
<simplelist>
|
||||
<member>
|
||||
<constant>MT_RAND_MT19937</constant>:
|
||||
@@ -54,8 +52,8 @@
|
||||
</member>
|
||||
<member>
|
||||
<constant>MT_RAND_PHP</constant>:
|
||||
Una implementación incorrecta para la retrocompatibilidad con <function>mt_srand</function> antes de
|
||||
PHP 7.1.0.
|
||||
Una implementación incorrecta para compatibilidad con versiones anteriores
|
||||
de <function>mt_srand</function> anterior a PHP 7.1.0.
|
||||
</member>
|
||||
</simplelist>
|
||||
</para>
|
||||
@@ -76,15 +74,14 @@
|
||||
</refsect1>
|
||||
-->
|
||||
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<example>
|
||||
<example annotations="non-interactive">
|
||||
<title>Ejemplo de <function>Random\Engine\Mt19937::__construct</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
// Utiliza una semilla aleatoria de 32 bits.
|
||||
// Usa una semilla aleatoria de 32 bits.
|
||||
$e = new \Random\Engine\Mt19937();
|
||||
|
||||
$r = new \Random\Randomizer($e);
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!-- EN-Revision: 826073522514072830b63bee2b6135dc675ea45d Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: yes -->
|
||||
<!-- EN-Revision: 1bcc40f8134305cbebf6c8378ee7e5fc8c569674 Maintainer: PhilDaiguille Status: ready -->
|
||||
<!-- Reviewed: no -->
|
||||
<refentry xml:id="random-engine-pcgoneseq128xslrr64.construct" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
|
||||
<refnamediv>
|
||||
<refname>Random\Engine\PcgOneseq128XslRr64::__construct</refname>
|
||||
@@ -16,9 +16,6 @@
|
||||
<para>
|
||||
|
||||
</para>
|
||||
|
||||
&warn.undocumented.func;
|
||||
|
||||
</refsect1>
|
||||
|
||||
<refsect1 role="parameters">
|
||||
@@ -28,8 +25,8 @@
|
||||
<term><parameter>seed</parameter></term>
|
||||
<listitem>
|
||||
<para>
|
||||
El estado interno de 128 bits (16 bytes) compuesto por un entero sin signo de 128 bits es
|
||||
inicializado dependiendo del tipo utilizado como <parameter>seed</parameter>.
|
||||
La forma en que se inicializa el estado interno de 128 bits (16 bytes) que consiste en un entero sin signo de 128 bits
|
||||
depende del tipo utilizado como <parameter>seed</parameter>.
|
||||
<informaltable>
|
||||
<tgroup cols="2">
|
||||
<thead>
|
||||
@@ -42,7 +39,7 @@
|
||||
<row>
|
||||
<entry><type>null</type></entry>
|
||||
<entry>
|
||||
Rellena el estado con 16 bytes aleatorios generados utilizando el <acronym>CSPRNG</acronym>.
|
||||
Rellena el estado con 16 bytes aleatorios generados usando el <acronym>CSPRNG</acronym>.
|
||||
</entry>
|
||||
</row>
|
||||
<row>
|
||||
@@ -56,8 +53,8 @@
|
||||
<row>
|
||||
<entry><type>string</type></entry>
|
||||
<entry>
|
||||
Rellena el estado interpretando una cadena de 16 bytes <type>string</type> como un entero sin signo
|
||||
de 128 bits en little-endian.
|
||||
Rellena el estado interpretando un <type>string</type> de 16 bytes como un entero sin signo de 128 bits
|
||||
en orden little-endian.
|
||||
</entry>
|
||||
</row>
|
||||
</tbody>
|
||||
@@ -85,8 +82,8 @@
|
||||
<itemizedlist>
|
||||
<listitem>
|
||||
<simpara>
|
||||
Si la longitud de un <type>string</type> <parameter>seed</parameter> no es de 16 bytes,
|
||||
se lanzará una <classname>ValueError</classname>.
|
||||
Si la longitud de un <type>string</type> <parameter>seed</parameter> no es
|
||||
de 16 bytes, se lanzará un <classname>ValueError</classname>.
|
||||
</simpara>
|
||||
</listitem>
|
||||
</itemizedlist>
|
||||
@@ -94,12 +91,12 @@
|
||||
|
||||
<refsect1 role="examples">
|
||||
&reftitle.examples;
|
||||
<example>
|
||||
<example annotations="non-interactive">
|
||||
<title>Ejemplo de <function>Random\Engine\PcgOneseq128XslRr64::__construct</function></title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
// utiliza una semilla aleatoria de 128 bits.
|
||||
// Usa una semilla aleatoria de 128 bits.
|
||||
$e = new \Random\Engine\PcgOneseq128XslRr64();
|
||||
|
||||
$r = new \Random\Randomizer($e);
|
||||
@@ -108,15 +105,15 @@ $r = new \Random\Randomizer($e);
|
||||
</programlisting>
|
||||
</example>
|
||||
<example>
|
||||
<title>Derivar una semilla de un &string;</title>
|
||||
<title>Derivar una semilla a partir de un &string;</title>
|
||||
<programlisting role="php">
|
||||
<![CDATA[
|
||||
<?php
|
||||
$string = "My string seed";
|
||||
$string = "Mi semilla de string";
|
||||
|
||||
// Hachea la cadena con un SHA-256 truncado utilizando una salida binaria
|
||||
// para transformar la cadena en una semilla de 128 bits. Utilizar la misma
|
||||
// cadena dará la misma secuencia de números aleatorios.
|
||||
// Aplica hash a la cadena con SHA-256 truncado usando salida binaria
|
||||
// para convertir el $string en una semilla de 128 bits. Usar la misma
|
||||
// cadena resultará en la misma secuencia de aleatoriedad.
|
||||
$e = new \Random\Engine\PcgOneseq128XslRr64(
|
||||
substr(hash('sha256', $string, binary: true), 0, 16)
|
||||
);
|
||||
|
||||
Reference in New Issue
Block a user