PHP-TUT-03 Manejo básico de datos con PHP

Facebooktwittergoogle_pluslinkedinmailFacebooktwittergoogle_pluslinkedinmail

En este artículo vamos a afrontar los conceptos básicos de la programación en el lado del servidor mediante PHP. Aprenderemos lo más básico para el manejo de datos, pares nombre-valor, tipos de datos y lo fundamental para gestionar variables y constantes.

CREAR UNA PÁGINA DINÁMICA

Vamos a crear nuestra primera página dinámica. Para ello usaremos un editor de texto plano, como el bloc de notas. No emplee ningún editor de texto RTF (tipo Word de Microsoft), ya que estos editores añaden al texto los códigos de formato y no son adecuados para la programación. El boc de notas o el VI de Linux son opciones validas, en principio, para códigos cortos y simples. Sin embargo, adolecen de muchas limitaciones. La más llamativa es que no colorean la sintaxis. Cuando tenemos un código de varios cientos de líneas, ver todo el listado en negro sobre blanco dificulta muchísimo la depuración, el seguimiento y cualquier cosa que queramos hacer. En el mercado existen editores de texto plano que reconocen la sintaxis de PHP y, según vamos escribiendo código, nos lo van coloreando, de modo que las palabras clave aparecen en un color, las cadenas literales en otro, los números en otro, etc. Estos colores son configurables, para que podamos elegir aquellos con los que nos sentimos más cómodos. De este modo, la escritura es mucho más fácil.

Existen varias alternativas; algunas son de pago y otras libres y gratuitas. Por supuesto, usaremos siempre que sea posible, estas últimas. Uno de los editores de texto para programación más empleados es el Notepad ++ que, además de ser gratis, no tiene nada que envidiar a otros de pago. Puedes descargarlo libremente en este enlace. Instalarlo es muy fácil y su uso básico es tan simple como pueda ser el bloc de notas. En un artículo aparte veremos un uso más avanzado de esta herramienta, los plugin que hay disponibles para extender sus funcionalidades, etc. De momento, lo usaremos sólo para grabar nuestros scripts PHP (lo que ya es bastante).

Abre el editor y copia (o copia desde el portapapeles) el siguiente código:

Grábalo en una carpeta dentro de la carpeta de tu disco duro que tienes definida como raíz de documentos en la configuración del servidor Apache. Si instalaste xampp, cómo vimos en un artículo anterior, la raíz de tus páginas dinámicas (lo que corresponde a localhost) es C:/xampp/htdocs/. Dentro de este directorio vamos a crear uno para este ejemplo. Lo llamaremos, digamos, prueba_1, y el archivo que acabamos de teclear lo grabamos con el nombre index.php, de modo que la ruta completa en disco a este archivo será C:/xampp/htdocs/prueba_1/index.php. Esta manera de organizar los scripts, en directorios, según el proyecto al que pertenezcan, es muy útil, e imprescindible a la hora de trabajar “en serio”, así que mejor que cojamos buenas costumbres desde el principio.

Fíjate en el código. Está acotado entre las etiquetas <html> y </html>. Dado que, después de todo, es un documento web, se va a mostrar en un navegador. Y los navegadores interpretan código HTML, no PHP. Ahora mira que el código PHP para el servidor está comprendido entre <?php y ?>. Estas etiquetas se usan para delimitar el comienzo y el final de las instrucciones que se deben ejecutar en el lado del servidor.

Vamos a ejecutar la página. Para ello, abrimos el navegador y tecleamos, en la barra de direcciones, lo siguiente:

http://localhost/prueba_1/index.php

Como alternativa, podríamos haber escrito, simplemente http://localhost/prueba_1/. Cuando, en la barra de direcciones indicamos una ruta, Apache busca, automáticamente, un documento con el nombre index.php, o index.html, o default.php o default.html. Si lo encuentra, lo procesa directamente. Si no tenemos un documento con uno de esos nombres, o bien queremos cargar específicamente otro documento, con un nombre diferente, entonces SÍ deberemos especificar el nombre del documento en la barra de direcciones.

Esta forma de abrir una página alojada en tu equipo local quizá te resulte un poco chocante. Si has estado trabajando hasta ahora con páginas estáticas estás acostumbrado a abrirlas haciendo doble clic sobre el icono. El navegador se abre y carga la página solicitada. Esto ya no nos sirve. Recuerda que una página con código dinámico se interpreta en el servidor y es éste el que envía el resultado al navegador (enseguida veremos ese proceso). Aunque sólo tengas un equipo físico, has montado en él una Red y, realmente, estás trabajando en una arquitectura cliente-servidor. Te ruego que me disculpe por insistir en este concepto, pero es de vital importancia para comprender la naturaleza de lo que estamos haciendo.

