====== PHP ======
===== Lo básico =====
Todo código de php se escribe entre '''' o entre ''''
Veamos qué ocurre cuando...
Uooooo!!!
A partir de aquí puedes hacer cosas como empotrar código html en php:
Hola
Los comentarios en código php pueden ser:
* ''//'' para una línea.
* ''#'' para una línea.
* ''/* ... */'' para varias líneas.
==== Variables ====
$a = $b + 3;
$b = "Hello world";
$c = 44;
$d = 3.14;
=== Arrays ===
* En PHP los índices de los arrays pueden ser integers o strings.
* Para indicar que una variable es un array haremos: ''$variable = array();''. Indicando dentro de los parentesis todos y cada uno de sus elementos:
* Distintas declaraciones:
$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.
* Para acceder a los elementos de un array haremos: ''$variable[índice]''
* Podemos ampliar el tamaño del array variablemente haciendo: ''$variable[indice_nuevo] = valor;'', esto añade otro índice y le asigna ese valor.
* Podemos anidar arrays: ''$variable = array(array(1, 2, 3), array(4, 5, 6));''
* Para saber el tamaño del array ''$a'' haremos: ''$n = count($a)'' y en ''$n'' se nos pondrá un integer que indicará su tamaño.
=== Equivalencia booleana ===
Un ''false'', qué equivale en otras variables?
* Integer: //0//
* String: //"0"// o //""//
* Decimal: //0.0//
* Array: Si no contiene ningún elemento.
* Null: Siempre será false.
* Objeto: Siempre será true.
=== 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 ====
* ''while (condicion) { ... }''
* ''do { ... } while (condicion)''
* ''for (inicio; condición de ejecución; fin) { ... }''
=== foreach ===
foreach (array as varTmp)
$jugadores = array("John", "Barbara", "Bill", "Nancy");
print "Los jugadores son:
";
foreach ($jugadores as $valor) {
print "$valor
";
}
foreach (array as varTmpClave => varTmpValor)
$jugadores = array("John", "Barbara", "Bill", "Nancy");
print "Los jugadores son:
";
foreach ($jugadores as $ind => $valor) {
print "$ind = $valor
";
}
==== 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 [[http://es.php.net/reserved.variables|aquí]], repasaremos la lista de variables globales predefinidas: \\
//Para utilizarlas, por ejemplo $_SERVER -> SERVER_NAME, sería:// ''print $_SERVER["SERVER_NAME"];''
* $_SERVER
* SERVER_NAME: Indica el nombre del servidor que ejecuta el script.
* REQUEST_METHOD: El método de petición con el que se llamó a la página.
* QUERY_STRING: Cadena de consulta con la que se accedió a la página.
* DOCUMENT_ROOT: Directorio raíz bajo el que se ejecuta el script.
* REMOTE_PORT
* REMOTE_ADDR
* SCRIPT_FILENAME: Ruta absoluta.
* SCRIPT_NAME: Nombre del documento.
* $_GET: Recoge los datos enviados con GET. [[sp:php#formularios|Ver formularios]]
* $_POST: Recoge los datos enviados con POST. [[sp:php#formularios|Ver formularios]]
* $_REQUEST: Recoge los datos enviados o con POST o con GET.
* $_COOKIE
* $_ENV
* $_SESSION
* $GLOBALS
==== Funciones predefinidas ====
* ''phpinfo'' muestra información sobre la instalación de php en esa máquina.
* ''print'', ''printf'' y ''echo'' reciben un string, este se mostrará por pantalla.
* Si el string pasado es con comillas dobles mostrará concatenados los valores de las variables que estén escritas dentro de este.
* Si el string es con comillas simples no hará caso a las secuencias de escape (\n, \t...).
* Para que printf te formatee un decimal: ''printf("%.2f\n", 1100.621);'', esto mostraría //1100.62//
* ''isset'' recibe por parámetro una variable, si esta está asignada devuelve ''true'', si no ''false''.
* ''unset'' recibe por parámetro una variable, lo que hace es borrar su valor dejándola "inasignada" (insincera???).
* ''print_r'' recibe por parámetro un array y lo imprime todo seguido.
* ''eval'' recibe por parámetro un string, este lo ejecuta como si de código se tratase.
* ''include'' no es una función propiamente dicha; se la llama junto con un string, este string corresponde a un fichero que se incluye (en código html o php) en el que se está ejecutando.
* ''require'' y ''require_once'', son funciones idénticas que hacen lo mismo que ''include'' (también se les pasa por parámetro un string del fichero a incrustar).
* La diferencia entre ''require'' e ''include'' es que este último trata los errores como warnings. El ''require'' detiene el proceso del script (Fatal Error).
* ''require_once'' es un ''require'' que sólo se ejecuta una vez. Si se ponen varios ''require'' la página se ejecutará tantas veces como puesto esté, con ''require_once'' sólo la primera vez.
* ''die'', recibe un string, acaba la ejecución del script PHP mostrando el texto pasado por parámetro.
* ''sleep'' y ''usleep'' retardan la ejecución del programa, el primero (sleep) en segundos y el segundo en microsegundos.
==== Funciones numéricas ====
* ''is_numeric'' indica si la variable que se le pase por parámetro es un integer.
* Redondear y acortar decimales:
$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
* Generar valores aleatorios entre $a y $b: ''mt_rand($a, $b);''
* La función ''number_format'' devuelve un string con el integer que se le pasa pero formateado.
$number = 1234.56;
print number_format($number, 2); // Muestra: 1,234.56
print number_format($number, 2, '@', '#'); // Muestra: 1#234@56
==== Funciones para arrays ====
* ''reset'', no recibe ningún parámetro, resetea el puntero interno del array. Has de llamarlo siempre antes de utilizar el list\each.
* ''each'', recibe por parámetro un array (A), muestra el elemento actual al que apunta el puntero interno de este y lo avanza un puesto. Devuelve un array (B) de cuatro indices: //0, 1, key// y //value//. Los indices de B //key// y //0// tienen el mismo valor: el índice dentro del array A del elemento actual; los //value// y //1// tienen el valor.
* ''list'' recibe por parámetros una serie de variables. Un array se igualará a él (¿?, ya lo sé...) y la list asignará por orden (correspondiente al orden de parámetro) los elementos a las variables.
//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
";
?>
* ''sort'' función a la que le pasas por parámetro un array. Después de la llamada a esta función el array estará ordenado.
* ''implode'' recibe dos parámetros, un string y un array, devuelve un string donde están unidos todos los elementos del array usando como separador el primer parámetro.
* Para crear un array a partir de un rango utilizamos la función range, por ejemplo:
* ''$array = range(2, 52);'' Crea un array con sus elementos internos de valores: 2, 3, 4, 5... 51, 52.
* ''$array = range(2, 52, 3);'' Crea un array con sus elementos internos de valores: 2, 4, 6... 50, 52.
:!: Eliminar elementos y demás...
==== Trato con Strings ====
* Para acceder a los carácteres de un string se tratará al string como un array: ''$a = $str[1];'' <- Asigna en $a el segundo carácter de $str
* Para concatenar strings lo haremos mediante un punto: ''$a = "hola" . " caracola";'' <- $a tiene como valor "hola caracola".
* ''strlen'' recibe un string y devuelve un entero con su tamaño.
* Para saber en qué posición de un string existe un carácter: ''strpos($string, 'c');''
* Para saber si en un string existe un carácter: ''strpos($string, 'c');'' comparandolo mediante el operador de identidad.
* Para sacar un substring: ''substring($string, $inicio, $final);''
* Para obtener un nuevo string con un substring reemplazado de un string inicial: ''substr_replace($old_string, $new_substring, $start);''
* Eliminar los espacios en blanco de los costados de un string: ''trim, rtrim, ltrim''.
=== 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.
* Nos permite trabajar con una cadena de más de una línea.
$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 "\n".wordwrap($s)."\n
";
* Nos permite dividir un texto largo
$texto = "El veloz murcielago hindo comia feliz cardillo y kiwi.";
$nuevo_texto = wordwrap($texto, 20, "
\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:
* Forma tradicional: una función con el mismo nombre que la clase.
* Utilizando la función: ''__construct''.
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 ====
* public
* private
* protected
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:
* La tradicional: ''nombreClase::nombreElemento''
* La de dentro de la clase: ''self::nombreElemento''
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:
... o ...
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:
* **Abrir sesión**, utilizamos la función ''session_start()''. Cada página que utilice sesiones debe tener una llamada a session_start y esta función debe ser llamada antes de todo, sobretodo antes de enviar html.
* **Definir variable de sesión**, utilizamos la función ''session_register('nombre_variable')'' (aunque no es obligatoria definirla).
* **Definir valor de variable de sesión**, utilizamos ''$_SESSION['nombre_variable']=valor''.
* **Obtener el valor de una variable de sesión** accediendo a ''$_SESSION['nombre_variable']''.
* **Eliminar alguna variable de sesión**, utilizamos la función ''session_unregister('nombre_variable')''
* **Cerrar sesión**, utilizamos la función ''session_destroy()''
Otras funciones que fueden sernos útiles:
* ''session_id()'' que devuelve el identificador de sesión.
* ''isset($_SESSION['nombre_variable'])'' indica si la variable está definida.
* ''session_unset()'' eliminta todas las variables de sesión.
* ''session_is_registered('nombre_variable')'' devuelve si la variable está registrada en la sesión.
Por ejemplo, tenemos el siguiente fichero a.php:
Iniciando.
ves al b!
Y el b.php:
asfasda
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 =====
* En toda clase existe una constante llamada ''__CLASS__'', esta devuelve el nombre de la clase donde se encuentra: ''$this->name = __CLASS__;''
==== Archivos ====
* {{ sp:php:emezeta-php-card-v0.1.png?75 |PHP CheatSheet (png)}}
* {{sp:php:emezeta-php-card-v0.1.zip|PHP CheatSheet (pdf)}}