PHP

-

Estructura de PHP
Un archivo PHP normalmente suele contener HTML y trozos de código PHP. Por ello antes de estudiar PHP es necesario haber estudiado HTML. A veces, se dice que PHP es un lenguaje “embebido” en HTML, es decir, incrustado en código HTML. Todos los fragmentos de código PHP deben comenzar con la siguiente cadena de caracteres: <?php ,y finalizar con ?>
  
Los símbolos <?php y ?> se dice que son los delimitadores del código PHP. Normalmente, una página PHP básica sería algo así:
<!DOCTYPE html>
<html>
<head>
<title>Ejemplo de una web con PHP - aprenderaprogramar.com</title>
<meta charset="utf-8">
</head>
<body>
<?php
/* Aquí vendría el código PHP */
/* Este código PHP podría ser una consulta a base de datos */
/* Y además podríamos mostrar esos datos */
?>
</body>
</html>

Tipos de Datos

 Los principales tipos de datos (considerados tipos de datos escalares) en PHP son:
  • boolean: almacenan valores verdadero o falso (true / false).
  • integer: números enteros.
  • float: números con decimales, usando el punto como separador decimal.
  • string: cadenas de texto.

PHP también incluye los siguientes tipos de datos compuestos (los trataremos en profundidad más adelante):
  • array: usados para almacenar varios valores.
  • object: almacena objetos en PHP.

Incluye también los siguientes tipos de datos especiales:
  • resource: hace referencia a recursos tales como archivos abiertos, conexiones establecidas con bases de datos, etc.
  • null: indique el valor está vacío (no contiene nada).

Estructuras Repetitivas

WHILE

(PHP 4, PHP 5)
Los bucles while son el tipo más sencillo de bucle en PHP. Se comportan igual que su contrapartida en C. La forma básica de una sentencia while es:
while (expr)
    sentencia
El significado de una sentencia while es simple. Le dice a PHP que ejecute las sentencias anidadas, tanto como la expresión while se evalúe como TRUE. El valor de la expresión es verificado cada vez al inicio del bucle, por lo que incluso si este valor cambia durante la ejecución de las sentencias anidadas, la ejecución no se detendrá hasta el final de la iteración (cada vez que PHP ejecuta las sentencias contenidas en el bucle es una iteración). A veces, si la expresión while se evalúa como FALSE desde el principio, las sentencias anidadas no se ejecutarán ni siquiera una vez.
Al igual que con la sentencia if, se pueden agrupar varias instrucciones dentro del mismo bucle while rodeando un grupo de sentencias con corchetes, o utilizando la sintaxis alternativa:
while (expr):
    sentencias
    ...
endwhile;
Los siguientes ejemplos son idénticos y ambos presentan los números del 1 al 10: 

<?php
$i = 1;
while ($i <= 10) {
    echo $i++;  /* el valor presentado sería
                   $i antes del incremento
                   (post-incremento) */
}

/* ejemplo 2 */

$i = 1;
while ($i <= 10):
    echo $i;
    $i++;
endwhile;
?>

FOR

(PHP 4, PHP 5)
Los bucles for son los ciclos más complejos en PHP. Se comportan como sus contrapartes en C. La sintaxis de un bucle for es: 

for (expr1; expr2; expr3)
    sentencia
 
La primera expresión (expr1) es evaluada (ejecutada) una vez incondicionalmente al comienzo del bucle.
En el comienzo de cada iteración, la expr2 es evaluada, Si es TRUE, el bucle continúa y las sentencias anidadas son ejecutadas. Si se evalúa como FALSE, termina la ejecución del bucle.
Al final de cada iteración, la expr3 es evaluada (ejecutada).
Cada una de las expresiones puede estar vacía o contener múltiples expresiones separadas por comas. En la expr2, todas las expresiones separadas por una coma son evaluadas pero el resultado se toma de la última parte. Que la expr2 esté vacía significa que el bucle deberá ser corrido indefinidamente (PHP implícitamente lo considera como TRUE, como en C). Esto puede no ser tan inútil como se pudiera pensar, ya que muchas veces se quiere terminar el bucle usando una sentencia condicional break en lugar de utilizar la expresión verdadera del for.
Considere los siguientes ejemplos. Todos ellos muestran los números del 1 al 10:
<?php
 