Vamos a analizar, por tanto, lo que hemos tecleado en la barra de direcciones. En primer lugar hemos tecleado http://, tal como ocurre cuando nos conectamos a Internet y llamamos a una página que está situada en un servidor remoto. Esta secuencia le está diciendo al navegador que nos vamos a conectar a una página que tiene que transmitirse, desde el servidor correspondiente, mediante el protocolo de transferencia de hiper-texto (Hyper Text Transfer Protocol). Este es uno de los protocolos más normalizados para la transferencia de documentos web entre el servidor (en este caso, Apache) y el cliente (el navegador web).

A continuación encontramos la palabra localhost. Cuando te conectas a Internet, en este punto tecleas www., lo que le indica al navegador que el documento que quiere cargar está en la Red de Redes (World Wide Web). Entonces el navegador ya sabe que tendrá que conectarse a los DNS para obtener la IP del documento solicitado. Al teclear localhost, le estamos diciendo al navegador que debe conectarse al servidor que tiene instalado en modo local. El navegador no necesita, por tanto, recurrir a los DNS; ya “sabe” que la IP de localhost es 127.0.0.1. Realmente quien “sabe” esto es el sistema operativo del ordenador, pero este último detalle no cambia nada respecto al funcionamiento. A continuación, en la barra de direcciones tecleamos /prueba_1/. Esta es el subdirectorio (dentro del directorio que actúa como localhost) donde se encuentra el documento que nos interesa. Una vez tecleada la dirección, pulsa INTRO y se te cargará la página.

Haz clic con el botón derecho sobre la página y, a continuación en Ver código fuente de la página..., o pulsa la combinación de teclas CTRL - U, para ver el código fuente de la página. Lo que se obtiene al abrir el editor de texto predeterminado por el navegador es parecido al código que hemos tecleado, pero no exactamente igual:

<html>
    <body>
    Mi primera página en PHP.
    </body>
</html>

Veamos qué ha ocurrido. Cuando el servidor lee la página y se encuentra con etiquetas HTML, tales como <html> o <body>, no las procesa de ningún modo, sino que se limita a enviarlas, tal como están, al navegador. Así mismo, tampoco efectúa ningún proceso específico con el contenido de estas etiquetas. De igual modo no lleva a cabo ninguna acción con un código de script que deba ser interpretado y ejecutado en el lado del cliente como, por ejemplo, JavaScript. Pero cuando encuentra código delimitado por <?php y ?> la cosa cambia. El servidor “sabe” que ese es un código que debe pasarle al intérprete de PHP. Éste lo recibe, lo interpreta, obtiene un resultado y se lo devuelve al servidor quien, a su vez, lo pasa al navegador. Al principio puede que este proceso le parezca un poco complejo, pero es más sencillo de lo que parece, sobre todo porque es totalmente transparente al usuario. Cuando solicitamos al navegador una página dinámica éste nos la muestra, y ya está. El usuario no tiene por qué saber lo que ocurre “al otro lado de los cables”.

En nuestro ejemplo tenemos una única instrucción de PHP:

echo "Mi primera página en PHP.";

La instrucción echo se emplea para mostrar información en pantalla. La instrucción, como la mayoría de las instrucciones en PHP, acaba en punto y coma. En su momento volveremos sobre este particular. Lo que se envía a la pantalla es una cadena de texto que debe ser volcada tal cual, por lo que la hemos encerrado entre comillas. Las comillas delimitan la cadena, pero no aparecerán en pantalla, porque no forman parte de ella.

El intérprete PHP toma la instrucción y genera un código HTML que muestra el texto en pantalla. Cuando, en HTML, queremos que aparezca un texto en la página, simplemente lo incluimos dentro de la misma. Pues eso es, exactamente, lo que ha hecho el intérprete de PHP.

Por último, la página HTML generada es enviada, por el servidor, al navegador, y eso es lo que obtenemos al ver el código fuente: un documento HTML creado a partir del código PHP. Píensalo un momento. Empleando esta técnica tendremos la ventaja de que los usuarios no tendrán acceso al código fuente de nuestras páginas, sino sólo al resultado final del mismo. No es, desde luego, el mejor modo de ocultar nuestro trabajo, pero es un comienzo.

Decía hace un momento que las instrucciones de PHP deben acabar en punto y coma (;). En el caso del ejemplo que hemos visto no tiene demasiada importancia, porque sólo hay una instrucción PHP. Cuando el intérprete ve el final del código, sabe que la instrucción ha terminado y no pasa nada. Pero ahora piensa en el listado error.php que aparece a continuación. Fíjate en que he “olvidado” (esta vez a propósito) el punto y coma al final de la primera instrucción.

