Sintaxis y semántica de PHP

La sintaxis y la semántica de PHP , un lenguaje de programación , forman un conjunto de reglas que definen cómo se puede escribir e interpretar un programa PHP.

Históricamente, el desarrollo de PHP ha sido un tanto caótico. Para contrarrestar esto, el PHP Framework Interop Group (FIG) ha creado los documentos PHP Standards Recommendation (PSR) que han ayudado a aportar más estandarización al lenguaje desde 2009. ^[1] Los estándares de codificación modernos están contenidos en PSR-1 (Basic Coding Standard) ^[2] y PSR-2 (Coding Style Guide). ^[3]

Algunas palabras clave representan cosas que parecen funciones, otras parecen constantes, pero en realidad son construcciones del lenguaje. Está prohibido utilizar palabras clave como constantes, nombres de clases, funciones o métodos. Se permite utilizarlas como nombres de variables, pero puede resultar confuso. ^[4]

PHP generalmente sigue la sintaxis de C , con excepciones y mejoras para su uso principal en el desarrollo web , que hace un uso intensivo de la manipulación de cadenas . Las variables de PHP deben tener como prefijo " $". Esto permite a PHP realizar interpolación de cadenas en cadenas entre comillas dobles , donde se admite la barra invertida como carácter de escape . No se realiza ningún escape o interpolación en cadenas delimitadas por comillas simples . PHP también admite una función sprintf similar a C. El código se puede modularizar en funciones definidas con la palabra clave function. PHP admite un estilo de codificación orientado a objetosclass opcional, con clases denotadas por la palabra clave. Las funciones definidas dentro de las clases a veces se denominan métodos . Las estructuras de control incluyen: if, while, do/while, for, foreachy switch. Las declaraciones terminan con un punto y coma, no con finales de línea. ^[5]

El procesador PHP solo analiza el código que se encuentra dentro de sus delimitadores . Todo lo que se encuentre fuera de sus delimitadores se envía directamente a la salida y PHP no lo analiza. Los únicos delimitadores de apertura/cierre permitidos por PSR-1 ^[6] son ​​" <?php" y " ?>" o y . <?=?>

El propósito de las etiquetas delimitadoras es separar el código PHP de los datos que no son PHP (principalmente HTML). Aunque es poco común en la práctica, PHP ejecutará código incrustado en cualquier archivo que se pase a su intérprete, incluidos archivos binarios como archivos PDF o JPEG, o en archivos de registro del servidor. ^{[7] [8]} Todo lo que esté fuera de los delimitadores es ignorado por el analizador PHP y se pasa como salida. ^[9]

Estos delimitadores recomendados crean documentos XHTML y otros documentos XML correctamente formados . ^[10] Esto puede ser útil si los documentos de código fuente alguna vez necesitan procesarse de otras maneras durante la vida del software.

Si la validación XML adecuada no es un problema y un archivo contiene solo código PHP, es preferible omitir la ?>etiqueta de cierre PHP ( ) al final del archivo. ^[11]

Se pueden utilizar otros delimitadores en algunos servidores, aunque la mayoría ya no son compatibles. ^[12] Algunos ejemplos son:

• " <script language="php">" y " </script>" (eliminados en PHP7)
• Etiquetas de apertura cortas ( <?) (configuradas con la short_open_tagconfiguración ini)
  • Una forma especial de la <?etiqueta es <?=, que repite automáticamente la siguiente declaración. Antes de PHP 5.4.0, esto también se controlaba con short_open_tag, pero siempre está disponible en versiones posteriores.
• Etiquetas de estilo ASP<% ( o <%=) (eliminadas en PHP7)

