Tcl Lists and List Handling
Tcl lists are fundamental data structures used to store collections of items. Unlike arrays, which are hash tables, lists are ordered sequences of elements. Each element in a Tcl list can itself be a complex string or even another list.
Creating Lists
Lists can be created simply by grouping elements with spaces. For lists containing elements with spaces or special characters, it's best to use the list command or enclose elements in quotes or braces.
set simple_list {item1 item2 item3}
set quoted_list "item one" "item two"
set complex_list [list "first item" {second item} "third {item} complex"]
puts $simple_list
puts $quoted_list
puts $complex_list
This will print:
item1 item2 item3
item one item two
first item {second item} {third {item} complex}
Accessing List Elements: lindex and llength
ll
To access individual elements or determine the number of elements in a list, you use the lindex and llength commands.
set my_list {apple banana orange grape}
puts "Second element: [lindex $my_list 1]" ;# Lists are 0-indexed
puts "Last element: [lindex $my_list end]"
puts "Number of elements: [llength $my_list]"
This will print:
Second element: banana Last element: grape Number of elements: 4
Adding Elements to a List: lappend
The lappend command is used to append new elements to a list variable. It treats the variable's current value as a list and appends additional arguments to it, separated by spaces, returning the new list.
set my_cart {milk bread}
lappend my_cart eggs
puts $my_cart
lappend my_cart "chocolate milk" cheese
puts $my_cart
This will print:
milk bread eggs
milk bread eggs {chocolate milk} cheese
Note that `lappend` is efficient as it modifies the list in place rather than creating a new list if possible.
Assigning List Elements to Variables: lassign
The lassign command is a powerful and concise way to assign multiple elements from a list to individual variables. It takes a list and one or more variable names.
set coordinates {100 200 300}
lassign $coordinates x y z
puts "X: $x, Y: $y, Z: $z"
set full_name {John Doe Developer}
lassign $full_name first_name last_name title
puts "Name: $first_name $last_name, Title: $title"
This will print:
X: 100, Y: 200, Z: 300 Name: John Doe, Title: Developer
You can also use lassign to capture remaining elements into a single variable by placing an extra variable name at the end.
set data {ID123 "Status Active" "User Admin" "Date 2025-07-25"}
lassign $data id status_info rest_data
puts "ID: $id"
puts "Status Info: $status_info"
puts "Remaining Data: $rest_data"
This will print:
ID: ID123
Status Info: Status Active
Remaining Data: User Admin {Date 2025-07-25}
Searching for Elements: lsearch
The lsearch command is used to search a list for a specific element or pattern. It returns the index of the first matching element, or -1 if no match is found.
set fruits {apple banana orange grape apple}
puts "Index of banana: [lsearch $fruits banana]"
puts "Index of kiwi: [lsearch $fruits kiwi]"
# Using glob-style matching
puts "Index of element starting with 'gra': [lsearch -glob $fruits gra*]"
# Using regular expression matching
puts "Index of element containing 'an': [lsearch -regexp $fruits {an}]"
This will print:
Index of banana: 1 Index of kiwi: -1 Index of element starting with 'gra': 3 Index of element containing 'an': 1
Common options for lsearch include:
-exact: (Default) Matches the exact string.-glob: Interprets patterns using glob-style matching (e.g., `*`, `?`).-regexp: Interprets patterns as regular expressions.-nocase: Performs a case-insensitive search.-all: Returns a list of all matching indices instead of just the first.-not: Returns elements that do NOT match the pattern.
Splitting Strings into Lists: split
The split command is used to break a string into a Tcl list based on a specified delimiter character (or set of characters). It's incredibly useful for parsing data.
Basic `split` Syntax
split string ?splitChars?
string: The string to be split.splitChars: (Optional) A string containing the characters to use as delimiters. If omitted, `split` uses whitespace characters (space, tab, newline, carriage return) as delimiters.
set sentence "This is a sample sentence." set words [split $sentence] puts "Words (default split): $words" set csv_data "apple,banana,orange,grape" set fruits [split $csv_data ","] puts "Fruits (comma split): $fruits" set path_string "/usr/local/bin" set path_components [split $path_string "/"] puts "Path Components (slash split): $path_components"
This will print:
Words (default split): This is a sample sentence.
Fruits (comma split): apple banana orange grape
Path Components (slash split): {} usr local bin
**Note:** If `splitChars` is an empty string `""`, `split` breaks the `string` into a list of individual characters. If a delimiter is at the beginning or end of the string, or if there are multiple delimiters together, it will result in empty list elements.
String Manipulation: The string Command
The string command in Tcl provides a wide range of subcommands for manipulating and querying strings. It's a versatile tool for text processing.
Getting String Length: string length
The string length subcommand returns the number of characters in a string.
set text "Hello Tcl!" puts "Length of '$text': [string length $text]" set empty_string "" puts "Length of empty string: [string length $empty_string]"
This will print:
Length of 'Hello Tcl!': 10 Length of empty string: 0
Comparing Strings: string equal
The string equal subcommand compares two strings for equality. It returns 1 if the strings are identical, and 0 otherwise. It supports options for case-insensitive comparison.
puts "Compare 'apple' and 'apple': [string equal apple apple]" puts "Compare 'apple' and 'Apple': [string equal apple Apple]" puts "Compare 'apple' and 'Apple' (nocase): [string equal -nocase apple Apple]" puts "Compare 'hello' and 'world': [string equal hello world]"
This will print:
Compare 'apple' and 'apple': 1 Compare 'apple' and 'Apple': 0 Compare 'apple' and 'Apple' (nocase): 1 Compare 'hello' and 'world': 0
Glob-Style Pattern Matching: string match
The string match subcommand checks if a string matches a given glob-style pattern. It returns 1 if there's a match, and 0 otherwise.
**Glob Patterns:**
*: Matches any sequence of zero or more characters.?: Matches any single character.[chars]: Matches any single character within the set `chars`.\\x: Matches the character `x` literally (escapes special characters).
puts "Does 'filename.txt' match '*.txt'? [string match *.txt filename.txt]" puts "Does 'doc1.pdf' match 'doc?.pdf'? [string match doc?.pdf doc1.pdf]" puts "Does 'report.doc' match 'r*.xls'? [string match r*.xls report.doc]" puts "Does 'apple' match 'ap[pl]e'? [string match ap[pl]e apple]" ;# Matches p or l
This will print:
Does 'filename.txt' match '*.txt'? 1 Does 'doc1.pdf' match 'doc?.pdf'? 1 Does 'report.doc' match 'r*.xls'? 0 Does 'apple' match 'ap[pl]e'? 1
Like other string subcommands, `string match` also supports the `-nocase` option for case-insensitive matching.