Al tratar de ejecutar esta página obtenemos un enorme montón de nada (en realidad, un mensaje de error). No se ejecuta la página, sino que se desencadena un error. Este es el más común de los errores que se cometen al transcribir código PHP. Afortunadamente es fácil de localizar y solventar.

A la hora de incluir código PHP en nuestras páginas dinámicas podemos hacerlo de tres maneras diferentes. Yo lo he incluido entre las etiquetas <?php y ?>. Éste es el modo elegido por la mayoría de los webmasters. Es el que yo siempre uso y el que veeremos en todos estos artículos. Existe un modo abreviado, usando las etiquetas cortas <? y ?>. Sin embargo, para que este sistema funcione es necesario activar una directiva en el fichero de configuración del intérprete (en su momento publicaremos un artículo a este respecto). Por último, existen las etiquetas de script, para delimitar el código PHP, colocándolo entre <script language="php"> y </script>. No me gustan, porque al revisar el código pueden inducir a error, pues se parecen a las etiquetas de JavaScript.

INICIACIÓN A LAS VARIABLES

Las variables, también llamadas pares nombre-valor, desempeñan en PHP un papel similar al que tienen en otros lenguajes de programación, tales como JavaScript: el almacenamiento temporal, en memoria, de datos que, en principio, se usarán para efectuar cálculos o para ser devueltos al usuario como resultados. Las variables en PHP no necesitan, a diferencia de otros lenguajes, ser declaradas específicamente. Cuando se inicializa una variable, es decir, cuando se le asigna su primer valor, se inicializa de forma automática. Esto quiere decir que el intérprete determina qué cantidad de memoria será necesaria para dicha variable, según el valor que se le haya asignado, y la reserva. En PHP los nombres de las variables van precedidos por el símbolo del dólar ($). Así pues, la forma correcta de asignarle a un nombre de variable un valor es escribir el signo del dólar, el nombre de la variable, el operador de asignación, el valor que se le asigna a esa variable en ese momento y el punto y coma, así:

$nombreDeVariable = valor;

Por ejemplo, las siguientes asignaciones serían perfectamente válidas:

$edad = 38;
$nombre = "José";
$clave = "miClaveDeAcceso";

Observa que a la izquierda del operador de asignación aparece el nombre de la variable, precedido, como es preceptivo, por el guarismo $. A la derecha del operador aparece el valor que se le asigna a la variable. En el primer ejemplo se trata de un valor numérico, que aparece tal cual. En los otros dos ejemplos es una cadena alfanumérica, que debe teclearse entre comillas. Las comillas se usan para delimitar cadenas alfanuméricas, pero no forman parte de estas, de modo que, al recuperar el valor de las dos últimas variables, las cadenas aparecerán sin las comillas. Para recuperar el valor de una variable podemos incluir su nombre en la instrucción echo que vimos en el apartado anterior. Observa el listado mostrarDatos.php:

Observando una vez más el código que se ha cargado en el navegador, encontramos lo siguiente:

<html>
<body>
38<br />
José<br />
miClaveDeAcceso
</body>
</html>

Así vemos, de nuevo, que lo que el navegador recibe, en última instancia, no es más que código HTML.

Nuestro código funciona como esperábamos. Crea unas variables, les asigna unos valores y, mediante la instrucción echo, devuelve esos valores para que sean mostrados en la página. Pero es un código bastante engorroso. En el listado de la página hemos incluido tres bloques de PHP para realizar algo muy sencillo. Si esto es así con esta página, uno podría pensar que para un resultado más sofisticado y útil necesitaríamos muchísimos bloques de PHP. Y todo porque entre un resultado y otro hemos necesitado intercalar el tag <br /> de HTML para que los datos nos aparezcan en tres líneas en la página. Parece que eso de intercalar código HTML en una página dinámica es un engorro. Nos obliga a estar abriendo y cerrando el código PHP a cada momento.

Los diseñadores de PHP captaron esta cuestión enseguida. Después de todo, si PHP se creó para programar páginas web, y el navegador sólo entiende los lenguajes de cliente, como son HTML y JavaScript, debía de haber un buen nivel de integración entre éstos y aquél. En realidad, dicho nivel es mucho más alto de lo que vamos a ver aquí, tal como iremos viendo según avance en el estudio de la programación dinámica. De momento, baste saber que PHP permite incluir etiquetas de HTML como si fueran cadenas. Al crear el código que se va a enviar al navegador, el intérprete inserta estas etiquetas de la forma apropiada. Así pues, el ejemplo anterior podría quedar como se ve en el listado mostrarBR.php a continuación:

El resultado es el mismo, pero con menos líneas de código. Y, ya que estamos con eso de optimizar el código (es decir, obtener el resultado deseado con un código lo más breve y claro posible), hablemos del operador de concatenación. A la hora de asignar o mostrar resultados podemos usar un punto (.) para que PHP ponga un resultado a continuación de otro. Lo verás más claro en el ejemplo del script encadenaBR.php, que aparece a continuación:

Ejecuta esta página y verás que el resultado es el mismo. Si a eso vamos, podríamos haber puesto las tres salidas en una sola línea, así:

echo $edad."<br />".$nombre."<br />".$clave;

Mediante el operador de concatenación se puede optimizar bastante el código. En realidad el límite de cuántos valores podemos concatenar viene dado por la claridad del código. Si formamos una serie de valores demasiado larga el código resultará menos legible.

NOMBRES EN PARES NOMBRE-VALOR

Hemos visto que para crear una variable (un par nombre-valor) es necesario asignarle un nombre por el que luego será identificada cuando la necesitemos (en breve empezaremos a ver qué podemos hacer con las variables). Este nombre debe ir siempre precedido del signo $. Es un error muy frecuente olvidar este signo, sobre todo si estás habituado a otros lenguajes de script, como JavaScript, que, normalmente, no lo emplean. Esto es causa de errores frecuentes al principio que, afortunadamente, son fáciles de encontrar.

Además, es necesario tener otros detalles en cuenta. Por ejemplo, los nombres de las variables son sensibles al uso de mayúsculas y minúsculas. Podemos ver esto en el script mayusVariables.php, que muestra cómo dos variables, cuyo nombre sólo difiere en el tipo de letra, pueden almacenar dos valores distintos.

El uso indiscriminado de mayúsculas y minúsculas siempre acaba dando problemas. Los programadores solemos escoger un criterio para construir los nombres de variables, de modo que si lo seguimos siempre no tendremos problemas con esto. Yo tengo dos criterios básicos: o bien uso el formato llamado semi Camel Cased, que consiste en poner en mayúscula la primera letra de cada palabra, excepto de la primera, así: $variableParaElNombre. El otro criterio que empleo en ciertos códigos es escribir todas las palabras del nombre en minúsculas, separadas por guiones bajos, así: $variable_para_el_nombre. Tú deberás escoger uno o dos criterios, y seguirlos siempre que puedas, para evitar errores.

Al ejecutar el script anterior verás que cada una de las variables almacena y conserva un valor diferente. Sin embargo, no es buena práctica crear nombres de diversas variables que sean iguales excepto por la capitalización de las letras empleadas, ya que induce a confusión.

Otro aspecto que debes tener en cuenta es que no se deben usar palabras reservadas (nombres de instrucciones, funciones, etc.) como nombres de variables. En realidad esto no es ningún problema si eres hispano parlante, ya que los nombres que le asignes a tus variables serán palabras en español, o adaptaciones de éstas, y las palabras reservadas son todas del idioma inglés. Cabe suponer que para un anglo parlante esto debe ser más complicado. Los nombres de variables deberán empezar, detrás del signo $, con una letra o un guión bajo, no con un número, aunque pueden tener números dentro del nombre, cómo por ejemplo, $estado_3. Tampoco debes incluir en los nombres de variables ningún signo de puntuación, ni letras acentuadas, ni letras de alfabetos locales, tales como la ñ o la ç, ni espacios en blanco. Sólo letras del alfabeto inglés.

A la hora de crear una variable no tiene mucho sentido asignarle un nombre como $variable_1, o similar. A menos que poseas una memoria prodigiosa, es casi preceptivo asignarles nombres lógicos que nos den una referencia acerca de la utilización que se les va a dar a esas variables en el código. Si observas los listados que hemos visto en este artículo, y los que veremos en otros, comprobarás que cada variable tiene asignado un nombre coherente con su uso.

GESTIÓN BÁSICA DE DATOS

Dentro de las variables se almacenan datos. Éstos pueden ser de varios tipos. En principio, vamos a manejar datos numéricos, que se pueden emplear para llevar a cabo operaciones aritméticas y/o lógicas, y datos alfanuméricos, o de cadena. Además, podemos emplear matrices y objetos (hablaremos de ambos en posteriores artículos).

Cuando a una variable se le asigna un valor numérico, éste se pone, tal cual, a la derecha del operador de asignación, tal como se ve en los ejemplos anteriores y en la línea siguiente:

$edad = 38;

Con las variables que contienen valores numéricos se pueden hacer operaciones aritméticas, desde las más simples a las más complejas. El script operacionesBasicas.php nos muestra unos breves ejemplos sencillos:

