Secuencias Numéricas Usando Dos Puntos En Perl

En el lenguaje de programación perl, podríamos escribir los números del 1 al 15, usando al forma básica con un arreglo:

#!/usr/bin/perl
#Este script imprime una 
#secuencia de numeros del 1 al 15

print(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);

O bien, podríamos hacer uso de la forma más económica siguiente, usando el operador de rango ..

#!/usr/bin/perl
#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de numeros

print(1..15);

Ambos casos dan como resultado la salida

123456789101112131415

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

Ésa es, como hemos visto, la llamada al intérprete de perl, y debe ir al principio de cada script.

#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de numeros

Éstas líneas son unos comentarios, que indican de qué va el programa.

print(1..15);

Ésta línea es la parte importante del script. Un arreglo es un tipo de datos adecuado para almacenar una serie de elementos, creando así una lista. Los elementos de un arreglo son incluidos dentro paréntesis (). Dentro de ésos paréntesis, hemos escrito, en el primer programa, los números 123456789101112131415, en tanto que en el siguiente aparece 1..15. Esos dos puntos se llaman operador de rango. Éste operador funciona tomando el valor de la derecha y sumando 1 sucesivamente hasta alcanzar el valor numérico de la derecha. El siguiente script es un ejemplo de un uso distinto:

#!/usr/bin/perl
#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de numeros

print(1,2,3,4..10,11);

Cada elemento del arreglo se separa por medio de una coma. Al llegar al elemento 4, aparece el operador de rango dos puntos, a partir de ahí se imprimen sucesivamente 5,6,7,8,9 y 10.
También es posible usar el operador con literales:

#!/usr/bin/perl
#Este script hace uso del operador
#de rango .. para imprimir una 
#secuencia de valores literales

print("A", "B".."z");

y la salida de éste script es la siguiente:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

La razón de que ocurra ésto es que en el código ASCII, las letras del alfabeto se representan con números consecutivos.

Cadena de Literales en Perl: Comillas Invertidas.