for ($i = 1; $i <= 10; $i++) {
    echo $i;
}

/* ejemplo 2 */

for ($i = 1; ; $i++) {
    if ($i > 10) {
        break;
    }
    echo $i;
}



$i = 1;
for (; ; ) {
    if ($i > 10) {
        break;
    }
    echo $i;
    $i++;
}




for ($i = 1, $j = 0; $i <= 10; $j += $i, print $i, $i++);
?> 
Por supuesto, el primer ejemplo parece ser el mejor (o quizás el cuarto), pero se puede encontrar que la posibilidad de usar expresiones vacías en los bucles for resulta útil en muchas ocasiones.
PHP también soporta la sintaxis alternativa de los dos puntos para bucles for. 

for (expr1; expr2; expr3):
    sentencia
    ...
endfor;
 
Es una cosa común a muchos usuarios iterar por medio de arrays como en el ejemplo de abajo. 

<?php
/*
* Este es un array con algunos datos que se desean modificar
* cuando se corra por el bucle for.
*/
$people = Array(
        Array('name' => 'Kalle', 'salt' => 856412),
        Array('name' => 'Pierre', 'salt' => 215863)
        );

for($i = 0; $i < sizeof($people); ++$i)
{
    $people[$i]['salt'] = rand(000000, 999999);
}
?> 
El problema radica en la segunda expresión del for. Este código puede ser lento porque tiene que calcular el tamaño del array en cada iteración. Dado que el tamaño nunca cambia, se pueden optimizar fácilmente usando una variable intermedia para almacenar el tamaño y usarla en el bucle en lugar del sizeof. El siguiente ejemplo ilustra esto: 

<?php
$people = Array(
        Array('name' => 'Kalle', 'salt' => 856412),
        Array('name' => 'Pierre', 'salt' => 215863)
        );

for($i = 0, $size = sizeof($people); $i < $size; ++$i)
{
    $people[$i]['salt'] = rand(000000, 999999);
}
?>


DO-WHILE

(PHP 4, PHP 5)

Los bucles do-while son muy similares a los bucles while, excepto que la expresión verdadera es verificada al final de cada iteración en lugar que al principio. La diferencia principal con los bucles while es que está garantizado que corra la primera iteración de un bucle do-while (la expresión verdadera sólo es verificada al final de la iteración), mientras que no necesariamente va a correr con un bucle while regular (la expresión verdadera es verificada al principio de cada iteración, si se evalúa como FALSE justo desde el comienzo, la ejecución del bucle terminaría inmediatamente).

Hay una sola sintaxis para bucles do-while:


<?php
$i = 0;
do {
echo $i;
} while ($i > 0);
?>

El bucle de arriba se ejecutaría exactamente una sola vez, ya que después de la primera iteración, cuando la expresión verdadera es verificada, se evalúa como FALSE ($i no es mayor que 0) y termina la ejecución del bucle.

Los usuarios avanzados de C pueden estar familiarizados con un uso distinto del bucle do-while, para permitir parar la ejecución en medio de los bloques de código, mediante el encapsulado con do-while (0), y utilizando la sentencia break. El siguiente fragmento de código demuestra esto:


