学习笔记-TCL

// helloWorld.tcl
#!/usr/bin/tclsh			// 脚本解释器
puts "Hello World!"

commandName  argument1  argument2 ...  argumentN

#!/usr/bin/tclsh
puts [expr 1 + 6 + 9]

#!/usr/bin/tclsh
set s1 "Hello World"
puts "Length of string s1"
puts [string length $s1]

Length of string s1
11

#!/usr/bin/tclsh
set s1 "Hello" 
append s1 " World"
puts $s1

Hello World

#!/usr/bin/tclsh

puts [format "%f" 43.5]
puts [format "%e" 43.5]
puts [format "%d %s" 4 tuts]
puts [format "%s" "Tcl Language"]
puts [format "%x" 40]

43.500000
4.350000e+01
4 tuts
Tcl Language
28

% scan "some 26 34" "some %d %d" a b
2
% set a
26
% set b
34
% scan "12.34.56.78" "%d.%d.%d.%d" c d e f
4
% puts [format "the value of c is %d,d is %d,e is %d ,f is %d" $c $d $e $f]
the value of c is 12,d is 34,e is 56 ,f is 78

#!/usr/bin/tclsh
puts [scan "90" \{\%\[0-9\]\} m]
puts [scan "abc" \{\%\[a-z\]\} m]
puts [scan "abc" \{\%\[A-Z\]\} m]
puts [scan "ABC" \{\%\[A-Z\]\} m]

1
1
0
1

set listName { item1 item2 item3 .. itemn }
# or
set listName [list item1 item2 item3]
# or 
set listName [split "items separated by a character" split_character]

#!/usr/bin/tclsh

set colorList1 {red green blue}
set colorList2 [list red green blue]
set colorList3 [split "red_green_blue" _]
puts $colorList1
puts $colorList2
puts $colorList3

#!/usr/bin/tclsh
set  myVariable  {red green blue}
puts [lindex $myVariable 2]
set myVariable "red green blue"
puts [lindex $myVariable 1]

append listName split_character value
# or
lappend listName value

[ llength  $listName ]

[ lindex  $listname  index ]

[ linsert   $listname index value1 value2..valuen ]

[ lreplace  $listname  firstindex lastindex value1 value2..valuen ]

set var {orange blue red green}
set var [lreplace $var 2 3 black white]

lset  listname  index  value 

#!/usr/bin/tclsh
set var {orange blue red green}
lset var 0 black 
puts $var

lassign  $listname  variable1 variable2.. variablen
set var {orange blue red green}
lassign $var colour1 colour2
puts $colour1
puts $colour2

lsort  listname

set var {orange blue red green}
set var [lsort $var]
puts $var

join

concat将连接多个列表（如下：
concat a b {c d e} {f {g h}}
将返回结果“a b c d e f {g h}”） 也可以全部都是非列表元素：
concat " a b {c   " d "  e} f"
将返回结果 “a b {c d e} f”。

concat "a   b   c" { d e f }
将返回结果“a b c d e f” 。

set ArrayName(Index) value

#!/usr/bin/tclsh
set   marks(english)  80
puts  $marks(english)
set  marks(mathematics)  90
puts  $marks(mathematics)

array set arrName { index1 value1 index2 value2 ...}

[array  size  variablename]

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts  [array size languages]

#!/usr/bin/tclsh
set languages(0) Tcl
set languages(1) "C Language"
for { set index 0 }  { $index < [array size languages] }  { incr index } {
      puts "languages($index) : $languages($index)"
}

#!/usr/bin/tclsh
set personA(Name) "Dave"
set personA(Age) 14
puts  $personA(Name)
puts  $personA(Age)

[array names variablename]

#!/usr/bin/tclsh
set personA(Name) "Dave"
set personA(Age) 14
puts [array names personA]
Age Name

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
foreach index [array names personA] {
   puts "personA($index): $personA($index)"
}