Las variables tienen como prefijo el símbolo del dólar y no es necesario especificar un tipo"" por adelantado. A diferencia de los nombres de funciones y clases, los nombres de variables distinguen entre mayúsculas y minúsculas. Tanto las cadenas entre comillas dobles ( ) como las cadenas heredoc permiten la posibilidad de incrustar el valor de una variable en la cadena. ^[13] Al igual que en C, las variables pueden convertirse a un tipo específico anteponiendo el tipo entre paréntesis. PHP trata las nuevas líneas como espacios en blanco , a la manera de un lenguaje de formato libre . El operador de concatenación es .(punto). Se accede a los elementos de la matriz y se establecen con corchetes tanto en matrices asociativas como en matrices indexadas. Las llaves se pueden utilizar para acceder a los elementos de la matriz, pero no para asignar.

PHP tiene tres tipos de sintaxis de comentarios : /* */que sirven como comentarios en bloque y //que #se utilizan para comentarios en línea. ^[14] Muchos ejemplos utilizan la printfunción en lugar de la echofunción. Ambas funciones son casi idénticas; la principal diferencia es que printes más lenta que echola función porque la primera devolverá un estado que indica si se realizó correctamente o no, además del texto a mostrar, mientras que la última no devuelve un estado y solo devuelve el texto a mostrar. ^[15]

El ejemplo de código habitual " Hola mundo " para PHP es: ^[16]

<?php 
echo  "Hola mundo! \n " ; 
?>

El ejemplo anterior genera el siguiente resultado:

¡Hola Mundo!

En lugar de utilizar <?phpla instrucción and echo, un "atajo" opcional es el uso de en lugar de que implícitamente repite los datos. Por ejemplo: <?=<?php

<!DOCTYPE html>
<html>​​
    < cabeza >
        < title > Programa PHP "¡Hola, mundo!" </ title >
    </cabeza>​​
    < cuerpo >
        < p > <? = "¡Hola mundo!" ?> </ p >
    </ cuerpo >
</html>​​

El ejemplo anterior también ilustra que el texto que no esté contenido dentro de las etiquetas PHP que lo encierran se imprimirá directamente.

PHP admite: operadores aritméticos , operadores de asignación , operadores bit a bit , operadores de comparación , operadores de control de errores, operadores de ejecución, operadores de incremento/decremento , operadores lógicos , operadores de cadena , operadores de matriz, operadores de asignación condicional . ^[17]

La sintaxis de una declaración if...else de PHP es la siguiente:

if  ( condición )  { 
    // declaraciones; 
}  elseif  ( condición2 )  { 
    // declaraciones; 
}  else  { 
    // declaraciones; 
}

En el caso de declaraciones individuales, los corchetes se pueden omitir y, opcionalmente, el if se puede condensar en una sola línea:

si  ( condición )  haceralgo (); 
si no  ( condición2 )  haceralgomás (); 
si no  hacerunaterceracosa ();

$abs  =  $valor  >=  0  ?  $valor  :  - $valor ;

/* Equivalente a */

si  ( $valor  >=  0 )  { 
    $abs  =  $valor ; 
}  de lo contrario  { 
    $abs  =  - $valor ; 
}

Desde PHP 5.3 se admite el operador Elvis ( ?:) en el que es posible omitir la parte media del operador ternario.

$c  =  $a  ?:  $b ; 

/* Equivalente a */

$c  =  $a  ?  $a  :  $b ;

Desde la versión 7.0, PHP también admite el operador de coalescencia nula ( ??).

$a  =  $b  ??  $c ;

/* Equivalente a */

$a  =  se establece ( $b )  ?  $b  :  $c ;

Desde la versión 7.4, PHP también admite el operador de fusión nula con la ??=sintaxis.

$a  ??=  $b ;

/* Equivalente a */

$a  =  $a  ??  $b ;

Desde la versión 8.0 PHP también soporta el operador de navegación segura ( ?->).

$variable  =  $objeto ?-> método ();

/* Equivalente a */

$variable  =   $objeto  !==  null  ?  $objeto -> método ()  :  null ;

Un ejemplo de la sintaxis de una declaración switch de PHP es el siguiente:

