Tabla de Contenidos

PHP

Lo básico

Todo código de php se escribe entre <? ?> o entre <?php ?> 

<HTML>
<BODY>
Veamos qué ocurre cuando... <br />
<strong>
<?php print "Hello world!"; ?>
</strong>
<br /> Uooooo!!!
</BODY>
</HTML>

A partir de aquí puedes hacer cosas como empotrar código html en php: 

<HTML>
<BODY>
<strong>
<?php for ($i=0; $i<10; $i++) { ?>
Hola <br />
<?php } ?>
</strong>
</BODY>
</HTML>

Los comentarios en código php pueden ser:

Variables

$a = $b + 3;
$b = "Hello world";
$c = 44;
$d = 3.14;

Arrays

$a = array(58, 25, 300);                           // Indices: 0, 1 y 2. Valores respectivos: 58, 25 y 300.
$b = array(0 => 58, 1 => 25, 2 => 300, 65 => 22);  // Indices: 0, 1, 2 y 65. Valores respectivos: 58, 25, 300 y 22.
$c = array("uno" => 1, "dos" => 2);                // Indices: uno y dos. Valores respectivos: 1 y 2
$d = array();                                      // Array vacío.

Equivalencia booleana

Un false, qué equivale en otras variables?

Variables indirectas

Podemos crear una variable asignando el nombre que tiene otra por valor. Para ello haríamos algo así: 

$variable = "nombre_de_nueva_variable";
$$variable = "asignación del valor de la nueva variable";
print ($nombre_de_nueva_variable); // Saldría: asignación del valor de la nueva variable ''

Por ejemplo, el siguiente código imprime “hola qué tal?”: 

$var = "John";
$$var = "hola qué tal?";
print $John;

Casting

Como siempre, para pasar de un tipo de datos a otro. Sólo hemos de poner delante, y entre parentesis: int, float, real, double, string, bool, array u object. 

$str = "5";
$num = (int) $str;

Asignación por referencia

En php también podemos asignar por referencia, como si de punteros se tratase: 

$name = "Judy";
$name_alias = &$name;
$name_alias = "Jonathan";
print $name;

Este código muestra “Jonathan”.

Globales

Desde cualquier parte del script podemos acceder a un array cargado en memoria llamado $GLOBALS, este se inicializa cada vez que se carga una página en memoria; la gracia está en usar nombres de variables que puedan ser accedidos desde clases, funciones… 

$var = "numSons";
$GLOBALS[$var] = 4;
...
print $GLOBALS["numSons"];

Constantes

Para declarar constantes utilizamos la función define: define (“nombre”, valor); 

define("MI_ERROR", 0);
...
if ($retorno = MI_ERROR) print ("fallo!!");

Condiciones

if 

if ($b < 3)
  printf("B is less than 3\n");
elseif ($b > 3)
  printf("B is more than 3\n");
else
  printf("B is greater than or equal to 3\n");

switch, case 

