TCL TK Tutorial: Tool Command Language
ะฉะพ ัะฐะบะต TCL?
TCL โ ัะต ะฟัะพะณัะฐะผะฐ ะพะฑะพะปะพะฝะบะธ, ัะบะฐ ะทัะธััั ะบะพะผะฐะฝะดั TCL ะทั ััะฐะฝะดะฐััะฝะพะณะพ ะฒะฒะพะดั ะฐะฑะพ ะท ัะฐะนะปั ัะฐ ะดะฐั ะฑะฐะถะฐะฝั ัะตะทัะปััะฐัะธ.
TCL โ ัะต ะผะพะฒะฐ ััะตะฝะฐัััะฒ ะฝะฐ ะพัะฝะพะฒั ััะดะบัะฒ, ะฐ ัะฐะบะพะถ ะฟัะพัะตะดััะฝะฐ ะผะพะฒะฐ. ะะฟะตััะต ัั ััะฒะพัะธะฒ ะะถะพะฝ ะััะตัั ะฐัั ั 1989 ัะพัั. ะะตัะพั ัะพะทัะพะฑะบะธ ัััั ะผะพะฒะธ ั ะปะตะณะบะต ะฒะฑัะดะพะฒะฐะฝะต ะฟัะพะณัะฐะผะฝะต ะทะฐะฑะตะทะฟะตัะตะฝะฝั inti ( ). ะฆั ะผะพะฒะฐ ะทะฐะทะฒะธัะฐะน ะฒะธะบะพัะธััะพะฒัััััั ะดะปั GUI ัะฐ ัะตัััะฒะฐะฝะฝั. ะะฐะฟัะธะบะปะฐะด, ัะฒะธะดะบะต ะฟัะพัะพัะธะฟัะฒะฐะฝะฝั, ะขะตัััะฒะฐะฝะฝั ะฒะทะฐัะผะพะดัั ะท ะฑะฐะทะพั ะดะฐะฝะธั ัะพัะพ. ะฃ TCL ะทะฐ ะทะฐะผะพะฒััะฒะฐะฝะฝัะผ ะฒัะต ั ััะดะบะพะผ.
ะฃ ััะพะผั ะฟัะดัััะฝะธะบั ะฒะธ ะดัะทะฝะฐััะตัั-
- ะฉะพ ัะฐะบะต TCL
- ะฏะบ ะทะฐะฟัััะธัะธ TCL
- ะกะบัะธะฟัะธ TCL
- ะขะธะฟ ะทะฐะผัะฝะธ TCL
- ะะผัะฝะฝะฐ TCL
- ะะธัะฐะท TCL ั Operaัะพั
- ะะพะฝััะพะปั ะฟะพัะพะบั TCL ั ะฟัะธะนะฝัััั ัััะตะฝั
ะฏะบ ะทะฐะฟัััะธัะธ TCL
ะัะฝัั ะดะฒะฐ ัะฟะพัะพะฑะธ ะฒะธะบะพะฝะฐะฝะฝั ะบะพะดั TCL
- Windows ะดะพะดะฐัะพะบ ะฝะฐ ะพัะฝะพะฒั ะดะพัััะฟะฝะธะน ััั ัะฐะนะป tcltutor exe
- ะัะพะณัะฐะผะฐ ะฝะฐ ะฑะฐะทั Linux
In Linux ัะฝัะตัะฐะบัะธะฒะฝะธะน ัะฝัะตัะฟัะตัะฐัะพั, ะผะธ ะผะพะถะตะผะพ ะฒะธะบะพะฝัะฒะฐัะธ ััะตะฝะฐััั TCL, ัะบ ะฟะพะบะฐะทะฐะฝะพ ะฝะธะถัะต
ะฉะพะฑ ะพััะธะผะฐัะธ ะดะพัััะฟ ะดะพ ัะฝัะตัะฐะบัะธะฒะฝะพะณะพ ัะตะฐะฝัั TCL, ะฒะธะบะพะฝะฐะนัะต ัะฐะบั ะบะพะผะฐะฝะดั

