A Smooth Introduction to TCL for Web Nerds

by Martin Elsman

last modified Feb 03, 2002

Preface

All the examples in these notes can be run using the tclsh interpreter. Versions of the tclsh interpreter exist for both UNIX and Windows. Under UNIX, simply type tclsh at the shell prompt, which will bring up the tcl prompt:

 %

Introduction

One Web server that makes the efficient implementation of Web services with tcl possible is AOLserver. AOLserver has a built-in tcl interpreter. The Web publisher implements pages in the tcl programming language, which when interpreted produces HTML code as output. Then, when a client with a browser requests a tcl page, AOLserver interprets the contents of the page and sends the output from interpreting the tcl code back to the client. In this way the Web publisher can program the content of Web pages.

In the following sections, we introduce the tcl language. First, we give an overview of what tcl commands look like. We then proceed with sections on Arithmetics, Variables, Nested Commands, Grouping, Escape Sequences, Comments, Conditionals, While-Loops and For-Loops, Strings, and Procedures.

Commands

  cmd arg1 arg2 ... argN

  % puts "I'm alive!"
  I'm alive

Arithmetics - computing with numbers

  % expr 3+4
  7

Variables

  % set age 30
  30
  % puts "I'm $age years old"
  I'm 30 years old

As mentioned earlier, variables can be used to hold values other than numbers. Here is an example where a variable my_name is used to hold the name of a person:

  % set my_name Martin
  Martin
  % puts "$my_name is $age years old"
  Martin is 30 years old

Nested Commands

  % set expected_time_to_reincarnation [expr 90 - $age]
  60

Programs

  % puts Hello; puts World
  Hello
  World

  set firstname Martin
  set lastname Elsman
  set age 30
  set email mael@itu.dk
  puts "My name is $firstname $lastname and my email address is $email."

  % source hello.tcl
  My name is Martin Elsman and my email address is mael@itu.dk.

Grouping: Double Quotes ("...") and Curly Braces ({...})

  % puts "My name is $firstname"
  My name is Martin
  % puts {My name is $firstname}
  My name is $firstname

Escape Sequences - the backslash (\)

  % puts "I can now write characters like \$, \{, \}, \[, \], and \""
  I can now write characters like $, {, }, [, ], and " 

  % puts "Sale items\ncar\t\$800\nbicycle\t\$200"
  Sale items
  car     $800
  bicycle $200

Comments

  % # Let's set the variable year
  % set year 2000   ;# we're in year 2000
  2000

Conditionals

  set number_of_courses 2
  if {$number_of_courses == 0} {
    puts "I'm taking no courses this semester"
  } elseif {$number_of_courses == 1} {
    puts "I'm taking one course this semester"
  } else {
    puts "I'm taking $number_of_courses courses this semester"
  }

In principle, the if command is just like any other command, except that it takes a non-fixed number of arguments; in the example above the if command takes seven arguments. Here is a use of the if command that takes only two arguments:

  set email "mael@it.edu"
  if { $email == "mael@it.edu" } {
    puts "Welcome home Martin"
  }

While-Loops and For-Loops

  set i 0
  while {$i < 3} {
    incr i
    puts "Soon, I'm a Web programmer..."
  }

With for-loops, it is possible to do exactly the same things that one can do with while-loops. A for command takes four arguments. The first argument is a command to be executed before the loop is entered; this command typically initializes a variable used in the loop. The second argument is a test, which is executed at each repetition; if the result of this test is false, the loop is terminated and evaluation proceeds after the loop. The third argument is a command, which is executed after each repetition. The fourth argument is the body of the loop. Here is an example for-loop, which prints a multiplication table:

  # after each repetition, x is increased by one
  for {set x 0} {$x<10} {incr x} {
    puts "$x times 9 is [expr $x * 9]"
  }

Strings

Tcl is well-suited for processing strings; it has a large set of built-in commands for string manipulation.

A string is basically a sequence of characters, so given a string, one can ask about the length of the string:

  % set mystring "This is a fairly long string..."
  This is a fairly long string...
  % string length $mystring
  31

Another important string command, which you have in fact already read about, is the append command. This command is so important that it is not a sub-command to the string command, but a real command! The append command takes two or more arguments. The effect of the append command is to set the variable to the concatenation of the old content of the variable and the remaining arguments:

  % set myotherstring "This is not"
  This is not
  % append myotherstring " a very" " long string" "..." 
  This is not a very long string...

  set page "<html>\n"
  append page " <head>\n"
  append page "   <title>Hello World</title>\n"
  append page " </head>\n"
  append page " <body>\n"
  append page "   Hello World\n"
  append page " </body>\n"
  append page "</html>"
  puts $page

Of course, to get the effect of printing the content of the variable page, we could just have printed the page with the one command:

  puts "<html>
          <head>
            <title>Hello World</title>
          </head>
          <body>
             Hello World
          </body>
        </html>"

Here is an example where it is practical to build up a string dynamically using the append command:

  set page "<html><head><title>Hello World</title></head>
            <body><center>\n"
  set i 1
  while { $i < 5 } {
    append page "<h$i>Haleluja</h$i>\n"
    incr i
  }
  append page "</center></body></html>"
  puts $page

Haleluja Haleluja Haleluja Haleluja

In Web applications it is important to be able to compare strings. Comparisons are necessary, for instance, to act differently on different user inputs. To compare two strings in tcl, we use the string compare command. The string compare command takes two strings as arguments and returns 0 if the strings are identical. Suppose that some user has registered on your site with the form variables first_names, last_name, email, and passwd. Assume also that the error command sends a reasonable response back to the user, based on the argument. At-least, we want our program to check that the form variables are non-empty and that the password is suitable:

  # compare the first_names value to the empty string
  if { [string compare $first_names ""] == 0 } {
     error "You must provide a first name"
  }

  # compare the last_name value to the empty string
  if { [string compare $last_name ""] == 0 } {
     error "You must provide a last name"
  }
  
  ...

  # require a password with at-least four characters
  if { [string length $passwd] <= 4 } {
     error "You must provide a password with at-last four characters"
  }

Procedures

   proc hyperlink {url} {
     set res "<a href=\""
     append res $url "\">" $url "</a>"
     return $res
   }

In the example procedure, the variable res is defined locally within the body of the procedure, which means that the variable can be accessed only in the body of the procedure. A variable named res defined outside of the procedure is not affected by the use of the hyperlink command. The return command at the end of the procedure body is used to return the result of the procedure, which in this case is the string contained in the res variable. The append command is used to construct the HTML hyper-link, based on the URL address, which is given as argument to the procedure.

The following tcl code uses the hyperlink command to output HTML code with a link to the much popular Google search-engine:

  % puts "Google has the URL [hyperlink {http://www.google.com}]"
  Google has the URL <a href="http://www.google.com">http://www.google.com</a>

The ability to define procedures allows the programmer to divide a programming task into sub-tasks. These sub-tasks can then be understood and implemented in isolation, maybe by somebody else than the programmer! Procedural abstraction is therefore very important for software engineering; a programming language that does not provide ways of defining procedures scales poorly to the construction and maintenance of large software systems.

Another important aspect of procedural abstraction is that a procedure defined once can be used in many different contexts. For instance, notice that in the body of the hyperlink procedure definition, the command append is used four times, each time with different arguments.

As another example, consider the following procedure:

  proc multi {word n} {
    set res "" 
    while {$n >= 1} {
      append res $word 
      set n [expr $n - 1]
    }
    return $res
  }

  % puts "I'm [multi {very } 3]smart!"
  I'm very very very smart!