switch  ( expr )  { 
    caso  0 : 
      // declaraciones; 
      break ; 
    caso  1 : 
      // declaraciones; 
      break ; 
    caso  2 : 
      // declaraciones; 
      break ; 
    predeterminado : 
      // declaraciones; 
}

Tenga en cuenta que, a diferencia de C , los valores en la declaración case pueden ser de cualquier tipo, no solo números enteros. ^[18]

PHP 8 introduce la matchexpresión. ^[19] La expresión de coincidencia es conceptualmente similar a una switchdeclaración y es más compacta para algunos casos de uso. ^[20] switch Las declaraciones se prefieren tradicionalmente para comparaciones simples basadas en valores, matchlas declaraciones brindan más flexibilidad y legibilidad, particularmente cuando se usan en condiciones o patrones complejos ^[21]

 coincidencia  de eco ( 1 )  { 
    0  =>  'Foo' , 
    1  =>  'Bar' , 
    2  =>  'Baz' , 
}; 
// barra

La sintaxis PHP de un bucle for es la siguiente:

para  ( inicialización ;  condición ;  reflexión posterior )  { 
    // declaraciones; 
}

La sintaxis para un bucle while de PHP es la siguiente:

mientras  ( condición )  { 
    // declaraciones; 
}

La sintaxis para un bucle do while de PHP es la siguiente:

hacer  { 
    // declaraciones; 
}  mientras  ( condición );

La sintaxis para un bucle PHP for each es la siguiente:

foreach  ( $establecer  como  $valor )  { 
    // declaraciones; 
}