<?php
do {
if ($i < 5) {
echo "i no es lo suficientemente grande";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
echo "i está bien";

/* procesar i */

} while (0);
?>

No se preocupe si no se entiende esto completamente o en absoluto. Se pueden codificar scripts e incluso scripts potentes sin usar esta 'característica'. Desde PHP 5.3.0, es posible utilizar el operador GOTO en lugar de este hack. 


FOREACH

(PHP 4, PHP 5)
El constructor foreach proporcina un modo sencillo de iterar sobre arrays. foreach funciona sólo sobre arrays y objetos, y emitirá un error al intentar usarlo con una variable de un tipo diferente de datos o una variable no inicializada. Existen dos sintaxis:


foreach (expresión_array as $valor) sentencias foreach (expresión_array as $clave => $valor) sentencias.


La primera forma recorre el array dado por expresión_array. En cada iteración, el valor del elemento actual se asigna a $valor y el puntero interno del array avanza una posición (así en la próxima iteración se estará observando el siguiente elemento).

La segunda forma además asigna la clave del elemento actual a la variable $clave en cada iteración.

También es posible personalizar la interacion de objetos.

Estructura Condicional

PHP al igual que la mayoría de lenguajes de programación necesita de herramientas que permitan tomar decisiones lógicas al servidor.
  1. If...Else
  2. If...Elseif...Else
  3. Switch
Estas son todas las posibilidades condicionales que nos permite este lenguaje de programación.

  • If...Else

Estas instrucciones son las mas usadas de todos los lenguajes de programación, ya que son las mas básicas. IF (Español: SI) ELSE (Español: SI NO).
Estructura:
 if(expresión)
 {
   ... Sentencias;
 }
 else
 {
   ... Sentencias;
 }
De momento, en ese cachito de codigo aunque sin nada tangible, estarías diciendo que si la expresión se cumple se realizan sentencias, y en este caso si no se cumpliese la expresión se evaluaría las sentencias que están dentro de else{...}.
Un ejemplo para probar en casa:
 <?php
 $galletas = true;
 if($galletas)
 {
   echo 'Hay galletas';
 }
 else
 {
   echo 'No hay galletas';
 }
 ?>
En este ejemplo, estamos dando un valor $galletas y comprobamos si es cierto o no, introduciendolo en la expresión del condicional. Tal cual está, este ejemplo produciría el resultado 'Hay galletas', aunque si cambiasemos $galletas = true; por $galletas = false daría como resultado la segunda sentencia.

  • If...Elseif...Else

La estructura de estas instrucciones viene a ser muy similar que la anterior, y de hecho el ejemplo anterior es válido igualmente para este.
Estructura:
 <?php
 if(expresión)
 {
   ... Sentencias;
 }
 elseif(expresión)
 {
   ... Sentencias;
 }
 else
 {
   ... Sentencias;
 } 
 ?>
Esta es la sintaxís con la que debe ser usada elseif. Un elseif se ejecutará, siempre y cuando, no haya alguna respuesta verdadera en el if o elseif anterior; luego de que se llega al final de los elseif, y ninguno ha sido verdadero, se ejecutará lo que está dentro de el else final.
Pueden haber varios elseif, pero estos estan siempre dentro de un if y un else(sólo uno) final.
Otro ejemplo, para dejar en claro el funcionamiento de elseif:
 <?php
 $test = 33;
 if ($test > 40) {
   echo "Sí, $test es mayor que 40.";
   } 
 elseif ($test > 35) 
   echo "Sí, $test es mayor que 35.";
   }
 elseif ($test > 30) {
   echo "Sí, $test es mayor que 30.";
   }
 else {
   echo "No, $test es menor que 40, 35 y 30.";
   }
 ?>
En este caso la respuesta sería:
Sí, 33 es mayor que 30.
Si el valor de $test se cambia a 22, la respuesta sería:
No, 22 es menor que 40, 35 y 30.

  • Switch

Las instrucciones If...Elseif...Else permiten seleccionar entre más de dos posibles condiciones que puedan ser evaluadas como true o false, pero en ocasiones nos encontraremos con casos en que queremos evaluar condiciones con una estructura como esta:
 if($variable==Valor1)
 {
   ... Sentencias;
 }
 elseif($variable==Valor2)
 {
   ... Sentencias;
 }
 elseif($variable==Valor3)
 {
   ... Sentencias;
 }else
 {
   ... Sentencias;
 }