No es que sean un nuevo tipo de datos. En realidad las comillas invertidas ` hacen una llamada al sistema. Lo que aparezca dentro de ellas es ejecutado por el sistema, así que debemos usar órdenes que sean reconocibles por la shell. Por ejemplo, bien podríamos listar el contenido de un directorio con el comando dir. Podríamos, incluso crear un pequeño script que apague nuestra computadora:
APAGAR LA COMPUTADORA:

#!/usr/bin/perl
#Este script apaga la computadora
#necesita ser root para lograrlo

print `shutdown -h now`;

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

Esta es la llamada al intérprete.

#Este script apaga la computadora
#necesita ser root para lograrlo

Estas dos líneas son un comentario. Se le avisa al usuario que sólo podrá apagar el sistema si es un superusuario.

print `shutdown -h now`;

Ésto es una llamada al sistema. Para comunicarnos con el sistema necesitamos escribir los comandos dentro de comillas invertidas:
`comandos `
El resultado del presente programa sería el mismo si no se incluye la instrucción print, es decir si sólo ponemos la esta línea sin print, igual hacemos la llamada a shutdown, sin embargo, es mejor hacerlo mediante print. Si usted no es root, entonces al ejecutar este programa verá un mensaje como este:

shutdown: Es necesario ser superusuario

ADVERTENCIA: si usted ejecuta este script y está trabajando como sudo, o como root, la computadora se apagará y puede perder información.
También podemos escribir un programa que presente su propio código como salida, por medio del comando cat:
UN PROGRAMA QUE IMPRIME SU PROPIO CÓDIGO FUENTE:

#!/usr/bin/perl
#Este programa imprime su propio codigo

print`cat Programa.pl`;

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

Esta línea la deben de llevar todos los programas al principio

#Este programa imprime su propio codigo

Esto es documentación del programa. Sirve solamente para que su creador, o quien modifique esto, sepa de qué trata el código.

print`cat Programa.pl`;

Desde luego, para que esto funcione, el programa debe de guardarse con el nombre Programa.pl y debe de estar en el mismo directorio. De no estar en el mismo directorio, debe nombrarse la ruta completa.
La salida, como se puede comprobar, es el mismo código del programa. Aquí se hace uso del comando cat

UN PROGRAMA QUE SE BORRA A SÍ MISMO:

#!/usr/bin/perl
#Este programa se borra a si mismo

print`rm -f Programa.pl`;

Vamos a revisar cada línea del programa:

#!/usr/bin/perl

De nuevo, esto debe ir siempre al inicio de un programa en perl. Para ser más precisos, use which perl y escriba esa dirección después de #!

#Este programa se borra a si mismo

Este es un comentario, e indica de qué se trata el script.

print `rm -f Programa.pl`;

Ésta línea borra el script con la orden rm -f Para que funcione, en Programa.pl se debe escribir el nombre del archivo que se quiere borrar.
=================================================================================
EJERCICIOS:
* Escriba un programa que liste todos los archivos con terminación .pl que tiene en su directorio (tal vez le convenga usar el comodín asterísco)
* Escriba un programa en perl que se llame a sí mismo de manera infinita. Para ver que su programa se ejecuta, imprima cada vez el mensaje «Hola!». En Unix los ciclos infinitos se terminan con la combinación de teclas Control + C
=================================================================================
ENTRADA ANTERIOR:
Cadena de Literales en Perl: Comillas Dobles

Cadena de Literales en Perl: Comillas Dobles.

Las cadenas de comillas dobles son un poco más completas que las cadenas de comillas sencillas. En particular es posible el uso de las secuencias de escape. Salvo estas secuencias, la función print imprime literalmente lo que se encuentra dentro de las comillas dobles, incluyendo saltos de línea, tabuladores y espacios en blanco. Para hacer una comparación, el programa anterior se puede escribir de la siguiente manera usando comillas dobles:

#!/usr/bin/perl
print "Su cuenta

Pan:\t\$34.45\n";
print "Fruta:\t\$45.00\n";
print "\t======\n";
print "\t\$79.45";

La ejecución de este programa imprime lo siguiente:

Su cuenta

Pan:	$34.45
Fruta:	$45.00
	======
	$79.45

================================================================================
Ahora vamos a revisar cada línea del programa:

#!/usr/bin/perl

Esta primera línea es un comentario. Los comentarios en Perl empiezan con el caracter # y terminan en el siguiente salto de línea. Pero este es un comentario especial, se incluye en todos los programas e indica la dirección del intérprete de Perl.

print "Su cuenta

Pan:\t\$34.45\n";

Estas tres líneas en realidad son una misma instrucción. Se trata de la función print. La estructura de ésta línea es:
print «cadena de caracteres»;
todo lo que aparece dentro de las comillas se imprime literalmente. Bueno, casi todo. Como se ha dicho, las secuencias de escape son caracteres especiales. En esta instrucción aparecen 2 de ellas: \t y \n. La primera es tabulador y la segunda indica salto de línea. Al terminar de imprimir, \n hace que el cursor quede justo al inicio de la siguiente línea. Todas las instrucciones print deben terminar con unpunto y coma. De lo contrario, la compilación del programa indicará error.

print "Fruta:\t\$45.00\n";

Esta es de nuevo una instrucción print. Aquí aparecen las secuencias de escape tabulador, \t, nueva línea, \n, y una nueva, \$, que imprime el signo de peso.

print "\t======\n";

En realidad toda la información que despliega este programa cabe en una instrucción print con comillas dobles. Sin embargo también es posible usar varias instrucciones print. Observe que cualquier instrucción print empieza a imprimir justo donde dejó el cursor la anterior.

print "\t\$79.45";

Esta línea marca el final del programa, todas las instrucciones deben de terminar con un punto y coma.
===============================================================================
ENTRADA ANTERIOR: Cadena de Literales en Perl: Comillas Sencillas
ENTRADA SIGUIENTE: Cadena de Literales en Perl: Comillas Invertidas

Cadena de Literales en Perl: Comillas Sencillas

Las literales de cadena en Perl son grupos de caracteres encerrados entre comillas, los cuales son tratados como un solo dato. En Perl existen tres tipos de comillas, las comillas sencillas ‘, las comillas dobles » y las comillas invertidas`.
El siguiente programa sirve para presentar una literal de cadena encerrada entre comillas sencillas. Las comillas sencillas imprimen literalmente lo que contienen. No es válido aquí utilizar secuencias de escape como \n, ya que se imprimiría literalmente \n. Sin embargo, para escribir comillas sencillas sí es posible usar el carácter de escape \. Si quisiéramos imprimir algo como ‘Hola’, se tendría que usar la forma …\’Hola\’…

#!/usr/bin/perl
print 'Su cuenta

Pan:    $34.45
Fruta:  $45.00
        ======
        $79.45';

La ejecución de este programa es:

Su cuenta

Pan:    $34.45
Fruta:  $45.00
        ======
        $79.45

Observe que los espacios y líneas en blanco también se imprimen tal cual aparecen en el código del programa.
=================================================================================
Ahora vamos a revisar cada línea del programa:

#!/usr/bin/perl

Este comentario hace referencia a la ubicación del intérprete de perl, que se encuentra en /usr/bin/perl. En unix basta con escribir en la consola which perl para saber dónde está el intérprete. Copie esa dirección en la primera línea del programa después de #!

print 'Su cuenta

Pan:    $34.45
Fruta:  $45.00
        ======
        $79.45';

En realidad esta es una sola instrucción. La función print imprime lo que se muestra a continuación. Las comillas sencillas sirven para imprimir todo lo que viene a continuación, tal cual aparece, como se ve en la ejecución.

Mostrar Archivos de un Directorio en Perl

Este programa imprime los archivos con terminación .c del directorio actual. Se hace uso de print con las comillas invertidas.

#!/usr/bin/perl
# Este programa muestra los archivos con  
# extension .c del directorio actual
# Se hace uso de las comillas invertidas
# Modificado la ultima vez el 13 de enero de 2012

print `dir *.c`

El resultado de ejecutar este programa, en mi computadora es:

binario.c     Kernighan17.c  Kernighan_ritchie_1.7.c
Hola_Mundo.c  Kernighan19.c  kernighan_ritchie_2_3.c

Secuencias de escape en Perl

El siguiente programa juega un poco con las secuencias de escape de Perl. El lenguaje tiene más secuencias que C.

 #Muestra secuencias de escape
 print("\n\aEste\b programa\nprueba \vdiversas \tsecuencias de escape\r");

Una tabla completa es la siguiente:
\a Alarma(Campana)
\b Retroceso
\e Escape
\f Salto de hoja
\n Salto de línea
\r Retorno de carro
\t Tabulador
\v Tabulador vertical
\$ Signo de $
\@ Ampersand
\% Signo de %
\nnn Número octal
\xnn Número hexadecimal
\cn Carácter de control
\l Cambia siguiente carácter a minúsculas
\u Cambia el siguiente carácter a mayúsculas
\L Cambia caracteres a minúsculas hasta encontrar \E.
\Q Cita metacaracteres a literales
\U Cambia los caracteres a mayúsculas hasta encontrar \E
\E Termina \L \U \Q
\\ Diagonal invertida

Hola Mundo en Perl

El lenguaje de programación Perl es el resultado de una suma de los lenguajes Sed y Awk junto con los Shell Scripts de Unix. Por lo tanto, fue pensado como un lenguaje para administrar sistemas operativos: editar/visualizar archivos, realizar reportes de estado, etc. Por lo mismo, hay quienes no lo llaman lenguaje de programación, sino lenguaje de scripts; sin embargo, ha evolucionado con el tiempo y es posible usarlo como lenguaje orientado a objetos y para crear aplicaciones web. Su creador es Larry Wall y su licencia es la artística de GNU. Originalmente se llamo pearl, pero ha devenido en perl. Ya que se trata de un comando Unix, entonces cualquier invocación a él se hace con minúsculas; sin embargo, para hacer resaltar el nombre, muchas personas se refieren a él como Perl. Como en todos los lenguajes, el primer programa es Hola Mundo.
La esencia de Perl es que puede ser usado para tareas simples que requerirían un código más o menos complicado en un lenguaje de programación como C. Está pensado como una utilidad poderosa de los sistemas Unix y por lo mismo, los programas cortos se ejecutan directamente desde la consola:

perl -e 'print"Hola, Mundo!\n";'

Esta es la forma más simple de escribir un Hola, Mundo! en perl.
La primera palabra invoca a perl, el cual está instalado en la mayoría de los Unix por default, la opción -e indica que deberá ejecutarse el código que aparece a continuación encerrado entre comillas sencillas.
La orden print es clara: hay que imprimir, y lo que hay que imprimir es justo lo que aparece encerrado entre comillas dobles después de print. Así pues, se imprime el mensaje «Hola, Mundo!» Pero qué es la diagonal invertida seguida de n que aparece a continuación; se trata de una secuencia de escape. Esa orden indica que, después de imprimir el mensaje, se debe colocar el promt justo al inicio de la siguiente línea. Si ese par de caracteres se suprimen, no pasa nada.
Al final hay un punto y coma. Todas las instrucciones en perl terminan con un punto y coma. En este caso particular, podría no ponerse, pero es conveniente incluirla siempre.
Con sólo teclear ENTER, aparecerá el mensaje en su pantalla

Hola, Mundo!

Sin embargo, también es posible guardar el código en un archivo y llamar al comando perl para la ejecución.

#!/usr/bin/perl
#Este es un comentario
 print("\n¡Hola, Mundo!\n");

Es necesario teclear lo anterior y guardarlo con la extensión .pl de esta manera estamos indicando que se trata de un archivo en Perl. La segunda línea es un comentario. Los comentarios documentan el programa y sirven solamente para que el programador sepa lo que el código hace. En este lenguaje, como en Shell Script, los comentarios inician con # y se prolongan hasta el próximo salto de línea. Sin embargo, Perl, al igual que los scripts incluyen en la primera línea una referencia al intérprete, que en este caso se encuentra en la dirección /usr/bin/perl Esto puede cambiar dependiendo del sistema operativo. Como norma, escriba la instrucción

$ which  perl

en una consola, y añada esa dirección al principio de sus programas a continuación de #!
La instrucción print es bastante clara; se usa para imprimir lo que viene a continuación. Bueno, casi todo; como en C y lenguajes derivados, las secuencias de escape no se imprimen, más bien sirven para indicarle al programa (en realidad a la computadora) que haga otra cosa. En particular \n indica salto de línea. Si lo omitimos, al terminar de ejecutar el programa dejará el promt justo después de Hola, Mundo, lo cual puede ser incómodo. Para compilarlo, en Unix, basta con escribir lo siguiente en la consola:

$ perl HolaMundo.pl

Lo cual produce la salida del texto

$ ¡Hola, Mundo!

=================================================================================
EJERCICIOS:
* Escriba un programa que imprima el mensaje «Bienvenido a Perl!»
* Escriba el mensaje anterior con cada palabra en una línea distinta.
* Haga los ejercicios anteriores usando una sola línea en la consola y guardando el código en un archivo.
=================================================================================
ENTRADA SIGUIENTE:
Las Secuencias de Escape en Perl