dict set dictname key value
# or 
dict create dictname key1 value1 key2 value2 .. keyn valuen

dict set colours  colour2 green
set colours [dict create colour1 "black" colour2 "white"]

[dict size dictname]

[dict get $dictname $keyname]

[dict keys  $dictname]

[dict values $dictname]

[dict exists $dictname $keyname]

set colours [dict create colour1 "black" colour2 "white"]
foreach item [dict keys $colours] {
    set value [dict get $colours $item]
    puts $value
}

set  myfile  [open "filename" r] 

#!/usr/bin/tclsh
set a 21
set b 10
set c [expr $a + $b]
puts "Line 1 - Value of c is $c\n"
set c [expr $a - $b]
puts "Line 2 - Value of c is $c\n"
set c [expr $a * $b]
puts "Line 3 - Value of c is $c\n"
set c [expr $a / $b]
puts "Line 4 - Value of c is $c\n"
set c [expr $a % $b]
puts "Line 5 - Value of c is $c\n"

#!/usr/bin/tclsh
set a 21
set b 10
if { $a == $b } {
	puts "Line 1 - a is equal to b\n"
} else {
	puts "Line 1 - a is not equal to b\n" 
}
if { $a < $b } {
	puts "Line 2 - a is less than b\n"
} else {
	puts "Line 2 - a is not less than b\n"
}
if { $a > $b } {
	puts "Line 3 - a is greater than b\n"
} else {
	puts "Line 3 - a is not greater than b\n"
}

#!/usr/bin/tclsh
set a 60  ;# 60 = 0011 1100   
set b 13  ;# 13 = 0000 1101 
set c [expr $a & $b] ;# 12 = 0000 1100 

#!/usr/bin/tclsh
set a 10;
set b [expr $a == 1 ? 20: 30]
puts "Value of b is $b\n"
set b [expr $a == 10 ? 20: 30]
puts "Value of b is $b\n"

if { boolean_expression } {
   # statement(s) will execute if the boolean expression is true
}

if {boolean_expression} {
  # statement(s) will execute if the boolean expression is true 
} else {
  # statement(s) will execute if the boolean expression is false
}

if {boolean_expression 1} {
   # Executes when the boolean expression 1 is true
} elseif {boolean_expression 2} {
   # Executes when the boolean expression 2 is true 
} elseif {boolean_expression 3} {
   # Executes when the boolean expression 3 is true 
} else {
   # executes when the none of the above condition is true 
}

switch switchingString {
   matchString1 {
      body1
   }
   matchString2 {
      body2
   }
...
   matchStringn {
      bodyn
   }
}

while {condition} {
   statement(s)
}

for {initialization} {condition} {increment} {
   statement(s);
}

for { set a 10}  {$a < 20} {incr a} {
   puts "value of a: $a"
}

#!/usr/bin/tclsh

set j 0;
for {set i 2} {$i<100} {incr i} {
   for {set j 2} {$j <= [expr $i/$j] } {incr j} {
      if {  [expr $i%$j] == 0 } {
         break
        } 
     }
   if {$j >[expr $i/$j] } {
      puts "$i is prime"
    }
}

proc procedureName {arguments} {
   body
}

proc factorial {number} {
   if {$number <= 1} {
      return 1
    } 
   return [expr $number * [factorial [expr $number - 1]]]
}
puts [factorial 3]
puts [factorial 5]

open  fileName  accessMode

close fileName

puts $filename "text to write"

set  fp  [open "input.txt" w+]
puts  $fp  "test"
close  $fp

set  file_data  [read  $fp]
set fp [open "input.txt" w+]
puts $fp "test"
close $fp
set fp [open "input.txt" r]
set file_data [read $fp]
puts $file_data
close $fp

set fp [open "input.txt" w+]
puts $fp "test\ntest"
close $fp
set fp [open "input.txt" r]

while { [gets $fp data] >= 0 } {
   puts $data
}
close $fp