En las que esperamos realizar una acción determinada según el valor tomado por una variable. Para estos casos la mayoría de los lenguajes de programación incluyen una instrucción que permite "seleccionar" entre los posibles valores de una variable: la instrucción Switch (Español: SELECCIONAR).
Estructura:
 switch($variable)
 {
    case Valor1:
     ... Sentencias;
     break;
    
    case Valor2:
     ... Sentencias;
     break;
    
    case Valor3:
     ... Sentencias;
     break;
    
    .
    .
    .
    
    default:
     ... Sentencias;
 }
En esta estructura, $variable es la variable que será comparada sucesivamente con cada una de las instrucciones case hasta hallar la que corresponda al valor de $variable, una vez que la encuentre se ejecutarán sucesivamente todas las instrucciones pertenecientes al switch hasta hallar la siguiente instrucción break; esta última hace un salto pasando el control del programa a la instrucción inmediata siguiente fuera del switch.
Si ninguna de las instrucciones case corresponde al valor de $variable se ejecutarán solo las instrucciones siguientes al default. Al igual que else, la instrucción default es opcional.
Veamos un ejemplo:
Usando if...elseif...elseUsando switch
 <?php
 $variable=2;
 if($variable==1)
 {
   echo '$Variable es igual a 1.';
 }
 elseif($variable==2)
 {
   echo '$Variable es igual a 2.';
 }
 elseif($variable==3)
 {
   echo '$Variable es igual a 3.';
 }else
 {
   echo '$Variable no es igual ' .
        'a 1, 2 o 3.';  
 }
 ?>

 <?php
 $variable=2;
 switch($variable)
 {
  case 1:
   echo '$Variable es igual a 1.';
   break;
  
  case 2:
   echo '$Variable es igual a 2.';
   break;
   
  case 3:
   echo '$Variable es igual a 3.';
   break;
  
  default:
   echo '$Variable no es igual ' .
        'a 1, 2 o 3.';
 }
 ?>
El resultado de ambas formas mostradas será:
$Variable es igual a 2.
Si por el contrario cambiamos $Variable=2 por $Variable=5 al inicio de código el resultado sería:
$Variable no es igual a 1, 2 o 3.
Una diferencia importante respecto a las instrucciones if...elseif...else es que se requiere de la instrucción break para salir del switch al terminar las instrucciones correspondientes a un case. Esto es así debido a que solo podemos especificar un valor en cada case. Veamos un ejemplo:
Usando if...elsefif...elseUsando switch
 <?php
 $variable=2;
 if($variable==1)
 {
   echo '$Variable es igual a 1.';
 }
 elseif($variable==2 
        OR $variable==3)
 {
   echo '$Variable es igual a 2 o 3.';
 }else
 {
   echo '$Variable no es igual ' .
        'a 1, 2 o 3.';  
 }
 ?>

 <?php
 $variable=2;
 switch($variable)
 {
  case 1:
   //Se ejecuta si $variable vale 1
   echo '$Variable es igual a 1.';
   break;
  
  case 2:
  case 3:
   //Se ejecuta si $variable vale 2 o 3
   echo '$Variable es igual a ' .
        '2 o 3.';
   break;
  
  default:
   //Se ejecuta en cualquier otro caso
   echo '$Variable no es igual ' .
        'a 1, 2 o 3.';
 }
 ?>
En cualquiera de las dos formas mostradas, la salida obtenida sería:
$Variable es igual a 2 o 3.
En este caso, al evaluarse la segunda instrucción case no se encuentra ningún break por lo que siguen ejecutandose las instrucciones siguientes al tercer case, aun cuando $Variable es diferente de 3. Más aún, si borramos el break del tercer case también se ejecutarán las instrucciones siguientes a default, y la salida sería entonces:
$Variable es igual a 2 o 3.
$Variable no es igual a 1, 2 o 3.

