PROGRAMACIÓN DE COMPUTADORES I

SEMANA 6

1
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
ÍNDICE

Introducción .................................................................................................................................. 3
Aprendizaje Esperado ................................................................................................................... 3
Cadenas ......................................................................................................................................... 4
Comillas Simples ........................................................................................................................ 5
Comillas Dobles ......................................................................................................................... 5
Casos Especiales ........................................................................................................................ 6
Operaciones con Strings................................................................................................................ 6
Visualización de su contenido ................................................................................................... 6
Alteración de su contenido ....................................................................................................... 7
Acceso a su contenido ............................................................................................................... 9
Sentencias de Selección y Repetición ......................................................................................... 10
If...Else ..................................................................................................................................... 10
If...Elseif...Else.......................................................................................................................... 12
Switch ...................................................................................................................................... 13
Ejercicios Propuestos .................................................................................................................. 18
Bibliografía .................................................................................................................................. 18

2
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
INTRODUCCIÓN
En este capítulo nos centraremos en el uso de cadenas de caracteres al interior de nuestros
programas. Definiremos y ejemplificaremos el uso de comillas simples y dobles para este tipo
de sentencias. Abordaremos también algunos casos especiales, importantes de tomar en
cuenta al momento de programar.

Asimismo, indicaremos las principales operaciones posibles de realizar con el contenido de los
strings, tales como: visualización, alteración y acceso al mismo.

Luego, nos centraremos en las sentencias de control de Selección, observando su sintaxis y

ejemplificando su utilización, aclarando su significado dentro de la ejecución de nuestros
scripts en PHP.

Terminamos, como es costumbre en el curso, con ejercicios propuestos para la ejercitación de

esta materia.

APRENDIZAJE ESPERADO

Se espera que al final de este capítulo, el alumno sea capaz identificar las principales
sentencias de control de Selección del lenguaje PHP, así como sus diferencias de operación.
Asimismo, deberá ser capaz de reconocer la sintaxis con las que se operan las cadenas de
caracteres en un programa construido en este lenguaje, y las operaciones posibles de realizar
en la utilización de strings.

3
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
CADENAS
Una cadena o string literal es una secuencia o serie de caracteres que básicamente se
encuentran comprendidos entre determinados delimitadores, y pueden ser especificados de
cuatro maneras diferentes:

• Comillas simples (‘ ’)
• Comillas dobles (“ “)
• Sintaxis heredoc (Documento incrustado (<<< >>>))
• Sintaxis nowdoc

En este curso, por su carácter introductorio, nos ocuparemos de los dos primeros casos por ser
los de menor complejidad procedimental.

Previo a esto, vamos a hablar de cierto proceso que es muy importante considerar en algunas
líneas de código. Habitualmente un programa permite que el usuario pueda introducir cierta
información por teclado para que dichos datos sean considerados dentro del flujo del
programa. Si no tomamos los resguardos necesarios, es posible que el usuario tenga la
capacidad de introducir caracteres especiales o reservados por el lenguaje, que nos pueden
provocar problemas en tiempo de ejecución ante un posterior tratamiento del texto ingresado.
Cuando se utilizan cadenas de caracteres es muy aconsejable “escapar” dichos caracteres para
evitar problemas en la ejecución de nuestro programa.

Habitualmente, un carácter de escape es usado para solucionar el problema de la utilización de

caracteres especiales o reservados por el lenguaje, dentro de una cadena o string.

Como parte de la sintaxis de un lenguaje de programación, los caracteres de escape invocan

una determinada interpretación de los caracteres que siguen a un carácter de escape.

Por ejemplo, se puede usar la barra o slash invertido (\) para especificar caracteres que tienen
un significado especial dentro de un programa en PHP. Los caracteres especiales que podemos
encontrar en un programa con delimitadores son:

Secuencia Significado
\n Nueva línea
\r Retorno de carro
\t Tabulación horizontal
\\ Barra invertida
\$ Signo de dólar
\" Comillas dobles

4
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
 COMILLAS SIMPLES
Es la manera más simple de especificar un string, pero también es la más estricta. Para una
cadena que va encerrada entre comillas simples (' ') solamente se pueden utilizar dos
caracteres de escape que serán comprendidos y que son: "\\" y "\'".

Lo anterior es por convenio, ya que así se pueden tener expresiones tipo string en comillas
simples y/o con barras invertidas en un string, entre comillas simples. Las variables quedan
exentas de esta regla, ya que no se expandirán dentro de una cadena entre comillas simples.

Ejemplo:

<?php
echo 'Ejemplo de \'cómo escapar varias comillas\',
de poner una barra invertida delante de una comilla \\\'
o de terminar la cadena con una barra invertida\\';
?>