La mayoría de las operaciones que hemos realizado en este código son operaciones que realizamos, a nivel doméstico, con una calculadora de bolsillo, todos los días (sumas, restas, divisiones, etc.). Sí quiero puntualizar un par de detalles. El operador de la multiplicación es el asterisco *, y el de la división es la barra inclinada a la derecha, conocida como slash /.

Hay, no obstante, un par de operadores con los que, quizás, no estés familiarizado. Observa las dos últimas líneas del código y del resultado. Se trata de los operadores de incremento (++) y de decremento (--). Estos operadores se aplican sobre una variable para incrementarla o decrementarla, respectivamente, en una unidad. A su vez cada uno de estos operadores puede aplicarse antes del valor original o después del mismo, conociéndose como operador de pre-incremento o pre-decremento (si es aplicado antes) o de post-incremento o post-decremento (si es aplicado después). El comportamiento es diferente en ambos casos. Vamos a aclarar esto. Mira el siguiente fragmento de código:

$valorInicial = 7;
$valorFinal = ++$valorInicial;

La variable $valorInicial es declarada con un valor de 7 en la primera línea. En la segunda, se realiza un pre-incremento. Esto quiere decir que primero se incrementa $valorInicial en una unidad, con lo que pasará a valer 8. Después se realiza la asignación a $valorFinal, con lo que esta valdrá, también, 8. Ahora mira estas líneas:

$valorInicial = 7;
$valorFinal = $valorInicial++;

La primera línea funciona igual que en el caso anterior, declarando una variable y su valor. La diferencia está en la segunda línea. En este caso hemos empleado el operador de post-incremento. Lo que ocurre es que primero se realiza la asignación, con lo que $valorFinal pasará a contener el valor 7, y después se lleva a cabo el incremento, con lo que $valorInicial pasará a valer 8, pero ya no se modifica $valorFinal, que sigue conservando el 7. Con los operadores de decremento el funcionamiento es idéntico, sólo que, en lugar de añadir una unidad, se resta. Como ves, estos operadores son muy cómodos de usar, cuando queremos añadir o restar una unidad a un valor. Pero veamos cómo hacerlo para añadir o restar mayores cantidades. Por ejemplo, supongamos que quieres incrementar un valor en tres unidades. Puedes hacer lo siguiente:

$variable = $variable + 3;

Desde el punto de vista matemático esta sentencia puede parecer un despropósito, pero no lo es en informática. No olvides que el operador = es de asignación. Así pues, esta sentencia dice: “Toma el valor almacenado en $variable, increméntale tres unidades y coloca el nuevo valor en $variable, de forma que, tras ejecutar la sentencia, valga tres unidades más de lo que valía antes”. Esto mismo puede hacerse de forma simplificada, así:

$variable += 3;

Siempre que vayas a incrementar una variable en varias unidades puedes usar la notación simplificada que acabamos de exponer. Esta notación también puede emplearse para otras operaciones comunes, tal como se muestra en los siguientes ejemplos:

$variable -= 3;
$variable *= 5;
$variable /= 4;
$variable %= 2;

Además, los valores numéricos permiten otras operaciones de las que hablaremos en posteriores artículos. Con las cadenas podemos llevar a cabo varias acciones, tales como extraer subcadenas, cambiar la capitalización, etc. De momento quiero ampliar un concepto al que ya nos hemos asomado: la concatenación mediante el operador punto (.). Se pueden concatenar cadenas tanto en la asignación de variables, como en la recuperación de los valores por pantalla. Es decir, los siguientes fragmentos de código funcionan de igual forma:

$nombre = "José ";
$apellido = "López";
echo $nombre.$apellido;

El resultado es el mismo que si escribimos:

$nombre = "José ";
$apellido = "López";
$nombreCompleto = $nombre.$apellido;
echo $nombreCompleto;

Quiero insistir (por última vez) en que los valores que son cadenas alfanuméricas deben ir limitados por comillas. Estas comillas no saldrán luego al recuperar el valor. Podemos usar comillas simples o dobles siempre que la comilla del principio de la cadena sea del mismo tipo que la comilla del final de la misma.

Los tipos de datos que contempla PHP son los siguientes:

  • integer. Son datos de tipo numérico entero.
  • double. Son datos numéricos en coma flotante (manejo de decimales).
  • string. Son cadenas alfanuméricas.
  • boolean. Son valores de tipo Verdadero o Falso. Se obtienen al evaluar una condición, el estado de una variable, etc.
  • array. Son matrices (hablaremos de ellas en un artículo posterior).
  • object. Los objetos son estructuras complejas de las que hablaremos en un artículo posterior.
  • class. Las clases son los “moldes” con los que se crean los objetos. Hablaremos de ello en un artículo posterior.
  • NULL. Es el tipo de una variable a la que aún no se le ha asignado valor alguno.

