Tcl

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. En versiones recientes permite la programación orientada a objetos, en las primeras versiones requería de una extensión para tal fin. 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.

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 (del inglés Tool Command Language), cuyas siglas en español 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 (de Tool Kit, en español, caja de herramientas), 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 ciertas tareas específicas, y están generalmente disponibles libremente en Internet.

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 carácter 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 aritmé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

% 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 símbolo $ seguido del nombre de la variable
El valor es $numero

% 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

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

  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" }
  }

• Factorial (estilo de programación funcional):

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 carácter 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://es.wikipedia.org/wiki/Tcl]
puts [http::data $tok]
http::cleanup $tok

Eclipse corriendo un programa Tcl que utiliza la extensió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.[5] 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.[6]

Tcl dispone nativamente de la programación orientada a objetos desde la versión 8.6 (20 de diciembre de 2012). La sintaxis es la siguiente:

objeto método arg1 arg2 ....

Ejemplo:

oo::class create DistribuidorTicket {
  variable contador
    
  constructor {} {set contador 0}
  
  method entregaTicket {{ticket 1}} {  
      incr contador
        for {set i 0} {$i < $ticket} {incr i} {
           puts "Entrega del ticket n° $i para el control $contador"
        }
  }
}

set macommande [DistribuidorTicket new]
$macommande entregaTicket 2

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,[7] buscando unificar a las demás extensiones.

• Wikimedia Commons alberga una categoría multimedia sobre Tcl.
• Wikilibros alberga un libro o manual sobre Programación en Tcl (en inglés).
• Tcl Developer Xchange sitio oficial (en inglés)
• Tcl8.6.5/Tk8.6.5 Documentation (en inglés)
• Tcl Tutorial (en inglés)

Implementaciones

• WinTclTk Distribución de Tcl/Tk para Windows (en inglés)
• C++/Tcl Integración de Tcl en C++ (en inglés)
• Tcl/Java Integración de Tcl en la plataforma Java (en inglés)
• Tcl Módulo Perl para acceder a la biblioteca de Tcl (en inglés)