COMILLAS DOBLES
En caso de que se necesite incluir una gran cantidad de valores almacenados en variables y
llevarlos dentro de un string, resulta tedioso y lento hacerlo usando en forma repetida el
concatenador de cadenas (.). En este caso, es más fácil, práctico y flexible hacerlo utilizando
comillas dobles. Esto tiene el inconveniente de que se debe poner atención a más cosas al
momento de insertar símbolos especiales. Si la cadena está encerrada entre comillas dobles
(" "), las variables que estén dentro de la cadena serán expandidas (es decir, en la cadena
aparecerá el valor de la variable y no su nombre).

Ejemplo:

<?php
$nPeras = 5;
$nManzanas = 12;
$frase1 = "Tengo $nManzanas manzanas y $nPeras peras.";
$frase2 = "Tengo \$nManzanas manzanas y \$nPeras peras.";
echo $frase1 . " - " . $frase2;
?>

5
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
 CASOS ESPECIALES
Debemos además mencionar un caso especial, que lo representa el uso de comillas dentro de
comillas en una cadena de caracteres. Para esto es necesario realizar lo que ya conocemos
como “escapar el carácter”, que es nada más que anteponer un slash (/) al carácter escapado.

Como sabemos, PHP dispone de una importante y numerosa cantidad de funciones, las cuales
nos permiten realizar en forma rápida ciertas operaciones al ser invocadas dentro de la
operatoria de un programa, tema que analizaremos detenidamente en semanas posteriores.
De hecho, algunos autores indican que el verdadero poder de PHP viene precisamente de sus
funciones. Por ahora, es importante puntualizar aquellas que nos permiten trabajar con
cadenas de caracteres, y que se observan en la siguiente tabla:

Función Significado
chr(valor) Devuelve en una variable del tipo cadena el carácter de la tabla de
códigos ASCII asociado a un valor que recibe como parámetro; el valor
que se pase debe estar entre 0 y 255.
ord(cadena) Devuelve un número entero que se corresponde con el código ASCII del
primer carácter que recibe como parámetro.

OPERACIONES CON STRINGS

Variadas operaciones se pueden realizar sobre las cadenas de caracteres y su contenido. Las
principales se explican en forma detallada a continuación.

• Visualización de su contenido.
• Alteración de su contenido.
• Acceso a su contenido.

VISUALIZACIÓN DE SU CONTENIDO
Existen varias formas de visualizar el contenido de una cadena de caracteres o string, y son las
siguientes:

Echo Es la forma más usada. Su sintaxis es la siguiente:

echo "texto";
Print Es la forma más sencilla de todas y muestra una cadena de
caracteres sobre su salida estándar. No soporta ningún
formato de salida y su sintaxis varía con respecto de la
anterior forma y es:

print(cadena);
Printf(formato,[valores]); Funciona igual que el caso anterior. Se diferencia sólo en
que esta forma soporta algunos formatos para la salida,
tales como su alineación (a la izquierda por defecto), un

6
| ESTE DOCUMENTO CONTIENE LA SEMANA 6

Sprintf(formato,[valores]);
valor numérico (que indica un número mínimo de caracteres
que deben mostrarse), la cantidad de decimales y el tipo de
datos a mostrar.
Funciona igual a printf. La única diferencia es que la cadena
de caracteres resultante de aplicarle un determinado
formato, se almacena en una variable.

Los tipos de dato posibles de mostrar con el comando Printf(formato,[valores]) son:

Símbolo Significado
% Representa el propio símbolo de porcentaje.
El argumento es tratado como un número entero y es representado en
b
codificación binaria.
El argumento es tratado como un número entero y se muestra el carácter
c
cuyo código ASCII corresponde al valor.
El argumento es tratado como número entero y es representado en
d
codificación decimal, sin su parte fraccionaria.
El argumento es tratado como un número del tipo double y es representado
f
como un decimal, sin coma flotante.
El argumento es tratado como un número entero y es representado en
o
codificación octal.
El argumento es tratado y se representa como una cadena de caracteres.
s

El argumento es considerado como un número entero y es representado en

x
codificación hexadecimal, en minúsculas.
El argumento es considerado un número entero y es representado en
X
codificación hexadecimal, en mayúsculas.

ALTERACIÓN DE SU CONTENIDO
En muchas ocasiones será necesario usar funciones para modificar el formato de salida de los
strings. Existe una gran variedad de funciones empleadas para este fin, algunas de las cuales
están contenidas en la siguiente tabla:

chop(cadena); Devuelve la cadena de caracteres con los caracteres en