En este apartado hemos visto que hay distintos tipos de valores que se pueden asignar a las variables. Algunos ya los hemos conocido, aunque sea por encima, como es el caso de las cadenas y los valores numéricos. Otros los iremos conociendo según necesitemos de su uso para continuar aprendiendo. Lo que sí necesitamos saber ahora es cómo manejar los tipos de datos para adaptarlos a nuestras necesidades en cada caso. Más adelante ya veremos para qué nos puede ser útil esto.

Antes de continuar con este tema quiero hacer un inciso para comentar la precedencia de operadores. Cuando PHP encuentra una operación aritmética en la que intervengan varios operadores, ejecuta primero los productos y las divisiones y luego las sumas y restas. Así pues, supongamos que escribimos la siguiente sentencia:

$valor = 3 + 2 * 5;

El resultado será 13. Primero se calcula el producto de 2 * 5, que es 10, y luego se le suma 3. Podemos romper la precedencia natural de los operadores mediante el uso de paréntesis. Por ejemplo:

$valor = (3 + 2) * 5;

En este caso, primero se efectúa la suma de 3 + 2, lo que da 5. Luego se realiza el producto, con lo que se obtiene 25.

GESTIONAR TIPOS DE DATOS

PHP nos permite conocer el tipo de dato que hay almacenado en una variable, mediante la función gettype (). Mira el script obtenerTipo.php, que aparece a continuación:

Ejecútalo para ver el resultado. Cómo ves, creamos algunas variables, les asignamos valores y luego, mediante la función gettype () determinamos qué tipo de datos contienen. Observa que esta función no muestra el valor que tiene la variable (eso hemos tenido que hacerlo aparte), sino el tipo de dato que es. Si una variable no está declarada no contiene ningún valor, por lo que el tipo de dato es NULL.

PHP nos proporciona otra función relacionada con el tipo de dato que contiene una variable. La función settype() permite modificar este tipo de dato, con ciertas limitaciones, como veremos a continuación. Observa el script cambiarTipo.php (he omitido las etiquetas HTML del principio y del final para facilitar la lectura del código).

Convertimos una variable de tipo double a integer, con lo que se trunca la parte fraccionaria. Pruébalo para ver como tira.

La función settype () recibe dos argumentos separados por una coma. El primero es la variable cuyo valor queremos cambiar de tipo. El segundo es el nombre del tipo de dato que le asignaremos, encerrado entre comillas. El nombre de los tipos de datos se corresponde con los que aparecen en la lista que he escrito anteriormente. Sin embargo, éste no es el único efecto de este tipo de conversión. Observa el script cambioAEntero.php:

Dos cosas: en primer lugar, al ser el valor de la variable muy grande aparece como notación exponencial. Por otra parte, al convertir el valor a integer el resultado es 0. Esto es porque los datos de tipo integer no pueden almacenar valores tan grandes como los de tipo double, ni siquiera eliminando la parte fraccionaria. Pruébalo y quédate con la copla, para andar con cuidado con esto.

Podemos convertir un valor numérico a una cadena. Mira el script cambioACadena.php.

Cuando ejecutes esta página verá que el valor que se muestra en la segunda línea es, aparentemente, el mismo que en la primera. Sin embargo, después de la conversión a tipo string la variable ya no contiene un valor numérico, sino una cadena.

Lo que también podemos hacer es convertir una variable de tipo cadena a tipo numérico. Observa el script cambioADoble.php.

También puede cambiarse el tipo de dato de una variable mediante lo que se conoce como casting. Consiste en anteponer el tipo deseado, entre paréntesis, antes del nombre de la variable. Por ejemplo, mira el listado casting.php, que aparece a continuación:

El resultado de ejecutar esta página será el siguiente:

La variable vale: 3402.34, y es de tipo: double
Ahora vale: 3402, y es de tipo: integer

Como ves, se ha cambiado el tipo de la variable a integer, truncándose, como es lógico, la parte fraccionaria.

EXPANSIÓN DE VARIABLES

PHP tiene una cualidad específica en el manejo de las variables. Cuando, en una cadena, se incluye el nombre de una variable (con el signo dólar incluido) el intérprete incluye el valor de dicha variable en lugar de su nombre. Observa el script expansion.php.