Funciones

Declaración
VARIABLES EN PHP
Las variables en PHP son representadas con un signo de dólar ($) seguido por el nombre de la variable. El nombre de la variable es sensible a minúsculas y mayúsculas. Es decir, las siguientes declaraciones de variables son distintas entre ellas: 

$variable, $Variable, $variAble, $VariAble, etc. representan a distintas variables.
Recordar que una variable es un espacio de la memoria del ordenador (en este caso del servidor) a la que asignamos un contenido que a grandes rasgos puede ser un valor numérico (sólo números, con su valor de cálculo) o alfanumérico (sólo texto o texto con números, sin valor de cálculo).
Para declarar un nombre de variable válido, éste tiene que empezar con una letra (o si no empieza con una letra, tendrá que hacerlo con un carácter de subrayado), seguido de cualquier número de letras, números y caracteres de subrayado, sin espacios. Veamos algunos ejemplos:
Posible nombre de variable
Validez
$4variable
Nombre de variable inválido.
$_4variable
Nombre de variable válido.
$variable4
Nombre de variable válido.
$otra
Nombre de variable válido.
$1_otra
Nombre de variable inválido.
$variable_de_nombre_muy_largo
Nombre de variable válido.
$ABC
Nombre de variable válido.
$ A B C
Nombre de variable inválido.
$A_y_B_x_C
Nombre de variable válido.

Cuando el intérprete PHP detecta un error en la sintaxis al declarar una variable, cuando tratamos de accecer a la página php nos aparecerá un mensaje de error. Por ejemplo si en un archivo php incluimos una línea como $ A B C = 5; donde el nombre de variable es inválido ya que tiene espacios intermedios, nos aparecerá un mensaje de error:
Parse error: syntax error, unexpected T_STRING, expecting T_VARIABLE or '$' in /home/miraiz/domains/midominio.com/public_html/prueba.php on line 3. Este mensaje nos informa de que hay un problema en el archivo php y nos indica la línea donde el intérprete considera que está el problema.

DIFERENCIAS ENTRE LOS OPERADORES DE ASIGNACIÓN E IGUALDAD. ASIGNACIÓN (=)
El operador de asignación es "=". Se podría pensar que es como un "igual a". No lo es. El operador igual en programación no tiene el mismo sentido que en matemáticas. En programación, significa que el valor de la expresión de la derecha se establece en el operando de la izquierda.
Fíjate en este ejemplo y en los comentarios.
<?php
$a = 3; // asignamos el valor 3 a la variable $a
$b = "cadena"; // asignamos el valor "cadena" a la variable $b

?>


OPERADOR DE IGUALDAD (==)
El operador comparador de igualdad es ==. Como su propio nombre indica, sirve para comparar dos valores o variables y no para asignar valores. Este operador devuelve el resultado de la operación lógica de 'igual a' tal y como podemos apreciar en el siguiente ejemplo.
Fíjate en este ejemplo y en los comentarios.
<?php
$a = 3;
$b = 3;
$a == $b; // El resultado de la comparación es TRUE porque $a es igual a $b
$a = 3;
$b = 4;
$a == $b; // El resultado de la comparación es FALSE porque $a no es igual a $b
?>


