Unidad8 PHP

SISTEMAS WEB
Facultad de Estadística e Informática

Bibliografía
▪ Documentación de PHP (2017). Obtenido de: http://php.net/docs.php

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.
<!DOCTYPE html> <!DOCTYPE html>

<html> <html>
<body> <body>
<?php Hola PHP!
echo "Hola PHP!"; </body>
?> </html>
</body>
</html>
Internet PHP
HTML BD
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.
<?php
// el código PHP va aquí
?>
Las líneas de PHP terminan con un punto y coma (;).

<?php
echo "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.
<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>
Desde PHP 5.4, la etiqueta de echo abreviada <?= siempre es aceptada y válida, independientemente
de la configuración de short_open_tag.
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.
<?php
echo 'Esto es una prueba';
?>
<?php echo 'Esto es una prueba' ?>
<?php echo 'Hemos omitido la última etiqueta de cierre';

Comentarios
PHP admite comentarios al estilo de 'C', 'C++' y de consola de Unix (estilo de Perl).
<?php
echo 'Esto es una prueba'; // Esto es un comentario al estilo de c++ de una sola línea
/* Esto es un comentario multilínea

y 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. <?php

◦ Cuatro tipos simples: $un_bool = TRUE; // un valor booleano
◦ boolean $un_str = "foo"; // una cadena de caracteres
◦ integer $un_str2 = 'foo'; // una cadena de caracteres
$un_int = 12; // un número entero
◦ float (número de punto flotante,
también conocido como double)
echo gettype($un_bool); // imprime: boolean
◦ string
echo gettype($un_str); // imprime: string
◦ Cuatro tipos compuestos:
◦ array // Si este valor es un entero, incrementarlo en cuatro
◦ object if (is_int($un_int)) {
◦ callable $un_int += 4;
}
◦ iterable
// Si $un_bool es una cadena, imprimirla
Y finalmente dos tipos especiales: // (no imprime nada)
◦ resource if (is_string($un_bool)) {
◦ NULL echo "Cadena: $un_bool";
}
?>
Booleanos <?php
$foo = True; // asigna el valor TRUE a $foo
?>
<?php
// == es un operador que comprueba la
// igualdad y devuelve un booleano
Este es el tipo más simple. Un boolean expresa if ($accion == "mostrar_version") {
un valor que indica verdad. Puede ser TRUE echo "La versión es 1.23";
(verdadero) o FALSE (falso). }
Para especificar un literal de tipo boolean se // esto no es necesario...

emplean las constantes TRUE o FALSE. Ambas no if ($mostrar_separadores == TRUE) {
son susceptibles a mayúsculas y minúsculas. 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
<?php
echo 'Esto es una cadena sencilla';
echo 'También se pueden incluir nuevas líneas en

La manera más sencilla de especificar un string un string de esta forma, ya que es
es delimitarlo con comillas simples (el carácter ‘). correcto hacerlo así';
Para especificar una comilla simple literal, se ha // Resultado: Arnold una vez dijo: "I'll be back"
de escapar con una barra invertida (\). Para echo 'Arnold una vez dijo: "I\'ll be back"';
especificar una barra invertida literal, se duplica // Resultado: Ha borrado C:\*.*?
(\\). echo 'Ha borrado C:\\*.*?';
Todas las demás instancias de barras invertidas // Resultado: Ha borrado C:\*.*?

serán tratadas como una barra invertida literal: echo 'Ha borrado C:\*.*?';
esto significa que otras secuencias de escape que // Resultado: Esto no se expandirá: \n una nueva línea
podrían utilizarse, tales como \r o \n, serán echo 'Esto no se expandirá: \n una nueva línea';
mostradas literalmente tal y como se especifican,
en lugar de tener cualquier otro significado // Resultado: Las variables $tampoco se $expandirán
echo 'Las variables $tampoco se $expandirán';
especial. ?>
Heredoc <?php
Una tercera forma de delimitar un string es $str = <<<EOD
mediante la sintaxis heredoc: <<<. Después de Ejemplo de una cadena
este operador, se deberá proporcionar un expandida en varias líneas
identificador y justo después una nueva línea. empleando la sintaxis heredoc.
A continuación va el propio string, y para EOD;
cerrar la notación se pone el mismo
identificador. /* Resultado: Mi nombre es "MiNombre". Estoy
escribiendo un poco de Foo.
El texto heredoc se comporta como un string Ahora, estoy escribiendo un poco de Bar2.
entre comillas dobles, pero sin tener comillas Esto debería mostrar una 'A' mayúscula: A
dobles. */
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: \x41
EOT;
?>
Nowdoc
Nowdoc 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 string
expandido en varias líneas
empleando 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]}.
*/
echo <<<'EOT'
Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.
Ahora, estoy escribiendo un poco de {$foo->bar[1]}.
EOT;
?>
Análisis de variables
Cuando 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 variables
Para casos más complejos <?php
$genial = 'fantástico';
se debe emplear la sintaxis // No funciona, muestra: Esto es { fantástico}
compleja. echo "Esto es { $genial}";
// Funciona, muestra: Esto es fantástico
echo "Esto es {$genial}";
Esta sintaxis no se llama // Funciona
compleja porque sea echo "Este cuadrado tiene {$cuadrado->width}00 centímetros de lado.";
// Funciona, las claves entre comillas sólo funcionan usando la sintaxis de llaves
compleja, sino porque echo "Esto funciona: {$arr['clave']}";
permite el empleo de // Funciona
echo "Esto funciona: {$arr[4][3]}";
expresiones complejas. // 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 string
echo "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()}";
?>
Arrays
Un 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 arrays
multidimensionales.
<?php
$array = array(
"foo" => "bar",
"bar" => "foo",
);
// a partir de PHP 5.4