blanco y nueva línea eliminados.
ltrim(cadena); Elimina los blancos que aparecen a la derecha de una
cadena de caracteres.
rtrim(cadena) ; Elimina los blancos que aparecen por la derecha en una
cadena de caracteres.

7
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
trim(cadena); Elimina los blancos que aparecen a izquierda y derecha
de la cadena de caracteres.
str_pad(cadena,longitud,relleno,luga Comprueba si la longitud de un string es menor que el
r); valor indicado; si es así añade los caracteres necesarios.
El lugar para añadir puede ser:

1) str_pad_left, añade por la derecha(opción por

defecto).
2) str_pad_right, añade por la izquierda.
3) str_pad_both añade por ambos extremos.

str_repeat(caracter,numero_veces); Repite un carácter el número de veces indicado.

strtolower(cadena); Pasa toda la cadena a letras minúsculas.
strtoupper(cadena); Pasa toda la cadena a letras mayúsculas.
ucfirst(cadena); Pasa a mayúscula el primer carácter de una cadena.
ucwords(cadena); Pone en mayúsculas el primer carácter de cada palabra
de la cadena.
str_replace(subcadena1,subcadena2, Sustituye una palabra por otra dentro de una cadena.
cadena);
strtr(cadena,originales,traducidos); Traduce ciertos caracteres. Un ejemplo de ello:
$persona=strt($persona,"áéíóú","a,e,i,o,u"); de esta
forma, se cambiarían todas las vocales con acento, por
vocales sin acento.
substr_replace(cadena,nueva,comien Sustituye una porción del contenido de una cadena.
zo,longitud);

8
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
 ACCESO A SU CONTENIDO
Las siguientes operaciones nos muestran cómo podemos acceder al contenido de una cadena
de caracteres.
- strlen(cadena);
- count_chars(cadena,modo);
- substr_count(cadena,subcadena);
-strchr(cadena,caracter);
- strstr(cadena,subcadena);
- stristr(cadena,subcadena);
- strpos(cadena,subcadena);
- strrpos(cadena,subcadena);
- ord(cadena);
- substr(cadena,comienzo,longitud);
strcmp(cadena1,cadena2);
strcasecmp(cadena1,cadena2);
strncmp(cadena1,cadena2,tamaño);
strnatcmp(cadena1,cadena2);
strnatcasecmp(cadena1,cadena2);
chunk_split(cadena,longitud,separador); Toma un string y le introduce separadores a una
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
Indica el número de caracteres de un string o el
largo de la cadena.
Cuenta el número de veces que se repite un
carácter en una cadena. Tiene cinco modos
posibles:
1. Matriz indexada con frecuencia de aparición
de todos los caracteres del código ASCII.
2. Matriz con caracteres ASCII con frecuencia
mayor que 0.
3. Matriz con caracteres que no aparecen en
la cadena.
4. Cadena con caracteres usados en el código
ASCII.
5. Cadena con caracteres no usados en el
código ASCII.
Muestra la frecuencia de aparición de una cadena
determinada.
Devuelve la subcadena que comienza en la primera
aparición del carácter indicado en el argumento.
Localiza una subcadena dentro de la cadena
original.
Realiza lo mismo que la función anterior pero no
distingue entre mayúsculas y minúsculas.
Muestra la primera ocurrencia de una cadena
dentro de otra.
Muestra la última ocurrencia de una cadena dentro
de otra.
Devuelve el valor ASCII de un carácter determinado.
Extrae la porción de texto que empieza en una
posición dada y tiene una longitud determinada en
el argumento.
Compara el contenido de dos cadenas siendo
sensible a mayúsculas y minúsculas.
Compara el contenido de dos cadenas sin ser
sensible a mayúsculas y minúsculas.
Compara los N primeros caracteres de una cadena.
Compara dos cadenas de caracteres siendo sensible
a mayúsculas y minúsculas.
Compara dos cadenas de caracteres no siendo
sensible a mayúsculas y minúsculas.
distancia determinada. Esta operación no modifica
el original, sino que constituye una nueva función.
9
explode(separador,cadena,limite);
implode(separador,elementos);
parse_str(cadena);
Permite extraer desde el original un string,
obteniéndose una matriz de cadenas de caracteres.
Usando como concatenación el separador pasado
como parámetro, junta en una cadena los
elementos de una matriz.
Permite extraer y crear variables que forman parte
de una cadena que se corresponde con un "query
string" recibido de una URL.

Nota: No existe en PHP limitación alguna respecto del tamaño de una cadena de caracteres,
siendo el único límite posible la memoria disponible del computador donde sea
ejecutado el programa que la contiene.

