TECNOLOGIAS PARA LA INTEGRACION DE SOLUCIONES(base 8) o binaria (base 2), opcionalmente precedidos...
61
Facultad de Estadística e Informática SISTEMAS WEB
Transcript of TECNOLOGIAS PARA LA INTEGRACION DE SOLUCIONES(base 8) o binaria (base 2), opcionalmente precedidos...
Facultad de Estadística e Informática
SISTEMAS WEB
Facultad de Estadística e Informática
Bibliografía
▪ Documentación de PHP (2017). Obtenido de: http://php.net/docs.php
Facultad de Estadística e Informática
Agenda
VI. Generación dinámica de contenido Web • Lenguajes de programación Web del lado del servidor
Introducción
¿Qué es PHP?PHP (Hypertext Preprocessor) es un lenguaje de programación que se ejecuta en el servidor Web permitiendo generar contenido interactivo y dinámico al usuario cliente.
HTMLInternet PHPBD
<!DOCTYPE html><html>
<body><?phpecho "Hola PHP!";?>
</body></html>
<!DOCTYPE html><html>
<body>Hola PHP!
</body></html>
Características de PHP
El lenguaje PHP se incrusta en el código HTML y sus scripts se ejecutan en el servidor. El resultado es devuelto al cliente como HTML plano.
▪Los archivos PHP pueden contener texto, HTML, CSS, Javascript y código PHP.
▪Los archivos PHP tienen la extensión “.php”.
▪Utiliza una sintaxis parecida al lenguaje C.
▪Se ejecuta en varias plataformas como Windows, Linux, Unix, Mac OS X.
▪Es Open Source.
▪Soporta un amplio rango de motores de bases de datos.
▪Es gratuito.
Instalación de PHP
Se requieren 3 componentes instalados para poder desarrollar páginas web PHP.◦ Servidor Web. IIS, IIS Express, Apache, nginx, entre otros.
◦ Base de datos. MSSQL, Oracle, MySQL, Postgress, entre otros.
◦ Motor PHP. Intérprete que genera la salida en HTML.
Desarrollo en Windows:◦ Instalar Microsoft Web Platform Installer 5.0 -> PHP 7.1 For IISExpress
https://www.microsoft.com/web/downloads/platform.aspx
◦ Instalar Visual Studio Code + Extensiones “IIS Express”, “PHP IntelliSense”
https://code.visualstudio.com/download
◦ Dentro de Visual Studio Code: Ctrl + F5 para ejecutar la aplicación.
◦ Configuración de IIS Express.
◦ Configuración de PHP.
Sintaxis
Bloques de código PHP
El motor de PHP necesita diferenciar el código PHP de otro elementos de la página, como código HTML. El mecanismo para realizar esto, es utilizar etiquetas de código PHP.
Las líneas de PHP terminan con un punto y coma (;).
<?php// el código PHP va aquí?>
<?phpecho "Hola mundo!";?>
Salir de HTML
Cualquier cosa fuera de un par de etiquetas de apertura y cierre es ignorado por el intérprete de PHP, lo que permite que los archivos de PHP tengan contenido mixto.
Desde PHP 5.4, la etiqueta de echo abreviada <?= siempre es aceptada y válida, independientemente de la configuración de short_open_tag.
<p>Esto va a ser ignorado por PHP y mostrado por el navegador.</p><?php echo 'Mientras que esto va a ser interpretado.'; ?><p>Esto también será ignorado por PHP y mostrado por el navegador.</p>
Puede emplear la etiqueta echo abreviada para <?= 'imprimir esta cadena' ?>.
Siempre está habilitada en PHP 5.4.0 y posterior, y es equivalente a<?php echo 'imprimir esta cadena' ?>.
Separación de instrucciones
Como en C o en Perl, PHP requiere que las instrucciones terminen en punto y coma al final de cada sentencia.
La etiqueta de cierre de un bloque de código de PHP automáticamente implica un punto y coma; no es necesario usar un punto y coma para cerrar la última línea de un bloque de PHP.
<?phpecho 'Esto es una prueba';?>
<?php echo 'Esto es una prueba' ?>
<?php echo 'Hemos omitido la última etiqueta de cierre';
ComentariosPHP admite comentarios al estilo de 'C', 'C++' y de consola de Unix (estilo de Perl).
<?phpecho 'Esto es una prueba'; // Esto es un comentario al estilo de c++ de una sola línea
/* Esto es un comentario multilíneay otra línea de comentarios */echo 'Esto es otra prueba';echo 'Una prueba final'; # Esto es un comentario al estilo de consola de una sola línea?>
<h1>Esto es un <?php # echo 'simple';?> ejemplo</h1><p>El encabezado anterior dirá 'Esto es un ejemplo'.</p>
<?php/*echo 'Esto es una prueba'; /* Este comentario causará un problema*/*/?>
Tipos
Introducción
PHP admite ocho tipos primitivos.◦ Cuatro tipos simples:
◦ boolean
◦ integer
◦ float (número de punto flotante, también conocido como double)
◦ string
◦ Cuatro tipos compuestos:◦ array
◦ object
◦ callable
◦ iterable
Y finalmente dos tipos especiales: ◦ resource
◦ NULL
<?php$un_bool = TRUE; // un valor booleano$un_str = "foo"; // una cadena de caracteres$un_str2 = 'foo'; // una cadena de caracteres$un_int = 12; // un número entero
echo gettype($un_bool); // imprime: booleanecho gettype($un_str); // imprime: string
// Si este valor es un entero, incrementarlo en cuatroif (is_int($un_int)) {
$un_int += 4;}
// Si $un_bool es una cadena, imprimirla// (no imprime nada)if (is_string($un_bool)) {
echo "Cadena: $un_bool";}?>
Booleanos
Este es el tipo más simple. Un boolean expresa un valor que indica verdad. Puede ser TRUE (verdadero) o FALSE (falso).
Para especificar un literal de tipo boolean se emplean las constantes TRUE o FALSE. Ambas no son susceptibles a mayúsculas y minúsculas.
<?php$foo = True; // asigna el valor TRUE a $foo?>
<?php// == es un operador que comprueba la// igualdad y devuelve un booleanoif ($accion == "mostrar_version") {echo "La versión es 1.23";
}
// esto no es necesario...if ($mostrar_separadores == TRUE) {echo "<hr>\n";
}
// ...porque se puede escribir simplemente:if ($mostrar_separadores) {echo "<hr>\n";
}?>
Números enteros (Integers)
Un número entero (o integer) es un número del conjunto ℤ = {..., -2, -1, 0, 1, 2, ...}.
Los integer pueden especificarse mediante notación decimal (base 10), hexadecimal (base 16), octal (base 8) o binaria (base 2), opcionalmente precedidos por un signo (- o +).
Para utilizar la notación octal, se antepone al número un 0 (cero). Para utilizar la notación hexadecimal, se antepone al número 0x. Para utilizar la notación binaria, se antepone al número 0b.
<?php$a = 1234; // número decimal$a = -123; // un número negativo$a = 0123; // número octal (equivale a 83 decimal)$a = 0x1A; // número hexadecimal (equivale a 26 decimal)$a = 0b11111111; // número binario (equivale al 255 decimal)?>
Números de punto flotante
Los números de punto flotante (también conocidos como "de coma flotante" en español, y "floats" en inglés) pueden ser especificados usando cualquiera de las siguientes sintaxis:
<?php$a = 1.234; $b = 1.2e3; $c = 7E-10;?>
Cadenas de caracteres (Strings)
Un string, o cadena, es una serie de caracteres donde cada carácter es lo mismo que un byte. Esto significa que PHP solo admite un conjunto de 256 caracteres, y de ahí que no ofrezca soporte nativo para Unicode.
Un string puede llegar a alcanzar hasta 2 GB de tamaño (2147483647 bytes máximo).
Un literal de tipo string se puede especificar de cuatro formas diferentes:◦ entrecomillado simple
◦ entrecomillado doble
◦ sintaxis heredoc
◦ sintaxis nowdoc (desde PHP 5.3.0)
Entrecomillado simple
La manera más sencilla de especificar un stringes delimitarlo con comillas simples (el carácter ‘).
Para especificar una comilla simple literal, se ha de escapar con una barra invertida (\). Para especificar una barra invertida literal, se duplica (\\).
Todas las demás instancias de barras invertidas serán tratadas como una barra invertida literal: esto significa que otras secuencias de escape que podrían utilizarse, tales como \r o \n, serán mostradas literalmente tal y como se especifican, en lugar de tener cualquier otro significado especial.
<?phpecho 'Esto es una cadena sencilla';
echo 'También se pueden incluir nuevas líneas enun string de esta forma, ya que escorrecto hacerlo así';
// Resultado: Arnold una vez dijo: "I'll be back"echo 'Arnold una vez dijo: "I\'ll be back"';
// Resultado: Ha borrado C:\*.*?echo 'Ha borrado C:\\*.*?';
// Resultado: Ha borrado C:\*.*?echo 'Ha borrado C:\*.*?';
// Resultado: Esto no se expandirá: \n una nueva líneaecho 'Esto no se expandirá: \n una nueva línea';
// Resultado: Las variables $tampoco se $expandiránecho 'Las variables $tampoco se $expandirán';?>
HeredocUna tercera forma de delimitar un string es mediante la sintaxis heredoc: <<<. Después de este operador, se deberá proporcionar un identificador y justo después una nueva línea. A continuación va el propio string, y para cerrar la notación se pone el mismo identificador.
El texto heredoc se comporta como un stringentre comillas dobles, pero sin tener comillas dobles.
<?php$str = <<<EODEjemplo de una cadenaexpandida en varias líneasempleando la sintaxis heredoc.EOD;
/* Resultado: Mi nombre es "MiNombre". Estoy escribiendo un poco de Foo.Ahora, estoy escribiendo un poco de Bar2.Esto debería mostrar una 'A' mayúscula: A*/echo <<<EOTMi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.Ahora, estoy escribiendo un poco de {$foo->bar[1]}.Esto debería mostrar una 'A' mayúscula: \x41EOT;?>
NowdocNowdoc es a los string con comillas simples lo mismo que Heredoc lo es a los string con comillas dobles.
Un nowdoc se especifica de forma análoga a un heredoc, pero no se realiza ningún análisis dentro del nowdoc.
La construcción es ideal para embeber código de PHP o grandes fragmentos de texto sin necesidad de escaparlos.
<?php$str = <<<'EOD'Ejemplo de un stringexpandido en varias líneasempleando la sintaxis nowdoc.EOD;
/* Resultado: Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.Ahora, estoy escribiendo un poco de {$foo->bar[1]}.Esto debería mostrar una 'A' mayúscula: \x41*/echo <<<'EOT'Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.Ahora, estoy escribiendo un poco de {$foo->bar[1]}.Esto debería mostrar una 'A' mayúscula: \x41EOT;?>
Análisis de variablesCuando un string es especificado mediante comillas dobles o mediante heredoc, las variables que haya dentro de dicho string se analizarán.
Existen dos tipos de sintaxis: una simple y otra compleja.
Si se encuentra un signo de dólar ($), el analizador tomará el mayor número de símbolos para formar un nombre de variable válido. Delimitar el nombre de la variable con llaves permite especificar explícitamente el final del nombre.
<?php$jugo = "manzana";
echo "Él tomó algo de jugo de $jugo."; // Inválido. "s" es un carácter válido para un nombre de variable, pero la variable es $jugo.echo "Él tomó algo de jugo hecho de $jugos.";// Válido. Explícitamente especifica el final del nombre de la variable encerrándolo entre llaves:echo "Él tomó algo de jugo hecho de ${jugo}s."
/* Resultado:Él tomó algo de jugo de manzana.Él tomó algo de jugo hecho de .Él tomó algo de jugo hecho de manzanas.*/?>
Análisis de variablesPara casos más complejos se debe emplear la sintaxis compleja.
Esta sintaxis no se llama compleja porque sea compleja, sino porque permite el empleo de expresiones complejas.
<?php$genial = 'fantástico';// No funciona, muestra: Esto es { fantástico}echo "Esto es { $genial}";// Funciona, muestra: Esto es fantásticoecho "Esto es {$genial}";// Funcionaecho "Este cuadrado tiene {$cuadrado->width}00 centímetros de lado.";// Funciona, las claves entre comillas sólo funcionan usando la sintaxis de llavesecho "Esto funciona: {$arr['clave']}";// Funcionaecho "Esto funciona: {$arr[4][3]}";// Esto no funciona por la misma razón que $foo[bar] es incorrecto fuera de un string.// En otras palabras, aún funcionaría, pero solamente porque PHP primero busca una// constante llamada foo; se emitirá un error de nivel E_NOTICE// (constante no definida).echo "Esto está mal: {$arr[foo][3]}"; // Funciona. Cuando se usan arrays multidimensionales, emplee siempre llaves que delimiten// a los arrays cuando se encuentre dentro de un stringecho "Esto funciona: {$arr['foo'][3]}";echo "Esto también funciona: {$obj->valores[3]->nombre}";echo "Este es el valor de la variable llamada $nombre: {${$nombre}}";echo "Este es el valor de la variable llamada por el valor devuelto por getNombre(): {${getNombre()}}";//No funciona, muestra: Esto es el valor devuelto por getNombre(): {getNombre()}echo "Esto es el valor devuelto por getNombre(): {getNombre()}";?>
ArraysUn array en PHP es en realidad un mapa ordenado. Un mapa es un tipo de datos que asocia valores con claves.
Ya que los valores de un array pueden ser otros arrays, también son posibles árboles y arraysmultidimensionales.
La coma después del último elemento del array es opcional, pudiéndose omitir.
<?php$array = array("foo" => "bar","bar" => "foo",
);
// a partir de PHP 5.4$array = [
"foo" => "bar","bar" => "foo",
];?>
ArraysSi varios elementos en la declaración del array usan la misma clave, sólo se utilizará la última, siendo los demás son sobrescritos.
Como todas las claves en el ejemplo anterior se convierten en 1, los valores serán sobrescritos en cada nuevo elemento, por lo que el último valor asignado "d" es el único que queda.
<?php$array = array(1 => "a","1" => "b",1.5 => "c",true => "d",
);var_dump($array);/* Resultado:array(1) {[1] => string(1) "d"
}*/?>
ArraysLos arrays de PHP pueden contener claves integer y string al mismo tiempo ya que PHP no distingue entre arrays indexados y asociativos.
<?php$array = array("foo" => "bar","bar" => "foo",100 => -100,-100 => 100,
);var_dump($array);
/* Resultado:array(4) {["foo"] => string(3) "bar"["bar"] => string(3) "foo"[100] => int(-100)[-100] => int(100)
} */?>
ArraysLa clave es opcional. Si no se especifica, PHP usará el incremento de la clave de tipo integer mayor utilizada anteriormente.
<?php$array = array("foo", "bar", "hello", "world");var_dump($array);
/* Resultado:array(4) {[0] => string(3) "foo"[1] => string(3) "bar"[2] => string(5) "hello"[3] => string(5) "world"
}*/?>
ArraysEs posible especificar la clave sólo para algunos elementos y excluir a los demás.
Como se puede ver, al último valor "d" se le asignó la clave 7. Esto es debido a que la mayor clave integer anterior era 6.
<?php$array = array(
"a","b",6 => "c","d",
);var_dump($array);
/* Resultado: array(4) {
[0] => string(1) "a"[1] => string(1) "b"[6] => string(1) "c"[7] => string(1) "d"
}*/?>
ArraysLos elementos de array se pueden acceder utilizando la sintaxis array[key].
Tanto los corchetes como las llaves pueden ser utilizados de forma intercambiable para acceder a los elementos de un array (p.ej.: $array[42] y $array{42} tendrán el mismo resultado en el ejemplo anterior).
<?php$array = array("foo" => "bar",42 => 24,"multi" => array(
"dimensional" => array("array" => "foo"
))
);var_dump($array["foo"]);var_dump($array[42]);var_dump($array["multi"]["dimensional"]["array"]);/* Resultado: string(3) "bar"int(24)string(3) "foo"}*/?>
ArraysUn array existente puede ser modificado estableciendo explícitamente valores en él.
Si $arr aún no existe, se creará, siendo también esta forma una alternativa de crear un array.
<?php$arr = array(5 => 1, 12 => 2);
$arr[] = 56; // Esto es lo mismo que $arr[13] = 56;// en este punto de el script
$arr["x"] = 42; // Esto agrega un nuevo elemento a// el array con la clave "x"
unset($arr[5]); // Esto elimina el elemento del array
unset($arr); // Esto elimina el array completo?>
ArraysEl constructor foreach proporciona un modo sencillo de iterar sobre arrays.
<?php$array = array(1, 2, 3, 4);foreach ($array as &$valor) {$valor = $valor * 2;
}// $array ahora es array(2, 4, 6, 8)
// sin unset($valor), $valor aún es una referencia al último elemento: $array[3]
foreach ($array as $clave => $valor) {// $array[3] se actualizará con cada valor de $array...echo "{$clave} => {$valor} ";print_r($array);
}// ...hasta que finalmente el penúltimo valor se copia al último valor
// salida:// 0 => 2 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 2 )// 1 => 4 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 4 )// 2 => 6 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 6 )// 3 => 6 Array ( [0] => 2, [1] => 4, [2] => 6, [3] => 6 )?>
ObjetosPara crear un nuevo objeto, utilice la sentencia new para instanciar una clase:
<?phpclass foo{function foo(){$this->propiedad = "Mi propiedad";
}function hacer_algo(){
echo "Haciendo algo."; }
}
$bar = new foo();$bar->hacer_algo();echo $bar->propiedad;?>
DevuelveHaciendo algo.Mi propiedad
RecursosUn valor tipo resource es una variable especial, que contiene una referencia a un recurso externo. Los recursos son creados y usados por funciones especiales.
Las variables resource contienen gestores especiales a archivos abiertos, conexiones con bases de datos.
<?php$mysqli = new mysqli('localhost', 'mi_usuario', 'mi_contraseña', 'mi_bd');
if ($mysqli->connect_error) {die('Error de Conexión (' . $mysqli->connect_errno . ') ‘ . $mysqli->connect_error);
}/** Use esto en lugar de $connect_error si necesita asegurarse* de la compatibilidad con versiones de PHP anteriores a 5.2.9 y 5.3.0.*/if (mysqli_connect_error()) {die('Error de Conexión (' . mysqli_connect_errno() . ') ‘ . mysqli_connect_error());
}
echo 'Éxito... ' . $mysqli->host_info . "\n";
$mysqli->close();?>
NULOEl valor especial NULL representa una variable sin valor. NULL es el único valor posible del tipo null.
Una variable es considerada null si:◦ se le ha asignado la constante NULL.
◦ no se le ha asignado un valor todavía.
◦ se ha destruido con unset().
No hay más que un valor de tipo null, y es la constante NULL insensible a mayúsculas/minúsculas.
<?php$var = NULL;$var = null;?>
Manipulación de tiposPHP no requiere (ni soporta) la definición explicita de tipos en la declaración de variables; el tipo de la variable se determina por el contexto en el cual se emplea la variable.
Es decir, si se asigna un valor string a una variable $var, entonces $var se convierte en un string. Si un valor integer es entonces asignado a la misma variable $var, ésta se convierte en integer.
<?php$foo = "0"; // $foo es string (ASCII 48)$foo += 2; // $foo es ahora un integer (2)$foo = $foo + 1.3; // $foo es ahora un float (3.3)$foo = 5 + "10 Cerditos pequeñitos"; // $foo es integer (15)$foo = 5 + "10 Cerdos pequeños"; // $foo es integer (15)?>
Forzado de tiposEl forzado de tipos en PHP funciona de la misma manera que en C:, donde el nombre del tipo deseado se escribe entre paréntesis antes de la variable que se quiera forzar.
Los siguientes forzados de tipos están permitidos:◦ (int), (integer) - forzado a integer
◦ (bool), (boolean) - forzado a boolean
◦ (float), (double), (real) - forzado a float
◦ (string) - forzado a string
◦ (array) - forzado a array
◦ (object) - forzado a object
◦ (unset) - forzado a NULL (PHP 5)
<?php$foo = 10; // $foo es un integer$bar = (boolean) $foo; // $bar es un boolean?>
Variables
Conceptos básicos
En PHP las variables se representan 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.
Los nombres de variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido tiene que empezar con una letra o un carácter de subrayado (underscore), seguido de cualquier número de letras, números y caracteres de subrayado.
$this es una variable especial que no puede ser asignada.
De forma predeterminada, las variables siempre se asignan por valor. Esto significa que cuando se asigna una expresión a una variable, el valor completo de la expresión original se copia en la variable de destino.
Para asignar por referencia, simplemente se antepone un signo ampersand (&) al comienzo de la variable cuyo valor se está asignando (la variable fuente).
Conceptos básicos
<?php$var = 'Roberto';$Var = 'Juan';echo "$var, $Var"; // imprime "Roberto, Juan"
$4site = 'aun no'; // inválido; comienza con un número$_4site = 'aun no'; // válido; comienza con un carácter de subrayado$täyte = 'mansikka'; // válido; 'ä' es ASCII (Extendido) 228?>
<?php$foo = 'Bob'; // Asigna el valor 'Bob' a $foo$bar = &$foo; // Referenciar $foo vía $bar.$bar = "Mi nombre es $bar"; // Modifica $bar...echo $bar;echo $foo; // $foo también se modifica.?>
Variables PredefinidasPHP proporciona una gran cantidad de variables predefinidas a cualquier script que se ejecute.
Superglobals — Superglobals son variables internas que están disponibles siempre en todos los ámbitos◦ $GLOBALS — Hace referencia a todas las variables disponibles en el ámbito global
◦ $_SERVER — Información del entorno del servidor y de ejecución
◦ $_GET — Variables HTTP GET
◦ $_POST — Variables POST de HTTP
◦ $_FILES — Variables de subida de ficheros HTTP
◦ $_REQUEST — Variables HTTP contiene el contenido de $_GET, $_POST y $_COOKIE
◦ $_SESSION — Variables de sesión
◦ $_ENV — Variables de entorno
◦ $_COOKIE — Cookies HTTP
$php_errormsg — El mensaje de error anterior
$HTTP_RAW_POST_DATA — Datos POST sin tratar
$http_response_header — Encabezados de respuesta HTTP
$argc — El número de argumentos pasados a un script
$argv — Array de argumentos pasados a un script
<?phpecho '$foo en el ámbito global: ' . $GLOBALS["foo"] . "\n";echo $_SERVER['SERVER_NAME'];echo 'Hola ' . htmlspecialchars($_GET["nombre"]) . '!';echo '¡Hola ' . htmlspecialchars($_POST["nombre"]) . '!';$_SESSION["newsession"] = $value;echo '¡Mi nombre de usuario es ' . $_ENV["USER"] . '!';echo '¡Hola ' . htmlspecialchars($_COOKIE["nombre"]) . '!';echo $php_errormsg;$postdata = file_get_contents("php://input");var_dump($http_response_header);var_dump($argc);var_dump($argv);?>
Ámbito de las variablesEl ámbito de una variable es el contexto dentro del que la variable está definida. La mayor parte de las variables PHP sólo tienen un ámbito simple. Este ámbito simple también abarca los archivos incluidos y los requeridos.
<?php$a = 1;include 'b.inc';?>
<?php$a = 1; /* ámbito global */
function test(){echo $a; /* referencia a una variable del ámbito local */}
test();?>
La palabra clave globalEn primer lugar, un ejemplo de uso de global:
Un segundo método para acceder a las variables desde un ámbito global es usando el array $GLOBALS
<?php$a = 1;$b = 2;function Suma(){global $a, $b;$b = $a + $b;
}
Suma();echo $b;?>
<?php$a = 1;$b = 2;
function Suma(){
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];}
Suma();echo $b;?>
Uso de variables staticUna variable estática existe sólo en el ámbito local de la función, pero no pierde su valor cuando la ejecución del programa abandona este ámbito.
<?php// No tiene utilidad. $a Siempre tiene 0function test(){$a = 0;echo $a;$a++;
}test(); // imprime: 0test(); // imprime: 0?>
<?php// $a se inicializa la primera vez y mantiene su valorfunction test(){static $a = 0;echo $a;$a++;
}test(); // imprime: 0test(); // imprime: 1?>
Variables variablesA veces es conveniente tener nombres de variables variables. Dicho de otro modo, son nombres de variables que se pueden definir y usar dinámicamente. Una variable normal se establece con una sentencia como:
Una variable variable toma el valor de una variable y lo trata como el nombre de una variable. En el ejemplo anterior, hola, se puede usar como el nombre de una variable utilizando dos signos de dólar. Es decir:
En este momento se han definido y almacenado dos variables en el árbol de símbolos de PHP: $a, que contiene "hola", y $hola, que contiene "mundo". Es más, esta sentencia:
produce el mismo resultado que:
<?php$a = 'hola';?>
<?php$$a = 'mundo';?>
<?phpecho "$a ${$a}";?>
<?phpecho "$a $hola";?>
Variables desde fuentes externas
Formularios HTML (GET y POST). Cuando se envía un formulario a un script de PHP, la información de dicho formulario pasa a estar automáticamente disponible en el script.
<form action="foo.php" method="post">Nombre usuario: <input type="text" name="username" /><br />Email: <input type="text" name="email" /><br /><input type="submit" name="submit" value="¡Enviarme!" />
</form>
<?phpecho $_POST['username'];echo $_REQUEST['username'];?>
Variables desde fuentes externas
Cookies HTTP. Las cookies son un mecanismo para almacenar datos en el navegador y así rastrear o identificar a usuarios que vuelven. Se pueden crear cookies usando la función setcookie().
Las cookies son parte de la cabecera HTTP, así que se debe llamar a la función SetCookie antes de que se envíe cualquier salida al navegador. Es la misma restricción que para la función header().
<?phpif (isset($_COOKIE['conteo'])) {$conteo = $_COOKIE['conteo'] + 1;
} else {$conteo = 1;
}setcookie('conteo', $conteo, time()+3600);setcookie("Carrito[$conteo]", $item, time()+3600);?>
Constantes
IntroducciónUna constante es un identificador (nombre) para un valor simple. Como el nombre sugiere, este valor no puede variar durante la ejecución del script.
Por defecto, una constante distingue mayúsculas y minúsculas. Por convención, los identificadores de constantes siempre se declaran en mayúsculas.
El nombre de una constante sigue las mismas reglas que cualquier otra etiqueta de PHP. Un nombre de constante válido empieza por una letra o guion bajo, seguido por cualquier número de letras, números o guiones bajos.
<?php
// Nombres de constantes correctosdefine("FOO", "something");define("FOO2", "something else");define("FOO_BAR", "something more");
// Nombres de constantes incorrectosdefine("2FOO", "something");
// Esto es válido, pero debe evitarse:// PHP podría cualquier día proporcionar una constante mágica // que rompiera el scriptdefine("__FOO__", "something"); ?>
SintaxisSe puede definir una constante usando la función define() o con la palabra reservada const.
Para obtener el valor de una constante solo es necesario especificar su nombre. A diferencia de las variables, no se debe prefijar una constante con el signo $.
Estas son las diferencias entre constantes y variables:◦ Las constantes no llevan el signo dólar ($), como prefijo.
◦ Antes de PHP 5.3, las constantes solo podían ser definidas usando la función define(), y no por simple asignación.
◦ Las constantes pueden ser definidas y accedidas desde cualquier sitio sin importar las reglas de acceso de variables.
◦ Las constantes no pueden ser redefinidas o eliminadas una vez se han definido; y
◦ Las constantes podrían evaluarse como valores escalares. A partir de PHP 5.6 es posible definir una constante de array con la palabra reservada const, y, a partir de PHP 7, las constantes de array también se pueden definir con define(). Se pueden utilizar arrays en expresiones escalares constantes (por ejemplo, const FOO = array(1,2,3)[0];), aunque el resultado final debe ser un valor de un tipo permitido.
SintaxisA diferencia de definir constantes usando define(), las constantes definidas con la palabra clave constdeben declararse en el nivel superior del entorno de la aplicación porque se definen en tiempo de ejecución. Esto significa que no pueden declararse dentro de funciones, bucles, sentencias if o bloques try/ catch.
<?php// Funciona a partir de PHP 5.3.0const CONSTANTE = 'Hola Mundo';
echo CONSTANTE;
// Funciona a partir de PHP 5.6.0const OTRA_CONSTANTE = CONSTANTE.'; Adiós Mundo';echo OTRA_CONSTANTE;
const ANIMALES = array('perro', 'gato', 'pájaro');echo ANIMALES[1]; // muestra "gato"
// Funciona a partir de PHP 7define('ANIMALES', array('perro','gato','pájaro'));echo ANIMALES[1]; // muestra "gato"?>
Constantes predefinidasPHP ofrece un gran número de constantes predefinidas a cualquier script en ejecución. Muchas de estas constantes, sin embargo, son creadas por diferentes extensiones, y sólo estarán presentes si dichas extensiones están disponibles.
◦ PHP_VERSION (string). La versión actual de PHP en notación "mayor.menor.edición[extra]".
◦ PHP_MAJOR_VERSION (integer) La versión "mayor" actual de PHP como valor integer (p.ej., int(5) en la versión "5.2.7-extra").
◦ PHP_MINOR_VERSION (integer) La versión "menor" actual de PHP como valor integer (p.ej, int(2) en la versión "5.2.7-extra").
◦ PHP_VERSION_ID (integer) La versión de PHP actual como valor integer, útil para comparar versiones (p.ej., int(50207) para la versión "5.2.7-extra").
◦ E_COMPILE_ERROR (integer)
◦ E_USER_DEPRECATED (integer)
◦ E_ALL (integer)
◦ E_STRICT (integer)
◦ TRUE (boolean)
◦ FALSE (boolean)
◦ NULL (null)
Lista completa: http://php.net/manual/es/reserved.constants.php
Constantes mágicasHay nueve constantes mágicas que cambian dependiendo de dónde se emplean. Por ejemplo, el valor de __LINE__ depende de la línea en que se use en el script. Todas estas constantes «mágicas» se resuelven durante la compilación, a diferencia de las constantes normales que lo hacen durante la ejecución. Estas constantes especiales son sensibles a mayúsculas Estas constantes especiales distinguen mayúsculas y minúsculas.
Nombre Descripción
__LINE__ El número de línea actual en el archivo.
__FILE__Ruta completa y nombre del fichero con enlaces simbólicos resueltos. Si se usa dentro de un include, devolverá el nombre del archivo incluido.
__DIR__Directorio del fichero. Si se utiliza dentro de un include, devolverá el directorio del fichero incluído. Esta constante es igual que dirname(__FILE__). El nombre del directorio no lleva la barra final a no ser que esté en el directorio root.
__FUNCTION__ Nombre de la función.
__CLASS__
Nombre de la clase. El nombre de la clase incluye el namespace declarado en (p.e.j. Foo\Bar). Tenga en cuenta que a partir de PHP 5.4 __CLASS__ también funciona con traits. Cuando es usado en un método trait, __CLASS__ es el nombre de la clase del trait que está siendo utilizado.
__TRAIT__El nombre del trait. El nombre del trait incluye el espacio de nombres en el que fue declarado (p.e.j. Foo\Bar).
__METHOD__ Nombre del método de la clase.
__NAMESPACE__ Nombre del espacio de nombres actual.
ClassName::class El nombre de clase completamente cualificado.
Expresiones
IntroducciónLa expresiones son los bloques de construcción más importantes de PHP. En PHP casi todo lo que se escribe es una expresión. La manera más simple y acertada de definir lo que es una expresión es «cualquier cosa que tiene un valor».
Las formas más básicas de expresiones son las constantes y las variables. Cuando se escribe "$a = 5", se está asignando '5' a $a.
Un ejemplo de expresiones algo más complejo son las funciones.
PHP es un lenguaje orientado a expresiones, en el sentido de que casi todo es una expresión.
Otro buen ejemplo de orientación a expresiones es el pre- y post-incremento y decremento. Los usuarios de PHP y de otros muchos lenguajes pueden estar familiarizados con la notación variable++y variable--.
Un tipo de expresiones muy comunes son las expresiones de comparación. Estas expresiones evalúan si algo es FALSE (falso) o TRUE (verdadero). PHP soporta > (mayor que), >= (mayor o igual que), == (igual), != (distinto), < (menor que) y <= (menor o igual que).
Ejemplos de expresiones<?php$primero ? $segundo : $tercero; // el operador condicional ternario:/*Si el valor de la primera subexpresión es TRUE (no es cero), se evalúa la segunda subexpresión, y ése será el resultado de la expresión condicional. Si no, se evalúa la tercera subexpresión, y ése será el valor. */
function doble($i){return $i*2;
}$b = $a = 5; /* asignar el valor cinco a la variable $a y $b */$c = $a++; /* post-incremento, asignar el valor original de $a(5) a $c */$e = $d = ++$b; /* pre-incremento, asignar el valor incrementado de $b (6) a $d y $e */
/* en este punto, $d y $e son iguales a 6 */
$f = doble($d++); /* asignar el doble del valor de $d antes del incremento, 2*6 = 12, a $f */$g = doble(++$e); /* asignar el doble del valor de $e después del incremento, 2*7 = 14, a $g */$h = $g += 10; /* primero, $g es incrementado en 10 y finaliza con el valor 24. El valor de la asignación (24) esasignado después a $h, y $h finaliza también con el valor 24. */?>
Operadores
Introducción
Un operador es algo que toma uno más valores y produce otro valor (de modo que la construcción en si misma se convierte en una expresión).
Los operadores se pueden agrupar de acuerdo con el número de valores que toman.◦ Los operadores unarios toman sólo un valor, por ejemplo ! (el operador lógico de negación) o ++ (el
operador de incremento).
◦ Los operadores binarios toman dos valores, como los familiares operadores aritméticos + (suma) y - (resta), y la mayoría de los operadores de PHP entran en esta categoría.
◦ Finalmente, hay sólo un operador ternario, ? :, el cual toma tres valores; usualmente a este se le refiere simplemente como "el operador ternario" (aunque podría tal vez llamarse más correctamente como el operador condicional).
Precedencia de operadoresLa precedencia de un operador indica qué tan "estrechamente" se unen dos expresiones juntas.
Asociatividad Operadores
no asociativo clone new
izquierda [
derecha **
derecha ++ -- ~ (int) (float) (string) (array) (object) (bool) @
no asociativo instanceof
derecha !
izquierda * / %
izquierda + - .
izquierda << >>
no asociativo < <= > >=
no asociativo == != === !== <> <=>
izquierda &
izquierda ^
izquierda |
izquierda &&
izquierda ||
derecha ??
izquierda ? :
derecha = += -= *= **= /= .= %= &= |= ^= <<= >>=
izquierda and
izquierda xor
izquierda or
<?php$a = 3 * 3 % 5; // (3 * 3) % 5 = 4// la asociatividad del operador ternario difiere de C/C++$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2
$a = 1;$b = 2;$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5?>
Operadores aritméticos¿Recuerda la aritmética básica de la escuela? Estos funcionan igual que aquellos.
Ejemplo Nombre Resultado
+$a Identidad Conversión de $a a int o float según el caso.
-$a Negación Opuesto de $a.
$a + $b Adición Suma de $a y $b.
$a - $b Sustracción Diferencia de $a y $b.
$a * $b Multiplicación Producto de $a y $b.
$a / $b División Cociente de $a y $b.
$a % $b Módulo Resto de $a dividido por $b.
$a ** $b Exponenciación Resultado de elevar $a a la potencia $bésima. Introducido en PHP 5.6.
<?phpecho (5 % 3)."\n"; // muestra 2echo (5 % -3)."\n"; // muestra 2echo (-5 % 3)."\n"; // muestra -2echo (-5 % -3)."\n"; // muestra -2?>
Operadores de asignaciónEl operador básico de asignación es "=". Se podría inclinar a pensar primero que es como un "igual a". No lo es. Realmente significa que el operando de la izquierda se establece con el valor de la expresión de la derecha (es decir, "se define como").
La asignación por referencia también está soportada, utilizando la sintaxis "$var = &$othervar;". Asignación por referencia significa que ambas variables terminan apuntando a los mismos datos y nada es copiado en ninguna parte.
<?php$a = 3;$a += 5; // establece $a en 8, como si se hubiera dicho: $a = $a + 5;$b = "Hola ";$b .= "ahí!"; // establece $b en "Hola ahí!", al igual que $b = $b . "ahí!";?>
<?php$a = 3;$b = &$a; // $b es una referencia para $a
print "$a\n"; // muestra 3print "$b\n"; // muestra 3
$a = 4; // cambia $a
print "$a\n"; // muestra 4print "$b\n"; // muestra 4 también, dado que $b es una referencia para $a, la cual ha sido cambiada?>
Facultad de Estadística e Informática
Gracias por su atención
