man perlfunc, comandos de PERL

Las así llamadas «builtin functions» son los ‘comandos’ normales del perl, que aceptan argumentos, hacen algo a nivel de argumentos o de sistema, y devuelven valores. Para informaciones más precisas consúltese «man perlfunc».
Muchas funciones no tienen necesidad de argumentos entre (), pero en las operaciones más complicadas los paréntesis son necesarios para aclarar qué se refiere a qué. Normalmente, por tanto, los () se evitan en las líneas más simples, como print $bleah; pero tienen que incluirse cuando se invoca más de una función en la misma declaración.

Las declaraciones en perl terminan siempre con el signo ;

Funciones (en orden alfabético):

• atan2 Función matemática: restituye el arcotangente de un valor. Ahí se puede también encontrar con

  sub tan { sin($_[0]) / cos($_[0]) }

• binmode Abre un file en la modalidad binaria; tiene que ser invocado después de ejecutar open (que abre el file):

  open (FILE, file.bin);
  binmode FILE;

• chdir Cambia el directorio de trabajo por el que está indicado como argumento de la función

  chdir ($HOME) or die «You’re homeless!\n»;

• chmod Acepta como argumentos un número y una lista de file, y setta el permiso en los file en función del número asignado. El número se tiene que expresar en notación octal.

  El valor de salida es falso si es 0 o », verdadero en todos los demás casos:

  chmod 0644, «README», «INSTALL»;

  @list = ( «abc», «def», «ghi»)
  chmod 755, @list;

• chop Toma como argumento un escalar, y elimina el último carácter restituyéndolo. A menudo se utiliza para eliminar el carácter \n de los file y darles input de teclado.

  $a = «scalare»; $b = chop($a);

  En la mayor parte de los casos, no nos interesa el valor restituido, por tanto es suficiente dar:

  chop $a; o bien sólo:

  chop;

  que opera con $_ . Téngase en cuenta que para nuestros fines chomp es equivalente a chop.

• chown Análogo al comando chown de los sistemas Unix: cambia el propietario de uno o más file. Los primeros 2 argumentos que tienen que pasarse a esta función son el uid (user id) y el gid (group id) numéricos, después el file o los file que hay que someter a la función. En general, la sintaxis es:

  chown $uid, $gid, @filenames;

  o bien

  chown $uid, $gid, ‘file1’, ‘file2’ …… ;

• cos Función matemática. Restituye el coseno del parámetro (expresado en radianes) pasado a la función. Si se omite el parámetro, cos opera sobre $_

• do Ejecuta un bloque de comandos y restituye el valor de la última expresión tomada en consideración. La sintaxis es:

  do BLOCCO;

  Una implementación útil de «do» puede ser la de repetir una parte de código hasta que una cierta condición se verifique. Veamos cómo:

  do {
  print «Elige 1 ó 2\n»;
  chop($sel=<STDIN>);
  until » 1 2 » =~ / $sel /;
  if ($sel == ‘1’) {
  print «Has elegido 1\n»;
  } elsif ($sel == ‘2’) {
  print «Has elegido 2\n»;
  }

  Este script muestra «has elegido 1» o «has elegido 2» según la tecla elegida por el usuario, a menos que éste haya tecleado cualquier otra tecla: en este caso, el script se desinteresa del terclado presionado y sigue mostrando «Elige 1 ó 2». ¿Para qué puede servir todo esto? Simple: quitad de este script las primeras cuatro líneas y teclead «3» cuando se os pida que elijáis 1 ó 2: el script se bloquea y sale: no pasa nada malo, quede claro, pero si tenéis un script de algún centenar de líneas que se bloquea por una pequeñez, puede ser molesto.

• die Toma como argumento una cadena y sal inmediatamente del programa viendo esta cadena como mensaje de error.

  if ($num != 18) {
  die «Non è 18\n»;
  }

• eval Toma una expresión como argumento y la ejecuta como si fuese un pequeño programa. Si no se indica ningún argumento, eval valora $_ . Eval restituye el valor de la última expresión considerada, pero se puede recurrir a return para restituir el valor a un determinado punto del bloque. En el siguiente ejemplo se ve cómo es posible ejecutar la misma operación con do y con eval:

  do ‘script.pl’;
  eval `cat script.pl`;

  Cuidado con los ápices inversos: ‘ esto es un apóstrofo` éste es el ápice inverso

• exec Sal del script Perl ejecutando otro programa. Normalmente, exec no vuelve a entrar en perl, pero si lo hiciese, restituye el valor falso, controlando qué ha sucedido a través del análisis de $! . Si se quiere volver al interior del script, se aconseja utilizar la función system

• exit Toma un número como argumento, y sal con ese número como código de estado.

  exit 0; para salir con éxito

  exit 1; o cualquier valor distinto de 0

  sal sin éxito.

  La diferencia con die es que die se utiliza en los casos del tipo «esto no tendría que haber sucedido».

• exp Función matemática. Calcula el valor de e elevado al parámetro que se entrega con exp: si falta éste, actúa en $_

• getpgrp Utilizado con la sintaxis ‘getpgrp PID’ restituye i/l proceso/i perteneciente/i al PID especificado. Si se utiliza esta función en sistemas que no implementan la llamada getgpgrp (véase man getpgrp), produce un error irreversible.

• goto Sintaxis: goto label: busca la línea marcada por label y retoma su ejecución. La sintaxis puede ser también goto expr o goto &name (véase la manpage para ulteriores profundizaciones)

• grep Ejecuta igual que el comando ‘grep’ en los sistemas Unix. En la práctica, busca una cadena y restituye los elementos por los que la expresión resulta verdadera. Véase la habitual man perlfunc y man perl (en los sistemas Unix)

• join Toma una cadena y una lista de valores de uno o más array, y produce una cadena obtenida con todos los valores del array, usando la cadena como separador.

  $bah = («:», «eek», «nada», 34); $bah se convierte en «eek:niente:34»

  @array = («uff», «abc», «foo»);

  print (join(» «, @array, «eek»), «\n»);

  muestra «uff abc foo eek»

• keys Restituye una lista formada por todas las llaves del hash indicado:

  $bla{‘eek’} = «*pat*»;

  $bla{‘uff’} = «erp»;

  @thekeys = keys(%bla);

  @thekeys è («eek», «uff»)

  print (join(» «, keys(%bla)), «\n»;);

  muestra «eek uff»

• kill Envía una señal a un proceso. Se puede usar como kill ‘STOP’ proceso; para las señales, véase man 7 signal.

• last la ejecución interrumpe el ciclo en cuestión (parecido al BREAK del C). Si no se especifica el ciclo, last is se refiere al más interno.

  LINE: while <STDIN> {

  last LINE if /^$/;

  sal cuando ha terminado con los headers

  …….

  el resto del ciclo

  }

• lenght Toma una cadena y restituye su longitud $n = «blip»;

  $l = $lenght($n);

  $l è 4

  print (lenght(34), «\n»);

  restituye 2

• link Crea un link al file especificado con la sintaxis igual a la de los sistemas Unix:

  link OLDFILE, NEWFILE

• local Modifica las variables catalogadas de modo que se conviertan en locales limitadamente según el bloque en curso. Si en la lista hay más variables, hay que meterlas entre paréntesis. Como alternativa a local, se puede usar también my.

  local $variable;

  declara $variable local

  local (@array, %hash);

  declara la lista de variables locales

  local $var = «valor»;

  declara $var local e le asigna un valor

  Para un tratamiento más completo, véase la sección ‘Temporary Values vía local()’ en man perlsub.

• log Función matemática: restituye el logaritmo en base y del argumento pasado a la función (o, como siempre, actúa sobre $_ )

• mkdir Crea un directorio, del que el primer elemento es el nombre; el segundo, los permisos sobre ella:

  mkdir «files», 0755;

  o mejor:

  if (!mkdir(«files», 0755)) {
  die «failed to create directory\n»;
  }

• my Declara que las variables consideradas son locales respecto al bloque que las contiene, al subroutine o al file corriente; si se especifican más variables, tienen que se puestas entre paréntesis. A diferencia de las variables creadas con ‘local’, éstas hacen completamente ‘invisibles’ las variables globales con el mismo nombre. Para informaciones más detalladas, véase Private Variables vía my() en man perlsub

• next Análogo a la instrucción CONTINUE del C, permite pasar directamente a la interacción del ciclo marcada por la etiqueta LABEL

  LINE: while (<STDIN>) {
  next LINE if /^#/;
  otro
  }

• oct Interpreta el argumento pasado como parámetro de la función como un valor octal y lo restotuye en valor decimal

• open Abre el file indicado como argumento de la función. El file se puede abir de diferentes maneras:

• con < se abre en lectura

• con >> se abre en escritura

• con >> el contenido no se sobreescribe, pero los nuevos datos se añaden al final del file

• con + delante de < o > para indicar que el file se tiene que abrir en lectura y escritura

• se empieza con | , se ve como un comando al que se pasa el output

• se termina con | , se ve como un comando del que se retira el input

  open /usr/src/linux/README

  Abre el file

  open log >> /tmp/log

  Abre el file log y pasa el contenido a /tmp/log, sin sobreescribirlo

  open <file;

  Abre el file para el cambio

  open(FILE, «<mifile;»);

  Como arriba, sólo que después será posible actuar sobre FILE

• pop Extrae y restituye el último valor de un array reduciéndole en 1 las dimensiones. Si el array está vacío, restituye »

• print Imprime una cadena o una lista de cadenas. Restituye 1 si se ha ejecutado con éxito 0 si no

  escribe «Hello world\n»;

  ¡todas las veces que veais este ejemplo!

  $bla = 3
  escribe «El valor de ‘bla’ es $bla\n»;

  muestra «el resultado de ‘bla es 3»

• push Añade uno o más elementos al final del array ampliando su longitud

  @bla = («a»);

  $arr = «xterm»;

  push(@bla, «eek», $arr, 12.5)

  @bla resulta ( «a»,»eek», $arr, 12.5);

• quotemeta Restituye una variante del argumento en el que los eventuales metacarácteres aparecen con el añadido del carácter backslash ( \ )

  quotemeta «.*» restituye «\.\*»

  rand La función random. Pasando un argumento numérico a la función, está devolverá un valor casual comprendido entre 0 y el número indicado. Si no se proporciona ningún argumento, devolverá un valor comprendido entre 0 e 1, extremos incluidos

• readlink Pasándole un link como argumento, la función devuelve el nombre del file ( o directorio) al que se dirige ese file

• rename Vuelve a nombrar un file: restituye 1 si la operación se ha realizado con éxito, 0 en caso contrario

• rmdir Quita el directorio indicado como argumento de la función

  rmdir «temp_dir»;

• shift Extrae el primer valor del array y lo restotuye, acortando en 1 la longitud del array y desviando los elementos restantes. En cierto sentido, es lo contrario de push. Si el array está vacío, lo deja vacío y devuelve un valor «undef».

  @bla = («a», «xterm», 12.5);

  $v = shift @bla;

  # @bla è («xterm», 12.5) e $v è «a»

• sin Función matemática: restituye el seno de un determinado valor

• sleep Espera los segundos indicados como argumento de la función.

• split Busca particulares secuencias de caracteres y descompone la cadena en una serie de subcadenas, restituyendo la lista generada (en contexto escalar) o el número de subcadenas generadas. Se explicará mejor más adelante, tras las explicaciones sobre las expresiones regulares.

• sqrt Función matemática: calcula la raíz cuadrada.

• symlink Crea un link simbólico. La sintaxis es:

  symlink OLDFILE, NEWFILE

  En los sistemas que no prevén los link simbólicos, la función saldrá con un error. En este caso véase la función link().

• system Ejecuta un programa. Es parecido a exec, pero después de terminar la ejecución del programa regresa en vez de salir.

  system («comando», «istrucciones»)

• undef Toma el nombre de una variable y la coloca come indefinida. Sin argumentos, restituye un valor indefinido. Undef no restituye nunca » o 0.

  undef %bla;

  se desembaraza del hash %bla

  undef $eek;

  se desembaraza del escalar $eek

  $eek = undef;

  como arriba

• unlink Borra un file o una lista de file.

  unlink «tempfile»;
  unlink «tempfile», «altrifile»;

• unshift Añade una lista de elementos al inicio del array y restituye el número de elementos.

  @bla = («a», «b»);
  $arr = «xterm»;
  unshift(@bla, «eek», $arr, 12.5); # @bla y («eek», «xterm», 12.5,

• warn Emite un ‘warning’ en el canal STDERR, como die pero sin salir.

  warn «debugger enebled» if $debug;

• <> Lee una línea de STDIN y la restituye.

  $_ = <>;

  lee una línea en $_

  chop;

  ejecuta chop en \n

  print «Has escrito ‘$_’\n»;

  muestra el output, o bien lo que se ha digitado precedido de «Has escrito»