TIPOS DE DATOS
En PHP no es obligatorio indicar el tipo de datos al que pertenece una variable como en otros lenguajes, sino que los tipos de datos son establecidos directamente por el intérprete PHP, que es el encargado de interpretar el código.
Ahora veremos en una tabla los distintos tipos de datos que se pueden usar en PHP.
TIPO DE DATO
DEFINICIÓN
integer
Los integers, o enteros, pueden tener distintos valores numéricos enteros que se expresan con diferentes notaciones.
$variable = 18; // Número entero positivo
$variable = -18; // Número entero negativo
$variable = 0x12; // Notación hexadecimal, en principio no la utilizaremos
float o double
Este tipo de datos son los números de punto flotante a los que normalmente llamamos “números decimales”, por ejemplo, 9.876. Ambos tienen mucha precisión, pero double es el más preciso (con más decimales). La sintaxis para utilizarlos es bastante simple:
$variable = 9.876;
string
El tipo de datos string, también conocido como cadena de caracteres, se expresa con la siguiente sintaxis:
$variable = "Yo soy una cadena";
boolean
Se trata de un tipo lógico. Sus posibles valores son true (verdadero) o false (falso).
$variable = true;
$variable = false;


INSTRUCCIÓN ECHO
Esta instrucción muchas veces se dice que sirve para que se muestre por pantalla un texto, una variable, o una combinación de texto y variables. Pero realmente no es así: echo no es una instrucción que sirva para mostrar algo por pantalla (aunque podemos usarla para esto), sino que sirve para insertar texto dentro del documento HTML subyacente al código PHP.
Por ejemplo: echo "salida por pantalla. "; hará que se inserte este texto en el documento html. Si lo hacemos entre las etiquetas <body> y </body> lo veremos por pantalla porque cualquier texto insertado en ese lugar se mostrará por pantalla, no porque la instrucción echo dé lugar a que se muestre por pantalla.
Sin embargo echo "<h1>Salida por pantalla. </h1> "; no hará que se muestren por pantalla las etiquetas h1 y el texto, sino que introducirá en el documento HTML las etiquetas con el texto, éstas etiquetas funcionarán como código HTML y lo que se mostrará por pantalla será Salida por pantalla con formato de título h1 (letras más grandes de lo normal).
En general en php son válidas tanto las comillas dobles como las comillas simples, por lo que se puede escribir tanto echo "<h1>Salida por pantalla. </h1> "; como echo '<h1>Salida por pantalla. </h1>';
Los paréntesis no son necesarios (echo en realidad no es una función sino que es lo que se denomina una <<construcción del lenguaje>>, de ahí que no sean estrictamente necesarios los paréntesis), pero se pueden incluir si se desea. Ejemplo: echo ('con paréntesis y comillas simples');
Crea un archivo php con el siguiente código, ponle un nombre como usoDeEcho.php y súbelo al servidor. Luego invócalo usando la ruta adecuada según la dirección web con la que estés trabajando (será similar a http://apr2.byethost7.com/usoDeEcho.php.)
<?php
echo "salida por pantalla. ";
$a = 5;
echo $a;
echo " El valor de a es $a.";
?>


La visualización en tu navegador deberá ser similar a esta. Puede variar ligeramente dependiendo del navegador que uses.

Ten en cuenta que $a se muestra por pantalla como 5 porque el intérprete de PHP considera que debe mostrarse siempre el valor de la variable, incluso si va dentro de un texto. Prueba a escribir la siguiente línea: echo " El valor de la variable \$a es $a.";
Comprobarás que se muestra por pantalla “salida por pantalla. 5 El valor de la variable $a es 5.”
Cuando antecedemos un nombre de variable del carácter \ hacemos que se interprete como texto en lugar de como una variable. El carácter \ se suele llamar “carácter de escape” porque permite que se considere texto algo que en principio se iba a interpretar como otra cosa (como una variable por ejemplo).
Crea ahora un archivo php con el siguiente código, ponle un nombre como usoDeEcho2.php y súbelo al servidor. Luego invócalo usando la ruta adecuada según la dirección web con la que estés trabajando (será similar a http://apr2.byethost7.com/usoDeEcho2.php.)

<html>
<head>
<title> Ejemplo php aprenderaprogramar.com </title>
<meta charset="utf-8">
</head>
<body>
<?php
echo 'con comillas simples<br/>';
echo ('con paréntesis y comillas simples<br/>');
echo ("con paréntesis y comillas dobles<br/>");
echo '<h1>Salida por pantalla</h1><br/>';
echo "salida por pantalla. ";
$a = 5;
echo $a;
echo " El valor de a es $a.";
?>
</body>
</html>

La visualización en tu navegador deberá ser similar a:
con comillas simples
con paréntesis y comillas simples
con paréntesis y comillas dobles

Salida por pantalla

salida por pantalla. 5 El valor de a es 5.

Puedes comprobar que <br/> no se muestra por pantalla porque es código HTML, y el navegador cuando detecta este código HTML introduce un salto de línea en lugar de mostrarlo por pantalla.
Para comprender bien la utilidad de la instrucción echo piensa en esta equivalencia:
<body>
<? php
echo '<h1>Cuzco</h1>'
?>
</body>
- - - - - - - - Equivale a - - - - - - - >
<body>
<h1>Cuzco</h1>
</body>

El navegador recibe el HTML “equivalente” generado y lo interpreta, dando lugar a los resultados que se mostrarán por pantalla.

Invocación
Ejemplo: Llamar a servicios
<?php
$quote  = $this->stock_quote->getQuote($ticker);
$rate   = $this->exchange_rate->getRate($currency);
?>
La llamada al servicio StockQuote es una llamada a un servicio local; la llamada al servicio ExchangeRate es una llamada a un servicio remoto. Observe que las llamadas se realizan de la misma manera, sin tener en cuenta si la llamada es a un servicio local o a uno remoto.
Los delegados que han sido inyectados se aseguran de que la manera de llamar a los componentes y el comportamiento sea el mismo, ya se trate de un servicio local o de uno remoto, por lo que los componentes no dependen de si una llamada es a un servicio local o a uno remoto. Por ejemplo, el delegado para un servicio local copia los argumentos y únicamente pasa esas copias, para asegurarse de que las llamadas sean por paso por valor, como lo harían para una llamada remota. También, el delegado para un servicio remoto toma los argumentos desde una lista de parámetros posicionales y se asegura de que están empaquetados apropiadamente en una petición SOAP y vueltos a convertir a una lista de parámetros posicionales al final de todo.
En el ejemplo de arriba, $ticker y $currency son claramente tipos escalares de PHP. Los componentes puede pasar los tipos escalares de PHP string, integer, float y boolean, pero las estructuras de datos sobre llamadas a servicios son siempre pasadas como Objetos de Datos de Servicio (SDOs). En un sección posterior se describe cómo un componente puede crear un SDO y pasarlo a una llamada a un servicio local o web, o cómo un componente puede crear un SDO para devolverlo.
Implementación
Las interfaces de objetos permiten crear código con el cual especificar qué métodos deben ser implementados por una clase, sin tener que definir cómo estos métodos son manipulados.
Las interfaces se definen de la misma manera que una clase, aunque reemplazando la palabra reservada classpor la palabra reservada interface y sin que ninguno de sus métodos tenga su contenido definido.
Todos los métodos declarados en una interfaz deben ser públicos, ya que ésta es la naturaleza de una interfaz.

implements ¶

Para implementar una interfaz, se utiliza el operador implements. Todos los métodos en una interfaz deben ser implementados dentro de la clase; el no cumplir con esta regla resultará en un error fatal. Las clases pueden implementar más de una interfaz si se deseara, separándolas cada una por una coma.
Nota:
Antes de PHP 5.3.9, una clase no puede implementar dos interfaces que especifiquen un método con el mismo nombre, ya que podría causar ambigüedad. Las versiones más recientes de PHP permiten esto siempre y cuando los métodos duplicados tengan la misma firma.
Nota:
Las interfaces se pueden extender al igual que las clases utilizando el operador extends.
Nota:
La clase que implemente una interfaz debe utilizar exactamente las mismas estructuras de métodos que fueron definidos en la interfaz. De no cumplir con esta regla, se generará un error fatal.

Constantes ¶

Es posible tener constantes dentro de las interfaces. Las constantes de interfaces funcionan como las constantes de clases excepto porque no pueden ser sobrescritas por una clase/interfaz que las herede.
Ejemplo #1 Ejemplo de interfaz
<?php// Declarar la interfaz 'iTemplate'interface iTemplate{
    public function setVariable($name, $var);
    public function getHtml($template);
}// Implementar la interfaz
// Ésto funcionará class Template implements iTemplate{
    private $vars = array();

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }

    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }

        return $template;
    }
}// Ésto no funcionará
// Error fatal: La Clase BadTemplate contiene un método abstracto
// y por lo tanto debe declararse como abstracta (iTemplate::getHtml)class BadTemplate implements iTemplate{
    private $vars = array();

    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
}?>
Ejemplo #2 Interfaces extensibles
<?phpinterface a{
    public function foo();
}