El nombre de la variable está dentro de la cadena, por lo que cabría pensar que PHP va a reproducir ese nombre tal cual lo hemos escrito. Al menos así actúan otros lenguajes de script que circulan por el mundo, como es el caso de JavaScript, VBScript, etc., así como otros lenguajes de programación, como Java, Visual Basic, etc. Sin embargo, PHP interpreta la variable y lo que incluye en la cadena es el valor correspondiente. Ejecútalo para verlo .Esta característica de PHP se conoce con el nombre de expansión de variables. En ese caso, ¿cómo podemos hacer que el nombre de una variable, incluyendo el signo dólar, se muestre tal cual, como parte de la cadena? Bien. Podemos delimitar la cadena completa mediante comillas simples, en lugar de comillas dobles, tal como se ve en el script comillaSimple.php.

Otra alternativa para lograr lo mismo es lo que se conoce como escapar un carácter. Consiste en añadirle a un carácter determinado un contraslash, o barra inclinada inversa, que anula el efecto de dicho carácter. En este caso se lo añadiríamos al carácter dólar del nombre de la variable, como aparece en el script escaparDolar.php.

Quizás la solución más empleada cuando se necesita obviar la expansión de variables sea ésta última, ya que el uso de comillas simples solemos reservarlo para otros fines que estudiaremos más adelante. En ambos casos el resultado de la ejecución del script es el mismo, cómo puedes comprobar en tu propio ordenador. Escapar un carácter ofrece más posibilidades. Aquí tenemos una tabla con la lista de los caracteres escapables más comunes.

CARÁCTER SIGNIFICADO
\n Nueva línea
\r Retorno de carro
\t Tabulación horizontal
\$ Singo $
\’ Comilla simple
\” Comilla doble
\\ Contraslash

Para ver un ejemplo, supongamos que quieres incluir unas comillas dobles dentro de una cadena alfanumérica. Tal vez pienses, a priori, en algo como lo siguiente:

$cadena = "Aquí hay alguien que dice "Hola".";

Sin embargo esto no funcionaría, ya que al encontrar el intérprete la segunda comilla doble (la que está delante de la H de Hola) se considera que la cadena termina ahí. El resto de lo que hemos escrito no es interpretable por PHP y genera un error. Sin embargo, podemos solucionarlo escapando las dos comillas dobles que hay dentro de la cadena (las que delimitan la palabra Hola), así:

$cadena = "Aquí hay alguien que dice \"Hola\".";

Como ves, he añadido un contraslash delante de cada uno de los caracteres que deseo escapar. Otra alternativa es el llamado anidamiento de comillas. Consiste en usar comillas simples en el interior de la cadena, así:

$cadena = "Aquí hay alguien que dice 'Hola'.";

Si lo que deseas es que aparezcan comillas dobles dentro de la cadena puede delimitar esta con comillas simples, para poder hacer anidamiento, así:

$cadena = 'Aquí hay alguien que dice "Hola".';

Sin embargo, voy a desaconsejarte esto último. Acostúmbrate a delimitar las cadenas con comillas dobles, como norma. Si quieres incluir otras comillas dobles en la cadena, escápalas.

MÁS SOBRE MANEJO DE VARIABLES

PHP incluye otras funciones para el manejo básico de variables. En primer lugar, tenemos la función isset (), que nos permite determinar si una variable concreta tiene ya un valor asignado o no. Esto es especialmente útil en procesos de depuración de scripts. Durante la corrección de los mismos se puede comprobar si hay contenido en una variable para rastrear posibles errores. La función isset () recibe como argumento el nombre de una variable y devuelve un valor de tipo booleano, es decir, true (verdadero) o false (falso). Cuando hablemos de condicionales veremos la utilidad de este tipo de valores. Para ver en la práctica el comportamiento de isset () observe el script variablesEstablecidas.php.

Pruébalo para ver el resultado y compararlo con el código. Observa una cosa curiosa. Los valores de tipo false no son mostrados en la página y los valores true aparecen como un 1. Esto puede resultar un poco confuso al principio, pero PHP los evalúa y maneja perfectamente. Si queremos ver el auténtico resultado booleano podemos usar la función var_dump(), que nos muestra el contenido de una expresión “tal cómo es” en realidad, cómo vemos en verContenidoReal.php:

También contamos con la función unset (), destinada a eliminar el contenido de una variable. Mira el script variablesEliminadas.php:

Observa el resultado cuando la variable ha sido eliminada en tu navegador. Se nos informa que el tipo de variable es NULL.

La función empty () tiene un efecto similar a isset (), pero con el resultado opuesto, es decir, devuelve un true booleano si la variable no tiene ningún valor. En caso contrario devuelve un resultado false. Lo ves si ejecutas el script variablesVacias.php.

Las funciones is_integer (), is_double () e is_string () reciben como argumento el nombre de una variable, y nos devuelven un valor booleano (true o false) dependiendo de que la variable sea un número entero, un número en coma flotante o una cadena, respectivamente. Sin embargo, para determinar el tipo de dato que contiene una variable podemos usar, en la mayoría de los casos, la función gettype(), vista anteriormente.