switch ($b) {        {
  case 1:
   printf("one\n");
   break;
  case 2:
   printf("two\n");
   break;
  default:
   printf("none of the above\n");
   break;
}

Asignación booleana 

$b = ($a == 1) ? 3 : 5;

Operador de identidad, o los tres iguales

A veces una función que tiene un uso puede ser usada para un uso alternativo, como es la strpos que retorna el número de posición donde está el carácter indicado, pero que si no lo encuentra esta retorna false y si quieres distinguir este boolean y el integer tendrás que utilizar el operador identidad: === , o su negativo !==.
En el ejemplo se comprueba si en una cadena existe o no, en la posición que sea, una arroba: 

if (strpos(strEMail, '@') === false) 
    print 'No existe arroba!';

Bucles

foreach

foreach (array as varTmp) 

$jugadores = array("John", "Barbara", "Bill", "Nancy");
print  "Los jugadores son: <br />";
foreach ($jugadores as $valor) {
       print "$valor <br />";
}

foreach (array as varTmpClave ⇒ varTmpValor) 

$jugadores = array("John", "Barbara", "Bill", "Nancy");
print  "Los jugadores son: <br />";
foreach ($jugadores as $ind => $valor) {
       print "$ind = $valor <br />";
}

Funciones

Funciones simples: 

function prueba () {
  echo ("Llamada a prueba!");
  $valor = 3;
  return $valor;
}
echo (prueba());

Funciones con parámetros: 

function sumaDos ($num) {
  return $num + 2;
}

Funciones con parámetros por defecto (Muestra: 45): 

function sumaDos ($num = 2) {
  return $num + 2;
}
printf(sumaDos());
printf(sumaDos(3));

Funciones con variables estáticas, las cuales sólo son definidas la primera vez que se llaman, las siguientes veces no volverá a definirla (Muestra: 455): 

function numero () {
 static $first = true;
 if ($first) {
   $first = false; 
   return 4;
 }
 return 5;
}
print(numero());
print(numero());
print(numero());

Funciones que devuelven valores por referencia (Muestra: 4): 

function &get_global_variable($name) {
    return $GLOBALS[$name];
}
$value =& get_global_variable("num");

Funciones que reciben parámetros por referencia: 

function cuadrado (&$num) {
 $num = $num * $num;
}
$n = 2;
cuadrado($n);
print $n;

Elementos predefinidos

Variables predefinidas

Aunque encontrarás la lista completa y mejor explicada aquí, repasaremos la lista de variables globales predefinidas:
Para utilizarlas, por ejemplo $_SERVER → SERVER_NAME, sería: print $_SERVER[“SERVER_NAME”];

Funciones predefinidas

<?php 
phpinfo();
...
if (isset($a)) print "Variable no asignada";
include "function.php";
?>

Funciones numéricas

$number = round(2.4);   // Redondea: $number = 2
$number = ceil(2.4);    // Redondea hacia arriba: $number = 3
$number = floor(2.4);   // Redondea hacia abajo: $number = 2
// ... //
$number = 56.9415;
$final = round($number, 2);   // Acorta decimales: $final = 56.94
$number = 1234.56;
print number_format($number, 2);                 // Muestra: 1,234.56
print number_format($number, 2, '@', '#');       // Muestra: 1#234@56

Funciones para arrays

Ejemplo de uso del list: (Muestra: JohnBarbaraBill) 

$players = array("John", "Barbara", "Bill", "Nancy");
list($a, $b, $c) = $players;
print $a;
print $b;
print $c;

Ejemplo de uso del list, each y reset: 

$players = array("John", "Barbara", "Bill", "Nancy");
reset($players);
while (list($idx, $val) = each($players))
	print "$idx: $val <br />";
?>

:!: Eliminar elementos y demás…

Trato con Strings

wordwrap

La función wordwrap facilita el trabajo con strings largos. Su sintaxis es:
string wordwrap ( string cadena [, int ancho [, string ruptura [, bool corte]]] )
Siendo cadena el string con el que trabajamos, ancho la cantidad de carácteres que se permiten por línea, ruptura el string que colocaremos hallá donde rompamos la cadena y corte si cortaremos en medio de las palabras o no. 

$s = "Four score and seven years ago our fathers brought forth 
on this continent a new nation, conceived in liberty and
dedicated to the proposition that all men are created equal.";
print "<pre>\n".wordwrap($s)."\n</pre>";
$texto = "El veloz murcielago hindo comia feliz cardillo y kiwi.";
$nuevo_texto = wordwrap($texto, 20, "<br />\n");
echo $nuevo_texto;

Trato con datos de fecha\hora

POO

Clases y objetos

Definición de una clase: 

class claseA {
    private $name;
    function setName($name) {
        $this->name = $name;
    }
    function getName() {
        return $this->name;
    }
};

Declaración de un objeto y acceso a sus métodos y variables: 

$obj1 = new claseA ();
$obj1->setName("Juan");
print $obj1->getName();

Como podemos ver en PHP la sintaxis es muy parecida a C++. Para acceder a los métodos utilizamos ->. También vemos que existe el puntero $this para referenciar al objeto de esta clase, pero date cuen que con las propiedades\métodos que llama no se usan $. Pero… Los objetos son tratados como referencias o por valores? Veamoslo: 

$obj1 = new claseA ();
$obj1->setName("Juan");
$obj2 = $obj1;
$obj2->setName("Pedro");
print $obj1->getName();

Este código devuelve Pedro, es decir, son referencias.
Otra cosa!! Como no, también existe el polimorfismo. Sí, eso de poder llamar a varios métodos con el mismo nombre pero con distintos parámetros.
PHP no es un lenguaje tipado, pero cuando jugamos con objetos y clases sí que podemos restringir que una función sólo acepte objetos de un tipo por parámetro (añadiendo el tipo antes del nombre del parámetro): 

function foo (miClase $obj) { ...

Constructores

Existen dos formas de crear un constructor a una clase:

Es decir, o con la función claseA: 

class claseA {
    private $name;
    function claseA ($name) {
    	$this->name=$name;
    }
...

O con la función __construct: 

class claseA {
    private $name;
    function __construct($name) {
    	$this->name = $name;
    }
...

Si una clase declarase las dos funciones sólo se usaría la función __construct quedando la otra renegada como una función cualquiera.

Destructores

Para definir un destructor a una clase crearemos un método llamado __destruct, este método se llamará cuando asignemos NULL a un objeto o cuando acabe el script de php: 

class claseA {
...
  function __destruct () {
    print "Destruido!";
  }
...
$obj1 = NULL;

Este código muestra Destruido!“.

Clonadores

Como los objetos se copian por referencia probablemente nos interese una forma de copiar objetos, para ello existe la función __clone. Se llama cuando hacemos algo parecido a lo siguiente: 

$obj1 = clone $obj2;

Esto copia en $obj1 un objeto de iguales características que $obj2.
Pero podemos sustituir el método __clone: 

function __clone () {
  $this->idx ++;
}
Ahora, al hacer el ''clone'', el $obj1 tiene el índice una unidad mayor que $obj2.

Modificadores de acceso

Tanto para las propiedades como para los métodos. 

public function tal {...
private function cual {...
protected $pascual;

Modificador static

Podemos declarar variables estáticas, para ello utilizaremos el modificador static: 

class claseB {
  private static $valor;
  public static function Escribe () { ...
  ...

Para acceder a una variable o método estáticos existen dos formas:

Por ejemplo, para llamar al método desde fuera de la clase (a la propiedad no podemos, es privada (pero si fuese pública podríamos de la misma forma)): 

claseB::Escribe();

Y para llamarlos a los dos desde dentro: 

 self::Escribe();
 print self::$valor;

Modificador const

Como en C++ puedes crear constantes dentro de clases, variables que quedan en memoria una sola vez (como las estáticas) pero que no cambian de valor en la ejecución. Para ello usa el modificador 'const': 

class claseC {
  const RED = "Red";
...

Para acceder a una variable constante lo haríamos como si de una estática se tratase: nombreClase::nombrePropiedad o self::nombrePropiedad.

Herencia e interfaces

Se realiza como en Java, para clases usamos extends para interfaces implements: 

class claseD extends claseC { ...

La interface tiene también su declaración en versión PHP: 

interface Persona {
  function getName ();
}
class Pepe implements Persona {
	function getName () {
		return __CLASS__;
	}
}

Podemos acceder a la clase de la que hereda llamando a parent::metodo, pongamos algo así: 

class claseM {
	function __construct () {
		print "A";
	}
}
class claseN extends claseM {
	function __construct () {
		parent::__construct();
		print "B";
	}
}
$obj = new claseN ();

Este código imprime AB.

instanceof

Podemos comprobar si un objeto viene de una clase o de una clase hija de una interface o hija de otra clase, para ello utilizamos instanceof. 

$obj = new Pepe ();
if ($obj instanceof Persona)
	print "Yes";

En este ejemplo Persona es una interface, pero podría ser una clase.

Operador final

En PHP también existe el operador final, este se puede aplicar a clases o métodos. Si se aplica en clases hace que de estas no puedan ser heredadas, si se aplica en métodos hace que estos no se puedan sobreescribir: 

public final function Escribe { ...
final class claseZ { ...

Clases abstractas

Clases abstractas… Son clases de las cuales se heredan y que tienen métodos abstractos, los cuales se han de implementar por cojones. Sips. Para indicar que una clase es abstracta se le añade abstract delante de class; para indicar que un método es abstracto delante de function, a estos no se les añade código. No puedes declarar métodos abstractos en clases no abstractas ni instanciar clases abstractas: 

abstract class claseO {
...
  abstract function foo ();
...
};
class claseP extends claseO {
  function foo() { ...

Excepciones

Las controlas con los try\catch de toda la vida: 

  try { ...} 
  catch (NullHandleException $excp) { ... }
  catch (Exception $excp) { ... }

La clase exception tiene esta forma: 

class Exception {
    function __construct($message);
    function __construct($message, $code);
    function __construct();
 
    final public getMessage();
    final public getCode();
    final public getFile();
    final public getLine();
    final public getTrace();
    final public getTraceAsString();
 
    protected $message;
    protected $code;
    protected $file;
    protected $line;
}

Con esto quiero decir que puedes heredar de ella y crear tus propias excepciones… como siempre.

Método __toString

Ya sabes para lo que sirve, no me engañes. Se sobreescribe en las clases y esta ya puede ser pasada como un string. 

class Person {
...
    function __toString() {
        return $this->name;
    }
...

Función __autoload

No es un método de clase. Es una función que la puedes escribir en tu código, esta función es llamada cuando una clase que se instancia no está incluida con un include o un require. Recibe por parámetro una variable con el nombre de la función: 

<?php
function __autoload ($class_name) {
  require_once($class_name . '.php');
}
?>

… o … 

<?php
function __autoload ($class_name) {
  require_once ($_SERVER["DOCUMENT_ROOT"] . "/classes/ $class_name.php");
}
?>

Puedes definir las clases en ficheros a parte e incluirlos automáticamente de esta forma.

Cómo...

Formularios

Cookies

Sesiones

Una sesión es un trato independiente de cada visita de los usuarios de una página web tratándolas de forma independiente, desde que esta inicia hasta que acaba. Esto se realiza sobre el objeto $_SESSION de php.
Un ejemplo de sesiones es el carrito de la compra de los usuarios, o la autentificación y acceso a algunas páginas (si no existe sesión o ciertas variables es que el usuario no es correcto).
Las acciones que debemos tener claras al utilizar las sesiones:

Otras funciones que fueden sernos útiles:

Por ejemplo, tenemos el siguiente fichero a.php: 

<?php
session_start();
$_SESSION['hola'] = "hello session!";
?>
<html>
<body>
Iniciando. <br></br>
<a href="b.php">ves al b!</a>
</body>
</html>

Y el b.php: 

<?php
session_start();
?>
<html>
<body>
<?php
echo $_SESSION['hola']; 
session_destroy();
?>
asfasda
</body>
</html>

La cuando se haga click en el link de a.php que envia al b.php se cargará b y se mostrará la frase. Pero si se recarga b no volverá a salir porque se habrá destruido la sesión.

Subir archivos

Notas

Archivos