SENTENCIAS DE SELECCIÓN Y REPETICIÓN

Como casi todos los lenguajes de programación, PHP necesita contar con herramientas del
lenguaje que le permitan al servidor tomar decisiones lógicas adecuadas. Por lo mismo, se le
debe indicar al programa qué acciones se deben realizar ante el cumplimiento o
incumplimiento, presencia o ausencia de ciertas condiciones. Este tipo de herramientas o
sentencias, como lo vimos anteriormente, se llaman Estructuras de Control. Las posibles
condicionales básicas que nos permite utilizar PHP, son las siguientes:

Selección Repetición
1 If...Else For
2 If...Elseif...Else While
3 Switch Do While

Esta semana empezaremos con las más importantes estructuras de control de Selección, para
la semana siguiente, abordar las estructuras de control de Repetición o Iteración.

IF...ELSE
Sin duda, esta es la estructura de control más utilizada en cualquier lenguaje de programación.
Es también la más básica y nos permite, como sabemos, cambiar la secuencia de ejecución de
nuestro programa ante el cumplimiento o no de ciertas condicionantes. Su significado es: IF
(Español SI) – ELSE (Español SI NO). Su sintaxis y estructura en PHP es:

10
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
 <?php
if(expresión)
{
... Sentencias-1;
}
else
{
... Sentencias-2;
}
?>

En la anterior porción de código, lo que estaríamos diciendo es que si la “expresión” se

cumple, se ejecuta Sentencias-1; en caso que no se cumpliese “expresión”, se ejecuta
Sentencias-2. O sea, sólo en este último caso, se evalúan las sentencias contenidas en el
else{…}.

Ejemplo:

<?php
$manzanas = true;
if($manzanas)
{
echo 'Hay manzanas';
}
else
{
echo 'No hay manzanas';
}
?>

En el ejemplo anterior se está asignando un valor “verdadero” a $manzanas. Luego se

comprueba si esto es cierto introduciendo la variable en la expresión condicional. Como la
hemos declarado verdadera, el resultado de la primera evaluación de la condición nos arrojará
el mensaje “Hay manzanas”, ya que la condición se cumple. Si cambiamos la declaración a
“$manzanas=false”, el resultado sería la visualización de la segunda sentencia “No hay
manzanas”, ya que la condición no se estaría cumpliendo, por lo cual se haría efectivo el
contenido de else.

11
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
 IF...ELSEIF...ELSE
Esta estructura de control posee una sintaxis muy similar a la anterior. Por lo mismo, el
ejemplo dado antes es igualmente válido en este caso.

Sintaxis/Estructura:

<?php
if(expresión)
{
... Sentencias-1;
}
elseif(expresión)
{
... Sentencias-2;
}
else
{
... Sentencias-3;
}
?>

Con esta sintaxis se debe usar un elseif. Este se ejecutará si y sólo si no produzca ninguna
respuesta afirmativa para el if o el elseif anterior. Luego que se evalúan todos los elseif y en el
caso que ninguno de ellos arroje un valor verdadero, se ejecutan las sentencias que componen
el else respectivo.

Esta estructura permite el uso de varios elseif, pero siempre y cuando estos se encuentren al
interior de una sentencia que empiece con un if y termine con un solo else.

12
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
Ejemplo:

<?php
$edad= 31;
if ($edad > 50) {
echo "Sí, $edad es mayor que 50.";
}
elseif ($edad > 40) {
echo "Sí, $edad es mayor que 40.";
}
elseif ($edad > 30) {
echo "Sí, $edad es mayor que 30.";
}
else {
echo "No, $edad es menor que 50, 40 y 30.";
}
?>

En este ejemplo la respuesta sería: Sí, 31 es mayor que 30.

Si cambiamos el valor de $edad por 29, la respuesta sería: No, 29 es menor que
50, 40 y 30.

SWITCH
La sentencia if…elseif…else nos permite seleccionar entre varias, más de dos, posibles
condiciones, que deben ser evaluadas como verdaderas o falsas. En la realidad, nos
encontraremos con muchos casos en los que debamos evaluar condicionales con estructuras
como la que a continuación se describe:

13
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
 <?php
if($variable==Valor1)
{
... Sentencias-1;
}
elseif($variable==Valor2)
{
... Sentencias-2;
}
elseif($variable==Valor3)
{
... Sentencias-3;
}else
{
... Sentencias-4;
}
?>

En este tipo de estructuras se espera que un programa ejecute una determinada acción de
acuerdo con el valor que tome una cierta variable. En estos casos, los lenguajes de
programación, en este caso PHP, disponen de una instrucción que nos permite seleccionar
entre los posibles valores que tome dicha variable y derivar la ejecución de instrucciones de
acuerdo a ese criterio. Esta instrucción se llama switch (Español SELECCIONAR).