ะกะบัะธะฟัะธ TCL
ะัะพะณัะฐะผะฐ TCL ะฟะพะฒะธะฝะฝะฐ ะผะฐัะธ ัะพะทัะธัะตะฝะฝั .tcl. ะะพะถะตะฝ ััะตะฝะฐััะน ะฒ UNIX/LINUX ะฟะพัะธะฝะฐััััั ะทั ัะปัั ั ะพะฑะพะปะพะฝะบะธ TCL
#!/usr/bin/tclsh
ะัะธะบะปะฐะด:-
#!/usr/bin/tclsh Puts "Hello World" Script execution:- $ chmod +x helloworld.tcl $ ./helloworld.tcl
ะะธั ัะด: ะัะธะฒัั ะกะฒัั
ะฃ TCL ะบะพะผะฐะฝะดะฐ ยซPutsยป ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะดััะบั ะฟะพะฒัะดะพะผะปะตะฝั ะฝะฐ ะบะพะฝัะพะปั. ะกะธะฝัะฐะบัะธั puts ะฝะฐะฒะตะดะตะฝะพ ะฝะธะถัะต
ััะฐะฒะธัั?-nonewline? ?channelId? ััะดะพะบ
- ะะตะท ะฝะพะฒะพะณะพ ััะดะบะฐ: ะฆะตะน ะดะพะดะฐัะบะพะฒะธะน ะฟะฐัะฐะผะตัั ะฟัะธะณะฝัััั ัะธะผะฒะพะป ะฝะพะฒะพะณะพ ััะดะบะฐ ะทะฐ ะทะฐะผะพะฒััะฒะฐะฝะฝัะผ. ะัะฝ ััะฐะฒะธัั ะฝะพะฒะธะน ััะดะพะบ ะดะพ ะบะพะถะฝะพะณะพ ััะดะบะฐ
- Channelid: ะฆะตะน ะฟะฐัะฐะผะตัั ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ััะฐะฝะดะฐััะฝะพะณะพ ะฒั ัะดะฝะพะณะพ ะบะฐะฝะฐะปั (stdin) ั ััะฐะฝะดะฐััะฝะพะณะพ ะฒะธั ัะดะฝะพะณะพ ะบะฐะฝะฐะปั (stdout).
ะะฐะฟัะธะบะปะฐะด:-
%puts "Hello World" % Hello World %puts stdout "Hello World" % Hello World
ะขะธะฟ ะทะฐะผัะฝะธ TCL
ะฃ TCL ั ััะธ ะฒะธะดะธ ะทะฐะผัะฝ
- ะะฐะผัะฝะฐ ะบะพะผะฐะฝะด
- ะะฐะผัะฝะฐ ะทะผัะฝะฝะพั
- ะะฐะผัะฝะฐ ะทะฒะพัะพัะฝะพั ะบะพัะพั ัะธัะบะธ
ะะฐะฒะฐะนัะต ะฒะธะฒัะฐัะธ ะฟะพ ะพะดะฝะพะผั
ะะฐะผัะฝะฐ ะบะพะผะฐะฝะด
ะะฒะฐะดัะฐัะฝั ะดัะถะบะธ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะฟัะดััะฐะฝะพะฒะบะธ ะบะพะผะฐะฝะด.
ะัะธะบะปะฐะด:-
% puts [expr 1*3] % 3
ะขัั ัะฟะพัะฐัะบั ะพะฑัะธัะปัััััั ะบะพะผะฐะฝะดะฐ ะฒ ะบะฒะฐะดัะฐัะฝะธั ะดัะถะบะฐั . ะ ะตะทัะปััะฐัะธ ะฟะพะฒะตััะฐััั .โะฒะธัะฐะทโ, ัะบะธะน ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะฒะธะบะพะฝะฐะฝะฝั ะฐัะธัะผะตัะธัะฝะพะณะพ ะพะฑัะธัะปะตะฝะฝั.
ะะฐะผัะฝะฐ ะทะผัะฝะฝะพั
TCL ะฒะธะบะพะฝัั ะฟัะดััะฐะฝะพะฒะบั ะทะผัะฝะฝะธั ะทะฐ ะดะพะฟะพะผะพะณะพั $ ะทะฝะฐะบ.
ะัะธะบะปะฐะด:-
#!/usr/bin/tclsh set a 10 puts a puts $a
ะขัั ะผะธ ััะฒะพัััะผะพ ะทะผัะฝะฝั ะฟัะด ะฝะฐะทะฒะพั ยซaยป ั ะฒััะฐะฝะพะฒะปััะผะพ ัะน ะทะฝะฐัะตะฝะฝั ยซ10ยป.
- puts a : ะฝะฐ ะบะพะฝัะพะปั ะฑัะดะต ะฒะธะฒะตะดะตะฝะพ ััะดะพะบ ยซaยป, ะฐะปะต ะฝะต ะทะฝะฐัะตะฝะฝั ยซaยป.
- puts $a : ะฝะฐ ะบะพะฝัะพะปั ะฑัะดะต ะฒะธะฒะตะดะตะฝะพ ะทะฝะฐัะตะฝะฝั 'a'
ะะฐะฒะฐะนัะต ะฒะธะบะพะฝะฐัะผะพ ั ะฟะตัะตะฒััะธะผะพ ัะต. ะะธ ะพััะธะผะฐััะต ัะตะทัะปััะฐั, ัะบ ะฟะพะบะฐะทะฐะฝะพ ะฝะธะถัะต.
$ ./substitution.tcl
a
10
ะะฐะผัะฝะฐ ะทะฒะพัะพัะฝะพั ะบะพัะพั ัะธัะบะธ
ะฃ Tcl ะทะฒะพัะพัะฝะฐ ะบะพัะฐ ัะธัะบะฐ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะตะบัะฐะฝัะฒะฐะฝะฝั ัะฟะตััะฐะปัะฝะธั ัะธะผะฒะพะปัะฒ, ะฐ ัะฐะบะพะถ ะดะปั ัะพะทะฟะพะดัะปั ะดะพะฒะณะธั ะบะพะผะฐะฝะด ะผัะถ ะบัะปัะบะพะผะฐ ััะดะบะฐะผะธ. ะัะดั-ัะบะธะน ัะธะผะฒะพะป ะฑะตะทะฟะพัะตัะตะดะฝัะพ ะฟััะปั ะทะฒะพัะพัะฝะพั ัะบััะฝะพั ัะธัะบะธ ะฑัะดะต ััะพััะธ ะฑะตะท ะทะฐะผัะฝะธ. ะฃ ะฝะฐะฒะตะดะตะฝะพะผั ะฝะธะถัะต ะฟัะธะบะปะฐะดั ะฒะธ ะผะพะถะตัะต ะฟะพะฑะฐัะธัะธ ัะฟะตััะฐะปัะฝะธะน ัะธะผะฒะพะป ยซ ยป, ัะบะธะน ะทะฐะปะธัะฐััััั ะฟััะปั ะทะฒะพัะพัะฝะพั ะบะพัะพั ัะธัะบะธ.
ะะตัะตะบะพะฝะฐัะผะพัั ะฒ ััะพะผั ะฝะฐ ะฟัะธะบะปะฐะดั
#!/usr/bin/tclsh puts "This is my \"car\" $ ./backslashsubstitution.tcl This is my "car"
ะะ ะะะะขะะ: -ะะปั ะบะพะผะตะฝััะฒะฐะฝะฝั ะฑัะดั-ัะบะพะณะพ ััะดะบะฐ ะฒ TCL ะฒะธะบะพัะธััะพะฒัััััั ยซ#ยป. ะฃัั ัะธะผะฒะพะปะธ ะฟััะปั ยซ#ยป ัะณะฝะพััััััั ะบะพะผะฐะฝะดะพั ะพะฑะพะปะพะฝะบะธ tclsh.
ะะผัะฝะฝะฐ TCL
ะะผัะฝะฝะฐ โ ัะต ัะดะตะฝัะธััะบะฐัะพั, ัะบะธะน ะผัััะธัั ะทะฝะฐัะตะฝะฝั. ะะฝัะธะผะธ ัะปะพะฒะฐะผะธ, ะทะผัะฝะฝะฐ - ัะต ะฟะพัะธะปะฐะฝะฝั ะฝะฐ ะฟะฐะผ'ััั ะบะพะผะฟ'ััะตัะฐ, ะดะต ะทะฑะตััะณะฐััััั ะทะฝะฐัะตะฝะฝั.
ะะผัะฝะฝั ััะฒะพััััััั ะบะพะผะฐะฝะดะพั ยซsetยป, ั ะฒัั ัะผะตะฝะฐ ะทะผัะฝะฝะธั ัััะปะธะฒั ะดะพ ัะตะณััััั. ะฆะต ะพะทะฝะฐัะฐั ะฟัะธะฒัั, ะฟัะธะฒัั, ะฟัะธะฒัั, ะฒัั ััะทะฝั ะฒ TCL. ะะพะดะธะฒััััั ะฝะฐ ะฟัะธะบะปะฐะด ะทะผัะฝะฝะพั, ัััะปะธะฒะพั โโะดะพ ัะตะณััััั.
% set name Techoit % set Name Technoit_1 % set NAME Technoit_2
ะะธั ัะด:-
% puts $name % Technoit %puts $Name %Technoit_1 %puts $NAME %Technoit_2
ะกัะฒะพัะตะฝะฝั ะทะผัะฝะฝะธั TCL
ะฉะพะฑ ััะฒะพัะธัะธ ะทะผัะฝะฝั ะฒ TCL, ะฟะพัััะฑะฝะพ ะฒะธะบะพัะธััะพะฒัะฒะฐัะธ ยซะฝะฐะฑััยป ะบะพะผะฐะฝะดะฐ
ะััะฐะฝะพะฒััั 10
ะฉะพะฑ ะพััะธะผะฐัะธ ะทะฝะฐัะตะฝะฝั ะทะผัะฝะฝะพั, ะฟะพัััะฑะฝะพ ะฒะธะบะพัะธััะพะฒัะฒะฐัะธ ัะธะผะฒะพะป ยซ$ยป, ะฝะฐะฟัะธะบะปะฐะด
% ะฟะพััะฐะฒะธัะธ $a
% 10
ะัะถะต, ะผะธ ะพััะธะผััะผะพ ะทะฝะฐัะตะฝะฝั ะทะผัะฝะฝะพั 'a' ัะบ 10.
ะะฝัะพัะผะฐััั ะฟัะพ ะบะพะผะฐะฝะดั TCL ััะฝัั
ะะพะผะฐะฝะดะฐ ยซsetยป ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ััะฒะพัะตะฝะฝั ัะฐ ัะธัะฐะฝะฝั ะทะผัะฝะฝะธั , ัะบ ะฟะพะบะฐะทะฐะฝะพ ะฒะธัะต. ะะพะผะฐะฝะดะฐ unset ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะทะฝะธัะตะฝะฝั ะทะผัะฝะฝะพั. ะะพะผะฐะฝะดะฐ ยซinfo existsยป ะฟะพะฒะตััะฐั 1, ัะบัะพ varName ััะฝัั ัะบ ะทะผัะฝะฝะฐ (ะฐะฑะพ ะตะปะตะผะตะฝั ะผะฐัะธะฒั) ั ะฟะพัะพัะฝะพะผั ะบะพะฝัะตะบััั, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0. (ะดะธะฒ. ะฟัะธะบะปะฐะด ะฝะธะถัะต).
ะฃ TCL ั ััะทะฝั ะบะพะผะฐะฝะดะธ ยซinfoยป, ัะบ-ะพั ยซinfo existsยป, ยซinfo functionsยป, ยซinfo globalยป ัะพัะพ. ะขัั ะผะธ ะฟะพะฑะฐัะธะผะพ ะฟัะธะบะปะฐะด ยซัะฝัะพัะผะฐััั ััะฝััยป.
ะะฐะฟัะธะบะปะฐะด:-
% set a 20 % puts $a % 20 % puts [info exists a] % 1 % unset a %puts [info exists a] % 0
ะ ัะทะฝั ะฑัะตะบะตัะธ ั ัั ะฟะพะฒะตะดัะฝะบะฐ
{} -> ะคัะณััะฝั ะดัะถะบะธ
ะคัะณััะฝั ะดัะถะบะธ ะฒ TCL ะณััะฟัััั ัะปะพะฒะฐ ัะฐะทะพะผ, ัะพะฑ ััะฐัะธ ะฐัะณัะผะตะฝัะฐะผะธ. ะคัะณััะฝั ะดัะถะบะธ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะฒะธะทะฝะฐัะตะฝะฝั ะฒัะดะบะปะฐะดะตะฝะพะณะพ ะฑะปะพะบั โ ัะฝัะธะผะธ ัะปะพะฒะฐะผะธ, ะนะพะณะพ ะผะพะถะฝะฐ ะทะฐะฟัััะธัะธ ะะะกะะฏ ัะตััะธ ะบะพะผะฐะฝะดะธ ะฒ ะฟะพัะพัะฝะพะผั ััะดะบั. ะกะธะผะฒะพะปะธ ะฒ ััะณััะฝะธั ะดัะถะบะฐั ะฟะตัะตะดะฐััััั ะบะพะผะฐะฝะดั ัะพัะฝะพ ัะฐะบ, ัะบ ะฒะพะฝะธ ะฝะฐะฟะธัะฐะฝั.
ะะตัะบั ะผะพะผะตะฝัะธ, ะฟัะพ ัะบั ะฒะฐััะพ ะฟะฐะผโััะฐัะธ
- ะะฐะผัะฝะฐ ะทะผัะฝะฝะพั ะฒ ััะณััะฝะธั ะดัะถะบะฐั {} ะทะฐะฑะพัะพะฝะตะฝะฐ
- ะัะฝ ะฒะธะบะพัะธััะพะฒัะฒะฐะฒัั ะดะปั ััะฒะพัะตะฝะฝั ัะธะฟั ะดะฐะฝะธั ัะฟะธัะบั
ะัะธะบะปะฐะด:-
% set x 10
% puts {$x}
% $x
%set number {1 2 3 4 5} -> ะขัั ัะธัะปะพ ั ัะธะฟะพะผ ะดะฐะฝะธั ัะฟะธัะบั
%ะฟะพะผััะฐั $number
%1 2 3 4 5
[] -> ะบะฒะฐะดัะฐัะฝั ะดัะถะบะธ
ะะฒะฐะดัะฐัะฝั ะดัะถะบะธ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ััะฒะพัะตะฝะฝั ะฒะบะปะฐะดะตะฝะพั ะบะพะผะฐะฝะดะธ. ะัะพััััะต ะบะฐะถััะธ, ะฒะธั ัะด ะพะดะฝััั ะบะพะผะฐะฝะดะธ ะฟะตัะตะดะฐััััั ัะบ ะฐัะณัะผะตะฝั ัะฝััะน ะบะพะผะฐะฝะดั. ะะฒะฐะดัะฐัะฝั ะดัะถะบะธ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะฒะธะทะฝะฐัะตะฝะฝั ะฑะปะพะบั, ัะบะธะน ะฒะธะบะพะฝัััััั ะะะ ะะ ัะตััะพั ะบะพะผะฐะฝะดะธ ะฒ ะฟะพัะพัะฝะพะผั ััะดะบั, ะฐ ัะตะทัะปััะฐั ะฟัะดััะฐะฒะปัััััั ะฒ ััะดะพะบ.
ะัะธะบะปะฐะด: โ
% set x 10 % puts "y : [set y [set x 10]]" %y : 10 % puts "x : $x" %x : 10
() -> ะบััะณะปั ะดัะถะบะธ
ะฆั ะบะพะผะฐะฝะดะฐ ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ััะฒะพัะตะฝะฝั ัะธะฟั ะดะฐะฝะธั ะผะฐัะธะฒั, ะฐ ัะฐะบะพะถ ะดะปั ะฒะบะฐะทัะฒะบะธ ะฟััะพัะธัะตัั ะพะฟะตัะฐัะพัะฐ.
% set a(1) 10 % set a(2) 20
ะขัั ยซaยป โ ัะต ะผะฐัะธะฒ ะทั ะทะฝะฐัะตะฝะฝัะผะธ 10 ั 20. ะะธะถัะต ะฝะฐะฒะตะดะตะฝะพ ะบะพะผะฐะฝะดะธ ะดะปั ะดััะบั ะบะปัััะฒ, ะฟะฐั ะบะปัััะฒ-ะทะฝะฐัะตะฝั ั ะทะฝะฐัะตะฝั ะผะฐัะธะฒั.
% puts [array get a] -> To print key value pairs we use this command % 1 10 2 20 % puts [array names a] -> To print only keys % 1 2 % puts $a(1) -> To print first value of array % 10 % puts $a(2) -> To print second value of array % 20
ะะปั ะดััะบั ยซN-ะณะพยป ะทะฝะฐัะตะฝะฝั ะผะฐัะธะฒั a ะผะธ ะฒะธะบะพัะธััะฐัะผะพ Puts $a(N)
ะัะณัะผะตะฝัะธ ะบะพะผะฐะฝะดะฝะพะณะพ ััะดะบะฐ TCL
ะะปะตะผะตะฝัะธ ะดะฐะฝะธั , ัะพ ะฟะตัะตะดะฐััััั ััะตะฝะฐััั ะท ะบะพะผะฐะฝะดะฝะพะณะพ ััะดะบะฐ, ะฝะฐะทะธะฒะฐััััั ะฐัะณัะผะตะฝัะฐะผะธ. ะัะปัะบัััั ะฐัะณัะผะตะฝััะฒ ะบะพะผะฐะฝะดะฝะพะณะพ ััะดะบะฐ ััะตะฝะฐััั Tcl ะฟะตัะตะดะฐััััั ัะบ ะณะปะพะฑะฐะปัะฝะฐ ะทะผัะฝะฝะฐ argc . ะะผ'ั ััะตะฝะฐััั Tcl ะฟะตัะตะดะฐััััั ััะตะฝะฐััั ัะบ ะณะปะพะฑะฐะปัะฝะฐ ะทะผัะฝะฝะฐ argv0 , ะฐ ัะตััะฐ ะฐัะณัะผะตะฝััะฒ ะบะพะผะฐะฝะดะฝะพะณะพ ััะดะบะฐ ะฟะตัะตะดะฐััััั ัะบ ัะฟะธัะพะบ ั argv.
TCL ะผะฐั 3 ะฟะพะฟะตัะตะดะฝัะพ ะฒะธะทะฝะฐัะตะฝั ะทะผัะฝะฝั, ะฝะฐะฟัะธะบะปะฐะด
$argc -> indicates the number of arguments passed to the script $argv -> indicates list of arguments $argv0 -> indicates the name of script
ะะฐะฟัะธะบะปะฐะด:โ
arg-script.tcl #!/usr/bin/tclsh< puts "number of arguments passed to the scripts : $argc" puts "list of arguments are passed to the script: $argv" puts "the name of scripts is: $argv0"
$ ./arg-script.tcl 10 20 30
ะฒะธั ัะด:-
- ะัะปัะบัััั ะฐัะณัะผะตะฝััะฒ, ะฟะตัะตะดะฐะฝะธั ะดะพ ััะตะฝะฐัััะฒ: 3
- ะกะบัะธะฟัั ะฟะตัะตะดะฐััััั ัะฟะธัะพะบ ะฐัะณัะผะตะฝััะฒ: 10 20 30
- ะะฐะทะฒะฐ ััะตะฝะฐััั: arg-script.tcl
ะะธัะฐะท TCL ั Operaัะพั
ะะธัะฐะท ัะบะปะฐะดะฐััััั ะท ะพะฟะตัะฐะฝะดัะฒ ั ะพะฟะตัะฐัะพััะฒ. ะัะฝ ะพะฑัะธัะปัััััั ะทะฐ ะดะพะฟะพะผะพะณะพั ะบะพะผะฐะฝะดะธ "expr". Operaัะพัะธ ะพััะฝัััััั ะฝะฐ ะพัะฝะพะฒั ะฟััะพัะธัะตัั ัะฐ ะฐัะพััะฐัะธะฒะฝะพััั. ะะพะฒะฐ TCL ะผะฐั ะฒะฑัะดะพะฒะฐะฝั ะพะฟะตัะฐัะพัะธ, ัะบ ะฟะพะบะฐะทะฐะฝะพ ะฝะธะถัะต
| Operaะขะพั ะะฐัะตะณะพััั | Symbol | ะะพะฟะตัะตะดะฝัััั/ะฐัะพััะฐัะธะฒะฝัััั |
|---|---|---|
| ะัะธัะผะตัะธะบะฐ Operaัะพั | + - * / % | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ะ ะตะปัััะนะฝะธะน Operaัะพั | == != < > <= >= | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ะปะพะณััะฝะธะน Operaัะพั | && || ! | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ะะพะฑััะพะฒะธะน Operaัะพั | & | ^ ~ | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ะขััะฝะฐัะฝะธะน Operaัะพั | ?: | ะัะฐะฒะพััั ะฝะฐะปัะฒะพ |
| Shift Operaัะพั | << >> | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ะะพััะฒะฝัะฝะฝั ััะดะบัะฒ Operaัะพั | eq ne | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ะะบัะฟะพะฝะตะฝััั Operaัะพั | ** | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
| ัะฟะธัะพะบ Operaัะพั | ะ ะฝั | ะะปัะฒะฐ ะฝะฐะฟัะฐะฒะพ |
ะัะธัะผะตัะธะบะฐ Operaัะพั
ะะธัะฐะท TCL ัะบะปะฐะดะฐััััั ะท ะบะพะผะฑัะฝะฐััั ะพะฟะตัะฐะฝะดัะฒ, ะพะฟะตัะฐัะพััะฒ ั ะบััะณะปะธั ะดัะถะพะบ. ะ ะพะทะณะปัะฝัะผะพ ะฟัะธะบะปะฐะด ะฐัะธัะผะตัะธัะฝะธั ะพะฟะตัะฐัะพััะฒ ั TCL
+ ะะพะดะฐะนัะต ะดะฒะฐ ะฐะฑะพ ะฑัะปััะต ะพะฟะตัะฐะฝะดัะฒ
ะะฐะฟัะธะบะปะฐะด:-
%set a 10 %set b 20 %puts [expr $a + $b] 30
- ะัะดะฝัะผะฐั ะดะฒะฐ ะฐะฑะพ ะฑัะปััะต ะพะฟะตัะฐะฝะดัะฒ
ะะฐะฟัะธะบะปะฐะด:-
%set a 20 %set b 10 %puts [expr $a - $b] 10
* ะะฝะพะถะตะฝะฝั ะดะฒะพั ะฐะฑะพ ะฑัะปััะต ะพะฟะตัะฐะฝะดัะฒ
%set a 20 %set b 10 %puts [expr $a * $b] 200
/ ะ ะพะทะดัะปััั ัะธัะตะปัะฝะธะบ ะฝะฐ ะฒัะดะผะตะฝะฝะธะบ
%set a 20 %set b 10 %puts [expr $a / $b] 2
% ะะฟะตัะฐัะพั ะผะพะดัะปั ะดัะปะธัั ัะธัะตะปัะฝะธะบ ะฝะฐ ะทะผะตะฝััะฒะฐั, ะฐะปะต ะฟะพะฒะตััะฐั ะฝะฐะณะฐะดัะฒะฐะฝะฝั
%set a 20 %set b 10 %puts [expr $a % $b] 0
ะ ะตะปัััะนะฝะธะน Operaัะพั
ะะตัะตะฒัััั, ัะธ ะทะฝะฐัะตะฝะฝั ะปัะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ ะฑัะปััะต ะทะฐ ะทะฝะฐัะตะฝะฝั ะฟัะฐะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ. ะฏะบัะพ ัะฐะบ, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0.
%set a 20 %set b 10 %puts [expr $a > $b] 1
ะะตัะตะฒัััะต, ัะธ ะทะฝะฐัะตะฝะฝั ะปัะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ ะผะตะฝัะต ะทะฐ ะทะฝะฐัะตะฝะฝั ะฟัะฐะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ. ะฏะบัะพ ัะฐะบ, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 10 %set b 20 %puts [expr $a < $b] 1
>= ะะตัะตะฒัััั, ัะธ ะทะฝะฐัะตะฝะฝั ะปัะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ ะฑัะปััะต ะฐะฑะพ ะดะพััะฒะฝัั ะทะฝะฐัะตะฝะฝั ะฟัะฐะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ, ัะบัะพ ัะฐะบ, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 20 %set b 10 %puts [expr $a >= $b] 1
<= ะะตัะตะฒัััั, ัะธ ะทะฝะฐัะตะฝะฝั ะปัะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ ะผะตะฝัะต ะฐะฑะพ ะดะพััะฒะฝัั ะทะฝะฐัะตะฝะฝั ะฟัะฐะฒะพะณะพ ะพะฟะตัะฐะฝะดะฐ, ัะบัะพ ัะฐะบ, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 20 %set b 10 %puts [expr $a <= $b] 0
!= ะะตัะตะฒัััั, ัะธ ะทะฝะฐัะตะฝะฝั ะดะฒะพั ะพะฟะตัะฐะฝะดัะฒ ััะฒะฝั ัะธ ะฝั, ัะบัะพ ะทะฝะฐัะตะฝะฝั ะฝะต ััะฒะฝั, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 20 %set b 10 %puts [expr $a != $b] 1
== ะะตัะตะฒัััั, ัะธ ะทะฝะฐัะตะฝะฝั ะดะฒะพั ะพะฟะตัะฐะฝะดัะฒ ััะฒะฝั ัะธ ะฝั, ัะบัะพ ัะฐะบ, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 20 %set b 10 %puts [expr $a == $b] 0
ะปะพะณััะฝะธะน Operaัะพั
&& ะฏะบัะพ ะพะฑะธะดะฒะฐ ะพะฟะตัะฐะฝะดะธ ะฝะต ะฝัะปัะพะฒั, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 20 %set b 10 %puts [expr $a && $b] 1
|| ะฏะบัะพ ะฑัะดั-ัะบะธะน ัะท ะดะฒะพั ะพะฟะตัะฐะฝะดัะฒ ะฒัะดะผัะฝะฝะธะน ะฒัะด ะฝัะปั, ัะพะดั ัะผะพะฒะฐ ััะฐั ัััะธะฝะฝะพั ัะฐ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0
%set a 0 %set b 10 %puts [expr $a || $b] 1
! ะะธะบะพัะธััะพะฒัััััั ะดะปั ะทะฒะพัะพัะฝะพะณะพ ัะตะทัะปััะฐัั ะฑัะดั-ัะบะพะณะพ ะฒะธัะฐะทั. ะขัั ั ะฒะธั ัะดะฝะธั ะดะฐะฝะธั ะฒะธ ะผะพะถะตัะต ะฟะพะฑะฐัะธัะธ, ัะพ ะทะฝะฐัะตะฝะฝั 'a' ัะตะฟะตั ะทะผัะฝะธะปะพัั ะฝะฐ 1 ะท 0. ะขะพะดั ัะบ ะทะฝะฐัะตะฝะฝั 'b' ััะฐะปะพ 0 ะท 1.
%set a 0 %set b 1 %puts [expr !$a] 1 %puts [expr !$b] 0
ะะพะฑััะพะฒะธะน Operaัะพั
& (ะฟะพัะพะทััะดะฝะพ ัะฐ) ะฒะธะบะพะฝะฐะนัะต ะฟะพะฑััะพะฒั ะพะฟะตัะฐััั ัะฐ ะดะพััะธะผัะนัะตัั ะฝะฐะฒะตะดะตะฝะพั ะฝะธะถัะต ัะฐะฑะปะธัั ะดะปั ะฒะธะบะพะฝะฐะฝะฝั ะพะฟะตัะฐััะน.
| A | B | A & B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 1 | 1 |
| 1 | 0 | 0 |
ะะฐะฟัะธะบะปะฐะด:-
%set A 10 %set B 20 Follow the sequence to convert decimal to binary number 128 64 32 16 8 4 2 1 10 binary equivalents will be 128 64 32 16 8 4 2 1 ร 0 0 0 0 1 0 1 0 20 binary equivalents will be 128 64 32 16 8 4 2 1 ร 0 0 0 1 0 1 0 0 So now as per above tabular rules A & B will be 0 0 0 0 0 0 0 0
| (ะฟะพัะพะทััะดะฝะพ ะฐะฑะพ) ะฒะธะบะพะฝะฐะนัะต ะฟะพัะพะทััะดะฝั ะพะฟะตัะฐััั ัะฐ ะดะพััะธะผัะนัะตัั ัะฐะฑะปะธัั ะฝะธะถัะต
| A | B | A | ะ |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 1 |
| 1 | 0 | 1 |
ะะฐะฟัะธะบะปะฐะด:-
%set A 10 %set B 20 Follow the sequence to convert decimal to binary number 128 64 32 16 8 4 2 1 10 binary equivalents will be 128 64 32 16 8 4 2 1 ร 0 0 0 0 1 0 1 0 20 binary equivalents will be 128 64 32 16 8 4 2 1 ร 0 0 0 1 0 1 0 0 So now as per above tabular rules A | B will be 0 0 0 1 1 1 1 0
^ (ะฟะพะฑััะพะฒะพ ะตะบัะบะปัะทะธะฒะฝะต ะฐะฑะพ) ะฒะธะบะพะฝะฐะนัะต ะฟะพะฑััะพะฒั ะพะฟะตัะฐััั ัะฐ ะดะพััะธะผัะนัะตัั ัะฐะฑะปะธัั ะฝะธะถัะต
| A | B | ะ ^ ะ |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 1 | 0 |
| 1 | 0 | 1 |
ะะฐะฟัะธะบะปะฐะด:-
%set A 10 %set B 20 Follow the sequence to convert decimal to binary number 128 64 32 16 8 4 2 1 10 binary equivalents will be 128 64 32 16 8 4 2 1 ร 0 0 0 0 1 0 1 0 20 binary equivalents will be 128 64 32 16 8 4 2 1 ร 0 0 0 1 0 1 0 0 So now as per above tabular rules A ^ B will be 0 0 0 1 1 1 1 0 ร 30
ะะฟะตัะฐัะพั ~ (ะฟะพัะพะทััะดะฝะต ะทะฐะฟะตัะตัะตะฝะฝั) ะทะผัะฝัั ะบะพะถะตะฝ 1 ะฝะฐ 0 ั 0 ะฝะฐ 1, ะดะพััะธะผัะนัะตัั ัะฐะฑะปะธัั ัะบ ะฟะพัะธะปะฐะฝะฝั
| A | ~A |
|---|---|
| 0 | 1 |
| 1 | 0 |
%set A 7 %puts [expr ~$A] -8
ะขััะฝะฐัะฝะธะน Operaัะพั (?:)
ะกะธะฝัะฐะบัะธั ั
condition-expression? expression_1: expression_2
ะฏะบัะพ ัะผะพะฒะฐ-exp ัััะธะฝะฝะฐ, exp1 ะพะฑัะธัะปัััััั ั ะฟะพะฒะตััะฐััััั ัะตะทัะปััะฐั. ะฏะบัะพ cond-exp ั ั ะธะฑะฝะธะผ, exp2 ะพะฑัะธัะปัััััั ัะฐ ะฟะพะฒะตััะฐััััั ะนะพะณะพ ัะตะทัะปััะฐั. ะฃ ะฝะฐัะพะผั ะฟัะธะบะปะฐะดั exp1 ั ัััะธะฝะฝะธะผ, ะพัะบัะปัะบะธ ะทะฝะฐัะตะฝะฝั A ะฑัะปััะต 6.
%set A 7 %set result [expr $A > 6 ? true : false] %puts $result true
Shift Operaัะพั
Shift ะฟะพะทะฝะฐัะฐััััั ะฐะฑะพ << ะพะฟะตัะฐัะพัะพะผ ะทััะฒั ะฒะปัะฒะพ, ะฐะฑะพ ะพะฟะตัะฐัะพัะพะผ >> ะทััะฒั ะฒะฟัะฐะฒะพ. ะะปั << ะพะฟะตัะฐัะพัะฐ ะทััะฒั ะฒะปัะฒะพ ะทะฝะฐัะตะฝะฝั ะปัะฒะธั ะพะฟะตัะฐะฝะดัะฒ ะฟะตัะตะผัััััััั ะฒะปัะฒะพ ะฝะฐ ะบัะปัะบัััั ะฑัััะฒ, ะฒะธะทะฝะฐัะตะฝั ะฟัะฐะฒะธะผ ะพะฟะตัะฐะฝะดะพะผ.
%set A 7 %set result [expr $A << 2] %puts $result
ะะปั ะพะฟะตัะฐัะพัะฐ ะทััะฒั ะฒะฟัะฐะฒะพ ะทะฝะฐัะตะฝะฝั ะปัะฒะธั ะพะฟะตัะฐะฝะดัะฒ ะฟะตัะตะผัััััััั ะฒะฟัะฐะฒะพ ะฝะฐ ะบัะปัะบัััั ะฑัััะฒ, ะฒะธะทะฝะฐัะตะฝั ะฟัะฐะฒะธะผ ะพะฟะตัะฐะฝะดะพะผ.
%set A 7 %set result [expr $A >> 2] %puts $result
ะะพััะฒะฝัะฝะฝั ััะดะบัะฒ Operaัะพั
ะะฟะตัะฐัะพั ะฟะพััะฒะฝัะฝะฝั ััะดะบัะฒ ะฟะพััะฒะฝัั ะทะฝะฐัะตะฝะฝั ะพะฑะพั ะพะฟะตัะฐะฝะดัะฒ. ะฏะบัะพ ะทะฝะฐัะตะฝะฝั ะพะฟะตัะฐะฝะดะฐ ะพะดะฝะฐะบะพะฒะต, ัะพะดั ะฒัะฝ ะฟะพะฒะตัะฝะต 1, ัะฝะฐะบัะต ะฟะพะฒะตัะฝะต 0. ะฃ ะฟัะธะบะปะฐะดั ะทะฝะฐัะตะฝะฝั ัะบ ะดะปั A, ัะฐะบ ั ะดะปั B ะดะพััะฒะฝัั 7, ัะพะผั ัะตะทัะปััะฐั ะฟะพะฒะตัะฝะต 1.
ะะฐะฟัะธะบะปะฐะด:-
%set A 7 %set B 7 %set result [expr $A eq $B] %puts $result 1
Ne (ัะบัะพ ะทะฝะฐัะตะฝะฝั ะพะฑะพั ะพะฟะตัะฐะฝะดัะฒ ััะทะฝั, ัะพะดั ะฟะพะฒะตััะฐััััั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐััััั 0)
%set A 7 %set B 8 %set result [expr $A ne $B] %puts $result 1
ะะฟะตัะฐัะพั ะฟัะดะฒะตะดะตะฝะฝั ะดะพ ััะตะฟะตะฝั
Pow () ั ** ะพะดะฝะฐะบะพะฒั. ะัะฝ ะทะฐะฒะถะดะธ ะฟะพะฒะตััะฐั ะฟะปะฐะฒะฐััะต ะทะฝะฐัะตะฝะฝั.
** ะฒะบะฐะทัั ะฟะพััะถะฝัััั ะฟะพัััะฑะฝะพะณะพ ะพะฟะตัะฐะฝะดะฐ.
ะะฐะฟัะธะบะปะฐะด:-
%set A 7 %set result [expr $A ** 2] %puts $result 49
ัะฟะธัะพะบ Operaัะพั
ะฏะบัะพ ะฝะตะพะฑั ัะดะฝะต ะทะฝะฐัะตะฝะฝั ะทะฝะฐะนะดะตะฝะพ ั ะฒะธะทะฝะฐัะตะฝะพะผั ัะฟะธัะบั, ะฒะพะฝะพ ะฟะพะฒะตััะฐั 1, ัะฝะฐะบัะต ะฟะพะฒะตััะฐั 0. ะฃ ะฟัะธะบะปะฐะดั ะทะฝะฐัะตะฝะฝั 1 ััะฝัั ั ะทะผัะฝะฝัะน ยซaยป, ะพัะถะต, ะฒะพะฝะพ ะฟะพะฒะตััะฐั 1.
set a {1 2 3}
if {1 in $a} {
puts "ok"
} else {
puts "fail"
}
Output: ok
ni, ัะบัะพ ะฝะตะพะฑั ัะดะฝะต ะทะฝะฐัะตะฝะฝั ะทะฝะฐะนะดะตะฝะพ ั ะฒะธะทะฝะฐัะตะฝะพะผั ัะฟะธัะบั, ัะพะดั ะฒะพะฝะพ ะฟะพะฒะตัะฝะต 0, ัะฝะฐะบัะต ะฟะพะฒะตัะฝะต 1.
ะะฐะฟัะธะบะปะฐะด: -
set a {1 2 3}
if {1 ni $a} {
puts "ok"
} else {
puts "fail"
}
Output: fail
ะะพะฝััะพะปั ะฟะพัะพะบั TCL ั ะฟัะธะนะฝัััั ัััะตะฝั
ะัะฝัััั ััะทะฝั ะบะพะผะฐะฝะดะธ ะบะตััะฒะฐะฝะฝั ะฟะพัะพะบะพะผ ั ะฟัะธะนะฝัััั ัััะตะฝั, ัะบั ะฒะธะบะพัะธััะพะฒัััััั ะดะปั ะทะผัะฝะธ ะฟะพัะพะบั ะฟัะพะณัะฐะผะธ. ะะธะบะพะฝะฐะฝะฝั ะฟัะพะณัะฐะผะธ ะทะฐะฒะถะดะธ ะฟะพัะธะฝะฐััััั ะท ะฒะตัั ะฝัะพั ัะฐััะธะฝะธ ะฒะธั ัะดะฝะพะณะพ ัะฐะนะปั ะดะพ ะฝะธะถะฝัะพั.
ะะฟะตัะฐัะพั If ัะบะปะฐะดะฐััััั ะท ะปะพะณััะฝะพะณะพ ะฒะธัะฐะทั, ะทะฐ ัะบะธะผ ัะปัะดัััั ะพะดะธะฝ ะฐะฑะพ ะฑัะปััะต ะพะฟะตัะฐัะพััะฒ.
ะฏะบัะพ ... ัะฒะตัะดะถะตะฝะฝั
ะกะธะฝัะฐะบัะธั: -
ัะบัะพ ะฒะธัะฐะท ?ัะพ? ััะปะพ
ัะบัะพ ะฒะธัะฐะท ะพััะฝัััััั ัะบ ัััะธะฝะฐ, ัะพะดั ะฒะธะบะพะฝัััััั ััะปะพ ะบะพะผะฐะฝะดะธ.
ะะฐะฟัะธะบะปะฐะด:-
set age 10
if {$age < 20} {
puts "Age is less than 20"
}
Output: Age is less than 20
ะะฟะตัะฐัะพั If ... else
ะกะธะฝัะฐะบัะธั: -
ะฏะบัะพ ะฒะธัะฐะท ? ัะพะดั body_1 ัะต body_2
ะฏะบัะพ ะฒะธัะฐะท ะพััะฝะตะฝะพ ัะบ ัััะธะฝะฝะธะน, ะฒัะฝ ะฟะพะฒะตัะฝะต ััะปะพ_1, ัะฝะฐะบัะต ะฟะพะฒะตัะฝะต ััะปะพ_2
ะัะธะบะปะฐะด:--
set age 10
if {$age < 20} {
puts "Age is less than 20"
} else {
Puts "Age is greater than 20"
}
output: Age is less than 20
ะะบะปะฐะดะตะฝะธะน ะพะฟะตัะฐัะพั if..else
ะฆะต ะพะทะฝะฐัะฐั, ัะพ ะพะดะธะฝ ะพะฟะตัะฐัะพั if ะฐะฑะพ else..if ะผะพะถะฝะฐ ะฟะพะผัััะธัะธ ะฒ ัะฝัะธะน ะพะฟะตัะฐัะพั if ะฐะฑะพ else..if.
ะกะธะฝัะฐะบัะธั: -
If {expression_1} {
Body_1
If {expression_2} {
Body_2
}
}
ะัะธะบะปะฐะด:--
set a 10
set b 20
if {$a == 10} {
# if expression_1 is true then it will go to expression_2
if {$b == 20} {
#if expression_2 is true then it will print the below string
puts "value of a is 10 and b is 20"
}
}
o/p: value of a is 10 and b is 20
ะะฐัะฒะฐ ะฟะตัะตะบะปััะตะฝะฝั
ะะฝััััะบััั switch ะดะฐั ะทะผะพะณั ะฟะตัะตะฒััะธัะธ ะทะผัะฝะฝั ะฝะฐ ะฒัะดะฟะพะฒัะดะฝัััั ัะฟะธัะบั ะทะฝะฐัะตะฝั. ะัะฝ ะพะฑัะธัะปัั ัะฟะธัะพะบ ะทะฝะฐัะตะฝั ั ะฟะพะฒะตััะฐั ัะตะทัะปััะฐั ััะพะณะพ ะพะฑัะธัะปะตะฝะฝั. ะฏะบัะพ ะถะพะดะฝะต ะทะฝะฐัะตะฝะฝั ะฝะต ะทะฑัะณะฐััััั, ะฟะพะฒะตััะฐััััั ะทะฝะฐัะตะฝะฝั ะทะฐ ะทะฐะผะพะฒััะฒะฐะฝะฝัะผ.
ะัะธะบะปะฐะด:
#!/usr/bin/tclsh
# switch_cmd.tcl
set domain x
switch $domain {
x { puts "x" }
y { puts "y" }
z { puts "z" }
default { puts "unknown" }
}
ะะบะปะฐะดะตะฝะธะน ะฟะตัะตะผะธะบะฐั
ะะบะปะฐะดะตะฝะธะน ะพะฟะตัะฐัะพั switch ะพะทะฝะฐัะฐั ะพะฟะตัะฐัะพั switch ะฒ ะพะฟะตัะฐัะพัั switch.
ัะธะฝัะฐะบัะธั :-
switch <switchingstring1> {
<matchstring1> {
body1
switch <switchingstring2> {
<matchstring2> {
body2
}
...
switch <switchingstringN> {
<matchStringN> {
bodyN
}
}
}
ะัะธะบะปะฐะด: ั ะฝะฐัััะฟะฝะพะผั ะฟัะธะบะปะฐะดั ะทะฝะฐัะตะฝะฝั a ะดะพััะฒะฝัั 100, ั ะทะฐ ะดะพะฟะพะผะพะณะพั ัะพะณะพ ัะฐะผะพะณะพ ะบะพะดั ะผะธ ะฟะตัะตะผะธะบะฐัะผะพ ะพะฟะตัะฐัะพั ะดะปั ัะฝัะพะณะพ ะทะฝะฐัะตะฝะฝั b ะดะพััะฒะฝัั 200. ะะธั ัะด ะฟะพะบะฐะถะต ะทะฝะฐัะตะฝะฝั ัะบ ะดะปั a, ัะฐะบ ั ะดะปั b.
#!/usr/bin/tclsh
set a 100
set b 200
switch $a {
100 {
puts "The value of a is $a"
switch $b {
200 {
puts "The value of b is $b"
}
}
}
}
ะะธั ัะด:-
ะะฝะฐัะตะฝะฝั a ะดะพััะฒะฝัั 100
ะะฝะฐัะตะฝะฝั b ะดะพััะฒะฝัั 200
ะะฟะตัะฐัะพั ัะธะบะปั TCL
ะะฟะตัะฐัะพั ัะธะบะปั ะดะพะทะฒะพะปัั ะฒะธะบะพะฝัะฒะฐัะธ ะพะฟะตัะฐัะพั ะฐะฑะพ ะณััะฟั ะพะฟะตัะฐัะพััะฒ ะบัะปัะบะฐ ัะฐะทัะฒ. Tcl ะฝะฐะดะฐั ะฝะฐัััะฟะฝั ัะธะฟะธ ะพะฟะตัะฐัะพััะฒ ัะธะบะปั.
ะะพะบะธ ะบะพะผะฐะฝะดะฐ
ะะพะปะธ ะทะฐะดะฐะฝะฐ ัะผะพะฒะฐ ั ัััะธะฝะฝะพั, ะพะฟะตัะฐัะพั ะฐะฑะพ ะณััะฟะฐ ะพะฟะตัะฐัะพััะฒ ะฟะพะฒัะพััััััั ะฒ ััะปั ัะธะบะปั.
ัะธะฝัะฐะบัะธั:
While {condition} {
Statements
}
ะะฐะฟัะธะบะปะฐะด: -
#!/usr/bin/tclsh
Set a 10
While {$a < 12} {
Puts "a is $a"
incr a
}
ะะธั ัะด:-
ะฐ ะดะพััะฒะฝัั 10
ะฐ ะดะพััะฒะฝัั 11
ะฃ ะฝะฐะฒะตะดะตะฝะพะผั ะฒะธัะต ะฟัะธะบะปะฐะดั ะฒะธะบะพัะธััะพะฒัััััั ะฒะฑัะดะพะฒะฐะฝะฐ ะบะพะผะฐะฝะดะฐ "incr". ะฆะต ะพะทะฝะฐัะฐั, ัะพ ะทะฝะฐัะตะฝะฝั ยซaยป ะฑัะดะต ะทะฑัะปััะตะฝะพ ะฝะฐ 1 ะดะพ ะผะฐะบัะธะผะฐะปัะฝะพะณะพ ะทะฝะฐัะตะฝะฝั (<12).
ะะปั ะฝะฐะบะฐะทั
ะัะฝ ะฒะธะบะพะฝัั ะฟะพัะปัะดะพะฒะฝัััั ะพะฟะตัะฐัะพััะฒ ะบัะปัะบะฐ ัะฐะทัะฒ ะฝะฐ ะพัะฝะพะฒั ะทะฝะฐัะตะฝะฝั ะปััะธะปัะฝะธะบะฐ. ะัะฝ ะฐะฒัะพะผะฐัะธัะฝะพ ะทะฑัะปัััััััั ะฐะฑะพ ะทะผะตะฝััััััั ะฟัะด ัะฐั ะบะพะถะฝะพะณะพ ะฟะพะฒัะพัะตะฝะฝั ัะธะบะปั.
ัะธะฝัะฐะบัะธั :-
For {start} {test} {next} {
Body
}
ะัะธะบะปะฐะด: ั ะฝะฐะฒะตะดะตะฝะพะผั ะฝะธะถัะต ะฟัะธะบะปะฐะดั ะทะฝะฐัะตะฝะฝั ยซiยป ะฒััะฐะฝะพะฒะปะตะฝะพ ะฝะฐ 0 ั ะทะฑัะปัััััััั ะดะพ ะทะฝะฐัะตะฝะฝั <5.
#!/usr/bin/tclsh
for {set i 0} {$i < 5} {incr i} {
put $i
}
ะะธั ัะด:-
0 1 2 3 4
ะัะฝะพะฒะฝะฐ ัะฝัะพัะผะฐััั:
- TCL โ ัะต ะผะพะฒะฐ ััะตะฝะฐัััะฒ ะฝะฐ ะพัะฝะพะฒั ััะดะบัะฒ, ะฐ ัะฐะบะพะถ ะฟัะพัะตะดััะฝะฐ ะผะพะฒะฐ
- ะฆั ะผะพะฒะฐ ะทะฐะทะฒะธัะฐะน ะฒะธะบะพัะธััะพะฒัััััั ะดะปั GUI ัะฐ ัะตัััะฒะฐะฝะฝั
- ะฃ TCL ะทะฐ ะทะฐะผะพะฒััะฒะฐะฝะฝัะผ ะฒัะต ั ััะดะบะพะผ
- TCL โ ัะต ะฟัะพะณัะฐะผะฐ ะพะฑะพะปะพะฝะบะธ, ัะบะฐ ะทัะธััั ะบะพะผะฐะฝะดั TCL ะทั ััะฐะฝะดะฐััะฝะพะณะพ ะฒะฒะพะดั ะฐะฑะพ ะท ัะฐะนะปั ัะฐ ะดะฐั ะฑะฐะถะฐะฝั ัะตะทัะปััะฐัะธ.
- ะัะพะณัะฐะผะฐ TCL ะฟะพะฒะธะฝะฝะฐ ะผะฐัะธ ัะพะทัะธัะตะฝะฝั .tcl