puts "$var" ；#输出变量var的值
puts {$var}  ；#输出大括号中的内容
puts " " 会把" "中的变量替换之后再输出，而puts {} 则是把{}中的内容原封不动的输出。使用puts进行输出，默认是换行的，如果希望输出后不换行，需要使用-nonewline参数进行设置。puts -nonewline "input x = "。

flush stdout； # 输出标准输出stdout内容，清空输出缓冲区
set x [gets stdin]；#把输入的数字赋值给变量x。

error message info code

catch script resultVarName

proc Div {a b} {
    if {$b == 0} {
     error "Error generated by error" "Info String for error" 401
    } else {
      return [expr $a/$b]
    }
}
if {[catch {puts "Result = [Div 10 0]"} errmsg]} {
   puts "ErrorMsg: $errmsg"
   puts "ErrorCode: $errorCode"
   puts "ErrorInfo:\n$errorInfo\n"
}
if {[catch {puts "Result = [Div 10 2]"} errmsg]} {
   puts "ErrorMsg: $errmsg"
   puts "ErrorCode: $errorCode"
   puts "ErrorInfo:\n$errorInfo\n"
}

regexp   optionalSwitches  patterns  searchString  fullMatch  subMatch1 ...  subMatchn

set card_type $::env(INS_CARD_TYPE)