interface b extends a{
    public function baz(Baz $baz);
}// Ésto sí funcionaráclass c implements b{
    public function foo()
    {
    }

    public function baz(Baz $baz)
    {
    }
}// Ésto no funcionará y resultará en un error fatalclass d implements b{
    public function foo()
    {
    }

    public function baz(Foo $foo)
    {
    }
}?>
Ejemplo #3 Herencia múltiple de interfaces
<?phpinterface a{
    public function foo();
}

interface b{
    public function bar();
}

interface c extends a, b{
    public function baz();
}

class d implements c{
    public function foo()
    {
    }

    public function bar()
    {
    }

    public function baz()
    {
    }
}?>
Una interfaz, junto con la determinación de tipos, proveen una buena forma de asegurarse que determinado objeto contiene métodos particulares.

Comments

Post a Comment

Popular posts from this blog

COBOL

-
Image
Estructura de COBOL Un program COBOL está compuesto de 4 divisiones bien diferenciadas, que son: 1. Identification Division (Identificación):   Contiene información del programa, el autor, nombre del programa, fecha de creación, comentarios, etc. 2. Environment Division (Ambiente):  Describe las características que debe tener el ordenador para poder ejecutar el programa, los dispositivos de Entrada / Salida, el compilador, etc. 3. Data Division (Información):   Incluye los nombres de las variables, las características de las variables, el contenido que van a tener, sus nombres, etc. 4. Procedure Division (Procedimiento):   Describe las órdenes y operaciones que se van a realizar y el orden de las mismas. La estructura general sería la siguiente... IDENTIFICATION DIVISION    PROGRAM-ID    AUTHOR    INSTALLATION    DATE-WRITTEN    DATE-COMPILED    SECURITY  ENVIRONMENT DIVISION    CONFIGURATION SECTION       SOURCE-COMPUTER       OBJECT-COMPUTER        SP
Read more

PASCAL

-
Image
Estructura de PASCAL 1. Todo programa en pascal comienza con la palabra program y el nombre del programa (max. 8 caracteres, sin espacios en blanco) seguido de un punto y coma. Ejemplo: program nomina; 2. Es conveniente utilizar la cláusula uses crt para utilizar las propiedades de la pantalla. Ejemplo: uses crt; 3. A continuación definimos las constantes: son aquellas que tienen un valor que no cambiará en todo el programa. Se comienza con la palabra const. Ejemplo: const linea = 66; max = 100; min = 0; n = 30; 4. A continuación definimos nuestros tipos de datos. Hay dos tipos de datos en pascal: los tipos de datos  estándares , es decir que el compilador pascal los reconoce automáticamente, como son: integer, real, boolean, char, byte. Estos tipos de datos no son necesarios definirlos aqui, sino directamente se asignan a las variables. Los tipos de datos que hay que colocar aqui son aquellos  definidos por el usuario . Ellos son: los tipo string (cadenas de caracter
Read more