O recuncho do PHP

En PHP para poder incluir no noso script código situado noutro arquivo, podemos incluir o segundo arquivo no noso script. Para elo dispoñemos de catro instrucións:

• include(“ficheiro_a_incluir.php”); : Inclúe o código contido no ficheiro a incluir nese punto do script, como se abrísemos o ficheiro a incluir e copiásemos o seu contido nese punto do noso script.
• require(“ficheiro_a_incluir.php”); : Igual que include, pero a diferencia deste, se o ficheiro_a_incluir non existe produce un fatal error e detén a execución do código a diferenza de inclúe que so produce un warning
• include_once(“ficheiro_a_incluir.php”); : Igual que include, pero só se inclúe o código unha vez durante todo o script, isto quere dicir que se xa se incluíu nun punto anterior do script non se volverá a incluír neste punto.
• require_once(“ficheiro_a_incluir.php”);: Igual que require, pero só se inclúe o código unha vez durante todo o script, isto quere dicir que se xa se incluíu nun punto anterior do script non se volverá a incluír neste punto.

Máis información na axuda oficial: http://www.php.net/manual/es/function.include.php e http://www.php.net/manual/es/function.require.php

Hai catro instrución iterativas, e dicir, para repetir varias veces o mesmo bloque de código.

• WHILE: Repite un bloque de código mentres se cumpra unha condición que é avaliada o comezo de cada iteración.

  while (condicion)
  { //codigo }
  

• DO_WHILE: Repite un bloque de código mentres se cumpra unha condición que é avaliada o final de cada iteración (polo tanto executase polo menos unha iteración)

  do
  { //codigo }
  while (condicion)
  

• FOR: Repite un bloque de código mentres se cumpra unha condición, executando un fragmento de código antes de comezar a primeira iteración (empregado para inicializar variables e contadores) e outro fragmento de código ao final de cada iteración (empregado para aumentar o decrementar contadores)

  for(inicio;condicion;final) {
    //codigo
  }
  

  Estos dous fragmentos son equivalentes:

  for($i=0,$j=0;$i<10;$i++){
   //codigo
  }
  
  $i=0;$j=0;
  while($i<10){
    //codigo
    $i++;
  }
  

• FOREACH: Empregado para recorrer arrays (en particular daqueles dos que non se coñece o índice para acceder os elementos deste).

    foreach ($lista as $clave => $valor) {
       echo "El elemento de clave $clave tiene por valor $valor ";
    }
  

E dúas para modificar o fluxo deste bucles:

• BREAK: Finaliza a execución de todas as iteracións restantes do bucle.
• CONTINUE: Finaliza a execución da iteración actual do bucle, pero continúan as seguintes.

Unha serie de instrucións que controlan por onde vai pasando o funcionamento do programa, chámanse instrucións de control de fluxo. O primeiro tipo son as instrucións condicionais, semellantes as existentes noutras linguaxes:

• IF-THEN-ELSE: Pouco que contar desta coñecida instrución. En PHP séguese unha sintase similar a de C if (condicion) {bloque_SI} else {bloque_NON} . Tanto no bloque_SI como no bloque_NON pode haber outras instrucións IF_THEN_ELSE anidades

    if (condicion) {
       if (condicion2) {
          //codigo
       }
       else {
          //codigo
       }
    }
    else {
        if (condicion3) {
            //codigo
        }
    }
  

• IF mediante o operador ternario ?:. A súa estructura é condicion?bloque_SI:bloque_NON . Os seguinte fragmentos son equivalente:

  $a = ($x>10)?"Maior que 10":"Menor ou igual que 10";
  

  if ($x>10) {
    $a = "Maior que 10"
  }
  else {
    $a = "Menor ou igual que 10";
  }
  

• É igual poñer else if que elseif cando no bloque else se quere por máis condicións if

    if (cond) { ... }
    elseif (cond2) { ... }
    elseif (cond3) { ... }
    else { ... }
  

• SWITCH. Cando se quere avaliar unha expresión e ver con que valores coincide emprégase esta instrución.

    switch (expresion) {
      case 'a' : .... ; break;
      case 'b' : .... ; break;
      default : ....;
    }
  

• No switch e importante ter en conta os seguintes aspectos: a expresión ten que devolver un valor, os casos (case) son valores individuais, o código de cada caso ten que terminar nunha instrución break, ou senón a execución continuará polos seguintes casos ata que atope unha instrución break; so entra no caso default se non entrou noutro caso, o caso default é opcional e podemos non poñelo, a instrución non ten porque entrar nun caso, pode non entrar en ningún se o valor da expresión non coincide con ningún e non hai defualt

Máis información na axuda oficial: http://www.php.net/manual/es/language.control-structures.php

Para rematar cos operadores, imos enumerar dos que non falamos con anterioridade:

• Operadores de bit: & (AND de bits, é 1 se os dous bits son 1), | (OR de bits, é 1 se alomenos un dos dous bits é 1), ^ (EXOR ou OR exclusivo de bits, é 1 se só un dos dous bits é 1), ~ (NOT de bits, é 1 se o bit é 0), <> (despraza bits a dereita no primeiro operando as posicións indicadas no segundo operando). http://www.php.net/manual/es/language.operators.bitwise.php
• Cos operadores de desprazamento hay que ter en conta situacións de overflow e underflow que xorden cando se desprazan a esquerda e dereita máis posicións das que pode representar o tipo enteiro no sistema operativo no que se execute o script.

    $x=1;
    echo $x << 32;
  

• Operadores lóxicos: && , and (AND lóxico, é verdadeiro se son verdadeiros os dous operandos), ||, or (OR lóxico, é verdadeiro se é verdadeiro alomenos un dos dous operandos), XOR (OR exclusivo lóxico, é verdadeiro se é verdadeiro só un dos dous operandos) , NOT, ! (Negación lóxica, é verdadeiro se é falso o operando e viceversa) http://www.php.net/manual/es/language.operators.logical.php
• Operador de erros: @ Evita que PHP amose certos mensaxes de erro devoltos por funcións ou ao avaliar certas expresións.

   $id = @mysq_connect(); // Se non pode establecer a conexión, tampouco da erro.
  

  http://www.php.net/manual/es/language.operators.errorcontrol.php

• Este operador emprégase habitualmente na seguinte estructura: @expresion or die(mensaxe);. Neste caso, se a expresión devolve un erro, a mensaxe de erro non se amosa, e a execución do programa detense por mor do die amosando a mensaxe indicada. Isto é asi, porque se a expresión se avalia ben (se avalia como verdadeiro) non é necesario executar o segundo operando (o die) e se se avalia mal (un erro, avalíase como falso) é necesario executar o segundo operando, que deten a execución do script e amosa un erro.

    $id = @mysql_connect($server,$user,$pwd) or
            die("Non se puido conectar co servidor de BD");
  

• Operador de execución: ` Se a cadea situada entre dúas aparicións deste operador é un comando ou programa executable no sistema operativo onde se execute PHP, realizase dita execución e o resultado devolvese a PHP.

    $a = `dir `; // Executa un dir en Windows (listado de arquivos) e garda o resultado nunha variable.
    $a = `ls -l `; // Executa un ls en Unix (listado de arquivos) e garda o resultado nunha variable.
  

  http://www.php.net/manual/es/language.operators.execution.php

• Non se debe confundir o operador de execución ` coas comiñas simples de comenzo ou final de cadea ‘
• Cando se avalian expresión debese ter en conta a precedencia ( cales se avalian antes ca outros) e asociatividade dos operandos (cando teñen igual precedencia, avalíanse de esquerda a dereita ou de dereita a esquerda) http://www.php.net/manual/es/language.operators.precedence.php

Os operadores de comparación maior > , menor =, e menor ou igual <= son facilmente comprensibles cando se trata de números, pero menos claros con outros tipos de datos. Por exemplo, se comparamos cadeas:

 $a = 'ABC';
 $b = 'ABD';
 echo ($a > $b);

A comparación neste caso faise byte a byte, dende o de máis á esquerda, e será maior a cadea que teña un valor maior no primeiro byte (se teñen o mesmo comparase o segundo, e así sucesivamente).
No exemplo anterior comparanse o primer byte das dúas cadeas (A e A), o ser iguais, pasase a comparar o segundo (B e B) que tamén son iguais, e despois o terceito (C e D). Neste caso o valor de D e maior que o valor de C, pois na tabla ASCII o C é equivalente ao valor 67 e o D ao valor 68, polo tanto a cadea que contén o D é maior, e a comparación do noso código falsa.

Tamén hai que ter en conta á hora de comparar cadeas que as letras maiúsculas e minúsculas non teñen o mesmo código ASCII, e polo tanto non son iguais a hora de comparalas.

 $a = 'abc';
 $b = 'ABC';
 echo ($a > $b);

O comparar o primeiro byte das dúas cadeas, a ten o valor 97 e A o 65, polo tanto a cadea ‘abc’ é maior que ‘ABC’. Polo tanto non é un bo operador para comparar cadeas se hai minúsculas e maiúsculas nestas, e é esta diferenza.

Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.comparison.php

Seguindo coa comparación de operadores que poden levar a confusión, outro par deles son o de equivalencia == e o de identidade ===.

O primeiro (equivalencia) compara que os valores dos dous operandos sexan iguais (se para elo ten que facer conversión de tipos dalgún dos dous operandos faino). Non lle importa que o tipo dos operandos sexa distinto, só o valor.

O segundo (identidade) compara que os valores e os tipos dos operandos sexan iguais (se teñen igual valor pero non igual tipo devolve FALSO).

  echo 10 == '10'; //DEVOLVE VERDADEIRO, igual valor
  echo 10 === '10'; //DEVOLVE FALSO, igual valor pero distinto tipo

Tamén podemos empregar os operadores de non equivalencia != e non identidade !==

Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.comparison.php

Hai un par de operadores que son causa de dor de cabeza para os programadores PHP, son os operadores de asignación = e o de comparación ==

• O operador de asignación é =

   $a = 10; // Asigna a $a o valor 10

• O operador de comparación é ==

   if ($a == 10) // Compara $a co valor 10
     echo $a; 

• Un erro moi frecuente é escribir o seguinte código

   if ($a = 10)
     echo $a;
  

  En realidade este código é como escribir:

  $a = 10;
  if ($a) // Onde $a convertido a boolean e VERDADEIRO
     echo $a;
  

  O que se está facendo e asignar (non comparar) 10 á variable $a, que convertida en boolean para avaliar dentro da condición IF, dado que ten un valor distinto de cero (10) convírtese a VERDADEIRO; e polo tanto sempre é certa a condición, e sempre entra no IF sexa ou non inicialmente a variable igual a 10.

Un truco para evitar este comportamento non desexado e do que é dificil decatarse, consiste en invertir as comparacións, poñendo na parte esquerda o valor e na parte dereita a variable.

if (10 == $a)
  ...

Neste caso, se nos trabucamos e poñemos o operador de asignación = no lugar do de comparación ==, dado que na parte esquerda o operador de asignación so admite variables e non valores, amosarase na pantalla un erro de sintase e así decatarémonos deste erro.

Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.comparison.php

• O operador de asignación é =
• O operador de asignación traballa por valor, é dicir, se o operando da dereita é unha variable, faise unha copia do valor desta para introducir dito valor no operando da esquerda
• É posible cambiar esta forma de traballar, para que non faga esa copia, e tanto a variable da dereita como a variable da esquerda apunten o mesmo valor en memoria. Para iso podemos empregar o operador de refencia & situado por diante da variable que ten o contido ao que vai apuntar a nova variable $b = &$a;
• O comportamento por valor é o predeterminado con todos os tipos de datos, excepto cos obxetos, onde o comportamento por referencia é o predeterminado

  $a = 10;  // Uso do operador de asignación
  $b = $a; // Fai unha copia do valor de $a
           // 10 e mete dito valor en $b
           // co que $b vale 10
  $b = 20; // $a segue valendo 10

  $b = &a;   // Non fai copia, senon que $b apunta
             // a mesma posición de memoria que $a
             // co que as duas variables valen 10 pois
             // teñen o mesmo contido.
  $b = 20;   // Tanto $a, como $b pasan a valer 20

Ademais de variables e constantes, fannos falta outros elementos para unir os anteriores mediante operacións, esos elementos son os operadores, en en PHP hainos de moitos tipos. Non nos vamos a centrar en enumeralos, (pódense atopar todos na axuda oficial: http://es.php.net/manual/es/language.operators.php ), senón en ver as particularidades do seu uso.

• Os operadores aritméticos son: + suma, – resta, * multiplicación, / división (o cociente da división), % módulo (o resto da división)
• A division devolve como cociente un número flotante

       echo 5/2;  // IMPRIME 2.5
  

  Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.arithmetic.php

• Os operadores autoincrementales/autodecrementales son ++ –

       $b=$a++;  // e igual que $b=$a e $a=$a+1;
       $b=$a--;  // e igual que b=$a e $a=$a-1;
       $b=++$a;  // e igual que $a=$a+1 e b=$a;
       $b=--$a;  // e igual que $a=$a-1 e b=$a;
  

  Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.increment.php

• O operador de concatenación de cadeas e o . (esta é o único xeito de concatenar cadeas, non se pode empregar o operador + que converte as cadeas en número antes de sumalas)

       $cadea.=' MAIS TEXTO';  // e igual que $cadea = $cadea . ' MAIS TEXTO';
  

  Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.string.php

• Os operadores de bits <> son desprazamentos de bits a esquerda e a dereita. A esquerda do operador vai o número enteiro onde se vai producir o desprazamento e a dereita do operador vai o número de bits a desprazar. Cada bit desprazado a esquerda e como multiplicar o número por dous, e cada bit desprazado a dereita e como dividir o número por dous

     $a=9;  // EN BINARIO 1001
     $a = $a << 2; // DESPLAZAR OS BITS 2 POSICIÓNS A ESQUERDA, CO QUE QUEDA 100100, E DICIR 36  = 9 * 2 *2
     $a = $a >> 3; // DESPLAZAR OS BITS 3 POSICIÓNS A DEREITA, CO QUE QUEDA 100, E DICIR 4  = (int) ((9 / 2) / 2)
  

  Hai que ter en conta, que ainda que estas operacións sexan similares a multiplicar e divir por dous, oua facer potencias de 2 ( pow(2,$i) ), hai que ter en conta situacións de overflow e underflow, como por exemplo a que se da neste caso:

     $a = 1 << 32; // AINDA QUE PAREZA 1 * pow(2,32), DA 0 PQ SO HAI 32 BITS PARA REPRESENTAR, E POÑENSE TODOS A 0
  

  Máis información na axuda oficial: http://es.php.net/manual/es/language.operators.bitwise.php

En PHP tamén se poden definir constantes seguindo esta regras:

• Só poden conter valores escalares:

    define('EMAIL','correo@dominio.es');  // VALIDO
    define('VALORES',array(1,2)); // NON VALIDO
  

• Son sensibles a maiúsculas:

    define('EMAIL','correo@dominio.es');
    define('email','correo@dominio.es');  // É distinta da anterior
  

• O seu nome segue as mesmas regras que os das variables.

    define('EMAIL','correo@dominio.es');  // VALIDO
    define('_EMAIL','correo@dominio.es');  // VALIDO
    define('EMAIL_1','correo@dominio.es');  // VALIDO
    define('1EMAIL','correo@dominio.es');  // NON VALIDO
  

• Recoméndase por nomes con todas as letras en maiúsculas

    define('EMAIL','correo@dominio.es');
  

• Defínense coa instrucción define()

    define('EMAIL','correo@dominio.es');
    define('VERDADE',TRUE);
    define('ZERO',0);
    define('A_DUAS_VELAS',0.0);
  

Máis información na axuda oficial: http://es.php.net/manual/es/language.constants.syntax.php