[file dirname [info script]
info script ?filename? returns or sets the name of the file containing the script currently being evaluated.

tclsh - Simple shell containing Tcl interpreter
SYNOPSIS
tclsh ?-encoding name? ?fileName arg arg ...?

DESCRIPTION
Tclsh is a shell-like application that reads Tcl commands from its
standard input or from a file and evaluates them. If invoked with no
arguments then it runs interactively, reading Tcl commands from 
standard input and printing command results and error messages to 
standard output. It runs until the exit command is invoked or until it 
reaches end-of-file on its standard input. If there exists a file .
tclshrc (or tclshrc.tcl on the Windows platforms) in the home directory
of the user, interactive tclsh evaluates the file as a Tcl script just 
before reading the first command from standard input.

SCRIPT FILES
If tclsh is invoked with arguments then the first few arguments specify
the name of a script file, and, optionally, the encoding of the text 
data stored in that script file. Any additional arguments are made 
available to the script as variables (see below). Instead of reading 
commands from standard input tclsh will read Tcl commands from the 
named file; tclsh will exit when it reaches the end of the file. The 
end of the file may be marked either by the physical end of the medium, 
or by the character, “\032” (“\u001a”, control-Z). If this character is 
present in the file, the tclsh application will read text up to but not 
including the character. An application that requires this character in 
the file may safely encode it as “\032”, “\x1a”, or “\u001a”; or may 
generate it by use of commands such as format or binary. There is no 
automatic evaluation of .tclshrc when the name of a script file is 
presented on the tclsh command line, but the script file can always source 
it if desired.

If you create a Tcl script in a file whose first line is

#!/usr/local/bin/tclsh

then you can invoke the script file directly from your shell if you mark 
the file as executable. This assumes that tclsh has been installed in the 
default location in /usr/local/bin; if it is installed somewhere else then 
you will have to modify the above line to match. Many UNIX systems do not 
allow the #! line to exceed about 30 characters in length, so be sure that 
the tclsh executable can be accessed with a short file name.

An even better approach is to start your script files with the following 
three lines: 

#!/bin/sh
# the next line restarts using tclsh \
exec tclsh "$0" ${1+"$@"}

This approach has three advantages over the approach in the previous 
paragraph. 
•	First, the location of the tclsh binary does not have to be hard-wired 
into the script: it can be anywhere in your shell search path. 

•	Second, it gets around the 30-character file name limit in the 
previous approach. 

•	Third, this approach will work even if tclsh is itself a shell script 
(this is done on some systems in order to handle multiple architectures or 
operating systems: the tclsh script selects one of several binaries to 
run). 
The three lines cause both sh and tclsh to process the script, but the 
exec is only executed by sh. sh processes the script first; it treats the 
second line as a comment and executes the third line. The exec statement 
cause the shell to stop processing and instead to start up tclsh to 
reprocess the entire script. When tclsh starts up, it treats all three 
lines as comments, since the backslash at the end of the second line 
causes the third line to be treated as part of the comment on the second 
line.
You should note that it is also common practice to install tclsh with its 
version number as part of the name. This has the advantage of allowing 
multiple versions of Tcl to exist on the same system at once, but also the 
disadvantage of making it harder to write scripts that start up uniformly 
across different versions of Tcl.

VARIABLES
Tclsh sets the following Tcl variables:
argc
Contains a count of the number of arg arguments (0 if none), not including 
the name of the script file.
argv
Contains a Tcl list whose elements are the arg arguments, in order, or an 
empty string if there are no arg arguments.
argv0
Contains fileName if it was specified. Otherwise, contains the name by 
which tclsh was invoked.
tcl_interactive
Contains 1 if tclsh is running interactively (no fileName was specified 
and standard input is a terminal-like device), 0 otherwise.

That's for compatibility with the Bourne shell. The Bourne shell was an 
old shell that was first released with Unix version 7 in 1979 and was 
still common until the mid 90s as /bin/sh on most commercial Unices. 

It is the ancestor of most Bourne-like shells like ksh, bash or zsh. 

It had a few awkward features many of which have been fixed in ksh and the 
other shells and the new standard specification of sh, one of which is 
this:

With the Bourne shell (at least those variants where it has not been fixed: 
"$@" expands to one empty argument if the list of positional parameters is 
empty ($# == 0) instead of no argument at all.

${var+something} expands to "something" unless $var is unset. It is 
clearly documented in all shells but hard to find in the bash 
documentation as you need to pay attention to this sentence:

When not performing substring expansion, using the forms documented below, 
bash tests for a parameter that is unset or null. Omitting the colon 
results in a test only for a parameter that is unset.


So ${1+"$@"} expands to "$@" only if $1 is set ($# > 0) which works around 
that limitation of the Bourne shell.

Note that the Bourne shell is the only shell with that problem. Modern shs 
(that is sh conforming to the POSIX specification of sh (which the Bourne 
shell is not)) don't have that issue. So you only need that if you need 
your code to work on very old systems where /bin/sh might be a Bourne 
shell instead of a standard shell (note that POSIX doesn't specify the 
location of the standard sh, so for instance on Solaris before Solaris 
11, /bin/sh was still a Bourne shell (though did not have that particular 
issue) while the normal/standard sh was in another location (/usr/xpg4/bin/sh)).

::tclreadline::Loop [historyfile ]

enter the tclreadline main loop. This command is typically called from the 
startup resource file (something .tclshrc, depending on the interpreter 
you use, see the file `sample.tclshrc'). The main loop sets up some 
completion characteristics as variable -- try something like "puts 
$b<TAB>" -- and command completion -- try "puts [in<TAB>". If the optional 
argument historyfile is given, this file will be used for reading and 
writing the command history instead of the default .tclsh-history . 
::tclreadline::Loop will normally not return. If you want to write your 
own main loop and/or own custom completers, it is probably a good idea to 
start with tclreadline::Loop (see the file tclreadlineSetup.tcl).

::tclreadline::prompt1

a proc which is called by ::tclreadline::Loop and returns a string which 
will be displayed as the primary prompt. This prompt will be something 
like "[info nameofexecutable] [[pwd]]" possibly fancy colored. The default 
proc is defined on entering the ::tclreadline::Loop, if it is not already 
defined. So: If you define your own proc ::tclreadline::prompt1 before 
entering ::tclreadline::Loop, this proc is called each time the prompt is 
to be displayed. Example:

     package require tclreadline 
     namespace eval tclreadline { 
         proc prompt1 {} { 
             return "[clock format [clock seconds]]> " 
         } 
     } 
     ::tclreadline::Loop