PHP ofrece una sintaxis alternativa que utiliza dos puntos en lugar de la sintaxis estándar de llaves (de " {...}"). Esta sintaxis afecta a las siguientes estructuras de control: if, while, for, foreachy switch. La sintaxis varía solo ligeramente de la sintaxis de llaves. En cada caso, la llave de apertura ( {) se reemplaza por dos puntos ( :) y la llave de cierre se reemplaza por endif;, endwhile;, endfor;, endforeach;o endswitch;, respectivamente. ^[22] No se admite la mezcla de estilos de sintaxis dentro del mismo bloque de control. Un ejemplo de la sintaxis para una declaración if/ elseifes el siguiente:

if  ( condición ) : 
     // código aquí 
elseif  ( condición ) : 
     // código aquí 
else : 
     // código aquí 
endif ;

Este estilo a veces se denomina sintaxis de plantilla, ya que suele resultar más fácil de leer cuando se combinan PHP y HTML o JavaScript para obtener una salida condicional:

< html > 
<?php  if  ( $day  ==  'Jueves' ) :  ?> 
  < div > ¡Mañana es viernes! </ div > 
<?php  elseif  ( $day  ==  'Viernes' ) :  ?> 
  < div > TGIF </ div > 
<?php  else :  ?> 
  < div > ugh </ div > 
<?php  endif ;  ?> 
</ html >

El método de manejo de excepciones en tiempo de ejecución en PHP se hereda de C++. ^[23]

función  inv ( $x ) 
{ 
    si  ( $x  ==  0 )  { 
        generar  nueva  excepción ( 'División por cero' ); 
    } 
    devolver  1  /  $x ; 
}

try  { 
    echo  inv ( 2 );  // imprime 0.5 
    echo  inv ( 0 );  // lanza una excepción 
    echo  inv ( 5 );  // no se ejecutará 
}  catch  ( Exception  $e )  { 
    echo   $e -> getMessage ();  // imprime División por cero 
}

// Continuar la ejecución 
echo  "Hola" ;  // imprime Hola

PHP admite cuatro tipos escalares: bool, int, float, string. ^[24]

PHP tiene un tipo booleano nativo , llamado " bool", similar a los tipos booleanos nativos en Java y C++ . Usando las reglas de conversión de tipos booleanos, los valores distintos de cero se interpretan como truey cero como false, como en Perl . Tanto las constantes truecomo las mayúsculas y falseminúsculas no distinguen entre mayúsculas y minúsculas. ^[25]

PHP almacena números enteros en un rango que depende de la plataforma. Este rango suele ser el de los números enteros con signo de 32 o 64 bits. ^[26] Las variables enteras se pueden asignar mediante notaciones decimales (positivas y negativas), octales , hexadecimales y binarias .

$a  =  1234 ;  // número decimal 
$b  =  0321 ;  // número octal (equivalente a 209 decimal) 
$c  =  0x1B ;  // número hexadecimal (equivalente a 27 decimal) 
$d  =  0 b11 ;  // número binario (equivalente a 3 decimal) 
$e  =  1 _234_567 ;  // número decimal (a partir de PHP 7.4.0)

Los números reales también se almacenan en un rango específico de la plataforma. Se pueden especificar mediante notación de punto flotante o dos formas de notación científica . ^[27]

$a  =  1,234 ; 
$b  =  1,2e3 ;      // 1200 
$c  =  7E-5 ;       // 0,00007 
$d  =  1 _234.567 ; // a partir de PHP 7.4.0 

PHP admite strings, que se puede utilizar con comillas simples, comillas dobles, sintaxis nowdoc o heredoc . ^[28]

Las cadenas entre comillas dobles admiten la interpolación de variables:

$edad  =  '23' ;

echo  "John tiene $age años" ;  // John tiene 23 años

Sintaxis de llaves: ^[29]

$f  =  "raíz cuadrada" ; 
$x  =  25 ;

echo  "a $xc \n " ;    // Advertencia: variable $xc no definida 
echo  "a { $x } c \n " ;  // imprime a25c 
echo  "a ${ x } c \n " ;  // también imprime a25c

echo  " $f ( $x ) es { $f ( $x ) } \n " ;  // imprime sqrt(25) es 5

PHP admite dos tipos especiales: null, resource. El nulltipo de datos representa una variable que no tiene valor. El único valor en el nulltipo de datos es NULL . La constante NULL no distingue entre mayúsculas y minúsculas. ^[30] Las variables del resourcetipo " " representan referencias a recursos de fuentes externas. Estas suelen ser creadas por funciones de una extensión particular y solo pueden ser procesadas por funciones de la misma extensión. Algunos ejemplos incluyen recursos de archivos, imágenes y bases de datos. ^[24]

PHP admite cuatro tipos compuestos: array, object, callable, iterable.

Las matrices pueden contener elementos mixtos de cualquier tipo, incluidos recursos y objetos. ^[31] Las matrices multidimensionales se crean asignando matrices como elementos de matriz. PHP no tiene un tipo de matriz verdadero. Las matrices PHP son nativamente dispersas y asociativas . Las matrices indexadas son simplemente hashes que utilizan números enteros como claves.

Matriz indexada:

$temporada  =  [ "Otoño" ,  "Invierno" ,  "Primavera" ,  "Verano" ];   
echo  $temporada [ 2 ];  // Primavera

Matriz asociativa:

$salario  =  [ "Alex"  =>  34000 ,  "Bill"  =>  43000 ,  "Jim"  =>  28000 ];   
echo  $salario [ "Bill" ];  // 43000

Matriz multidimensional:

$mark  =  [ 
    "Alex"  =>  [ 
        "biología"  =>  73 , 
        "historia"  =>  85 
    ], 
    "Jim"  =>  [ 
        "biología"  =>  86 , 
        "historia"  =>  92 
    ] 
];

echo  $mark [ "Jim" ][ "historial" ];   // 92

El objecttipo de datos es una combinación de variables, funciones y estructuras de datos en el paradigma de programación orientada a objetos .

clase  Persona 
{ 
    //... 
}

$persona  =  nueva  Persona ();

Desde la versión 5.3 PHP tiene funciones de primera clase que pueden usarse, por ejemplo, como argumento de otra función.

función  ejecutor ( invocable  $función ,  mixta  ... $args ) 
{ 
    return  $función ( ... $args ); 
}

$f  =  fn ( $x ,  $y )  =>  $x  **  $y ;

función  suma ( int | float  ... $args ) 
{ 
    devolver  array_sum ( $args ); 
}

echo  runner ( fn ( $x )  =>  $x  **  2 ,  2 );  // imprime 4 
echo  runner ( $f ,  2 ,  3 );  // imprime 8 
echo  runner ( 'sum' ,  1 ,  2 ,  3 ,  4 );  // imprime 10

IterableEl tipo indica que la variable se puede utilizar con foreachun bucle. ^[32] Puede ser cualquier objeto arrayo generatorque implemente la interfaz interna especial Traversable^[33] .

función  printSquares ( iterable  $datos ) 
{ 
    foreach  ( $datos  como  $valor )  { 
        echo  ( $valor  **  2 )  .  " " ; 
    }

    eco  " \n " ; 
}

// matriz 
$matriz  =  [ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ,  7 ,  8 ,  9 ,  10 ];

// generador 
$generador  =  función  () :  Generador  { 
    para  ( $i  =  1 ;  $i  <=  10 ;  $i ++ )  { 
        rendimiento   $i ; 
    } 
};

// objeto 
$arrayIterator  =  nuevo  ArrayIterator ([ 1 ,  2 ,  3 ,  4 ,  5 ,  6 ,  7 ,  8 ,  9 ,  10 ]);

printCuadrados ( $matriz ); // 1 4          9 16 25 36 49 64 81 100 
printCuadrados ( $generador ());    // 1 4 9 16 25 36 49 64 81 100 
printCuadrados ( $Iteradormatriz );  // 1 4 9 16 25 36 49 64 81 100

Los tipos de unión se introdujeron en PHP 8.0 ^[34]

función  foo ( cadena | int  $foo ) :  cadena | int  {}

PHP tiene cientos de funciones base y miles más provenientes de extensiones. Antes de la versión 5.3.0 de PHP, las funciones no eran funciones de primera clase y solo se podía hacer referencia a ellas por su nombre, mientras que PHP 5.3.0 introduce cierres. ^[35] Las funciones definidas por el usuario se pueden crear en cualquier momento y sin necesidad de crear prototipos. ^[35] Las funciones se pueden definir dentro de bloques de código, lo que permite tomar una decisión en tiempo de ejecución sobre si se debe definir o no una función. No existe el concepto de funciones locales. Las llamadas a funciones deben usar paréntesis, con la excepción de las funciones constructoras de clase de argumento cero llamadas con el newoperador PHP, donde los paréntesis son opcionales.

Un ejemplo de definición de función es el siguiente:

función  hola ( $target = 'Mundo' ) 
{ 
    echo  "Hola $target ! \n " ; 
}

hola ();  // genera "¡Hola mundo!" 
hola ( 'Wikipedia' );  // genera "¡Hola Wikipedia!"

Las llamadas a funciones se pueden realizar a través de variables, donde el valor de una variable contiene el nombre de la función a llamar. Esto se ilustra en el siguiente ejemplo:

función  hola () 
{ 
    return  'Hola' ; 
}

función  mundo () 
{ 
    return  "¡Mundo!" ; 
}

$función1  =  'hola' ; 
$función2  =  'mundo' ;

echo  " { $función1 () } { $función2 () } " ; 

Se puede asignar un valor predeterminado para los parámetros en la definición de la función, pero antes de PHP 8.0 no se admitían parámetros nombrados ni omisiones de parámetros. ^[36] Algunos desarrolladores principales de PHP han expresado públicamente su decepción con esta decisión. ^[37] Otros han sugerido soluciones alternativas para esta limitación. ^[38]

Los argumentos con nombre se introdujeron en PHP 8.0

función  potencia ( $base ,  $exp ) 
{ 
    return  $base  **  $exp ; 
}

// Usando argumentos posicionales: 
echo  power ( 2 ,  3 );  // imprime 8

// Usando argumentos nombrados: 
echo  power ( base :  2 ,  exp :  3 );  // imprime 8 
echo  power ( exp :  3 ,  base :  2 );  // imprime 8

La especificación de los tipos de parámetros de función y valores de retorno de función se admite desde PHP 7.0. ^[39]

Declaración del tipo de retorno:

función  suma ( $a ,  $b ) :  float  
{ 
    return  $a  +  $b ; 
}

var_dump ( suma ( 1 ,  2 ));  // imprime float(3)

Parámetros de escritura:

función  suma ( int  $a ,  int  $b ) 
{ 
    devolver  $a  +  $b ; 
}

var_dump ( suma ( 1 ,  2 ));      // imprime int(3) 
var_dump ( suma ( 1.6 ,  2.3 ));  // imprime int(3)

Sin tipificación estricta habilitada:

$f1  =  fn  ( $a ,  $b ) :  int  =>  $a  +  $b ; 
$f2  =  fn  ( int  $a ,  int  $b )  =>  $a  +  $b ;

var_dump ( $f1 ( 1.3 ,  2.6 ));  // imprime int(3) 
var_dump ( $f1 ( 1 ,  '2' )) ;    // imprime int(3) 
var_dump ( $f2 ( 1.3 ,  2.6 ));  // imprime int(3) 
var_dump ( $f2 ( 1 ,  '2' ));    // imprime int(3)

Con la escritura estricta habilitada:

declarar ( tipos_estrictos = 1 );

 $f1  =  fn  ( $a ,  $b ) :  int  = >  $ a  + $  b ; 
$f2  =  fn  ( int  $a ,  int  $b )  =>  $a  +  $b ;

var_dump ( $f1 ( 1.3 ,  2.6 ));  // Error fatal: el valor de retorno debe ser de tipo int, se debe devolver un valor float 
var_dump ( $f1 ( 1 ,  '2' ));    // imprime int(3) 
var_dump ( $f2 ( 1.3 ,  2.6 ));  // Error fatal: el argumento n.° 1 ($a) debe ser de tipo int, se debe proporcionar un valor float 
var_dump ( $f2 ( 1 ,  '2' ));    // Error fatal: el argumento n.° 2 ($b) debe ser de tipo int, se debe proporcionar una cadena

PHP admite funciones anónimas verdaderas a partir de la versión 5.3. ^[35] En versiones anteriores, PHP solo admitía funciones cuasi anónimas a través de la create_function()función.

$x  =  3 ; 
$func  =  function ( $z )  {  return  $z  *  2 ;  }; 
echo  $func ( $x );  // imprime 6

Desde la versión 7.4, PHP también admite la sintaxis de funciones de flecha ( =>). ^[40]

$x  =  3 ; 
$func  =  fn ( $z )  =>  $z  *  2 ; 
echo  $func ( $x );  // imprime 6

Creando cierres

$add  =  fn ( $x )  =>  fn ( $y )  =>  $y  +  $x ;

/* Equivalente a */

$add  =  función  ( $x )  { 
    devolver  función  ( $y )  usar  ( $x )  { 
        devolver  $y  +  $x ; 
    }; 
};

usando

$f  =  $add ( 5 );

echo  $f ( 3 );        // imprime 8 
echo  $add ( 2 )( 4 );   // imprime 6

función  suma ( ... $nums ) :  int 
{ 
    return  array_sum ( $nums ); 
}

eco  suma ( 1 ,  2 ,  3 );  // 6

función  suma ( int  ... $nums ) :  int 
{ 
    return  array_sum ( $nums ); 
}

echo  sum ( 1 ,  'a' ,  3 );  // TypeError: El argumento 2 pasado a sum() debe ser del tipo int (desde PHP 7.3)

Al usar generadores, podemos escribir código que use foreach para iterar sobre un conjunto de datos sin tener que crear una matriz en la memoria, lo que puede resultar en una sobrecarga de memoria o un tiempo de procesamiento significativo para la generación.

La funcionalidad básica de programación orientada a objetos se agregó en PHP 3. ^[41] El manejo de objetos se reescribió completamente para PHP 5, expandiendo el conjunto de características y mejorando el rendimiento. ^[42] En versiones anteriores de PHP, los objetos se manejaban como tipos primitivos . ^[42] El inconveniente de este método era que se copiaba todo el objeto cuando se asignaba o pasaba una variable como parámetro a un método. En el nuevo enfoque, los objetos se referencian por identificador y no por valor. PHP 5 introdujo variables miembro y métodos privados y protegidos, junto con clases abstractas y clases finales , así como métodos abstractos y métodos finales . También introdujo una forma estándar de declarar constructores y destructores , similar a la de otros lenguajes orientados a objetos como C++ , y un modelo estándar de manejo de excepciones . Además, PHP 5 agregó Interfaces y permite implementar múltiples Interfaces. Hay interfaces especiales que permiten que los objetos interactúen con el sistema de tiempo de ejecución. Los objetos que implementan ArrayAccess se pueden utilizar con la sintaxis de matriz y los objetos que implementan Iterator o IteratorAggregate se pueden utilizar con la construcción del lenguaje foreach . Las características de método estático y variable de clase en Zend Engine 2 no funcionan de la forma en que algunos esperarían. No hay una característica de tabla virtual en el motor, por lo que las variables estáticas se vinculan con un nombre en lugar de una referencia en el momento de la compilación. ^[43]

Este ejemplo muestra cómo definir una clase, Foo, que hereda de la clase Bar. El método myStaticMethodes un método público estático que se puede llamar con Foo::myStaticMethod();.

clase  Foo  extiende  Bar 
{ 
    función  __construct () 
    { 
        $doo  =  "wah dee dee" ; 
    }

     función estática  pública myStaticMethod () { $dee = "dee dee dum" ; } } 
    
          
    

Si el desarrollador crea una copia de un objeto utilizando la palabra reservada clone , el motor Zend comprobará si __clone()se ha definido un método o no. Si no, llamará a un valor predeterminado __clone()que copiará las propiedades del objeto. Si __clone()se define un método, entonces será responsable de establecer las propiedades necesarias en el objeto creado. Para mayor comodidad, el motor proporcionará una función que importe las propiedades del objeto de origen, de modo que el programador pueda comenzar con una réplica por valor del objeto de origen y solo anular las propiedades que se deben cambiar. ^[44]

// El 
rasgo de plantilla  TSingleton 
{ 
    private  static  $_instance  =  null ;

     función  privada __construct ()  {}  // Debe tener un constructor privado predeterminado y tener cuidado de no abrirlo en la clase

     función pública estática  obtenerInstancia () { if ( null === self :: $_instance ) { self :: $_instance = new self (); } 
    
            
               
        

        devuelve  yo mismo :: $_instancia ; 
    } 
}

clase  FrontController 
{ 
    usar  TSingleton ; 
}

// También se puede utilizar en clases ya extendidas 
class  WebSite  extends  SomeClass 
{ 
    use  TSingleton ; 
}

rasgo  TBounding 
{ 
    público  $x ,  $y ,  $ancho ,  $alto ; 
}

rasgo  TMoveable 
{ 
    función pública  moveTo ( $x , $y ) { // … } }  
    
        
    


rasgo  TResizeable 
{ 
    función pública  redimensionar ( $newWidth , $newHeight ) { // … } }  
    
        
    


clase  Rectángulo 
{ 
    usa  TBounding ,  TMoveable ,  TResizeable ;

     función  pública fillColor ( $color ) 
    { 
        // … 
    } 
}

• HTML (lenguaje de marcado de hipertexto)
• Sistema de plantillas web