VARIABLES DE VARIABLES

PHP puede reconocer y manejar variables que se refieran a otras variables. Se trata de variables cuyo contenido es el nombre de otras variables. Esto resulta especialmente útil cuando se quiere crear código dinámico, basado en ciertas condiciones establecidas por los usuarios de nuestras páginas. Por ejemplo, supongamos que necesitas crear un mensaje de saludo que pueda aparecer en español o en inglés (podríamos ponerlo en más idiomas, por supuesto, pero se trata de un ejemplo sencillo). Puedes almacenar los dos saludos en variables de memoria y luego mostrar el que convenga, como muestra el script variablesVariables.php:

Ejecuta el script para ver el resultado y veamos que ha ocurrido. En primer lugar fíjate en que tenemos una variable llamada $saludo, cuyo contenido varía durante la ejecución del script y otra, llamada $saludoParaMostrar, cuyo contenido es el nombre de la anterior, sin el signo $. Cuando queremos recuperar el contenido de $saludoParaMostrar debemos anteponer un doble signo de dólar, tal como se ve en las dos líneas con echo. De este modo, el intérprete recupera el contenido de la variable $saludo. Así pues, $saludoParaMostrar está actuando como un puntero a $saludo, y se actualiza en tiempo real. Por supuesto, en este ejemplo no es muy útil. Está diseñado, únicamente, para ilustrar el funcionamiento de esta técnica. Sin embargo, cuando se manejan cookies, bases de datos, ficheros de disco, etc., resulta muy práctica para simplificar el código del script. Yo he escrito scripts en PHP que ahorran hasta un 15% de código mediante el empleo de esta técnica, y en sucesivos artículos la emplearemos con frecuencia.

CONSTANTES

En ocasiones es necesario crear y utilizar pares nombre-valor cuyo contenido va a permanecer inmutable durante toda la ejecución del script. Por ejemplo, supongamos que queremos almacenar el valor de Pi (3.1415927) para efectuar distintos cálculos aritméticos. Este valor no cambia nunca. Para esta finalidad empleamos constantes, que se crean mediante el uso de la función define (). Esta recibe dos argumentos separados con una coma. El primero es el nombre de la constante y el segundo es su valor. Lo vemos en el script constantes.php.

Al ejecutarlo verás que en la página aparece el valor de la constante definida. Cuando se define una constante no se puede modificar su valor en ningún punto de la ejecución del script. Por eso se les llama constantes. Si intentamos redefinirla obtendremos un error, por lo que deberemos tomar buena nota de las constantes ya definidas.

Al igual que ocurre con las variables, el nombre de las constantes es sensible a las mayúsculas y minúsculas, por lo que, por ejemplo, Pi no es la misma constante que pi.

Si queremos determinar si una constante está definida en algún punto concreto del script (por ejemplo, a efectos de depuración) podemos usar la función defined (), que recibe como argumento el nombre de la constante (entre comillas) y nos devuelve un valor booleano (true o false). Podríamos usar algo así:

var_dump (defined ("Pi"));

El uso de constantes puede simplificar algunas acciones que quieras realizar en tus páginas. Por ejemplo, si quieres establecer un color de letra determinado que se aplicará a ciertas palabras o frases del texto para destacarlas y llamar la atención del usuario. Puedes definir el color en una constante, como en el siguiente ejemplo:

define ("colorDestacado", "#FF0000");

Como ya sabemos que desde PHP se pueden incluir etiquetas de HTML (en muchos de los ejemplos anteriores hemos incluido la etiqueta <br /> en varias ocasiones) cuando, en otra parte del código, necesitemos usar el color que destaque el texto incluiremos en la página lo siguiente:

<?php
    echo "<font color=".colorDestacado.">";
?>

Esto tiene la ventaja de que la constante sólo es necesario definirla una vez en todo el script, con independencia de cuántas veces se utilice. Lo lógico es definirla al principio del script. Así, si en algún momento decides que no te gusta el color que has empleado en las palabras destacadas y quieres emplear otro, sólo debes cambiar una línea de código (aquella en la que se define la constante). Quiero que te fijes en algo que, seguramente, te habrá llamado la atención. Al usar una constante no se antepone, en ningún caso, el signo $, como hacemos con las variables. Las constantes y las variables constituyen dos categorías completamente diferentes de pares nombre-valor, de modo que PHP permite que exista una variable y una constante con el mismo nombre en el mismo script y las reconoce como dos datos diferentes. Sin embargo, yo desaconsejo esta práctica, por razones de claridad. Es muy fácil cometer errores con esto.

     

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *