Tcl

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Tcl
Tool Command Language
Tcl.svg
Desarrollador(es)
Tcl Core Team[1]
www.tcl.tk
Información general
Paradigma multiparadigma: POO , funcional, procedural, Programación dirigida por eventos
Apareció en 1988
Diseñado por John Ousterhout
Última versión estable 8.6.0 [2] (20 de diciembre de 2012)
Tipo de dato dinámico, cualquier cosa puede tratarse como una cadena
Implementaciones ActiveTcl
Influido por C, Lisp, Shell, Awk, SCL
Ha influido a Python, PowerShell[3]
Sistema operativo multiplataforma
Licencia BSD

Tcl (pronunciado /tí.quel/, originado del acrónimo en inglés "Tool Command Language" o lenguaje de herramientas de comando, actualmente se escribe como "Tcl" en lugar de "TCL"), es un lenguaje de script creado por John Ousterhout, que ha sido concebido con una sintaxis sencilla para facilitarse su aprendizaje, sin detrimento de la funcionalidad y expresividad.

Se utiliza principalmente para el desarrollo rápido de prototipos, aplicaciones "script", interfaces gráficas y pruebas. La combinación de Tcl con Tk (del inglés Tool Kit) es conocida como Tcl/Tk, y se utiliza para la creación de interfaces gráficas.

Características[editar]

Tcl es un lenguaje interpretado, y su código puede ser creado y modificado dinámicamente. Sus reglas sintácticas son extremadamente simples y posee reglas de alcance dinámico. Permite escribir código fácil de mantener. Los "scripts" Tcl son a menudo más compactos y legibles que los programas funcionalmente equivalentes en otros lenguajes de programación. Es un lenguaje multiplataforma, con intérpretes que se ejecutan sobre Windows, Linux, UNIX, MacOS y OSX e incluso microprocesadores PIC.

Todos los elementos de un programa son comandos, incluyendo las estructuras del lenguaje. Dichos comandos se escriben en notación polaca y pueden ser redefinidos o sobreescritos de manera dinámica.

Una característica notable es que los datos son manejados como cadenas de caracteres Unicode, incluyendo el código fuente, soportando Unicode desde el lanzamiento de la versión 8.1, en el año 1999.

Una de las características más usadas de Tcl es su extensibilidad. Por ejemplo, si una aplicación requiere algo de funcionalidad no ofrecida por el Tcl estándar, los nuevos comandos de Tcl pueden ser implementados usando el lenguaje C, un integrado sumamente fácil. Tcl es "extensible" a través de C, C++ y Java. Mediante una extensión, permite la programación orientada a objetos. Puede extenderse también a entornos gráficos, a través de una interfaz denominada Tk.

La programación orientada a eventos se realiza sobre "sockets" y archivos, además son posibles los eventos basados en tiempo y los definidos por el usuario.

Antecedentes[editar]

Ejemplo de un menú realizado con Tcl/Tk.

El lenguaje Tcl fue originalmente proyectado para ser un lenguaje de comando reutilizable. Quienes desarrollaron Tcl estaban creando una serie de herramientas interactivas, y cada una constaba de su propio lenguaje de comando. Desde que comenzaron a interesarse más en estas herramientas que en los lenguajes de comandos que utilizarían, estos lenguajes comenzaron a construirse rápidamente sin considerar el diseño apropiado, sin mucha importancia.

Después de implementar varios lenguajes de comandos creados de esta forma y experimentar problemas con cada uno de ellos, decidieron concentrar su atención en la implementación de un objetivo general: un lenguaje de comando eficaz que pudiera ser integrado fácilmente en nuevas aplicaciones. Es de esta manera que nace el lenguaje Tcl (Tool Command Language), cuyas siglas en Inglés significan Lenguaje de Herramientas de Comando.

Desde ese entonces, el lenguaje Tcl ha sido utilizado como lenguaje de código. En muchos casos, Tcl es usado en combinación con la biblioteca Tk ("Tool Kit"), un conjunto de comandos y procedimientos que hacen relativamente fácil para programar interfaces de usuario gráficas.

Desde que Tcl comenzó a ser un lenguaje fácilmente extensible, se han escrito muchas extensiones para tareas determinadas, y están generalmente disponibles libremente en Internet.

Sintaxis y semántica fundamental[editar]

Un script Tcl consiste de varias invocaciones de comandos. Una invocación de un comando es una lista de palabras separadas por un espacio y terminada en un caracter de nueva línea o un punto y coma.

palabra0 palabra1 palabra2 ... palabraN

La primera palabra es el nombre de un comando, el cual no está dentro del lenguaje, sino en una biblioteca. Las siguientes palabras son los argumentos. Así se tiene:

nombreComando argumento1 argumento2 ... argumentoN

Un ejemplo práctico, usando el comando puts el cual envía una cadena de caracteres a una salida (añadiendo una nueva línea al final) en forma predeterminada sobre el canal stdout:

puts "Hola, mundo!"

Las variables y los resultados de otros comandos pueden introducirse también dentro de las cadenas de caracteres, tal como en este ejemplo donde usamos set (comando de asignación de variables) y expr (comando de expresiones artiméticas) para almacenar el resultado de un cálculo en una variable, y puts para imprimir el resultado junto con un texto explicativo:

set suma [expr {1+2+3+4+5}] ;#asigna a la variable suma el resultado de la evaluación de la expresión aritmética 1+2+3+4+5
puts "La suma de los números 1..5 es $suma." ;#muestra  una cadena de caracteres con el resultado almacenado en la variable suma

El punto y coma ; sirve para poner dos o más comandos en una misma línea, o para agregar un comentario después de un comando (un comentario se empieza con el símbolo #):

#Comentario en una línea sin comandos
puts "¡Hola Mundo!" ; puts "otra linea de caracteres"
set i 0 ; #Comentario, con un ';' para separarlo del comando

Agrupamiento[editar]

Las formas de agrupar elementos en Tcl son:

  • Con "" (bloques entre dobles comillas) se representan cadenas con el agregado de que se puede intercalar el valor de variables (sustituye el contenido de la variable) utilizando el símbolo $ seguido del nombre de la variable.
  • Con {} (bloques entre llaves) pueden contener cadenas, pero no se pueden intercalar variables como en el caso de las doble comillas, por ejemplo, en una consola tcl (invocando tclsh en un terminal):
% set numero 545 ;#Asignación a la variable numero con 545
545
% puts "El valor es $numero" ;# Con dobles comillas podemos poner el contenido de la variable numero
El valor es 545
% puts {El valor es $numero} ;# Pero entre llaves muestra el simbolo $ seguido del nombre de la variable
El valor es $numero

Los bloques entre llaves sirven además para las estructuras de control, ya que son tratadas como cualquier otro comando.

  • Los () (paréntesis) sirven para encerrar los índices en las tablas asociativas, o para agrupar en expresiones aritméticas.
  • Con [] (bloques entre corchetes) se realiza la sustitución del contenido de un resultado, por ejemplo, en una consola tcl:
% puts [ expr {1 + [set u 342]} ] ; # Muestra el resultado de la expresión de sumarle 1 a la variable u que se le asigna antes 342
343
% puts $u ;# Muestra el contenido de u
342

Tipos de variables[editar]

Las variables no tienen tipos explícitamente. Sin embargo podemos definir seis tipos

  • Booleanas : 0/no/off (en caso de ser falso) y 1/yes/on/ (en caso de ser verdadero) o un número diferente de 0
  • Números : 1 0 3.14 1.e-10, se tratan como cadenas, salvo en expresiones aritméticas en que se convierte primero en binario.
  • Cadenas de caracteres : Bienvenido, "Madame De Labas", 32 , {z 3.14}
  • Listas : de booleanas, nombres, cadenas o listas (pudiendo anidar listas)
  • Diccionarios : Son pares clave-valor, similares a las tablas asociativas. Pueden contener cualquier tipo de dato en el valor. Este tipo de variables se incluye desde Tcl 8.5 en adelante.
  • Tablas asociativas : T(clave) M(2,3) que puedan contener los 5 tipos anteriores, incluso mezclados.

Las cinco primeros tipos son llamados tipos escalares, así que pueden ser pasados por valor y regresar al llamar a un procedimiento. Los tipos de escalar se convierten automáticamente en el tipo adecuado, por ejemplo, una cadena puede ser una lista como se ve a continuación utilizando una consola tcl:

% set frutas albaricoque
% puts $frutas
albaricoque
% set frutas "pomelo naranja banana"
pomelo naranja banana
% puts [lindex $frutas end]
banana
% puts [lindex $frutas 1]
naranja

Una función puede devolver una cadena o una lista, pero no una tabla asociativa ya que no es una variable escalar. Estos pueden ser pasados por referencia. Los diccionarios se pueden utilizar como un parámetro de un procedimiento, e incluso puede ser devuelto.

Estructuras de control[editar]

Contrariamente a lo que ocurre con otros lenguajes de programación, las palabras que se utilizan para las estructuras de control en Tcl no son palabras reservadas con una sintaxis especial. "for", "if", "while" son procedimientos que siguen la sintaxis habitual Tcl.

  while { unaExpresionLogica }   { 
      unCommando
      unCommando
      ....
  }
 
  if {$x<0} {
     set x 0
  } elseif { $x<5 } {
     set x 5
  } else {
     set x 10
  }
 
  for {set i 0} {$i<10} {incr i} { 
      puts $i 
  }
 
  foreach i [list "youpii" "aujourd'hui" "il fait beau" "bravo !" "bravo !"] {
      puts $i
  }
  # no es necesario usar el comando list con valores fijos; esto es equivalente
  foreach i {"youpii" "aujourd'hui" "il fait beau" "bravo !" "bravo !"} {
      puts $i
  }
 
  foreach a $listaA  b $listaB  c $listaC {
      puts "$a $b $c"
  }
 
  foreach {x y} [list Sr Gaston Sra Jeanne Sr Robert Sra Raymonde] {
      puts "$x $y"
  }
 
  set color azul
  switch $color {
    rojo   { puts "FF0000" }
    azul   { puts "0000FF" }
    verde  { puts "00FF00" }
    blanco { puts "FFFFFF" }
    negro  { puts "000000" }
    default { puts "desconocido" }
  }

Ejemplos[editar]

proc ! x {expr {$x<2? 1: $x*[! [incr x -1]]}}
  • Hacer la suma de una lista de números

Con un bucle foreach que sigue la lista :

set numeros {10 9 8 7 6 5 4 3 2 1}
set suma 0
foreach i $numeros { 
   set suma [expr {$suma + $i}]
}

O más compacto utilizando el comando join en lugar del lazo con foreach :

set suma [expr [join $numeros +]]
  • Un operador es un caracter como cualquier otro, así que puede ser almacenado en una variable:
set numeros {10 9 8 7 6 5 4 3 2 1}
foreach opr {+ * - /} {
   set resultado [expr [join $numeros $opr]]
   puts "El resultado para el operador $opr es $resultado"
}
  • Descarga de una página HTML
package require http
set tok [http::geturl http://mini.net/tcl/540]
puts [http::data $tok]
http::cleanup $tok

Desarrollo y ejecución[editar]

Eclipse corriendo un programa Tcl que utiliza la extensón incr Tcl para la programación orientada a objetos.

En Linux y otras plataformas de derivados de Unix, el intérprete Tcl/Tk a menudo se instala de manera predeterminada. Si este no es el caso, normalmente es necesario instalar los paquetes correspondientes a la distribución o sino utilizar el código fuente de Tcl y compilarlo para luego proceder con su instalación. Por otra parte, la ejecución de un código Tcl se realiza escribiendo en el intérprete de comandos o consola:

$ tclsh archivo.tcl

También se puede obtener una consola Tcl escribiendo en ella solamente tclsh. Existen otras consolas para Tcl, como TkCon, que es un intérprete mejorado escrito por Jeff Hobbs.[4] La programación de Tcl/Tk es soportada por gran variedad de IDEs, tal como Eclipse a través del proyecto DLTK (Dynamic Languages Toolkit), que contiene plugins para compiladores de lenguajes dinámicos Tcl, Ruby, Javascript y Python.[5]

Programación orientada a objetos[editar]

Tcl no contaba en sus orígenes con construcciones específicas en su sintaxis para soportar el paradigma de la programación orientada a objetos (POO). La inclusión de la POO en Tcl fue un tema de discusión recurrente dentro de la comunidad de usuarios de este lenguaje. Las opiniones estaban divididas porque la POO no es el único paradigma adaptable, por el deseo de conservar compacto a TCL y por la gran variedad de adaptaciones posibles a los conceptos de objetos. Por esta razón existen varias extensiones diferentes que implementan la POO.

Pese a esto, desde la versión 8.6 cuenta nativamente en su núcleo con un sistema básico de orientación a objetos basado en XOTcl,[6] buscando unificar a las demás extensiones.

Extensión Desarrollado con Descripción del modelado
XOTcl[7] C Definición dinámica de clases, metaclases y métodos con introspección. Herencia simple y múltiple. Agregación de objetos dinámicos, clases anidadas, mixins, filtro condicional, ranuras. Influido por CLOS, Smalltalk y Self.
incr Tcl C Basado en el modelo de C++. Herencia múltiple. Clases privadas y públicas.
OTcl[8] C

Definición dinámica de clases, metaclases y métodos con introspección. Herencia simple y múltiple. Influido por CLOS, Smalltalk y Self.

Snit[9] Tcl Utiliza el paradigma de objetos puro, a diferencia de otras extensiones, no se basa en la herencia de objetos, sino que trabaja con herencia a vínculos elegidos. Un objeto trabaja con delegaciones.

Referencias[editar]

  1. «Tcl Core Team» (en inglés).
  2. «Latest Release: Tcl/Tk 8.6.0 (dic 20, 2012)» (en inglés). Tcl Developer Xchange Web Site..
  3. Jeffrey Snover. «PowerShell and WPF: WTF» (en inglés). Microsoft Developer Network.
  4. «Tcl Tutorial: Running Tcl» (en inglés). Tcl Developer Xchange.
  5. «Dynamic Languages ToolKit» (en inglés). The Eclipse Foundation.
  6. «Object-Oriented Programming in Tcl» (en inglés). Consultado el 8 de febrero de 2011.
  7. «Extended Object Tcl (XOTcl)» (en inglés).
  8. «MIT Object Tcl (OTcl)» (en inglés).
  9. «Snit's Not Incr Tcl» (en inglés).

Enlaces externos[editar]

Wikilibros

Implementaciones