14
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
Sintaxis/Estructura:

<?php
switch($variable)
{
case Valor1:
Sentencias-1;
break;

case Valor2:
Sentencias-2;
break;

case Valor3:
Sentencias-3;
break;
...
...
...
default:
... Sentencias-4;
}
?>

En esta estructura de control, $variable contiene el valor que será comparado en cada uno de
los case siguientes, a fin de encontrar el que corresponda al valor de la variable. Cuando esto
sucede, se ejecutan una a una y sucesivamente todas las sentencias que pertenezcan a ese
switch, hasta que se encuentre con el primer break en el camino de ejecución. En ese
momento, el programa hace un salto y se pasa en control del programa a la instrucción
inmediatamente siguiente, fuera del ciclo switch.

15
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
En caso de que ninguno de los case contengan el valor de la variable ($variable), se ejecutan
las instrucciones que siguen a default, la cual es opcional en la sintaxis de este comando, al
igual que lo es else, en la estructura anteriormente tratada.

En el siguiente ejemplo haremos un comparativo entre if…elseif…else y switch, para apreciar

sus diferencias.

Usando if...elseif...else Usando switch

<?php <?php
$var=2; $var=2;
if($var==1) switch($var)
{ {
echo '$Var es igual a 1.'; case 1:
} echo '$Var es igual a 1.';
elseif($var==2) break;
{
echo '$Var es igual a 2.'; case 2:
} echo '$Var es igual a 2.';
elseif($var==3) break;
{
echo '$Var es igual a 3.'; case 3:
}else echo '$Var es igual a 3.';
{ break;
echo '$Var no es igual a 1, 2 ni 3.';
} default:
?> echo '$Var no es igual a 1, 2 ni 3.';
}
?>

Para ambos comandos el resultado mostrado será:

$Var es igual a 2.

Si cambiamos el valor de $Var=2 a $Var=5 al momento de declarar la variable, el resultado

mostrado será:

$Var no es igual a 1, 2 ni 3.

Una diferencia notable entre if…elseif…else y switch es que en este último caso, se requiere
usar el break para abandonar el switch al terminar de ejecutarse un determinado case. Esto se
debe a que solamente se puede especificar un valor para cada case.

16
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
Ejemplo:

Usando if...elseif...else Usando switch

<?php <?php
$Var=2; $Var=2;
if($Var==1) switch($Var)
{ {
echo '$Var es igual a 1.'; case 1:
} //Se ejecutará si y solo si $Var vale 1
elseif($Var==2 echo '$Variable es igual a 1.';
OR $Var==3) break;
{
echo '$Var es igual a 2 o 3.'; case 2:
}else case 3:
{ //Se ejecutará si y solo si $Var vale 2 o 3
echo '$Var no es igual a 1, 2 ni 3.'; echo '$Variable es igual a 2 o 3.';
} break;
?>
default:
//Se ejecutará en cualquier otro caso
echo '$Variable no es igual a 1, 2 ni 3.';
}
?>

En cualquiera de los dos casos se obtendría el mensaje:

$Var es igual a 2 o 3.

En dicho caso, cuando el programa evalúe el segundo case, como no existe un break para
cambiar el flujo del programa, seguirán ejecutándose aquellas instrucciones que siguen al
tercer case, aún cuando el valor de $Var no es igual a 3.

Aún más interesante resulta el que, si borramos el break del tercer case, también se
ejecutarán las sentencias que siguen a default, por lo que el mensaje obtenido sería entonces:

$Var es igual a 2 o 3.
$Var no es igual a 1, 2 o 3.

17
| ESTE DOCUMENTO CONTIENE LA SEMANA 6
EJERCICIOS PROPUESTOS

1. Utilizando IF…ELSE o bien IF…ELSEIF…ELSE confeccione un algoritmo en pseudocódigo

que permita comparar 3 números naturales y determinar cuál de ellos es el mayor. Al
final de este algoritmo, se deberá imprimir por pantalla un mensaje indicando cuál es
el número que se obtuvo. Implemente este pseudocódigo en PHP.

2. Utilizando SWITCH confeccione un algoritmo en pseudocódigo que permita resolver el

problema anterior. Implemente este pseudocódigo en PHP.

BIBLIOGRAFÍA

1. Achour, M., Betz, F., Dovgal, A., Lopes, N., Olson, P., Richter, G., y otros. (2005).
Manual de PHP. Grupo de Documentación PHP.

18
| ESTE DOCUMENTO CONTIENE LA SEMANA 6