$array = [
"foo" => "bar",
"bar" => "foo",
];
?>
La coma después del último elemento del array es opcional, pudiéndose omitir.
Arrays
Si varios elementos en la declaración del array usan la misma clave, sólo se utilizará la última, siendo
los demás son sobrescritos.
<?php
$array = array(
1 => "a",
"1" => "b",
1.5 => "c",
true => "d",
);
var_dump($array);
/* Resultado:
array(1) {
[1] => string(1) "d"
}
*/
?>
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.
Arrays
Los 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)
} */
?>
Arrays
La 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"
}
*/
?>
Arrays
Es posible especificar la clave sólo para algunos elementos y excluir a los demás.
<?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"
}
*/
?>
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.
Arrays
Los elementos de array se pueden acceder utilizando la sintaxis array[key].
<?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"
}
*/
?>
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).
Arrays
Un 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

?>
Arrays
El 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 )
?>
Objetos
Para crear un nuevo objeto, utilice la sentencia new para instanciar una clase:
<?php
class foo
{
function foo()
{
$this->propiedad = "Mi propiedad";
}
function hacer_algo()
{
echo "Haciendo algo.";
}
}
$bar = new foo();

$bar->hacer_algo();
Devuelve echo $bar->propiedad;
Haciendo algo.Mi propiedad ?>
Recursos
Un 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();
?>
NULO
El 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. <?php
◦ se ha destruido con unset(). $var = NULL;
$var = null;
?>
No hay más que un valor de tipo null, y es la constante NULL insensible a mayúsculas/minúsculas.
Manipulación de tipos
PHP 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 tipos
El 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 Predefinidas
PHP 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
echo '$foo en el ámbito global: ' . $GLOBALS["foo"] . "\n";
$php_errormsg — El mensaje de error anterior echo $_SERVER['SERVER_NAME'];
echo 'Hola ' . htmlspecialchars($_GET["nombre"]) . '!';
$HTTP_RAW_POST_DATA — Datos POST sin tratar echo '¡Hola ' . htmlspecialchars($_POST["nombre"]) . '!';
$_SESSION["newsession"] = $value;
$http_response_header — Encabezados de respuesta HTTP echo '¡Mi nombre de usuario es ' . $_ENV["USER"] . '!';
echo '¡Hola ' . htmlspecialchars($_COOKIE["nombre"]) . '!';
$argc — El número de argumentos pasados a un script echo $php_errormsg;
$postdata = file_get_contents("php://input");
$argv — Array de argumentos pasados a un script var_dump($http_response_header);
var_dump($argc);
var_dump($argv);
?>
Ámbito de las variables
El á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 global
<?php
En primer lugar, un ejemplo de uso de global: $a = 1;
$b = 2;
function Suma()
{
global $a, $b;
$b = $a + $b;
}
Suma();
Un segundo método para acceder a las variables desde un echo $b;
ámbito global es usando el array $GLOBALS ?>
<?php
$a = 1;
$b = 2;
function Suma()
{
$GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}
Suma();
echo $b;
?>
Uso de variables static
Una 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 <?php
// No tiene utilidad. $a Siempre tiene 0 // $a se inicializa la primera vez y
function test() mantiene su valor
{ function test()
$a = 0; {
echo $a; static $a = 0;
$a++; echo $a;
} $a++;
test(); // imprime: 0 }
test(); // imprime: 0 test(); // imprime: 0
?> test(); // imprime: 1
?>
Variables variables
A 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:
<?php
$a = 'hola';
?>
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:
<?php
$$a = 'mundo';
?>
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:
<?php
echo "$a ${$a}";
?>
produce el mismo resultado que:
<?php
echo "$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>
<?php
echo $_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().
<?php
if (isset($_COOKIE['conteo'])) {
$conteo = $_COOKIE['conteo'] + 1;
} else {
$conteo = 1;
}
setcookie('conteo', $conteo, time()+3600);
setcookie("Carrito[$conteo]", $item,
time()+3600);
?>
Constantes
Introducción
Una 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 correctos

define("FOO", "something");
define("FOO2", "something else");
define("FOO_BAR", "something more");
// Nombres de constantes incorrectos

define("2FOO", "something");
// Esto es válido, pero debe evitarse:

// PHP podría cualquier día proporcionar una constante mágica
// que rompiera el script
define("__FOO__", "something");
?>
Sintaxis
Se 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.
Sintaxis
A diferencia de definir constantes usando define(), las constantes definidas con la palabra clave const
deben 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.0
const CONSTANTE = 'Hola Mundo';
echo CONSTANTE;
// Funciona a partir de PHP 5.6.0

const 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 7

define('ANIMALES', array(
'perro',
'gato',
'pájaro'
));
echo ANIMALES[1]; // muestra "gato"
?>
Constantes predefinidas
PHP 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ágicas
Hay 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.
Ruta completa y nombre del fichero con enlaces simbólicos resueltos. Si se usa dentro
__FILE__
de un include, devolverá el nombre del archivo incluido.
Directorio del fichero. Si se utiliza dentro de un include, devolverá el directorio del

__DIR__ 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.
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
__CLASS__
traits. Cuando es usado en un método trait, __CLASS__ es el nombre de la clase del trait
que está siendo utilizado.
El nombre del trait. El nombre del trait incluye el espacio de nombres en el que fue
__TRAIT__
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ón
La 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) es
asignado 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 operadores
La precedencia de un operador indica qué tan "estrechamente" se unen dos expresiones juntas.
Asociatividad Operadores
no asociativo clone new
izquierda [
<?php derecha **
$a = 3 * 3 % 5; // (3 * 3) % 5 = 4 derecha ++ -- ~ (int) (float) (string) (array) (object) (bool) @
// la asociatividad del operador ternario difiere de C/C++ no asociativo instanceof
$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2 derecha !
izquierda */%
$a = 1; izquierda +-.
izquierda << >>
$b = 2;
no asociativo < <= > >=
$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5
no asociativo == != === !== <> <=>
?> izquierda &
izquierda ^
izquierda |
izquierda &&
izquierda ||
derecha ??
izquierda ?:
derecha = += -= *= **= /= .= %= &= |= ^= <<= >>=
izquierda and
izquierda xor
izquierda or
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.
<?php
echo (5 % 3)."\n"; // muestra 2
echo (5 % -3)."\n"; // muestra 2
echo (-5 % 3)."\n"; // muestra -2
echo (-5 % -3)."\n"; // muestra -2
?>
Operadores de asignación
El 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").
<?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í!";
?>
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;
$b = &$a; // $b es una referencia para $a
print "$a\n"; // muestra 3

print "$b\n"; // muestra 3
$a = 4; // cambia $a
print "$a\n"; // muestra 4

print "$b\n"; // muestra 4 también, dado que $b es una referencia para $a, la cual ha sido cambiada
?>
Gracias por su atención

Unidad8 PHP

Cargado por

Copyright:

Formatos disponibles

Unidad8 PHP

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad8 PHP

Cargado por

Copyright:

Formatos disponibles

SISTEMAS WEB

Facultad de Estadística e Informática

Facultad de Estadística e Informática

VI. Generación dinámica de contenido Web

Facultad de Estadística e Informática

<!DOCTYPE html> <!DOCTYPE html>

El lenguaje PHP se incrusta en el código HTML y sus scripts se ejecutan en el

Se requieren 3 componentes instalados para poder desarrollar páginas web PHP.

El motor de PHP necesita diferenciar el código PHP de otro elementos de la página,

Las líneas de PHP terminan con un punto y coma (;).

Siempre está habilitada en PHP 5.4.0 y posterior, y es equivalente a

<?php echo 'Esto es una prueba' ?>

<?php echo 'Hemos omitido la última etiqueta de cierre';

/* Esto es un comentario multilínea

<h1>Esto es un <?php # echo 'simple';?> ejemplo</h1>

PHP admite ocho tipos primitivos. <?php

Para especificar un literal de tipo boolean se // esto no es necesario...

// ...porque se puede escribir simplemente:

echo 'También se pueden incluir nuevas líneas en

Todas las demás instancias de barras invertidas // Resultado: Ha borrado C:\*.*?

/* Resultado: Mi nombre es "$nombre". Estoy escribiendo un poco de $foo->foo.

echo "Él tomó algo de jugo de $jugo.";

// a partir de PHP 5.4

$arr[] = 56; // Esto es lo mismo que $arr[13] = 56;

$arr["x"] = 42; // Esto agrega un nuevo elemento a

unset($arr); // Esto elimina el array completo

// sin unset($valor), $valor aún es una referencia al último elemento: $array[3]

foreach ($array as $clave => $valor) {

$bar = new foo();

echo 'Éxito... ' . $mysqli->host_info . "\n";

$4site = 'aun no'; // inválido; comienza con un número

// Nombres de constantes correctos

// Nombres de constantes incorrectos

// Esto es válido, pero debe evitarse:

// Funciona a partir de PHP 5.6.0

const ANIMALES = array('perro', 'gato', 'pájaro');

// Funciona a partir de PHP 7

Lista completa: http://php.net/manual/es/reserved.constants.php

Directorio del fichero. Si se utiliza dentro de un include, devolverá el directorio del

__FUNCTION__ Nombre de la función.

Nombre de la clase. El nombre de la clase incluye el namespace declarado en (p.e.j.

/* en este punto, $d y $e son iguales a 6 */

derecha = += -= *= **= /= .= %= &= |= ^= <<= >>=

print "$a\n"; // muestra 3

print "$a\n"; // muestra 4

Facultad de Estadística e Informática

También podría gustarte

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Todas las demás instancias de barras invertidas // Resultado: Ha borrado C:\.?

FUNCTION Nombre de la función.