Tcl-Tk - คู่มือฉบับย่อ

Tcl เป็นรูปแบบย่อของ Tool Command Language. John Ousterhout จาก University of California, Berkeley เป็นผู้ออกแบบ มันเป็นการรวมกันของภาษาสคริปต์และล่ามของตัวเองที่ฝังอยู่ในแอปพลิเคชันเราพัฒนาด้วย

Tcl ได้รับการพัฒนาครั้งแรกสำหรับ Unix จากนั้นพอร์ตไปยัง Windows, DOS, OS / 2 และ Mac OSX Tcl นั้นคล้ายกับภาษาเชลล์ยูนิกซ์อื่น ๆ มากเช่น Bourne Shell (Sh), C Shell (csh), Korn Shell (sh) และ Perl

มีจุดมุ่งหมายเพื่อให้โปรแกรมสามารถโต้ตอบกับโปรแกรมอื่น ๆ และสำหรับทำหน้าที่เป็นล่ามแบบฝังได้ แม้ว่าจุดมุ่งหมายเดิมคือการเปิดใช้งานโปรแกรมเพื่อโต้ตอบคุณสามารถค้นหาแอปพลิเคชันเต็มรูปแบบที่เขียนด้วย Tcl / Tk

คุณสมบัติของ Tcl

คุณสมบัติของ Tcl มีดังนี้ -

ลดเวลาในการพัฒนา
ชุดอินเทอร์เฟซผู้ใช้ที่มีประสิทธิภาพและเรียบง่ายพร้อมการรวม TK
เขียนครั้งเดียววิ่งได้ทุกที่ ทำงานบน Windows, Mac OS X และเกือบทุกแพลตฟอร์ม Unix
ค่อนข้างง่ายในการเริ่มต้นสำหรับโปรแกรมเมอร์ที่มีประสบการณ์ เนื่องจากภาษานั้นง่ายมากจนพวกเขาสามารถเรียนรู้ Tcl ได้ภายในไม่กี่ชั่วโมงหรือหลายวัน
คุณสามารถขยายแอปพลิเคชันที่มีอยู่ได้อย่างง่ายดายด้วย Tcl นอกจากนี้ยังสามารถรวม Tcl ใน C, C ++ หรือ Java เป็น Tcl หรือในทางกลับกัน
มีชุดฟังก์ชันเครือข่ายที่มีประสิทธิภาพ
ในที่สุดก็เป็นโอเพ่นซอร์สฟรีและสามารถใช้สำหรับแอปพลิเคชันเชิงพาณิชย์ได้โดยไม่ จำกัด จำนวน

การใช้งาน

Tcl เป็นภาษาที่ใช้งานทั่วไปและคุณสามารถค้นหา Tcl ได้ทุกที่ รวมถึง

เว็บไซต์ที่ปรับขนาดได้ซึ่งมักจะได้รับการสนับสนุนจากฐานข้อมูล
เว็บเซิร์ฟเวอร์ประสิทธิภาพสูงสร้างด้วย TclHttpd
Tcl กับเว็บไซต์ที่ใช้ CGI
แอปพลิเคชัน GUI บนเดสก์ท็อป
แอปพลิเคชันในตัว

การตั้งค่าสภาพแวดล้อมท้องถิ่น

หากคุณยินดีที่จะตั้งค่าสภาพแวดล้อมของคุณสำหรับ Tcl คุณต้องมีแอพพลิเคชั่นซอฟต์แวร์สองตัวต่อไปนี้บนคอมพิวเตอร์ของคุณ -

แก้ไขข้อความ
ล่าม Tcl

แก้ไขข้อความ

สิ่งนี้จะใช้ในการพิมพ์โปรแกรมของคุณ ตัวอย่างของโปรแกรมแก้ไขข้อความบางตัว ได้แก่ Windows Notepad, OS Edit command, Brief, Epsilon, EMACS และ vim หรือ vi

ชื่อและเวอร์ชันของโปรแกรมแก้ไขข้อความอาจแตกต่างกันไปตามระบบปฏิบัติการต่างๆ ตัวอย่างเช่น Notepad จะใช้กับ Windows และสามารถใช้ vim หรือ vi บน windows ได้เช่นเดียวกับ Linux หรือ UNIX

ไฟล์ที่คุณสร้างด้วยโปรแกรมแก้ไขข้อความเรียกว่าซอร์สไฟล์และมีซอร์สโค้ดของโปรแกรม ไฟล์ต้นฉบับสำหรับโปรแกรม Tcl ถูกตั้งชื่อด้วยนามสกุล".tcl".

ก่อนเริ่มเขียนโปรแกรมตรวจสอบให้แน่ใจว่าคุณมีโปรแกรมแก้ไขข้อความหนึ่งตัวและคุณมีประสบการณ์เพียงพอในการเขียนโปรแกรมคอมพิวเตอร์บันทึกลงในไฟล์สร้างและดำเนินการในที่สุด

ล่าม Tcl

เป็นเพียงโปรแกรมเล็ก ๆ ที่ช่วยให้คุณสามารถพิมพ์คำสั่ง Tcl และเรียกใช้งานทีละบรรทัด หยุดการเรียกใช้ไฟล์ tcl ในกรณีที่พบข้อผิดพลาดซึ่งแตกต่างจากคอมไพเลอร์ที่ดำเนินการอย่างสมบูรณ์

มามีไฟล์ helloWorld.tcl ดังนี้ เราจะใช้โปรแกรมนี้เป็นโปรแกรมแรกเราทำงานบนแพลตฟอร์มที่คุณเลือก

#!/usr/bin/tclsh

puts "Hello World!"

การติดตั้งบน Windows

ดาวน์โหลดเวอร์ชันล่าสุดสำหรับตัวติดตั้ง windows จากรายการไบนารี Active Tcl ที่มีให้ รุ่นชุมชน Tcl ที่ใช้งานได้ฟรีสำหรับการใช้งานส่วนตัว

เรียกใช้ไฟล์ปฏิบัติการที่ดาวน์โหลดมาเพื่อติดตั้ง Tcl ซึ่งสามารถทำได้โดยทำตามคำแนะนำบนหน้าจอ

ตอนนี้เราสามารถสร้างและเรียกใช้ไฟล์ Tcl โดยพูดว่า helloWorld.tcl โดยสลับไปยังโฟลเดอร์ที่มีไฟล์โดยใช้คำสั่ง 'cd' จากนั้นเรียกใช้โปรแกรมโดยใช้ขั้นตอนต่อไปนี้

C:\Tcl> tclsh helloWorld.tcl

เราสามารถดูผลลัพธ์ต่อไปนี้

C:\Tcl> helloWorld

C: \ Tcl คือโฟลเดอร์ที่ฉันใช้บันทึกตัวอย่าง คุณสามารถเปลี่ยนเป็นโฟลเดอร์ที่คุณบันทึกโปรแกรม Tcl ได้

การติดตั้งบน Linux

ระบบปฏิบัติการ Linux ส่วนใหญ่มาพร้อมกับ Tcl ในตัวและคุณสามารถเริ่มต้นได้ทันทีในระบบเหล่านั้น ในกรณีที่ไม่สามารถใช้งานได้คุณสามารถใช้คำสั่งต่อไปนี้เพื่อดาวน์โหลดและติดตั้ง Tcl-Tk

$ yum install tcl tk

ตอนนี้เราสามารถสร้างและเรียกใช้ไฟล์ Tcl โดยพูดว่า helloWorld.tcl โดยสลับไปยังโฟลเดอร์ที่มีไฟล์โดยใช้คำสั่ง 'cd' จากนั้นเรียกใช้โปรแกรมโดยใช้ขั้นตอนต่อไปนี้ -

$ tclsh helloWorld.tcl

เราสามารถดูผลลัพธ์ต่อไปนี้ -

$ hello world

การติดตั้งบนระบบที่ใช้ Debian

ในกรณีที่ไม่มีในระบบปฏิบัติการของคุณคุณสามารถใช้คำสั่งต่อไปนี้เพื่อดาวน์โหลดและติดตั้ง Tcl-Tk -

$ sudo apt-get install tcl tk

$ tclsh helloWorld.tcl

เราสามารถดูผลลัพธ์ต่อไปนี้ -

$ hello world

การติดตั้งบน Mac OS X

ดาวน์โหลดเวอร์ชันล่าสุดสำหรับแพ็คเกจ Mac OS X จากรายการไบนารี Active Tcl ที่มีให้ รุ่นชุมชน Tcl ที่ใช้งานได้ฟรีสำหรับการใช้งานส่วนตัว

เรียกใช้ไฟล์ปฏิบัติการที่ดาวน์โหลดมาเพื่อติดตั้ง Active Tcl ซึ่งสามารถทำได้โดยทำตามคำแนะนำบนหน้าจอ

ตอนนี้เราสามารถสร้างและเรียกใช้ไฟล์ Tcl โดยพูดว่า helloWorld.tcl โดยสลับไปยังโฟลเดอร์ที่มีไฟล์โดยใช้ 'cd' จากนั้นเรียกใช้โปรแกรมโดยใช้ขั้นตอนต่อไปนี้ -

$ tclsh helloWorld.tcl

เราสามารถดูผลลัพธ์ต่อไปนี้ -

$ hello world

การติดตั้งจากไฟล์ต้นฉบับ

คุณสามารถใช้ตัวเลือกในการติดตั้งจากไฟล์ต้นฉบับเมื่อไม่มีแพ็กเกจไบนารี โดยทั่วไปนิยมใช้ไบนารี Tcl สำหรับ Windows และ Mac OS X ดังนั้นการรวบรวมเฉพาะแหล่งที่มาบนระบบที่ใช้ยูนิกซ์เท่านั้นที่แสดงด้านล่าง

ดาวน์โหลดไฟล์ต้นฉบับ
ตอนนี้ใช้คำสั่งต่อไปนี้เพื่อแยกรวบรวมและสร้างหลังจากเปลี่ยนไปใช้โฟลเดอร์ที่ดาวน์โหลด

$ tar zxf tcl8.6.1-src.tar.gz $ cd tcl8.6.1
$ cd unix $ ./configure —prefix=/opt —enable-gcc
$ make $ sudo make install

Note - ตรวจสอบให้แน่ใจว่าคุณได้เปลี่ยนชื่อไฟล์เป็นเวอร์ชันที่คุณดาวน์โหลดจากคำสั่ง 1 และ 2 ที่ระบุไว้ข้างต้น

ใน Tcl เราจำแนกตัวแปรบางตัวเป็นตัวแปรพิเศษและมีการใช้งาน / ฟังก์ชันที่กำหนดไว้ล่วงหน้า รายการตัวแปรพิเศษแสดงอยู่ด้านล่าง

ซีเนียร์	ตัวแปรพิเศษและคำอธิบาย
1	argc หมายถึงอาร์กิวเมนต์บรรทัดคำสั่งจำนวนหนึ่ง
2	argv หมายถึงรายการที่มีอาร์กิวเมนต์บรรทัดคำสั่ง
3	argv0 หมายถึงชื่อไฟล์ของไฟล์ที่กำลังตีความหรือชื่อที่เราเรียกใช้สคริปต์
4	env ใช้สำหรับแทนอาร์เรย์ขององค์ประกอบที่เป็นตัวแปรสภาพแวดล้อม
5	errorCode ระบุรหัสข้อผิดพลาดสำหรับข้อผิดพลาด Tcl ล่าสุด
6	errorInfo จัดเตรียมการติดตามสแต็กสำหรับข้อผิดพลาด Tcl ล่าสุด
7	tcl_interactive ใช้เพื่อสลับระหว่างโหมดโต้ตอบและโหมดไม่โต้ตอบโดยตั้งค่านี้เป็น 1 และ 0 ตามลำดับ
8	tcl_library ใช้สำหรับตั้งค่าตำแหน่งของไลบรารี Tcl มาตรฐาน
9	tcl_pkgPath แสดงรายการไดเร็กทอรีที่โดยทั่วไปมีการติดตั้งแพ็กเกจ
10	tcl_patchLevel หมายถึงระดับแพตช์ปัจจุบันของล่าม Tcl
11	tcl_platform ใช้สำหรับแสดงอาร์เรย์ขององค์ประกอบที่มีออบเจ็กต์รวมถึง byteOrder, machine, osVersion, platform และ os
12	tcl_precision หมายถึงความแม่นยำเช่นจำนวนหลักที่จะคงไว้เมื่อแปลงเป็นตัวเลขทศนิยมเป็นสตริง ค่าเริ่มต้นคือ 12
13	tcl_prompt1 หมายถึงพรอมต์หลัก
14	tcl_prompt2 หมายถึงพรอมต์รองที่มีคำสั่งที่ไม่ถูกต้อง
15	tcl_rcFileName จัดเตรียมไฟล์เริ่มต้นเฉพาะสำหรับผู้ใช้
16	tcl_traceCompile ใช้สำหรับควบคุมการติดตามของการคอมไพล์ bytecode ใช้ 0 สำหรับไม่มีเอาต์พุต 1 สำหรับสรุปและ 2 สำหรับรายละเอียด
17	tcl_traceExec ใช้สำหรับควบคุมการติดตามของการดำเนินการ bytecode ใช้ 0 สำหรับไม่มีเอาต์พุต 1 สำหรับสรุปและ 2 สำหรับรายละเอียด
18	tcl_version ส่งคืนเวอร์ชันปัจจุบันของตัวแปล Tcl

ตัวแปรพิเศษข้างต้นมีความหมายพิเศษสำหรับล่าม Tcl

ตัวอย่างการใช้ตัวแปรพิเศษ Tcl

มาดูตัวอย่างตัวแปรพิเศษกัน

รุ่น Tcl

#!/usr/bin/tclsh

puts $tcl_version

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

8.6

เส้นทางสิ่งแวดล้อม Tcl

#!/usr/bin/tclsh

puts $env(PATH)

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

/home/cg/root/GNUstep/Tools:/usr/GNUstep/Local/Tools:/usr/GNUstep/
System/Tools:/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/webmaster/.local/bin:/
home/webmaster/bin:/usr/local/scriba/bin:/usr/local/smlnj/
bin:/usr/local/bin/std:/usr/local/bin/extra:/usr/local/fantom/bin:/usr/
local/dart/bin:/usr/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/opt/mono/
bin:/opt/mono/lib/mono/4.5:/usr/local/bin:.:/usr/libexec/sdcc:/usr/local/
icon-v950/bin:/usr/local/mozart/bin:/opt/Pawn/bin:/opt/jdk1.7.0_75/bin:/
opt/jdk1.7.0_75/jre/bin:/opt/pash/Source/PashConsole/bin/Debug/

เส้นทางแพ็คเกจ Tcl

#!/usr/bin/tclsh

puts $tcl_pkgPath

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

/usr/lib64/tcl8.6 /usr/share/tcl8.6 /usr/lib64/tk8.6 /usr/share/tk8.6

ห้องสมุด Tcl

#!/usr/bin/tclsh

puts $tcl_library

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

/usr/share/tcl8.6

ระดับแพทช์ Tcl

#!/usr/bin/tclsh

puts $tcl_patchLevel

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

8.6.6

ความแม่นยำ Tcl

#!/usr/bin/tclsh

puts $tcl_precision

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

ไฟล์เริ่มต้น Tcl

#!/usr/bin/tclsh

puts $tcl_rcFileName

เมื่อคุณรันโปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง -

~/.tclshrc

Tcl นั้นค่อนข้างง่ายในการเรียนรู้และมาเริ่มสร้างโปรแกรม Tcl ตัวแรกของเรากันเถอะ!

โปรแกรม Tcl แรก

ให้เราเขียนโปรแกรม Tcl ง่ายๆ ไฟล์ Tcl ทั้งหมดจะมีนามสกุลคือ. tcl ดังนั้นใส่ซอร์สโค้ดต่อไปนี้ในไฟล์ test.tcl

#!/usr/bin/tclsh

puts "Hello, World!"

สมมติว่าสภาพแวดล้อม Tcl ได้รับการตั้งค่าอย่างถูกต้อง มารันโปรแกรมหลังจากเปลี่ยนเป็นไดเร็กทอรีของไฟล์แล้วรันโปรแกรมโดยใช้ -

$ tclsh test.tcl

เราจะได้ผลลัพธ์ดังต่อไปนี้ -

Hello, World!

ตอนนี้ให้เราดูโครงสร้างพื้นฐานของโปรแกรม Tcl เพื่อให้คุณเข้าใจโครงสร้างพื้นฐานของภาษา Tcl ได้ง่าย ใน Tcl เราใช้บรรทัดใหม่หรืออัฒภาคเพื่อยกเลิกบรรทัดก่อนหน้าของโค้ด แต่ไม่จำเป็นต้องใช้อัฒภาคหากคุณใช้ขึ้นบรรทัดใหม่สำหรับแต่ละคำสั่ง

ความคิดเห็น

ความคิดเห็นเป็นเหมือนการช่วยเหลือข้อความในโปรแกรม Tcl ของคุณและล่ามไม่สนใจ ความคิดเห็นสามารถเขียนโดยใช้เครื่องหมายแฮช _ (#) ในการเริ่มต้น

#!/usr/bin/tclsh

# my first program in Tcl
puts "Hello World!"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello World!

ความคิดเห็นหลายบรรทัดหรือบล็อกเขียนโดยใช้ 'if' with condition '0' ตัวอย่างแสดงด้านล่าง

#!/usr/bin/tclsh

if 0 {
   my first program in Tcl program
   Its very simple
}
puts "Hello World!"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello World!

ความคิดเห็นแบบอินไลน์ใช้; #. ตัวอย่างได้รับด้านล่าง

#!/usr/bin/tclsh

puts "Hello World!" ;# my first print in Tcl program

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello World!

ตัวระบุ

ตัวระบุ Tcl คือชื่อที่ใช้เพื่อระบุตัวแปรฟังก์ชันหรือรายการที่ผู้ใช้กำหนดอื่น ๆ ตัวระบุเริ่มต้นด้วยตัวอักษร A ถึง Z หรือ a ถึง z หรือขีดล่าง (_) ตามด้วยตัวอักษรศูนย์หรือมากกว่าขีดล่างดอลลาร์ ($) และตัวเลข (0 ถึง 9)

Tcl ไม่อนุญาตให้ใช้อักขระเครื่องหมายวรรคตอนเช่น @ และ% ภายในตัวระบุ Tcl คือcase sensitive_ ภาษา ดังนั้นกำลังคนและกำลังคนจึงเป็นตัวบ่งชี้สองตัวที่แตกต่างกันใน Tcl นี่คือตัวอย่างบางส่วนของตัวระบุที่ยอมรับได้ -

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

คำสงวน

รายการต่อไปนี้แสดงคำสงวนบางส่วนใน Tcl ห้ามใช้คำสงวนเหล่านี้เป็นค่าคงที่หรือตัวแปรหรือชื่อตัวระบุอื่น ๆ

หลังจาก	ผนวก	อาร์เรย์	auto_execok
auto_import	auto_load	auto_load_index	auto_qualify
ไบนารี่	Bgerror	หยุดพัก	จับ
ซีดี	นาฬิกา	ปิด	concat
ดำเนินการต่อ	ผบ	ค่าเริ่มต้น	อื่น
อื่น ๆ	การเข้ารหัส	eof	ข้อผิดพลาด
ประเมิน	Exec	ทางออก	expr
fblocked	F กำหนดค่า	fcopy	ไฟล์
fileevent	ฟลัช	สำหรับ	แต่ละ
รูปแบบ	ได้รับ	ลูกโลก	ทั่วโลก
ประวัติศาสตร์	ถ้า	ข้อมูล	ล่าม
เข้าร่วม	Lappend	ต้นไม้ชนิดหนึ่ง	linsert
รายการ	ความยาว	โหลด	lrange
lreplace	Lsearch	สั้น	เนมสเปซ
เปิด	แพ็คเกจ	pid	pkg_mkIndex
proc	ทำให้	pwd	อ่าน
regexp	Regsub	เปลี่ยนชื่อ	ทรัพยากร
กลับ	สแกน	แสวงหา	ชุด
เบ้า	ที่มา	แยก	สตริง
สถานีย่อย	สวิตซ์	tclLog	บอก
เวลา	ติดตาม	ไม่ทราบ	ยกเลิกการตั้งค่า
อัพเดต	Uplevel	upvar	ตัวแปร
vwait	ในขณะที่

ช่องว่างใน Tcl

บรรทัดที่มีเฉพาะช่องว่างซึ่งอาจมีความคิดเห็นเรียกว่า a blank lineและล่าม Tcl ไม่สนใจมันโดยสิ้นเชิง

Whitespace เป็นคำที่ใช้ใน Tcl เพื่ออธิบายช่องว่างแท็บอักขระขึ้นบรรทัดใหม่และข้อคิดเห็น ช่องว่างแยกส่วนหนึ่งของคำสั่งออกจากอีกส่วนหนึ่งและช่วยให้ล่ามระบุตำแหน่งที่องค์ประกอบหนึ่งในคำสั่งเช่น puts สิ้นสุดและองค์ประกอบถัดไปเริ่มต้น ดังนั้นในข้อความต่อไปนี้ -

#!/usr/bin/tclsh

puts "Hello World!"

ต้องมีอักขระเว้นวรรคอย่างน้อยหนึ่งตัว (โดยปกติจะเป็นช่องว่าง) ระหว่าง "puts" และ "Hello World!" เพื่อให้ล่ามสามารถแยกแยะได้ ในทางกลับกันในข้อความต่อไปนี้ -

#!/usr/bin/tclsh

puts [expr 3 + 2] ;# print sum of the 3 and 2

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ไม่จำเป็นต้องใช้อักขระเว้นวรรคระหว่าง 3 ถึง + หรือระหว่าง + และ 2 แม้ว่าคุณมีอิสระที่จะรวมบางส่วนหากคุณต้องการเพื่อจุดประสงค์ในการอ่าน

อย่างที่คุณทราบ Tcl เป็นภาษาคำสั่ง Tool คำสั่งเป็นส่วนสำคัญที่สุดของภาษา คำสั่ง Tcl สร้างขึ้นในภาษาโดยแต่ละคำสั่งมีฟังก์ชันที่กำหนดไว้ล่วงหน้าของตัวเอง คำสั่งเหล่านี้สร้างคำสงวนของภาษาและไม่สามารถใช้สำหรับการตั้งชื่อตัวแปรอื่นได้ ข้อดีของคำสั่ง Tcl เหล่านี้คือคุณสามารถกำหนดการใช้งานของคุณเองสำหรับคำสั่งใด ๆ เหล่านี้เพื่อแทนที่ฟังก์ชันการทำงานในตัวดั้งเดิม

คำสั่ง Tcl แต่ละคำสั่งตรวจสอบความถูกต้องของอินพุตและจะลดการทำงานของล่าม

คำสั่ง Tcl เป็นรายการคำโดยคำแรกเป็นตัวแทนของคำสั่งที่จะดำเนินการ คำถัดไปแสดงถึงข้อโต้แย้ง ในการจัดกลุ่มคำให้เป็นอาร์กิวเมนต์เดียวเราจะใส่คำหลายคำด้วย "" หรือ {}

ไวยากรณ์ของคำสั่ง Tcl มีดังนี้ -

commandName argument1 argument2 ... argumentN

มาดูตัวอย่างง่ายๆของคำสั่ง Tcl -

#!/usr/bin/tclsh

puts "Hello, world!"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello, world!

ในโค้ดด้านบน 'puts' คือคำสั่ง Tcl และ "Hello World" คืออาร์กิวเมนต์ 1 อย่างที่กล่าวไว้ก่อนหน้านี้เราได้ใช้ "" เพื่อจัดกลุ่มคำสองคำ

มาดูอีกตัวอย่างของคำสั่ง Tcl ที่มีสองอาร์กิวเมนต์ -

#!/usr/bin/tclsh

puts stdout "Hello, world!"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello, world!

ในโค้ดด้านบน 'puts' คือคำสั่ง Tcl 'stdout' คืออาร์กิวเมนต์ 1 และ "Hello World" คืออาร์กิวเมนต์ 2 ที่นี่ stdout ทำให้โปรแกรมพิมพ์ในอุปกรณ์เอาต์พุตมาตรฐาน

การแทนที่คำสั่ง

ในการแทนคำสั่งจะใช้วงเล็บเหลี่ยมเพื่อประเมินสคริปต์ภายในวงเล็บเหลี่ยม ตัวอย่างง่ายๆในการเพิ่มตัวเลขสองตัวแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

puts [expr 1 + 6 + 9]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

การทดแทนตัวแปร

ในการแทนที่ตัวแปร $ จะถูกใช้ก่อนชื่อตัวแปรและส่งคืนเนื้อหาของตัวแปร ตัวอย่างง่ายๆในการกำหนดค่าให้กับตัวแปรและพิมพ์แสดงไว้ด้านล่าง

#!/usr/bin/tclsh

set a 3
puts $a

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

การทดแทนแบ็กสแลช

สิ่งเหล่านี้เรียกกันทั่วไป escape sequences; ด้วยเครื่องหมายแบ็กสแลชแต่ละตัวตามด้วยตัวอักษรที่มีความหมายในตัวเอง ตัวอย่างง่ายๆสำหรับการเปลี่ยนตัวขึ้นบรรทัดใหม่แสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

puts "Hello\nWorld"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello
World

ประเภทข้อมูลดั้งเดิมของ Tcl คือสตริงและบ่อยครั้งที่เราพบเครื่องหมายคำพูดบน Tcl เป็นภาษาสตริงเท่านั้น ชนิดข้อมูลดั้งเดิมเหล่านี้จะสร้างชนิดข้อมูลผสมสำหรับรายการและอาร์เรย์ที่เชื่อมโยง ใน Tcl ชนิดข้อมูลไม่เพียง แต่แสดงถึงอ็อบเจ็กต์ Tcl ธรรมดาเท่านั้น แต่ยังสามารถแสดงถึงอ็อบเจ็กต์ที่ซับซ้อนเช่นแฮนเดิลอ็อบเจ็กต์กราฟิก (ส่วนใหญ่เป็นวิดเจ็ต) และช่อง I / O ลองดูรายละเอียดเกี่ยวกับแต่ละข้อข้างต้น

วัตถุ Tcl อย่างง่าย

ใน Tcl ไม่ว่าจะเป็นตัวเลขจำนวนเต็มบูลีนเลขทศนิยมหรือสตริง เมื่อคุณต้องการใช้ตัวแปรคุณสามารถกำหนดค่าให้กับตัวแปรได้โดยตรงโดยไม่มีขั้นตอนของการประกาศใน Tcl อาจมีการแสดงภายในสำหรับวัตถุประเภทต่างๆเหล่านี้ สามารถแปลงประเภทข้อมูลหนึ่งไปเป็นอีกประเภทหนึ่งได้เมื่อต้องการ ไวยากรณ์สำหรับการกำหนดค่าให้กับตัวแปรมีดังนี้ -

#!/usr/bin/tclsh

set myVariable 18
puts $myVariable

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ข้อความข้างต้นจะสร้างชื่อตัวแปร myVariable และเก็บเป็นสตริงแม้ว่าเราจะไม่ได้ใช้อัญประกาศคู่ก็ตาม ตอนนี้ถ้าเราพยายามสร้างเลขคณิตให้กับตัวแปรมันจะเปลี่ยนเป็นจำนวนเต็มโดยอัตโนมัติ ตัวอย่างง่ายๆแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

set myVariable 18
puts [expr $myVariable + 6 + 9]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

สิ่งสำคัญอย่างหนึ่งที่ควรทราบก็คือตัวแปรเหล่านี้ไม่มีค่าเริ่มต้นและต้องกำหนดค่าก่อนที่จะใช้

หากเราพยายามพิมพ์โดยใช้พัตตัวเลขจะถูกเปลี่ยนเป็นสตริงที่เหมาะสม การมีตัวแทนสองแบบทั้งภายในและภายนอกช่วยให้ Tcl สร้างโครงสร้างข้อมูลที่ซับซ้อนได้ง่ายเมื่อเทียบกับภาษาอื่น ๆ นอกจากนี้ Tcl ยังมีประสิทธิภาพมากกว่าเนื่องจากลักษณะของวัตถุแบบไดนามิก

การแสดงสตริง

ไม่เหมือนกับภาษาอื่น ๆ ใน Tcl คุณไม่จำเป็นต้องใส่เครื่องหมายคำพูดคู่เมื่อเป็นเพียงคำเดียว ตัวอย่างสามารถ -

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

hello

เมื่อเราต้องการแทนหลายสตริงเราสามารถใช้เครื่องหมายคำพูดคู่หรือวงเล็บปีกกา ดังแสดงด้านล่าง -

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable set myVariable {hello world} puts $myVariable

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

hello world
hello world

รายการ

รายการเป็นเพียงกลุ่มขององค์ประกอบ กลุ่มคำที่ใช้เครื่องหมายอัญประกาศคู่หรือวงเล็บปีกกาสามารถใช้เพื่อแสดงรายการอย่างง่าย รายการง่ายๆแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

set myVariable {red green blue}
puts [lindex $myVariable 2] set myVariable "red green blue" puts [lindex $myVariable 1]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

blue
green

Associative Array

อาร์เรย์ที่เชื่อมโยงมีดัชนี (คีย์) ที่ไม่จำเป็นต้องเป็นจำนวนเต็ม โดยทั่วไปเป็นสตริงที่ทำหน้าที่เหมือนคู่ค่าคีย์ ตัวอย่างง่ายๆแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

set  marks(english) 80
puts $marks(english) set marks(mathematics) 90 puts $marks(mathematics)

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

80
90

ที่จับ

ที่จับ Tcl มักใช้เพื่อแสดงไฟล์และวัตถุกราฟิก ซึ่งอาจรวมถึงการจัดการกับคำขอเครือข่ายและช่องทางอื่น ๆ เช่นการสื่อสารพอร์ตอนุกรมซ็อกเก็ตหรืออุปกรณ์ I / O ต่อไปนี้เป็นตัวอย่างที่สร้างที่จับไฟล์

set myfile [open "filename" r]

คุณจะเห็นรายละเอียดเพิ่มเติมเกี่ยวกับไฟล์ในบทI / O ของไฟล์ Tcl

ใน Tcl ไม่มีแนวคิดเรื่องการประกาศตัวแปร เมื่อพบชื่อตัวแปรใหม่ Tcl จะกำหนดตัวแปรใหม่

การตั้งชื่อตัวแปร

ชื่อของตัวแปรสามารถมีอักขระและความยาวได้ คุณสามารถมีช่องว่างสีขาวได้โดยการใส่ตัวแปรไว้ในวงเล็บปีกกา แต่ไม่ต้องการ

คำสั่ง set ใช้สำหรับกำหนดค่าให้กับตัวแปร ไวยากรณ์สำหรับคำสั่ง set คือ

set variableName value

ตัวอย่างของตัวแปรแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

set variableA 10
set {variable B} test
puts $variableA puts ${variable B}

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

10
test

ดังที่คุณเห็นในโปรแกรมด้านบน $ variableName ถูกใช้เพื่อรับค่าของตัวแปร

การพิมพ์แบบไดนามิก

Tcl เป็นภาษาที่พิมพ์แบบไดนามิก ค่าของตัวแปรสามารถแปลงเป็นประเภทที่ต้องการได้แบบไดนามิกเมื่อต้องการ ตัวอย่างเช่นตัวเลข 5 ที่เก็บไว้เป็นสตริงจะถูกแปลงเป็นตัวเลขเมื่อทำการคำนวณทางคณิตศาสตร์ ดังแสดงด้านล่าง -

#!/usr/bin/tclsh

set variableA "10"
puts $variableA
set sum [expr $variableA +20]; puts $sum

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

10
30

นิพจน์ทางคณิตศาสตร์

ดังที่คุณเห็นในตัวอย่างข้างต้น expr ถูกใช้เพื่อแสดงนิพจน์ทางคณิตศาสตร์ ความแม่นยำเริ่มต้นของ Tcl คือ 12 หลัก เพื่อให้ได้ผลลัพธ์ทศนิยมเราควรเพิ่มทศนิยมหนึ่งหลักเป็นอย่างน้อย ตัวอย่างง่ายๆอธิบายข้างต้น

#!/usr/bin/tclsh

set variableA "10"
set result [expr $variableA / 9]; puts $result
set result [expr $variableA / 9.0]; puts $result
set variableA "10.0"
set result [expr $variableA / 9]; puts $result

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

1
1.1111111111111112
1.1111111111111112

ในตัวอย่างข้างต้นคุณจะเห็นสามกรณี ในกรณีแรกเงินปันผลและตัวหารเป็นจำนวนเต็มและเราได้ผลลัพธ์เป็นจำนวนเต็ม ในกรณีที่สองตัวหารเพียงอย่างเดียวคือเลขฐานสิบและในกรณีที่สามเงินปันผลคือเลขฐานสิบ ทั้งในกรณีที่สองและสามเราจะได้ตัวเลขทศนิยมเป็นผลลัพธ์

ในโค้ดด้านบนคุณสามารถเปลี่ยนความแม่นยำได้โดยใช้ตัวแปรพิเศษ tcl_precision ดังแสดงด้านล่าง -

#!/usr/bin/tclsh

set variableA "10"
set tcl_precision 5
set result [expr $variableA / 9.0]; puts $result

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

1.1111

ตัวดำเนินการคือสัญลักษณ์ที่บอกให้คอมไพเลอร์ดำเนินการจัดการทางคณิตศาสตร์หรือตรรกะเฉพาะ ภาษา Tcl อุดมไปด้วยตัวดำเนินการในตัวและมีตัวดำเนินการประเภทต่อไปนี้ -

ตัวดำเนินการเลขคณิต
ตัวดำเนินการเชิงสัมพันธ์
ตัวดำเนินการทางตรรกะ
ตัวดำเนินการ Bitwise
Ternary Operator

บทนี้จะอธิบายเกี่ยวกับตัวดำเนินการทางคณิตศาสตร์เชิงสัมพันธ์ตรรกะบิตและตัวดำเนินการทีละตัว

ตัวดำเนินการเลขคณิต

ตารางต่อไปนี้แสดงตัวดำเนินการเลขคณิตทั้งหมดที่ภาษา Tcl รองรับ สมมติว่าตัวแปร 'A' ถือ 10 และตัวแปร 'B' ถือ 20 จากนั้น -

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
+	เพิ่มสองตัวถูกดำเนินการ	A + B จะให้ 30
-	ลบตัวถูกดำเนินการที่สองจากตัวแรก	A - B จะให้ -10
*	คูณตัวถูกดำเนินการทั้งสอง	A * B จะให้ 200
/	หารเศษด้วยตัวเศษ	B / A จะให้ 2
%	ตัวดำเนินการโมดูลัสและส่วนที่เหลือหลังจากการหารจำนวนเต็ม	B% A จะให้ 0

ตัวดำเนินการเชิงสัมพันธ์

ตารางต่อไปนี้แสดงตัวดำเนินการเชิงสัมพันธ์ทั้งหมดที่สนับสนุนโดยภาษา Tcl สมมติตัวแปรA ถือ 10 และตัวแปร B ถือ 20 แล้ว -

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
==	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A == B) ไม่เป็นความจริง
! =	ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง	(A! = B) เป็นจริง
>	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A> B) ไม่เป็นความจริง
<	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A <B) เป็นจริง
> =	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A> = B) ไม่เป็นความจริง
<=	ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง	(A <= B) เป็นจริง

ตัวดำเนินการทางตรรกะ

ตารางต่อไปนี้แสดงตัวดำเนินการทางตรรกะทั้งหมดที่ภาษา Tcl สนับสนุน สมมติตัวแปรA ถือ 1 และตัวแปร B ถือ 0 แล้ว -

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
&&	เรียกว่าตัวดำเนินการ Logical AND หากตัวถูกดำเนินการทั้งสองไม่ใช่ศูนย์เงื่อนไขจะกลายเป็นจริง	(A && B) เป็นเท็จ
\|\|	เรียกว่า Logical OR Operator หากตัวถูกดำเนินการสองตัวใดตัวหนึ่งไม่เป็นศูนย์เงื่อนไขจะกลายเป็นจริง	(A \|\| B) เป็นจริง
!	เรียกว่า Logical NOT Operator ใช้เพื่อย้อนกลับสถานะตรรกะของตัวถูกดำเนินการ หากเงื่อนไขเป็นจริงตัวดำเนินการ Logical NOT จะสร้างเท็จ	! (A && B) เป็นเรื่องจริง

ตัวดำเนินการ Bitwise

ตัวดำเนินการ Bitwise ทำงานบนบิตและดำเนินการแบบบิตต่อบิต ตารางความจริงสำหรับ &, | และ ^ มีดังนี้ -

น	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

สมมติว่า A = 60; และ B = 13; ตอนนี้ในรูปแบบไบนารีพวกเขาจะเป็นดังนี้ -

A = 0011 1100

B = 0000 1101

----------------------

A&B = 0000 1100

ก | B = 0011 1101

ก ^ B = 0011 0001

ตัวดำเนินการ Bitwise ที่รองรับโดยภาษา Tcl แสดงอยู่ในตารางต่อไปนี้ สมมติตัวแปรA ถือ 60 และตัวแปร B ถือ 13 แล้ว -

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
&	ไบนารี AND Operator จะคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง	(A & B) จะให้ 12 ซึ่งก็คือ 0000 1100
\|	ไบนารีหรือตัวดำเนินการจะคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง	(A \| B) จะให้ 61 ซึ่งก็คือ 0011 1101
^	ตัวดำเนินการ XOR ไบนารีจะคัดลอกบิตหากตั้งค่าไว้ในตัวถูกดำเนินการเดียว แต่ไม่ใช่ทั้งสองอย่าง	(A ^ B) จะให้ 49 ซึ่งก็คือ 0011 0001
<<	ตัวดำเนินการกะซ้ายแบบไบนารี ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา	A << 2 จะให้ 240 ซึ่งก็คือ 1111 0000
>>	ตัวดำเนินการกะไบนารีขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา	A >> 2 จะให้ 15 ซึ่งก็คือ 0000 1111

Ternary Operator

แสดงตัวอย่าง

ตัวดำเนินการ	คำอธิบาย	ตัวอย่าง
เหรอ? :	Ternary	ถ้า Condition เป็นจริง? จากนั้นค่า X: หรือค่า Y

ลำดับความสำคัญของผู้ปฏิบัติงานใน Tcl

ลำดับความสำคัญของตัวดำเนินการกำหนดการจัดกลุ่มคำศัพท์ในนิพจน์ สิ่งนี้มีผลต่อวิธีการประเมินนิพจน์ ตัวดำเนินการบางอย่างมีลำดับความสำคัญสูงกว่าผู้อื่น ตัวอย่างเช่นตัวดำเนินการคูณมีลำดับความสำคัญสูงกว่าตัวดำเนินการบวก

For example: x = 7 + 3 * 2; ที่นี่ x ถูกกำหนด 13 ไม่ใช่ 20 เนื่องจากตัวดำเนินการ * มีลำดับความสำคัญสูงกว่า + ดังนั้นก่อนอื่นจึงคูณด้วย 3 * 2 แล้วบวกเป็น 7

ที่นี่ตัวดำเนินการที่มีลำดับความสำคัญสูงสุดจะปรากฏที่ด้านบนสุดของตารางตัวดำเนินการที่มีค่าต่ำสุดจะปรากฏที่ด้านล่าง ภายในนิพจน์ตัวดำเนินการที่มีลำดับความสำคัญสูงกว่าจะได้รับการประเมินก่อน

แสดงตัวอย่าง

ประเภท	ตัวดำเนินการ	ความสัมพันธ์
ยูนารี	+ -	จากขวาไปซ้าย
หลายหลาก	* /%	จากซ้ายไปขวา
สารเติมแต่ง	+ -	จากซ้ายไปขวา
กะ	<< >>	จากซ้ายไปขวา
เชิงสัมพันธ์	<<=>> =	จากซ้ายไปขวา
Bitwise AND	&	จากซ้ายไปขวา
Bitwise XOR	^	จากซ้ายไปขวา
Bitwise หรือ	\|	จากซ้ายไปขวา
ตรรกะ AND	&&	จากซ้ายไปขวา
ตรรกะหรือ	\|\|	จากซ้ายไปขวา
Ternary	?:	จากขวาไปซ้าย

โครงสร้างการตัดสินใจกำหนดให้โปรแกรมเมอร์ระบุเงื่อนไขอย่างน้อยหนึ่งเงื่อนไขที่จะประเมินหรือทดสอบโดยโปรแกรมพร้อมกับคำสั่งหรือคำสั่งที่จะดำเนินการหากเงื่อนไขถูกกำหนดให้เป็นจริงและเป็นทางเลือกที่จะเรียกใช้คำสั่งอื่น ๆ หากเงื่อนไข ถูกกำหนดให้เป็นเท็จ

ต่อไปนี้เป็นรูปแบบทั่วไปของโครงสร้างการตัดสินใจทั่วไปที่พบในภาษาโปรแกรมส่วนใหญ่ -

ภาษา Tcl ใช้คำสั่ง expr ภายในดังนั้นเราจึงไม่จำเป็นต้องใช้คำสั่ง expr อย่างชัดเจน

ภาษา Tcl มีข้อความประกอบการตัดสินใจประเภทต่อไปนี้ -

ซีเนียร์	คำชี้แจงและคำอธิบาย
1	ถ้าคำสั่ง คำสั่ง 'if' ประกอบด้วยนิพจน์บูลีนตามด้วยหนึ่งคำสั่งหรือมากกว่า
2	if ... else คำสั่ง คำสั่ง 'if' สามารถตามด้วยคำสั่ง 'else' ซึ่งจะดำเนินการเมื่อนิพจน์บูลีนเป็นเท็จ
3	คำสั่ง if ซ้อนกัน คุณสามารถใช้คำสั่ง 'if' หรือ 'else if' ในอีกคำสั่ง 'if' หรือ 'else if'
4	สลับคำสั่ง ก switch คำสั่งอนุญาตให้ทดสอบตัวแปรเพื่อความเท่าเทียมกับรายการค่า
5	คำสั่งสวิตช์ที่ซ้อนกัน คุณสามารถใช้ switch คำสั่งภายในอื่น switch คำสั่ง (s)

เดอะ? : ผู้ปฏิบัติงาน

เราได้ครอบคลุม conditional operator ? : ในบทก่อนหน้าซึ่งสามารถใช้เพื่อแทนที่ if...elseงบ มีรูปแบบทั่วไปดังต่อไปนี้ -

Exp1 ? Exp2 : Exp3;

โดยที่ Exp1, Exp2 และ Exp3 เป็นนิพจน์ สังเกตการใช้และตำแหน่งของลำไส้ใหญ่

ค่าของ '? นิพจน์ 'ถูกกำหนดเช่นนี้: Exp1 ถูกประเมิน ถ้าเป็นจริง Exp2 จะถูกประเมินและกลายเป็นค่าของ '? นิพจน์. ' ถ้า Exp1 เป็นเท็จระบบจะประเมิน Exp3 และค่าของมันจะกลายเป็นค่าของนิพจน์ ตัวอย่างแสดงด้านล่าง

#!/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"

เมื่อคุณคอมไพล์และรันโปรแกรมข้างต้นโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

Value of b is 30
Value of b is 20

อาจมีสถานการณ์ที่คุณต้องดำเนินการบล็อกโค้ดหลาย ๆ ครั้ง โดยทั่วไปคำสั่งจะดำเนินการตามลำดับ: คำสั่งแรกในฟังก์ชันจะถูกเรียกใช้งานก่อนตามด้วยคำสั่งที่สองและอื่น ๆ

ภาษาโปรแกรมจัดเตรียมโครงสร้างการควบคุมต่างๆที่ช่วยให้เส้นทางการดำเนินการซับซ้อนมากขึ้น

คำสั่งวนซ้ำช่วยให้เราดำเนินการคำสั่งหรือกลุ่มของคำสั่งได้หลายครั้งและต่อไปนี้เป็นรูปแบบทั่วไปของคำสั่งลูปในภาษาโปรแกรมส่วนใหญ่ -

ภาษา Tcl จัดเตรียมลูปประเภทต่อไปนี้เพื่อจัดการกับข้อกำหนดการวนซ้ำ

ซีเนียร์	ประเภทห่วงและคำอธิบาย
1	ในขณะที่วนซ้ำ ทำซ้ำคำสั่งหรือกลุ่มของคำสั่งในขณะที่เงื่อนไขที่กำหนดเป็นจริง จะทดสอบเงื่อนไขก่อนที่จะดำเนินการร่างกายลูป
2	สำหรับห่วง เรียกใช้ลำดับของคำสั่งหลาย ๆ ครั้งและย่อโค้ดที่จัดการตัวแปรลูป
3	ลูปที่ซ้อนกัน คุณสามารถใช้ลูปหนึ่งหรือหลายวงในอีกอันในขณะที่สำหรับหรือทำ .. ในขณะที่ลูป

คำสั่งควบคุมลูป

คำสั่งควบคุมแบบวนซ้ำเปลี่ยนการดำเนินการจากลำดับปกติ เมื่อการดำเนินการออกจากขอบเขตอ็อบเจ็กต์อัตโนมัติทั้งหมดที่สร้างขึ้นในขอบเขตนั้นจะถูกทำลาย

Tcl สนับสนุนคำสั่งควบคุมต่อไปนี้

ซีเนียร์	คำชี้แจงและคำอธิบายการควบคุม
1	คำสั่งทำลาย ยุติคำสั่งลูปหรือสวิตช์และโอนการดำเนินการไปยังคำสั่งทันทีตามลูปหรือสวิตช์
2	ดำเนินการต่อ ทำให้ลูปข้ามส่วนที่เหลือของร่างกายและทดสอบสภาพของมันใหม่ทันทีก่อนที่จะย้ำอีกครั้ง

ห่วงไม่มีที่สิ้นสุด

ลูปจะกลายเป็นลูปไม่มีที่สิ้นสุดหากเงื่อนไขไม่เคยเป็นเท็จ whileloop ถูกใช้เพื่อจุดประสงค์นี้ คุณสามารถสร้างการวนซ้ำที่ไม่มีที่สิ้นสุดโดยปล่อยนิพจน์เงื่อนไขเป็น 1

while {1} {
   puts "This loop will run forever."
}

เมื่อไม่มีนิพจน์เงื่อนไขจะถือว่าเป็นจริง โปรแกรมเมอร์ Tcl มักใช้โครงสร้าง while {1} เพื่อแสดงถึงการวนซ้ำที่ไม่มีที่สิ้นสุด

NOTE - คุณสามารถยุติการวนซ้ำที่ไม่มีที่สิ้นสุดได้โดยกดปุ่ม Ctrl + C

อาร์เรย์คือการจัดเรียงกลุ่มขององค์ประกอบอย่างเป็นระบบโดยใช้ดัชนี ไวยากรณ์สำหรับอาร์เรย์ธรรมดาแสดงอยู่ด้านล่าง

set ArrayName(Index) value

ตัวอย่างการสร้างอาร์เรย์อย่างง่ายแสดงอยู่ด้านล่าง

#!/usr/bin/tclsh

set languages(0) Tcl
set languages(1) "C Language"
puts $languages(0) puts $languages(1)

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Tcl
C Language

ขนาดของอาร์เรย์

ไวยากรณ์สำหรับการคำนวณขนาดอาร์เรย์แสดงไว้ด้านล่าง

[array size variablename]

ตัวอย่างการพิมพ์ขนาดดังแสดงด้านล่าง

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

การทำซ้ำอาร์เรย์

แม้ว่าดัชนีอาร์เรย์อาจไม่ต่อเนื่องเหมือนค่าที่ระบุสำหรับดัชนี 1 จากนั้นดัชนี 10 เป็นต้น แต่ในกรณีที่ต่อเนื่องกันเราสามารถใช้การวนซ้ำอาร์เรย์เพื่อเข้าถึงองค์ประกอบของอาร์เรย์ได้ การทำซ้ำอาร์เรย์อย่างง่ายสำหรับการพิมพ์องค์ประกอบของอาร์เรย์แสดงอยู่ด้านล่าง

#!/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)"
}

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

languages(0) : Tcl
languages(1) : C Language

อาร์เรย์เชื่อมโยง

ใน Tcl อาร์เรย์ทั้งหมดโดยธรรมชาติจะเชื่อมโยงกัน อาร์เรย์จะถูกจัดเก็บและเรียกค้นโดยไม่มีลำดับที่เฉพาะเจาะจง อาร์เรย์ที่เชื่อมโยงมีดัชนีที่ไม่จำเป็นต้องเป็นตัวเลขและอาจมีประชากรเบาบาง ตัวอย่างง่ายๆสำหรับการเชื่อมโยงอาร์เรย์กับดัชนีที่ไม่ใช่ตัวเลขแสดงอยู่ด้านล่าง

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts  $personA(Name) puts $personA(Age)

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Dave
14

ดัชนีของอาร์เรย์

ไวยากรณ์สำหรับการดึงดัชนีของอาร์เรย์แสดงอยู่ด้านล่าง

[array names variablename]

ตัวอย่างการพิมพ์ขนาดดังแสดงด้านล่าง

#!/usr/bin/tclsh

set personA(Name) "Dave"
set personA(Age) 14
puts [array names personA]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Age Name

การทำซ้ำของ Associative Array

คุณสามารถใช้ดัชนีของอาร์เรย์เพื่อวนซ้ำผ่านอาร์เรย์ที่เชื่อมโยงกัน ตัวอย่างแสดงด้านล่าง

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

personA(Age): 14
personA(Name): Dave

ประเภทข้อมูลดั้งเดิมของ Tcl คือสตริงและบ่อยครั้งที่เราพบเครื่องหมายคำพูดบน Tcl เป็นภาษาสตริงเท่านั้น สตริงเหล่านี้สามารถประกอบด้วยอักขระที่เป็นตัวอักษรและตัวเลขคละกันตัวเลขบูลีนหรือแม้แต่ข้อมูลไบนารี Tcl ใช้อักขระ Unicode 16 บิตและอักขระที่เป็นตัวเลขและตัวอักษรสามารถประกอบด้วยตัวอักษรรวมทั้งอักขระที่ไม่ใช่ละตินตัวเลขหรือเครื่องหมายวรรคตอน

ค่าบูลีนสามารถแสดงเป็น 1 ใช่หรือจริงสำหรับจริงและ 0 ไม่ใช่หรือเท็จสำหรับเท็จ

การแสดงสตริง

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

hello

#!/usr/bin/tclsh

set myVariable "hello world"
puts $myVariable set myVariable {hello world} puts $myVariable

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

hello world
hello world

ลำดับการหนีสตริง

อักขระลิเทอรัลอาจเป็นอักขระธรรมดา (เช่น 'x'), ลำดับการหลีก (เช่น '\ t') หรืออักขระสากล (เช่น '\ u02C0')

มีอักขระบางตัวใน Tcl เมื่อนำหน้าด้วยแบ็กสแลชซึ่งจะมีความหมายพิเศษและใช้แทนเช่น newline (\ n) หรือ tab (\ t) ที่นี่คุณมีรายการรหัสลำดับการหลบหนีดังกล่าว -

ลำดับการหลบหนี	ความหมาย
\\	\ อักขระ
\ '	'ตัวละคร
\ "	"ตัวละคร
\?	เหรอ? ตัวละคร
\ ก	แจ้งเตือนหรือกระดิ่ง
\ b	Backspace
\ ฉ	ฟีดรูปแบบ
\ n	ขึ้นบรรทัดใหม่
\ r	การกลับรถ
\ t	แท็บแนวนอน
\ v	แท็บแนวตั้ง

ต่อไปนี้เป็นตัวอย่างเพื่อแสดงอักขระลำดับการหลีกเลี่ยงไม่กี่ตัว -

#!/usr/bin/tclsh

puts "Hello\tWorld\n\nTutorialspoint";

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello   World

Tutorialspoint

คำสั่งสตริง

รายการคำสั่งย่อยสำหรับคำสั่ง string แสดงรายการในตารางต่อไปนี้ -

ซีเนียร์	วิธีการและคำอธิบาย
1	compare string1 string2 เปรียบเทียบ string1 และ string2 ตามศัพท์ ส่งคืน 0 ถ้าเท่ากัน -1 ถ้า string1 มาก่อน string2 มิฉะนั้น 1
2	first string1 string2 ส่งคืนดัชนีที่เกิดขึ้นครั้งแรกของ string1 ใน string2 หากไม่พบให้ส่งกลับ -1
3	index ดัชนีสตริง ส่งกลับอักขระที่ดัชนี
4	last string1 string2 ส่งคืนดัชนีการเกิดครั้งสุดท้ายของ string1 ใน string2 หากไม่พบให้ส่งกลับ -1
5	length สตริง ส่งกลับความยาวของสตริง
6	match pattern สตริง ส่งคืน 1 หากสตริงตรงกับรูปแบบ
7	range สตริง index1 index2 ส่งกลับช่วงของอักขระในสตริงจาก index1 ถึง index2
8	tolower สตริง ส่งคืนสตริงตัวพิมพ์เล็ก
9	toupper สตริง ส่งคืนสตริงตัวพิมพ์ใหญ่
10	trim สตริง? trimcharacters? ลบทริมอักขระในปลายทั้งสองด้านของสตริง ตัวตัดแต่งเริ่มต้นคือช่องว่าง
11	trimleft สตริง? trimcharacters? ลบทริมอักขระในจุดเริ่มต้นด้านซ้ายของสตริง ตัวตัดแต่งเริ่มต้นคือช่องว่าง
12	trimright สตริง? trimcharacters? ลบทริมอักขระที่ปลายด้านซ้ายของสตริง ตัวตัดแต่งเริ่มต้นคือช่องว่าง
13	wordend ดัชนี findstring ส่งคืนดัชนีใน findstring ของอักขระหลังคำที่มีอักขระที่ดัชนี
14	wordstart ดัชนี findstring ส่งคืนดัชนีใน findstring ของอักขระตัวแรกในคำที่มีอักขระที่ดัชนี

ตัวอย่างของคำสั่งย่อยสตริง Tcl ที่ใช้กันทั่วไปมีให้ด้านล่าง

การเปรียบเทียบสตริง

#!/usr/bin/tclsh

set s1 "Hello"
set s2 "World"
set s3 "World"
puts [string compare $s1 $s2]
if {[string compare $s2 $s3] == 0} {
   puts "String \'s1\' and \'s2\' are same.";
}

if {[string compare $s1 $s2] == -1} {
   puts "String \'s1\' comes before \'s2\'.";
}

if {[string compare $s2 $s1] == 1} {
   puts "String \'s2\' comes after \'s1\'.";
}

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

-1
String 's1' and 's2' are same.
String 's1' comes before 's2'.
String 's2' comes after 's1'.

ดัชนีของสตริง

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "o"
puts "First occurrence of $s2 in s1" puts [string first $s2 $s1] puts "Character at index 0 in s1" puts [string index $s1 0]
puts "Last occurrence of $s2 in s1" puts [string last $s2 $s1] puts "Word end index in s1" puts [string wordend $s1 20]
puts "Word start index in s1"
puts [string wordstart $s1 20]

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

First occurrence of o in s1
4
Character at index 0 in s1
H
Last occurrence of o in s1
7
Word end index in s1
11
Word start index in s1
6

ความยาวของสตริง

#!/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 World"
puts "Uppercase string of s1"
puts [string toupper $s1] puts "Lowercase string of s1" puts [string tolower $s1]

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Uppercase string of s1
HELLO WORLD
Lowercase string of s1
hello world

การตัดแต่งอักขระ

#!/usr/bin/tclsh

set s1 "Hello World"
set s2 "World"
puts "Trim right $s2 in $s1"
puts [string trimright $s1 $s2]

set s2 "Hello"
puts "Trim left $s2 in $s1"
puts [string trimleft $s1 $s2]

set s1 " Hello World "
set s2 " "
puts "Trim characters s1 on both sides of s2"
puts [string trim $s1 $s2]

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Trim right World in Hello World
Hello 
Trim left Hello in Hello World
 World
Trim characters s1 on both sides of s2
Hello World

การจับคู่สตริง

#!/usr/bin/tclsh

set s1 "[email protected]" 
set s2 "*@*.com"
puts "Matching pattern s2 in s1"
puts [string match "*@*.com" $s1 ] puts "Matching pattern tcl in s1" puts [string match {tcl} $s1]

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Matching pattern s2 in s1
1
Matching pattern tcl in s1
0

ผนวกคำสั่ง

#!/usr/bin/tclsh

set s1 "Hello" 
append s1 " World"
puts $s1

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

Hello World

คำสั่ง Format

ตารางต่อไปนี้แสดงรายการตัวระบุรูปแบบที่มีอยู่ใน Tcl -

ตัวระบุ	ใช้
% s	การแทนค่าสตริง
% d	การแทนจำนวนเต็ม
% ฉ	การแสดงจุดลอย
% จ	การแสดงจุดลอยตัวด้วยรูปแบบเลขชี้กำลังของแมนทิสซา
% x	การแทนค่าฐานสิบหก Hexa

ตัวอย่างง่ายๆมีให้ด้านล่าง -

#!/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 ใช้สำหรับการแยกวิเคราะห์สตริงตามตัวระบุรูปแบบ ตัวอย่างบางส่วนแสดงไว้ด้านล่าง

#!/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]

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานจะให้ผลลัพธ์ดังนี้ -

รายการเป็นหนึ่งในประเภทข้อมูลพื้นฐานที่มีอยู่ใน Tcl ใช้สำหรับแสดงคอลเลกชันของรายการที่สั่งซื้อ สามารถรวมรายการประเภทต่างๆไว้ในรายการเดียวกัน นอกจากนี้รายการอาจมีรายการอื่น

สิ่งสำคัญที่ต้องสังเกตคือรายการเหล่านี้จะแสดงเป็นสตริงอย่างสมบูรณ์และประมวลผลเพื่อสร้างแต่ละรายการเมื่อจำเป็น ดังนั้นหลีกเลี่ยงรายการขนาดใหญ่และในกรณีเช่นนี้ ใช้อาร์เรย์

การสร้างรายการ

ไวยากรณ์ทั่วไปสำหรับรายการได้รับด้านล่าง -

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

red green blue
red green blue
red green blue

การต่อท้ายรายการในรายการ

ไวยากรณ์สำหรับการต่อท้ายรายการในรายการมีให้ด้านล่าง -

append listName split_character value
# or
lappend listName value

ตัวอย่างบางส่วนได้รับด้านล่าง -

#!/usr/bin/tclsh

set var orange
append var " " "blue"
lappend var "red" 
lappend var "green" 
puts $var

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

orange blue red green

ความยาวของรายการ

ไวยากรณ์สำหรับความยาวของรายการแสดงไว้ด้านล่าง -

llength listName

ตัวอย่างความยาวของรายการแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

List Item ที่ Index

ไวยากรณ์สำหรับการเลือกรายการที่ดัชนีเฉพาะได้รับด้านล่าง -

lindex listname index

ตัวอย่างรายการที่ดัชนีได้รับด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

blue

แทรกรายการที่ดัชนี

ไวยากรณ์สำหรับการแทรกรายการที่ดัชนีเฉพาะได้รับด้านล่าง

linsert listname index value1 value2..valuen

ตัวอย่างสำหรับการแทรกรายการที่ดัชนีเฉพาะแสดงไว้ด้านล่าง

#!/usr/bin/tclsh

set var {orange blue red green}
set var [linsert  $var 3 black white]
puts $var

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

orange blue red black white green

แทนที่รายการที่ดัชนี

ไวยากรณ์สำหรับการแทนที่รายการที่ดัชนีเฉพาะแสดงไว้ด้านล่าง -

lreplace listname firstindex lastindex value1 value2..valuen

ตัวอย่างสำหรับการแทนที่รายการที่ดัชนีเฉพาะแสดงไว้ด้านล่าง

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

orange blue black white

ตั้งค่ารายการที่ดัชนี

ไวยากรณ์สำหรับการตั้งค่ารายการที่ดัชนีเฉพาะได้รับด้านล่าง -

lset listname index value

ตัวอย่างการตั้งค่ารายการที่ดัชนีเฉพาะระบุไว้ด้านล่าง -

#!/usr/bin/tclsh

set var {orange blue red green}
lset var 0 black 
puts $var

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

black blue red green

แปลงรายการเป็นตัวแปร

ไวยากรณ์สำหรับการคัดลอกค่าไปยังตัวแปรได้รับด้านล่าง -

lassign listname variable1 variable2.. variablen

ตัวอย่างการแปลงรายการเป็นตัวแปรแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

set var {orange blue red green}
lassign $var colour1 colour2 puts $colour1
puts $colour2

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

orange
blue

การจัดเรียงรายการ

ไวยากรณ์สำหรับการจัดเรียงรายการได้รับด้านล่าง -

lsort listname

ตัวอย่างการจัดเรียงรายการแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

blue green orange red

พจนานุกรมคือการจัดเรียงสำหรับการแมปค่ากับคีย์ ไวยากรณ์สำหรับพจนานุกรมทั่วไปแสดงไว้ด้านล่าง -

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

ตัวอย่างบางส่วนสำหรับการสร้างพจนานุกรมแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

colour1 red
colour1 red colour2 green
colour1 black colour2 white

ขนาดของ Dict

ไวยากรณ์สำหรับการรับขนาดของ dict แสดงไว้ด้านล่าง -

[dict size dictname]

ตัวอย่างการพิมพ์ขนาดดังแสดงด้านล่าง -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
puts [dict size $colours]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

การทำซ้ำพจนานุกรม

การทำซ้ำพจนานุกรมอย่างง่ายสำหรับการพิมพ์คีย์และมูลค่าของพจนานุกรมแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

black
white

ค่าสำหรับคีย์ใน Dict

ไวยากรณ์สำหรับการดึงค่าสำหรับคีย์ใน dict แสดงไว้ด้านล่าง -

[dict get $dictname $keyname]

ตัวอย่างการดึงค่าสำหรับคีย์แสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set value [dict get $colours colour1]
puts $value

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

black

คีย์ทั้งหมดใน Dict

ไวยากรณ์สำหรับการดึงคีย์ทั้งหมดใน dict แสดงไว้ด้านล่าง -

[dict keys $dictname]

ตัวอย่างการพิมพ์คีย์ทั้งหมดแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set keys [dict keys $colours] puts $keys

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

colour1 colour2

ค่าทั้งหมดใน Dict

ไวยากรณ์สำหรับการดึงค่าทั้งหมดใน dict แสดงไว้ด้านล่าง -

[dict values $dictname]

ตัวอย่างการพิมพ์ค่าทั้งหมดแสดงด้านล่าง -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set values [dict values $colours]
puts $values

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

black white

คีย์มีอยู่ใน Dict

ไวยากรณ์สำหรับการตรวจสอบว่ามีคีย์อยู่ใน dict หรือไม่แสดงอยู่ด้านล่าง -

[dict exists $dictname $key]

ตัวอย่างการตรวจสอบว่ามีคีย์อยู่ใน dict หรือไม่แสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

set colours [dict create colour1 "black" colour2 "white"]
set result [dict exists $colours colour1]
puts $result

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

โพรซีเดอร์ไม่ใช่อะไรนอกจากบล็อกโค้ดที่มีชุดคำสั่งที่ให้ฟังก์ชันการใช้งานซ้ำเฉพาะ ใช้เพื่อหลีกเลี่ยงการใช้รหัสเดียวกันซ้ำในหลายตำแหน่ง ขั้นตอนเทียบเท่ากับฟังก์ชันที่ใช้ในภาษาโปรแกรมต่างๆและมีให้ใช้งานใน Tcl ด้วยความช่วยเหลือของproc คำสั่ง

ไวยากรณ์ของการสร้างขั้นตอนง่ายๆแสดงไว้ด้านล่าง -

proc procedureName {arguments} {
   body
}

ตัวอย่างง่ายๆสำหรับขั้นตอนดังต่อไปนี้ -

#!/usr/bin/tclsh

proc helloWorld {} {
   puts "Hello, World!"
}
helloWorld

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Hello, World!

ขั้นตอนที่มีหลายอาร์กิวเมนต์

ตัวอย่างสำหรับขั้นตอนที่มีอาร์กิวเมนต์แสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

proc add {a b} {
   return [expr $a+$b]
}
puts [add 10 30]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ขั้นตอนที่มีอาร์กิวเมนต์ตัวแปร

ตัวอย่างสำหรับขั้นตอนที่มีอาร์กิวเมนต์แสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

proc avg {numbers} {
   set sum 0
   foreach number $numbers {
      set sum  [expr $sum + $number]
   }
   set average [expr $sum/[llength $numbers]]
   return $average
}
puts [avg {70 80 50 60}]
puts [avg {70 80 50 }]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

65
66

ขั้นตอนที่มีอาร์กิวเมนต์เริ่มต้น

อาร์กิวเมนต์ดีฟอลต์ใช้เพื่อระบุค่าดีฟอลต์ที่สามารถใช้ได้หากไม่มีการระบุค่า ตัวอย่างสำหรับโพรซีเดอร์ที่มีอาร์กิวเมนต์เริ่มต้นซึ่งบางครั้งเรียกว่าอาร์กิวเมนต์โดยปริยายแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

proc add {a {b 100} } {
   return [expr $a+$b]
}
puts [add 10 30]
puts [add 10]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

40
110

ขั้นตอนการเรียกซ้ำ

ตัวอย่างสำหรับขั้นตอนการเรียกซ้ำแสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

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

}
puts [factorial 3]
puts [factorial 5]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

6
120

แพ็กเกจใช้สำหรับสร้างโค้ดที่สามารถใช้ซ้ำได้ แพ็กเกจประกอบด้วยคอลเล็กชันไฟล์ที่มีฟังก์ชันการทำงานเฉพาะ คอลเล็กชันของไฟล์นี้ถูกระบุโดยชื่อแพ็กเกจและสามารถมีไฟล์เดียวกันได้หลายเวอร์ชัน แพคเกจสามารถเป็นชุดของสคริปต์ Tcl ไลบรารีไบนารีหรือทั้งสองอย่างรวมกัน

แพ็คเกจใช้แนวคิดของเนมสเปซเพื่อหลีกเลี่ยงการชนกันของชื่อตัวแปรและชื่อโพรซีเดอร์ ดูเพิ่มเติมในบทช่วยสอน ' เนมสเปซ ' ถัดไปของเรา

การสร้างแพ็คเกจ

สามารถสร้างแพ็คเกจได้ด้วยความช่วยเหลือของไฟล์ขั้นต่ำสองไฟล์ ไฟล์หนึ่งมีรหัสแพ็คเกจ ไฟล์อื่นมีไฟล์แพ็กเกจดัชนีสำหรับการประกาศแพ็กเกจของคุณ

รายการขั้นตอนในการสร้างและใช้งานแพ็คเกจมีให้ด้านล่าง

ขั้นตอนที่ 1: การสร้างรหัส

สร้างรหัสสำหรับแพ็คเกจภายในโฟลเดอร์พูดว่า HelloWorld ให้ไฟล์ชื่อ HelloWorld.tcl พร้อมรหัสตามรูปด้านล่าง -

# /Users/rajkumar/Desktop/helloworld/HelloWorld.tcl 
# Create the namespace
namespace eval ::HelloWorld {
 
  # Export MyProcedure
  namespace export MyProcedure
 
  # My Variables
   set version 1.0
   set MyDescription "HelloWorld"
 
  # Variable for the path of the script
   variable home [file join [pwd] [file dirname [info script]]]
 
}
 
# Definition of the procedure MyProcedure
proc ::HelloWorld::MyProcedure {} {
   puts $HelloWorld::MyDescription } package provide HelloWorld $HelloWorld::version
package require Tcl 8.0

ขั้นตอนที่ 2: การสร้างดัชนีแพ็คเกจ

เปิด tclsh เปลี่ยนไปใช้ไดเรกทอรี HelloWorld และใช้คำสั่ง pkg_mkIndex เพื่อสร้างไฟล์ดัชนีดังที่แสดงด้านล่าง -

% cd /Users/rajkumar/Desktop/helloworld 
% pkg_mkIndex . *.tcl

ขั้นตอนที่ 3: การเพิ่ม Directory ใน Autopath

ใช้คำสั่ง lappend เพื่อเพิ่มแพ็คเกจในรายการส่วนกลางดังที่แสดงด้านล่าง -

% lappend auto_path "/Users/rajkumar/Desktop/helloworld"

ขั้นตอนที่ 4: การเพิ่มแพ็คเกจ

ต่อไปเพิ่ม package ในโปรแกรมโดยใช้ package require statement ดังรูปด้านล่าง -

% package require HelloWorld 1.0

ขั้นตอนที่ 5: การเรียกใช้ขั้นตอน

ตอนนี้ทุกอย่างกำลังตั้งค่าเราสามารถเรียกใช้ขั้นตอนของเราได้ดังที่แสดงด้านล่าง -

% puts [HelloWorld::MyProcedure]

คุณจะได้รับผลลัพธ์ดังต่อไปนี้ -

HelloWorld

สองขั้นตอนแรกสร้างแพ็คเกจ เมื่อสร้างแพ็คเกจแล้วคุณสามารถใช้มันในไฟล์ Tcl ใดก็ได้โดยเพิ่มคำสั่งสามคำสุดท้ายดังที่แสดงด้านล่าง -

lappend auto_path "/Users/rajkumar/Desktop/helloworld"
package require HelloWorld 1.0
puts [HelloWorld::MyProcedure]

คุณจะได้รับผลลัพธ์ดังต่อไปนี้ -

HelloWorld

เนมสเปซเป็นคอนเทนเนอร์สำหรับชุดตัวระบุที่ใช้ในการจัดกลุ่มตัวแปรและโพรซีเดอร์ Namespaces พร้อมใช้งานจาก Tcl เวอร์ชัน 8.0 ก่อนการเปิดตัวเนมสเปซมีขอบเขตส่วนกลางเดียว ขณะนี้มีเนมสเปซเรามีพาร์ติชันเพิ่มเติมสำหรับขอบเขตส่วนกลาง

การสร้างเนมสเปซ

เนมสเปซถูกสร้างขึ้นโดยใช้ namespaceคำสั่ง ตัวอย่างง่ายๆสำหรับการสร้างเนมสเปซแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

namespace eval MyMath {
  # Create a variable inside the namespace
  variable myResult
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
  set ::MyMath::myResult [expr $a + $b]
}
MyMath::Add 10 23

puts $::MyMath::myResult

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ในโปรแกรมด้านบนคุณจะเห็นว่ามีเนมสเปซพร้อมตัวแปร myResult และขั้นตอน Add. สิ่งนี้ทำให้สามารถสร้างตัวแปรและโพรซีเดอร์ที่มีชื่อเดียวกันภายใต้เนมสเปซที่ต่างกัน

เนมสเปซที่ซ้อนกัน

Tcl อนุญาตการซ้อนของเนมสเปซ ตัวอย่างง่ายๆสำหรับการซ้อนเนมสเปซมีดังต่อไปนี้ -

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
}

namespace eval extendedMath {
   # Create a variable inside the namespace
   namespace eval MyMath {
      # Create a variable inside the namespace
      variable myResult
   }
}
set ::MyMath::myResult "test1"
puts $::MyMath::myResult
set ::extendedMath::MyMath::myResult "test2"
puts $::extendedMath::MyMath::myResult

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

test1
test2

การนำเข้าและส่งออกเนมสเปซ

คุณสามารถดูได้ในตัวอย่างเนมสเปซก่อนหน้านี้เราใช้ตัวดำเนินการแก้ไขขอบเขตจำนวนมากและใช้งานได้ซับซ้อนกว่า เราสามารถหลีกเลี่ยงสิ่งนี้ได้โดยการนำเข้าและส่งออกเนมสเปซ ตัวอย่างได้รับด้านล่าง -

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
   namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
   return [expr $a + $b]
}

namespace import MyMath::*
puts [Add 10 30]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ลืมเนมสเปซ

คุณสามารถลบเนมสเปซที่นำเข้าได้โดยใช้ forgetคำสั่งย่อย ตัวอย่างง่ายๆแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

namespace eval MyMath {
   # Create a variable inside the namespace
   variable myResult
   namespace export Add
}

# Create procedures inside the namespace
proc MyMath::Add {a b } {  
   return [expr $a + $b]
}
namespace import MyMath::*
puts [Add 10 30]
namespace forget MyMath::*

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Tcl รองรับการจัดการไฟล์ด้วยความช่วยเหลือของคำสั่งในตัวเปิดอ่านวางรับและปิด

ไฟล์แสดงลำดับของไบต์ไม่สำคัญว่าจะเป็นไฟล์ข้อความหรือไฟล์ไบนารี

กำลังเปิดไฟล์

Tcl ใช้คำสั่ง open เพื่อเปิดไฟล์ใน Tcl ไวยากรณ์สำหรับการเปิดไฟล์มีดังนี้ -

open fileName accessMode

ที่นี่ filename เป็นสตริงลิเทอรัลซึ่งคุณจะใช้ตั้งชื่อไฟล์และ accessMode สามารถมีค่าใดค่าหนึ่งต่อไปนี้ -

ซีเนียร์	โหมดและคำอธิบาย
1	r เปิดไฟล์ข้อความที่มีอยู่เพื่อจุดประสงค์ในการอ่านและไฟล์ต้องมีอยู่ นี่คือโหมดเริ่มต้นที่ใช้เมื่อไม่มีการระบุ accessMode
2	w เปิดไฟล์ข้อความสำหรับการเขียนหากไม่มีอยู่ไฟล์ใหม่จะถูกสร้างขึ้นมิฉะนั้นไฟล์ที่มีอยู่จะถูกตัดทอน
3	a เปิดไฟล์ข้อความสำหรับการเขียนในโหมดต่อท้ายและต้องมีไฟล์อยู่ ที่นี่โปรแกรมของคุณจะเริ่มต่อท้ายเนื้อหาในเนื้อหาไฟล์ที่มีอยู่
4	r+ เปิดไฟล์ข้อความสำหรับอ่านและเขียนทั้งสองอย่าง ไฟล์ต้องมีอยู่แล้ว
5	w+ เปิดไฟล์ข้อความสำหรับอ่านและเขียนทั้งสองอย่าง ขั้นแรกให้ตัดทอนไฟล์ให้มีความยาวเป็นศูนย์หากมีอยู่ให้สร้างไฟล์หากไม่มีอยู่
6	a+ เปิดไฟล์ข้อความสำหรับอ่านและเขียนทั้งสองอย่าง จะสร้างไฟล์หากไม่มีอยู่ การอ่านจะเริ่มจากจุดเริ่มต้น แต่การเขียนสามารถต่อท้ายได้เท่านั้น

การปิดไฟล์

ในการปิดไฟล์ให้ใช้คำสั่งปิด ไวยากรณ์สำหรับการปิดมีดังนี้ -

close fileName

ไฟล์ใด ๆ ที่ถูกเปิดโดยโปรแกรมจะต้องปิดเมื่อโปรแกรมเสร็จสิ้นโดยใช้ไฟล์นั้น ในกรณีส่วนใหญ่ไม่จำเป็นต้องปิดไฟล์อย่างชัดเจน จะปิดโดยอัตโนมัติเมื่ออ็อบเจ็กต์ไฟล์ถูกยกเลิกโดยอัตโนมัติ

การเขียนไฟล์

คำสั่ง puts ใช้เพื่อเขียนไปยังไฟล์ที่เปิดอยู่

puts $filename "text to write"

ตัวอย่างง่ายๆสำหรับการเขียนลงไฟล์แสดงไว้ด้านล่าง

#!/usr/bin/tclsh

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

เมื่อโค้ดด้านบนถูกคอมไพล์และเรียกใช้งานโค้ดจะสร้างไฟล์ใหม่ input.txt ในไดเร็กทอรีที่เริ่มต้นภายใต้ (ในไดเร็กทอรีการทำงานของโปรแกรม)

การอ่านไฟล์

ต่อไปนี้เป็นคำสั่งง่ายๆในการอ่านจากไฟล์ -

set file_data [read $fp]

ตัวอย่างการอ่านและเขียนที่สมบูรณ์แสดงอยู่ด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อรวบรวมและดำเนินการโค้ดด้านบนจะอ่านไฟล์ที่สร้างในส่วนก่อนหน้าและสร้างผลลัพธ์ต่อไปนี้ -

test

นี่คืออีกตัวอย่างหนึ่งสำหรับการอ่านไฟล์จนจบไฟล์ทีละบรรทัด -

#!/usr/bin/tclsh

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

test
test

การจัดการข้อผิดพลาดใน Tcl มีให้ด้วยความช่วยเหลือของ error และ catchคำสั่ง ไวยากรณ์สำหรับแต่ละคำสั่งเหล่านี้แสดงไว้ด้านล่าง

ไวยากรณ์ผิดพลาด

error message info code

ในไวยากรณ์คำสั่งข้อผิดพลาดด้านบนข้อความคือข้อความแสดงข้อผิดพลาดข้อมูลถูกตั้งค่าใน errorInfo ตัวแปรส่วนกลางและรหัสถูกตั้งค่าใน errorCode ตัวแปรส่วนกลาง

จับไวยากรณ์

catch script resultVarName

ในไวยากรณ์คำสั่ง catch ด้านบนสคริปต์คือรหัสที่จะเรียกใช้ resultVarName เป็นตัวแปรที่เก็บข้อผิดพลาดหรือผลลัพธ์ คำสั่ง catch จะคืนค่า 0 หากไม่มีข้อผิดพลาดและ 1 หากมีข้อผิดพลาด

ตัวอย่างสำหรับการจัดการข้อผิดพลาดอย่างง่ายแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

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

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ErrorMsg: Error generated by error
ErrorCode: 401
ErrorInfo:
Info String for error
   (procedure "Div" line 1)
   invoked from within
"Div 10 0"

Result = 5

ดังที่คุณเห็นในตัวอย่างด้านบนเราสามารถสร้างข้อความแสดงข้อผิดพลาดที่กำหนดเองได้ ในทำนองเดียวกันเป็นไปได้ที่จะตรวจจับข้อผิดพลาดที่สร้างโดย Tcl ตัวอย่างแสดงด้านล่าง -

#!/usr/bin/tclsh

catch {set file [open myNonexistingfile.txt]} result
puts "ErrorMsg: $result" puts "ErrorCode: $errorCode"
puts "ErrorInfo:\n$errorInfo\n"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

ErrorMsg: couldn't open "myNonexistingfile.txt": no such file or directory
ErrorCode: POSIX ENOENT {no such file or directory}
ErrorInfo:
couldn't open "myNonexistingfile.txt": no such file or directory
   while executing
"open myNonexistingfile.txt"

Tcl มีฟังก์ชันในตัว (โพรซีเดอร์) จำนวนมากสำหรับการดำเนินการต่างๆ ซึ่งรวมถึง -

ฟังก์ชั่นสำหรับการจัดการรายการ
ฟังก์ชั่นสำหรับการจัดการสตริง
ฟังก์ชั่นสำหรับการจัดการอาร์เรย์
ฟังก์ชั่นสำหรับการจัดการพจนานุกรม
ฟังก์ชั่นสำหรับไฟล์ I / Oการจัดการ
ฟังก์ชั่นสำหรับสร้างเนมสเปซและแพ็กเกจ
ฟังก์ชันสำหรับการดำเนินการทางคณิตศาสตร์
ฟังก์ชั่นสำหรับการทำงานของระบบ

แต่ละข้อข้างต้นยกเว้นฟังก์ชันคณิตศาสตร์และระบบจะครอบคลุมในบทก่อนหน้านี้ ฟังก์ชันในตัวคณิตศาสตร์และระบบมีคำอธิบายด้านล่าง

ฟังก์ชันคณิตศาสตร์

ฟังก์ชันทางคณิตศาสตร์ที่มีอยู่ใน Tcl แสดงอยู่ในตารางต่อไปนี้ -

ซีเนียร์	วิธีการและคำอธิบาย
1	abs อาร์กิวเมนต์ คำนวณค่าสัมบูรณ์ของ arg
2	acos อาร์กิวเมนต์ คำนวณ arccosine ของ arg
3	asin อาร์กิวเมนต์ คำนวณอาร์กไซน์ของอาร์กิวเมนต์
4	atan อาร์กิวเมนต์ คำนวณอาร์กแทนเจนต์ของอาร์กิวเมนต์
5	atan2 yx คำนวณอาร์กแทนเจนต์ของผลหารของอาร์กิวเมนต์ (y / x)
6	ceil อาร์กิวเมนต์ คำนวณจำนวนเต็มที่น้อยที่สุดที่มากกว่าหรือเท่ากับตัวเลข
7	cos อาร์กิวเมนต์ คำนวณโคไซน์ของอาร์กิวเมนต์
8	cosh อาร์กิวเมนต์ คำนวณไฮเพอร์โบลิกโคไซน์ของอาร์กิวเมนต์
9	double อาร์กิวเมนต์ คำนวณว่า arg เป็นค่าทศนิยมหรือไม่ให้ส่งกลับ arg หรือจะแปลง arg เป็น floating-point และส่งกลับค่าที่แปลงแล้ว
10	exp อาร์กิวเมนต์ คำนวณฟังก์ชันเอกซ์โพเนนเชียล (e ยกกำลังอาร์กิวเมนต์)
11	floor อาร์กิวเมนต์ คำนวณจำนวนเต็มที่มากที่สุดน้อยกว่าหรือเท่ากับ arg
12	fmod xy คำนวณเศษทศนิยมที่เหลือของการหาร x ด้วย y ถ้า y เป็น 0 ข้อผิดพลาดจะถูกส่งกลับ
13	hypot xy คำนวณความยาวของด้านตรงข้ามมุมฉากของสามเหลี่ยมมุมฉาก sqrt (x * x + y * y)
14	int อาร์กิวเมนต์ คำนวณว่า arg เป็นค่าจำนวนเต็มที่มีความกว้างเท่ากับคำของเครื่องหรือไม่ให้ส่งกลับ arg หรือจะแปลง arg เป็นจำนวนเต็ม
15	log อาร์กิวเมนต์ คำนวณลอการิทึมธรรมชาติของ arg
16	log10 อาร์กิวเมนต์ คำนวณลอการิทึมฐาน 10 ของอาร์กิวเมนต์
17	pow xy คำนวณค่า x ยกกำลัง y ถ้า x เป็นลบ y ต้องเป็นค่าจำนวนเต็ม
18	rand คำนวณตัวเลขสุ่มหลอกระหว่าง 0 ถึง 1
19	round อาร์กิวเมนต์ คำนวณค่าของ arg ที่ปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุด
20	sin อาร์กิวเมนต์ คำนวณไซน์ของอาร์กิวเมนต์
21	sinh อาร์กิวเมนต์ คำนวณไฮเพอร์โบลิกไซน์ของอาร์กิวเมนต์
22	sqrt อาร์กิวเมนต์ คำนวณรากที่สองของ arg อาร์กิวเมนต์ต้องเป็นบวก
23	srand อาร์กิวเมนต์ คำนวณจำนวนสุ่มหลอกระหว่าง 0 ถึง 1 อาร์กิวเมนต์ซึ่งต้องเป็นจำนวนเต็มใช้เพื่อรีเซ็ตเมล็ดพันธุ์สำหรับตัวสร้างตัวเลขสุ่มของแรนด์
24	tan อาร์กิวเมนต์ คำนวณแทนเจนต์ของอาร์กิวเมนต์
25	tanh อาร์กิวเมนต์ คำนวณไฮเพอร์โบลิกแทนเจนต์ของอาร์กิวเมนต์
26	wide อาร์กิวเมนต์ คำนวณค่าจำนวนเต็มกว้างอย่างน้อย 64 บิต (โดย sign-extension ถ้า arg เป็นตัวเลข 32 บิต) สำหรับ arg ถ้ายังไม่มี

ตัวอย่างการใช้ฟังก์ชันทางคณิตศาสตร์มีให้ด้านล่าง -

#!/usr/bin/tclsh

namespace import ::tcl::mathfunc::*
puts [tan 10]
puts [pow 10 2]
puts [ceil 10.34]
puts [hypot 10 20]
puts [srand 45]
puts [log 10]
puts [srand 45]

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

0.6483608274590866
100.0
11.0
22.360679774997898
0.0003521866166741525
2.302585092994046
0.0003521866166741525

ฟังก์ชั่นระบบ

ฟังก์ชันระบบที่สำคัญใน Tcl ประกอบด้วย

clock - ฟังก์ชั่นวินาทีซึ่งคืนเวลาปัจจุบันเป็นวินาที
clock - ฟังก์ชันรูปแบบซึ่งจัดรูปแบบวินาทีให้เป็นวันที่และเวลา
clock - ฟังก์ชั่นสแกนซึ่งจะสแกนสตริงอินพุตและแปลงเป็นวินาที
open - ฟังก์ชันซึ่งใช้เพื่อเปิดไฟล์
exec - ฟังก์ชันซึ่งใช้เพื่อดำเนินการคำสั่งระบบ
close - ฟังก์ชันที่ใช้ปิดไฟล์

ตัวอย่างบางส่วนของฟังก์ชันข้างต้นแสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

#get seconds
set currentTime [clock seconds]
puts $currentTime
#get format 
puts "The time is: [clock format $currentTime -format %H:%M:%S]" puts "The date is: [clock format $currentTime -format %D]"

set date "Jun 15, 2014"
puts [clock scan $date -format {%b %d, %Y}] puts [exec ls] puts [exec dir] set a [open input.txt] puts [read $a];
puts $a close $a

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

1402819756
The time is: 03:09:16
The date is: 06/15/2014
1402808400
input.txt
main.tcl
input.txt  main.tcl
This is the file you can use to provide input to your program and later on open
   it inside your program to process the input.

file3

ตารางต่อไปนี้แสดงสตริงรายการที่สามารถใช้เพื่อจัดรูปแบบวันที่และเวลา

ซีเนียร์	รูปแบบและคำอธิบาย
1	%a วันในรูปแบบสั้นเช่นดวงอาทิตย์
2	%A วันในรูปแบบเต็มเช่นวันอาทิตย์
3	%b เดือนในรูปแบบสั้น
4	%B เดือนในรูปแบบเต็ม
5	%d วันของเดือน
6	%j วันจูเลียนของปี
7	%m จำนวนเดือน
8	%y ปีเป็นตัวเลขสองหลัก
9	%Y ปีเป็นตัวเลขสี่หลัก
10	%H ชั่วโมงในนาฬิกา 24 ชั่วโมง
11	%I ชั่วโมงในนาฬิกา 12 ชั่วโมง
12	%M นาที.
13	%S วินาที
14	%p AM หรือ PM
15	%D วันที่เป็นตัวเลขมม. / วว. / ปปป.
16	%r เวลาใน 12 ชั่วโมงนาฬิกา
17	%R เวลาใน 24 ชั่วโมงนาฬิกาโดยไม่ต้องวินาที
18	%T เวลาใน 24 ชั่วโมงนาฬิกาวินาที
19	%Z ชื่อโซนเวลาเช่น GMT, IST, EST และอื่น ๆ

คำสั่ง "regexp" ใช้เพื่อจับคู่นิพจน์ทั่วไปใน Tcl นิพจน์ทั่วไปคือลำดับของอักขระที่มีรูปแบบการค้นหา ประกอบด้วยกฎหลายข้อและตารางต่อไปนี้จะอธิบายกฎเหล่านี้และการใช้งานที่เกี่ยวข้อง

ซีเนียร์	กฎและคำอธิบาย
1	x คู่ที่เหมาะสม.
2	[a-z] อักษรตัวพิมพ์เล็กจาก az
3	. อักขระใด ๆ
4	^ สตริงเริ่มต้นควรตรงกัน
5	$ สตริงสิ้นสุดควรตรงกัน
6	\^ ลำดับฟันเฟืองเพื่อจับคู่อักขระพิเศษ ^ ในทำนองเดียวกันคุณสามารถใช้กับอักขระอื่นได้
7	() เพิ่มลำดับข้างต้นในวงเล็บเพื่อสร้างนิพจน์ทั่วไป
8	x* ควรตรงกับ 0 ครั้งหรือมากกว่าที่เกิดขึ้นของ x ก่อนหน้า
9	x+ ควรตรงกับ 1 เหตุการณ์หรือมากกว่าที่เกิดขึ้นของ x ก่อนหน้า
10	[a-z]? ควรตรงกับ 0 หรือ 1 ครั้งของ x ที่อยู่ข้างหน้า
11	{digit} จับคู่ตัวเลขที่เกิดขึ้นของนิพจน์ regex ก่อนหน้าทุกประการ ตัวเลขที่ประกอบด้วย 0-9
12	{digit,} จับคู่ตัวเลข 3 หลักขึ้นไปของนิพจน์ regex ก่อนหน้า ตัวเลขที่ประกอบด้วย 0-9
13	{digit1,digit2} เหตุการณ์ที่เกิดขึ้นตรงกับช่วงระหว่างการเกิด digit1 และ digit2 ของนิพจน์ regex ก่อนหน้า

ไวยากรณ์

ไวยากรณ์สำหรับ regex ได้รับด้านล่าง -

regexp optionalSwitches patterns searchString fullMatch subMatch1 ... subMatchn

นี่คือคำสั่ง regex เราจะดูเกี่ยวกับสวิตช์เสริมในภายหลัง รูปแบบเป็นกฎตามที่กล่าวไว้ก่อนหน้านี้ สตริงการค้นหาคือสตริงจริงที่ดำเนินการ regex การจับคู่แบบเต็มคือตัวแปรใด ๆ ที่จะเก็บผลลัพธ์ของผลลัพธ์ regex ที่ตรงกัน Submatch1 ถึง SubMatchn เป็นตัวแปร subMatch ที่เป็นทางเลือกที่เก็บผลลัพธ์ของรูปแบบการจับคู่ย่อย

ลองดูตัวอย่างง่ายๆก่อนที่จะดำดิ่งสู่สิ่งที่ซับซ้อน ตัวอย่างง่ายๆสำหรับสตริงที่มีตัวอักษรใด ๆ เมื่อพบอักขระอื่น ๆ ใน regex การค้นหาจะหยุดและส่งคืน

#!/usr/bin/tclsh

regexp {([A-Za-z]*)} "Tcl Tutorial" a b 
puts "Full Match: $a"
puts "Sub Match1: $b"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Full Match: Tcl
Sub Match1: Tcl

หลายรูปแบบ

ตัวอย่างต่อไปนี้แสดงวิธีค้นหารูปแบบต่างๆ นี่คือรูปแบบตัวอย่างสำหรับตัวอักษรใด ๆ ตามด้วยอักขระใด ๆ ตามด้วยตัวอักษรใด ๆ

#!/usr/bin/tclsh

regexp {([A-Za-z]*).([A-Za-z]*)} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b" puts "Sub Match2: $c"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Full Match: Tcl Tutorial
Sub Match1: Tcl
Sub Match2: Tutorial

โค้ดข้างต้นที่แก้ไขแล้วเพื่อแสดงว่ารูปแบบย่อยสามารถมีได้หลายรูปแบบดังแสดงด้านล่าง -

#!/usr/bin/tclsh

regexp {([A-Za-z]*.([A-Za-z]*))} "Tcl Tutorial" a b c  
puts "Full Match: $a" puts "Sub Match1: $b"
puts "Sub Match2: $c"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

สวิตช์สำหรับคำสั่ง Regex

รายการสวิตช์ที่มีอยู่ใน Tcl ได้แก่

nocase - ใช้เพื่อละเว้นกรณี
indices - จัดเก็บตำแหน่งของรูปแบบย่อยที่ตรงกันแทนที่จะเป็นอักขระที่ตรงกัน
line- การจับคู่บรรทัดใหม่ที่ละเอียดอ่อน ละเว้นอักขระหลังขึ้นบรรทัดใหม่
start index - ตั้งค่าชดเชยการเริ่มต้นของรูปแบบการค้นหา
ทำเครื่องหมายจุดสิ้นสุดของสวิตช์

ในตัวอย่างข้างต้นฉันจงใจใช้ [AZ, az] สำหรับตัวอักษรทั้งหมดคุณสามารถใช้ -nocase แทนดังที่แสดงด้านล่าง -

#!/usr/bin/tclsh

regexp -nocase {([A-Z]*.([A-Z]*))} "Tcl Tutorial" a b c  
puts "Full Match: $a"
puts "Sub Match1: $b" puts "Sub Match2: $c"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Full Match: Tcl Tutorial
Sub Match1: Tcl Tutorial
Sub Match2: Tutorial

อีกตัวอย่างการใช้สวิตช์แสดงไว้ด้านล่าง -

#!/usr/bin/tclsh

regexp -nocase -line -- {([A-Z]*.([A-Z]*))} "Tcl \nTutorial" a b 
puts "Full Match: $a" puts "Sub Match1: $b"
regexp -nocase -start 4 -line -- {([A-Z]*.([A-Z]*))} "Tcl \nTutorial" a b  
puts "Full Match: $a" puts "Sub Match1: $b"

เมื่อดำเนินการโค้ดด้านบนจะให้ผลลัพธ์ดังนี้ -

Full Match: Tcl 
Sub Match1: Tcl 
Full Match: Tutorial
Sub Match1: Tutorial

Tk หมายถึง Toolkit และมีวิดเจ็ต GUI ข้ามแพลตฟอร์มซึ่งช่วยคุณในการสร้างอินเทอร์เฟซผู้ใช้แบบกราฟิก ได้รับการพัฒนาเป็นส่วนขยายของภาษาสคริปต์ Tcl โดย John Ousterhout Tk ยังคงอยู่ในการพัฒนาเป็นอิสระจาก Tcl โดยมีเวอร์ชันที่แตกต่างกันก่อนหน้านี้มันถูกสร้างขึ้นโดยซิงค์กับ Tcl ในเวอร์ชัน 8.0

คุณสมบัติของ Tk

เป็นข้ามแพลตฟอร์มที่รองรับระบบปฏิบัติการ Linux, Mac OS, Unix และ Microsoft Windows

มันเป็นโอเพ่นซอร์ส
ให้ความสามารถในการขยายได้ในระดับสูง
สามารถปรับแต่งได้
สามารถกำหนดค่าได้
มีวิดเจ็ตจำนวนมาก
สามารถใช้กับภาษาไดนามิกอื่น ๆ ได้ไม่ใช่แค่ Tcl
GUI มีลักษณะเหมือนกันในทุกแพลตฟอร์ม

แอพพลิเคชั่นที่สร้างขึ้นใน Tk

มีการสร้างแอปพลิเคชันที่ประสบความสำเร็จขนาดใหญ่ใน Tcl / Tk

ส่วนต่อประสานผู้ใช้ Dashboard Soft
แบบฟอร์ม GUI สำหรับฐานข้อมูลเชิงสัมพันธ์
Ad Hoc GUI สำหรับฐานข้อมูลเชิงสัมพันธ์
การออกแบบระบบซอฟต์แวร์ / ฮาร์ดแวร์
Xtask - การจัดการงาน
Musicology กับ Tcl และ Tk
แอปปฏิทิน
Tk mail
Tk Debugger

โดยทั่วไป Mac และ Linux mac ทั้งหมดมาพร้อมกับ Tk ที่ติดตั้งไว้ล่วงหน้า ในกรณีที่ไม่สามารถใช้งานได้หรือคุณต้องการเวอร์ชันล่าสุดคุณอาจต้องติดตั้ง Windows ไม่ได้มาพร้อมกับ Tcl / Tk และคุณอาจต้องใช้ไบนารีเฉพาะเพื่อติดตั้ง

ล่าม Tk

เป็นเพียงโปรแกรมเล็ก ๆ ที่ช่วยให้คุณพิมพ์คำสั่ง Tk และเรียกใช้งานทีละบรรทัด หยุดการทำงานของไฟล์ tcl ในกรณีที่พบข้อผิดพลาดซึ่งแตกต่างจากคอมไพเลอร์ที่ดำเนินการอย่างสมบูรณ์

#!/usr/bin/wish

grid [ttk::button .mybutton -text "Hello World"]

ส่วนต่อไปนี้อธิบายเฉพาะวิธีการติดตั้ง Tcl / Tk บนแต่ละแพลตฟอร์มที่มี

การติดตั้งบน Windows

ดาวน์โหลดเวอร์ชันล่าสุดสำหรับตัวติดตั้ง windows จากรายการไบนารี Active Tcl / Tk ที่มีให้ Active Tcl / Tk community edition ฟรีสำหรับการใช้งานส่วนตัว

เรียกใช้ไฟล์ปฏิบัติการที่ดาวน์โหลดมาเพื่อติดตั้ง Tcl และ Tk ซึ่งสามารถทำได้โดยทำตามคำแนะนำบนหน้าจอ

ตอนนี้เราสามารถสร้างและเรียกใช้ไฟล์ Tcl โดยพูดว่า helloWorld.tcl โดยสลับไปยังโฟลเดอร์ที่มีไฟล์โดยใช้ cd จากนั้นทำตามขั้นตอนต่อไปนี้ -

C:\Tcl> wish helloWorld.tcl

กด Enter และเราจะเห็นผลลัพธ์ดังที่แสดงด้านล่าง -

การติดตั้งบน Linux

ระบบปฏิบัติการ Linux ส่วนใหญ่มาพร้อมกับ Tk inbuilt และคุณสามารถเริ่มต้นได้ทันทีในระบบเหล่านั้น ในกรณีที่ไม่สามารถใช้งานได้คุณสามารถใช้คำสั่งต่อไปนี้เพื่อดาวน์โหลดและติดตั้ง Tcl-Tk

$ yum install tcl tk

ตอนนี้เราสามารถสร้างและเรียกใช้ไฟล์ Tcl พูดว่า helloWorld.tcl โดยเปลี่ยนไปใช้โฟลเดอร์ที่มีไฟล์โดยใช้ cd command จากนั้นใช้ขั้นตอนต่อไปนี้ -

$ wish helloWorld.tcl

กด Enter และเราจะเห็นผลลัพธ์ที่คล้ายกับรายการต่อไปนี้ -

การติดตั้งบนระบบที่ใช้ Debian

$ sudo apt-get install tcl tk

$ wish helloWorld.tcl

กด Enter และเราจะเห็นผลลัพธ์ที่คล้ายกับรายการต่อไปนี้ -

การติดตั้งบน Mac OS X

ดาวน์โหลดเวอร์ชันล่าสุดสำหรับแพ็คเกจ Mac OS X จากรายการไบนารี Active Tcl / Tk ที่มีให้ Active Tcl community edition ฟรีสำหรับการใช้งานส่วนตัว

$ wish helloWorld.tcl

กด Enter และเราจะเห็นผลลัพธ์ดังที่แสดงด้านล่าง -

การติดตั้งจากไฟล์ต้นฉบับ

คุณสามารถใช้ตัวเลือกในการติดตั้งจากไฟล์ต้นฉบับเมื่อไม่มีแพ็กเกจไบนารี โดยทั่วไปนิยมใช้ Tk binaries สำหรับ Windows และ Mac OS X ดังนั้นการรวบรวมเฉพาะแหล่งที่มาบนระบบที่ใช้ unix เท่านั้นที่แสดงด้านล่าง -

ดาวน์โหลดไฟล์ต้นฉบับ
ตอนนี้ใช้คำสั่งต่อไปนี้เพื่อแยกรวบรวมและสร้างหลังจากเปลี่ยนไปใช้โฟลเดอร์ที่ดาวน์โหลด

$ tar zxf tk8.6.1-src.tar.gz
$ cd tcl8.6.1 $ cd unix
$ ./configure —with-tcl=../../tcl8.6.1/unix —prefix=/opt —enable-gcc $ make
$ sudo make install

Note - ตรวจสอบให้แน่ใจว่าคุณได้เปลี่ยนชื่อไฟล์เป็นเวอร์ชันที่คุณดาวน์โหลดจากคำสั่ง 1 และ 2 ในข้างต้น

ใน Tk เราจำแนกตัวแปรบางตัวเป็นตัวแปรพิเศษและมีการใช้งาน / ฟังก์ชันที่กำหนดไว้ล่วงหน้า รายการตัวแปรพิเศษแสดงอยู่ด้านล่าง

ซีเนียร์	ตัวแปรพิเศษและคำอธิบาย
1	tk_library ใช้สำหรับตั้งค่าตำแหน่งของไลบรารี Tk มาตรฐาน
2	tk_patchLevel หมายถึงระดับแพตช์ปัจจุบันของล่าม Tk
3	tk_strictMotif เมื่อไม่เป็นศูนย์ Tk จะพยายามยึดมั่นในรูปลักษณ์ของ Motif ให้ใกล้เคียงที่สุด
4	tk_version แสดงเวอร์ชัน Tk

ตัวแปรพิเศษข้างต้นมีความหมายพิเศษสำหรับล่าม Tk

ตัวอย่างการใช้ตัวแปรพิเศษ Tk

มาดูตัวอย่างตัวแปรพิเศษกัน

รุ่น TK

#!/usr/bin/wish

puts $tk_version

เมื่อคุณเรียกใช้โปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง

8.5

TK LIBRARY PATH

#!/usr/bin/wish

puts $tk_library

เมื่อคุณเรียกใช้โปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง

/Library/Frameworks/Tk.framework/Versions/8.6/Resources/Scripts

TK PATCH ระดับ

#!/usr/bin/wish

puts $tk_patchLevel

เมื่อคุณเรียกใช้โปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง

8.6.1

TK STRICTMOTIF

#!/usr/bin/wish

puts $tk_strictMotif

เมื่อคุณเรียกใช้โปรแกรมคุณจะได้ผลลัพธ์ที่คล้ายกันดังแสดงด้านล่าง

ส่วนประกอบพื้นฐานของแอปพลิเคชันที่ใช้ Tk เรียกว่าวิดเจ็ต บางครั้งส่วนประกอบเรียกว่าหน้าต่างเนื่องจากใน Tk "หน้าต่าง" และ "วิดเจ็ต" มักใช้แทนกันได้ Tk เป็นแพ็คเกจที่มีชุดส่วนประกอบกราฟิกมากมายสำหรับการสร้างแอพพลิเคชั่นกราฟิกด้วย Tcl

Tk มีวิดเจ็ตที่หลากหลายตั้งแต่วิดเจ็ต GUI พื้นฐานเช่นปุ่มและเมนูไปจนถึงวิดเจ็ตแสดงข้อมูล วิดเจ็ตสามารถกำหนดค่าได้มากเนื่องจากมีการกำหนดค่าเริ่มต้นทำให้ใช้งานง่าย

แอ็พพลิเคชัน Tk เป็นไปตามลำดับชั้นของวิดเจ็ตซึ่งอาจมีวิดเจ็ตจำนวนเท่าใดก็ได้ในวิดเจ็ตอื่นและวิดเจ็ตเหล่านั้นภายในวิดเจ็ตอื่น วิดเจ็ตหลักในโปรแกรม Tk เรียกว่าวิดเจ็ตรูทและสามารถสร้างได้โดยการสร้างอินสแตนซ์ใหม่ของคลาส TkRoot

การสร้างวิดเจ็ต

ไวยากรณ์สำหรับการสร้างวิดเจ็ตได้รับด้านล่าง

type variableName arguments options

ประเภทในที่นี้หมายถึงประเภทวิดเจ็ตเช่นปุ่มป้ายกำกับและอื่น ๆ อาร์กิวเมนต์สามารถเป็นทางเลือกและจำเป็นตามไวยากรณ์ของแต่ละวิดเจ็ต ตัวเลือกมีตั้งแต่ขนาดไปจนถึงการจัดรูปแบบของแต่ละองค์ประกอบ

อนุสัญญาการตั้งชื่อวิดเจ็ต

วิดเจ็ตใช้โครงสร้างคล้ายกับการตั้งชื่อแพ็คเกจ ใน Tk หน้าต่างรูทถูกตั้งชื่อด้วยจุด (.) และองค์ประกอบในหน้าต่างเช่นปุ่มชื่อ. myButton1 ชื่อตัวแปรควรขึ้นต้นด้วยตัวอักษรพิมพ์เล็กตัวเลขหรือเครื่องหมายวรรคตอน (ยกเว้นจุด) หลังจากอักขระตัวแรกอักขระอื่น ๆ อาจเป็นตัวอักษรตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กตัวเลขหรือเครื่องหมายวรรคตอน (ยกเว้นจุด) ขอแนะนำให้ใช้ตัวอักษรพิมพ์เล็กในการเริ่มฉลาก

อนุสัญญาการตั้งชื่อสี

สีสามารถประกาศโดยใช้ชื่อเช่นสีแดงสีเขียวและอื่น ๆ นอกจากนี้ยังสามารถใช้เลขฐานสิบหกแทนด้วย # จำนวนเลขฐานสิบหกสามารถเป็น 3, 6, 9 หรือ 12

อนุสัญญามิติ

หน่วยเริ่มต้นคือพิกเซลและใช้เมื่อเราระบุว่าไม่มีมิติ ขนาดอื่น ๆ คือ i สำหรับนิ้ว m สำหรับมิลลิเมตร c สำหรับเซนติเมตรและ p สำหรับจุด

ตัวเลือกทั่วไป

มีตัวเลือกทั่วไปมากมายสำหรับวิดเจ็ตทั้งหมดและมีการระบุไว้ด้านล่างในตารางต่อไปนี้ -

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	-background color ใช้เพื่อกำหนดสีพื้นหลังสำหรับวิดเจ็ต
2	-borderwidth width ใช้เพื่อวาดเส้นขอบในลักษณะพิเศษ 3 มิติ
3	-font fontDescriptor ใช้เพื่อตั้งค่าฟอนต์สำหรับวิดเจ็ต
4	-foreground color ใช้เพื่อกำหนดสีพื้นหน้าสำหรับวิดเจ็ต
5	-height number ใช้เพื่อตั้งค่าความสูงสำหรับวิดเจ็ต
6	-highlightbackground color ใช้เพื่อตั้งค่าสี่เหลี่ยมผืนผ้าสีเพื่อวาดรอบวิดเจ็ตเมื่อวิดเจ็ตไม่มีโฟกัสอินพุต
7	-highlightcolor color ใช้เพื่อตั้งค่าสี่เหลี่ยมผืนผ้าสีเพื่อวาดรอบวิดเจ็ตเมื่อวิดเจ็ตมีอินพุตโฟกัส
8	-padx number ตั้งค่า padx สำหรับวิดเจ็ต
9	-pady number ตั้งค่า pady สำหรับวิดเจ็ต
10	-relief condition ตั้งค่าการบรรเทา 3D สำหรับวิดเจ็ตนี้ สภาพอาจยกขึ้นจมแบนสันแข็งหรือเป็นร่อง
11	-text text ตั้งค่าข้อความสำหรับวิดเจ็ต
12	-textvariable varName ตัวแปรที่เกี่ยวข้องกับวิดเจ็ต เมื่อข้อความของวิดเจ็ตเปลี่ยนแปลงตัวแปรจะถูกตั้งค่าด้วยข้อความของวิดเจ็ต
13	-width number ตั้งค่าความกว้างสำหรับวิดเจ็ต

ตัวอย่างง่ายๆสำหรับตัวเลือกแสดงอยู่ด้านล่าง

#!/usr/bin/wish

grid [label .myLabel -background red -text "Hello World" -relief ridge -borderwidth 3]
   -padx 100 -pady 100

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้

รายการวิดเจ็ตที่มีอยู่แบ่งตามประเภทด้านล่าง -

วิดเจ็ตพื้นฐาน

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	Label วิดเจ็ตสำหรับแสดงข้อความบรรทัดเดียว
2	Button วิดเจ็ตที่สามารถคลิกได้และทริกเกอร์การดำเนินการ
3	Entry วิดเจ็ตใช้เพื่อยอมรับข้อความบรรทัดเดียวเป็นอินพุต
4	Message วิดเจ็ตสำหรับแสดงข้อความหลายบรรทัด
5	Text วิดเจ็ตสำหรับแสดงและเลือกแก้ไขข้อความหลายบรรทัด
6	Toplevel หน้าต่างที่มีขอบและการตกแต่งทั้งหมดที่ผู้จัดการหน้าต่างจัดเตรียมไว้ให้

วิดเจ็ตเค้าโครง

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	Frame วิดเจ็ตคอนเทนเนอร์เพื่อเก็บวิดเจ็ตอื่น ๆ
2	Place วิดเจ็ตเพื่อเก็บวิดเจ็ตอื่น ๆ ไว้ในสถานที่เฉพาะพร้อมพิกัดที่มาและขนาดที่แน่นอน
3	Pack วิดเจ็ตอย่างง่ายเพื่อจัดระเบียบวิดเจ็ตในบล็อกก่อนวางในวิดเจ็ตหลัก
4	Grid วิดเจ็ตเพื่อซ้อนวิดเจ็ตที่บรรจุในทิศทางต่างๆ

วิดเจ็ตการเลือก

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	Radiobutton วิดเจ็ตที่มีชุดปุ่มเปิด / ปิดและป้ายกำกับซึ่งอาจเลือกได้
2	Checkbutton Widget ที่มีชุดปุ่มเปิด / ปิดและป้ายหลาย ๆ ปุ่มให้เลือก ..
3	Menu วิดเจ็ตที่ทำหน้าที่เป็นตัวยึดสำหรับรายการเมนู
4	Listbox วิดเจ็ตที่แสดงรายการของเซลล์ซึ่งอาจเลือกได้ตั้งแต่หนึ่งเซลล์ขึ้นไป

วิดเจ็ตขนาดใหญ่

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	Dialog วิดเจ็ตสำหรับแสดงกล่องโต้ตอบ
2	Spinbox วิดเจ็ตที่ให้ผู้ใช้เลือกหมายเลข
3	Combobox วิดเจ็ตที่รวมรายการเข้ากับรายการตัวเลือกที่มีให้ใช้งาน
4	Notebook วิดเจ็ตแบบแท็บที่ช่วยในการสลับไปมาระหว่างหนึ่งในหลายเพจโดยใช้แท็บดัชนี
5	Progressbar วิดเจ็ตเพื่อแสดงความคิดเห็นเกี่ยวกับความคืบหน้าของการดำเนินการที่ยาวนานเช่นการอัปโหลดไฟล์
6	Treeview วิดเจ็ตเพื่อแสดงและอนุญาตให้เรียกดูตามลำดับชั้นของรายการเพิ่มเติมในรูปแบบของต้นไม้
7	Scrollbar การเลื่อนวิดเจ็ตโดยไม่มีวิดเจ็ตข้อความหรือพื้นที่
8	Scale ปรับขนาดวิดเจ็ตเพื่อเลือกค่าตัวเลขผ่านแถบเลื่อน

วิดเจ็ตอื่น ๆ

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	Canvas วิดเจ็ตการวาดสำหรับแสดงกราฟิกและรูปภาพ ..

เราจะกล่าวถึงแต่ละวิดเจ็ตเหล่านี้ในบทต่อ ๆ ไป

วิดเจ็ตพื้นฐานเป็นวิดเจ็ตทั่วไปที่มีอยู่ในแอปพลิเคชัน Tk เกือบทั้งหมด รายการวิดเจ็ตพื้นฐานที่มีอยู่ด้านล่าง -

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	ฉลาก วิดเจ็ตสำหรับแสดงข้อความบรรทัดเดียว
2	ปุ่ม วิดเจ็ตที่สามารถคลิกได้และทริกเกอร์การดำเนินการ
3	รายการ วิดเจ็ตใช้เพื่อยอมรับข้อความบรรทัดเดียวเป็นอินพุต
4	ข้อความ วิดเจ็ตสำหรับแสดงข้อความหลายบรรทัด
5	ข้อความ วิดเจ็ตสำหรับแสดงและเลือกแก้ไขข้อความหลายบรรทัด
6	ระดับสูง Widget ที่ใช้สร้างกรอบที่เป็นหน้าต่างระดับบนสุดใหม่

ตัวอย่างง่ายๆของ Tk แสดงไว้ด้านล่างโดยใช้วิดเจ็ตพื้นฐาน -

#!/usr/bin/wish

grid [label .myLabel -text "Label Widget" -textvariable labelText] 
grid [text .myText -width 20 -height 5]
.myText insert 1.0 "Text\nWidget\n"
grid [entry .myEntry -text "Entry Widget"]
grid [message .myMessage -background red -foreground white -text "Message\nWidget"]
grid [button .myButton1  -text "Button" -command "set labelText clicked"]

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

วิดเจ็ตเลย์เอาต์ใช้เพื่อจัดการเลย์เอาต์สำหรับแอปพลิเคชัน Tk วิดเจ็ตเฟรมใช้จัดกลุ่มวิดเจ็ตอื่น ๆ และสถานที่แพ็คและตารางเป็นตัวจัดการเลย์เอาต์เพื่อให้คุณสามารถควบคุมการเพิ่มไปยังหน้าต่างของคุณได้ทั้งหมด รายการวิดเจ็ตเลย์เอาต์ที่มีอยู่ดังแสดงด้านล่าง -

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	กรอบ วิดเจ็ตคอนเทนเนอร์เพื่อเก็บวิดเจ็ตอื่น ๆ
2	สถานที่ วิดเจ็ตเพื่อเก็บวิดเจ็ตอื่น ๆ ไว้ในสถานที่เฉพาะพร้อมพิกัดที่มาและขนาดที่แน่นอน
3	แพ็ค วิดเจ็ตอย่างง่ายเพื่อจัดระเบียบวิดเจ็ตในบล็อกก่อนวางในวิดเจ็ตหลัก
4	กริด วิดเจ็ตเพื่อซ้อนวิดเจ็ตที่บรรจุในทิศทางต่างๆ

ตัวอย่างง่ายๆของ Tk แสดงไว้ด้านล่างสำหรับวิดเจ็ตเค้าโครง -

#!/usr/bin/wish

frame .myFrame1 -background red  -relief ridge -borderwidth 8 -padx 10 -pady 10
   -height 100 -width 100
frame .myFrame2 -background blue  -relief ridge -borderwidth 8 -padx 10 -pady 10
   -height 100 -width 50
pack .myFrame1 
pack .myFrame2

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

วิดเจ็ตการเลือกใช้เพื่อเลือกตัวเลือกต่างๆในแอปพลิเคชัน Tk รายการวิดเจ็ตการเลือกที่มีอยู่ดังแสดงด้านล่าง

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	Radiobutton วิดเจ็ตที่มีชุดปุ่มเปิด / ปิดและป้ายกำกับซึ่งอาจเลือกได้
2	ปุ่มตรวจสอบ วิดเจ็ตที่มีชุดปุ่มเปิด / ปิดและป้ายกำกับซึ่งหลายปุ่มสามารถเลือกได้
3	เมนู วิดเจ็ตที่ทำหน้าที่เป็นตัวยึดสำหรับรายการเมนู
4	Listbox วิดเจ็ตที่แสดงรายการของเซลล์ซึ่งอาจเลือกได้ตั้งแต่หนึ่งเซลล์ขึ้นไป

ตัวอย่างง่ายๆของ Tk แสดงไว้ด้านล่างโดยใช้วิดเจ็ตการเลือก -

#!/usr/bin/wish

grid [frame .gender ]
grid [label .label1  -text "Male" -textvariable myLabel1 ] 
grid [radiobutton .gender.maleBtn -text "Male"   -variable gender -value "Male"
   -command "set  myLabel1 Male"] -row 1 -column 2
grid [radiobutton .gender.femaleBtn -text "Female" -variable gender -value "Female"
   -command "set  myLabel1 Female"] -row 1 -column 3
.gender.maleBtn select
grid [label .myLabel2  -text "Range 1 not selected" -textvariable myLabelValue2 ] 
grid [checkbutton .chk1 -text "Range 1" -variable occupied1 -command {if {$occupied1 } {
   set myLabelValue2 {Range 1 selected}
} else {
   set myLabelValue2 {Range 1 not selected}
} }]
proc setLabel {text} {
   .label configure -text $text 
}

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

ผ้าใบใช้สำหรับจัดเตรียมพื้นที่วาดภาพ ไวยากรณ์สำหรับวิดเจ็ตพื้นที่แสดงอยู่ด้านล่าง -

canvas canvasName options

ตัวเลือก

ตัวเลือกที่พร้อมใช้งานสำหรับวิดเจ็ตผ้าใบแสดงอยู่ด้านล่างในตารางต่อไปนี้ -

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	-background color ใช้เพื่อกำหนดสีพื้นหลังสำหรับวิดเจ็ต
2	-closeenough distance ตั้งค่าความใกล้เคียงของเคอร์เซอร์เมาส์เป็นรายการที่แสดงได้ ค่าเริ่มต้นคือ 1.0 พิกเซล ค่านี้อาจเป็นเศษส่วนและต้องเป็นบวก
3	-scrollregion boundingBox กล่องขอบเขตสำหรับพื้นที่ทั้งหมดของผืนผ้าใบนี้
4	-height number ใช้เพื่อตั้งค่าความสูงสำหรับวิดเจ็ต
5	-width number ตั้งค่าความกว้างสำหรับวิดเจ็ต
6	-xscrollincrement size จำนวนที่จะเลื่อนในแนวนอนเมื่อมีการร้องขอการเลื่อน
7	-yscrollincrement size จำนวนที่จะเลื่อนในแนวตั้งเมื่อมีการร้องขอการเลื่อน

ตัวอย่างง่ายๆสำหรับวิดเจ็ตผ้าใบแสดงไว้ด้านล่าง -

#!/usr/bin/wish

canvas .myCanvas -background red -width 100 -height 100 
pack .myCanvas

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

วิดเจ็ตสำหรับการวาดใน Canvas

รายการวิดเจ็ตที่ใช้ได้สำหรับการวาดในแคนวาสแสดงอยู่ด้านล่าง -

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	ไลน์ วาดเส้น
2	อาร์ค วาดส่วนโค้ง
3	สี่เหลี่ยมผืนผ้า วาดรูปสี่เหลี่ยมผืนผ้า
4	วงรี วาดวงรี
5	รูปหลายเหลี่ยม วาดรูปหลายเหลี่ยม
6	ข้อความ วาดข้อความ
7	บิตแมป วาดบิตแมป
8	ภาพ วาดภาพ

ตัวอย่างการใช้วิดเจ็ตผ้าใบที่แตกต่างกันแสดงไว้ด้านล่าง -

#!/usr/bin/wish

canvas .myCanvas -background red -width 200 -height 200 
pack .myCanvas
.myCanvas create arc 10 10 50 50 -fill yellow
.myCanvas create line 10 30 50 50 100 10 -arrow both -fill yellow -smooth true
   -splinesteps 2
.myCanvas create oval 50 50 100 80 -fill yellow
.myCanvas create polygon 50 150 100 80 120 120 100 190 -fill yellow -outline green
.myCanvas create rectangle 150 150 170 170  -fill yellow
.myCanvas create text 170 20 -fill yellow -text "Hello" -font {Helvetica -18 bold}
.myCanvas create bitmap 180 50 -bitmap info

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

วิดเจ็ตขนาดใหญ่ประกอบด้วยวิดเจ็ตที่ซับซ้อนจำนวนมากซึ่งมักจำเป็นในแอปพลิเคชัน Tk ขนาดใหญ่บางตัว รายการวิดเจ็ตขนาดใหญ่ที่มีอยู่ดังแสดงด้านล่าง -

ซีเนียร์	วิดเจ็ตและคำอธิบาย
1	กล่องโต้ตอบ วิดเจ็ตสำหรับแสดงกล่องโต้ตอบ
2	Spinbox วิดเจ็ตที่ให้ผู้ใช้เลือกหมายเลข
3	Combobox วิดเจ็ตที่รวมรายการเข้ากับรายการตัวเลือกที่มีให้ใช้งาน
4	สมุดบันทึก วิดเจ็ตแบบแท็บที่ช่วยในการสลับไปมาระหว่างหนึ่งในหลายเพจโดยใช้แท็บดัชนี
5	แถบความคืบหน้า วิดเจ็ตเพื่อแสดงความคิดเห็นเกี่ยวกับความคืบหน้าของการดำเนินการที่ยาวนานเช่นการอัปโหลดไฟล์
6	Treeview วิดเจ็ตเพื่อแสดงและอนุญาตให้เรียกดูตามลำดับชั้นของรายการเพิ่มเติมในรูปแบบของต้นไม้
7	แถบเลื่อน การเลื่อนวิดเจ็ตโดยไม่มีวิดเจ็ตข้อความหรือพื้นที่
8	มาตราส่วน ปรับขนาดวิดเจ็ตเพื่อเลือกค่าตัวเลขผ่านแถบเลื่อน

ตัวอย่างง่ายๆของ Tk แสดงไว้ด้านล่างโดยใช้วิดเจ็ตขนาดใหญ่

#!/usr/bin/wish

ttk::treeview .tree -columns "Creator Year" -displaycolumns "Year Creator" 
.tree heading Creator -text "Creator" -anchor center
.tree heading Year -text "Year" -anchor center
pack .tree
.tree insert {} end -id Languages -text "Languages"
.tree insert Languages end -text C -values [list "Dennis Ritchie" "1990"]
proc scaleMe {mywidget scaleValue} {
	$mywidget configure -length $scaleValue
} 
pack [scale .s2  -from 100.0 -to 200.0 -length 100 -background yellow -borderwidth 5
   -font{Helvetica -18 bold} -foreground red -width 40 -relief ridge -orien horizontal
   -variable a -command "scaleMe .s2" ]
pack [ttk::progressbar .p1 -orient horizontal -length 200 -mode indeterminate -value 90]
pack [ttk::progressbar .p2 -orient horizontal -length 200 -mode determinate -variable a
   -maximum 75 -value 20]

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

มีวิดเจ็ตจำนวนมากที่รองรับการแสดงข้อความ สิ่งเหล่านี้ส่วนใหญ่มีตัวเลือกของแอตทริบิวต์แบบอักษร ไวยากรณ์สำหรับการสร้างแบบอักษรแสดงด้านล่าง -

font create fontName options

ตัวเลือก

ตัวเลือกที่ใช้ได้สำหรับการสร้างแบบอักษรแสดงอยู่ด้านล่างในตารางต่อไปนี้ -

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	-family familyName ชื่อของตระกูลแบบอักษร
2	-size number ขนาดของแบบอักษร
3	-weight level น้ำหนักสำหรับแบบอักษร

ตัวอย่างง่ายๆสำหรับการสร้างฟอนต์แสดงไว้ด้านล่าง -

#!/usr/bin/wish

font create myFont -family Helvetica -size 18 -weight bold 
pack [label .myLabel -font myFont -text "Hello World"]

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

เพื่อให้ได้ฟอนต์ทั้งหมดเราสามารถใช้คำสั่งต่อไปนี้ -

#!/usr/bin/wish

puts [font families]

เมื่อเรารันคำสั่งดังกล่าวเราจะได้ผลลัพธ์ดังต่อไปนี้ -

{Abadi MT Condensed Extra Bold} {Abadi MT Condensed Light} {Al Bayan} {Al Nile}
{Al Tarikh} {American Typewriter} {Andale Mono} Arial {Arial Black}
{Arial Hebrew} {Arial Narrow} {Arial Rounded MT Bold} {Arial Unicode MS}
Athelas Avenir {Avenir Next} {Avenir Next Condensed} Ayuthaya Baghdad {Bangla MN}
{Bangla Sangam MN} {Baoli SC} Baskerville {Baskerville Old Face} Batang {Bauhaus 93}
Beirut {Bell MT} {Bernard MT Condensed} BiauKai {Big Caslon} {Book Antiqua}
{Bookman Old Style} {Bookshelf Symbol 7} Braggadocio {Britannic Bold} {Brush Script MT}
Calibri {Calisto MT} Cambria {Cambria Math} Candara Century {Century Gothic}
{Century Schoolbook} Chalkboard {Chalkboard SE} Chalkduster {Charcoal CY} Charter
Cochin {Colonna MT} {Comic Sans MS} Consolas Constantia {Cooper Black} Copperplate
{Copperplate Gothic Bold} {Copperplate Gothic Light} Corbel {Corsiva Hebrew} Courier
{Courier New} {Curlz MT} Damascus {DecoType Naskh} Desdemona {Devanagari MT}
{Devanagari Sangam MN} Didot {DIN Alternate} {DIN Condensed} {Diwan Kufi} {Diwan Thuluth}
{Edwardian Script ITC} {Engravers MT} {Euphemia UCAS} Eurostile Farah Farisi
{Footlight MT Light} {Franklin Gothic Book} {Franklin Gothic Medium}
Futura Gabriola Garamond {GB18030 Bitmap} {Geeza Pro} Geneva {Geneva CY}
Georgia {Gill Sans} {Gill Sans MT} {Gloucester MT Extra Condensed}
{Goudy Old Style} {Gujarati MT} {Gujarati Sangam MN} Gulim GungSeo {Gurmukhi MN}
{Gurmukhi MT} {Gurmukhi Sangam MN} Haettenschweiler {Hannotate SC} {Hannotate TC}
{HanziPen SC} {HanziPen TC} Harrington HeadLineA Hei {Heiti SC} {Heiti TC}
Helvetica {Helvetica CY} {Helvetica Neue} Herculanum {Hiragino Kaku Gothic Pro}
{Hiragino Kaku Gothic ProN} {Hiragino Kaku Gothic Std} {Hiragino Kaku Gothic StdN}
{Hiragino Maru Gothic Pro} {Hiragino Maru Gothic ProN}
{Hiragino Mincho Pro} {Hiragino Mincho ProN} {Hiragino Sans GB}
{Hoefler Text} Impact {Imprint MT Shadow} InaiMathi {Iowan Old Style} Kai Kailasa
{Kaiti SC} {Kaiti TC} {Kannada MN} {Kannada Sangam MN} Kefa {Khmer MN} {Khmer Sangam MN}
{Kino MT} Kokonor Krungthep KufiStandardGK {Lantinghei SC} {Lantinghei TC} {Lao MN}
{Lao Sangam MN} {Libian SC} {LiHei Pro} {LiSong Pro} {Lucida Blackletter} {Lucida Bright}
{Lucida Calligraphy} {Lucida Console} {Lucida Fax} {Lucida Grande} {Lucida Handwriting}
{Lucida Sans} {Lucida Sans Typewriter} {Lucida Sans Unicode} {Malayalam MN}
{Malayalam Sangam MN} Marion {Marker Felt} Marlett {Matura MT Script Capitals}
Meiryo Menlo {Microsoft Sans Serif} Mishafi Mistral {Modern No. 20} Monaco {MS Gothic}
{MS Mincho} {MS PGothic} {MS PMincho} {MS Reference Sans Serif} {MS Reference Specialty}
Mshtakan {MT Extra} Muna {Myanmar MN} {Myanmar Sangam MN} Nadeem {Nanum Brush Script}
{Nanum Gothic} {Nanum Myeongjo} {Nanum Pen Script} {New Peninim MT} {News Gothic MT}
Noteworthy Onyx Optima {Oriya MN} {Oriya Sangam MN} Osaka Palatino {Palatino Linotype}
Papyrus PCMyungjo Perpetua {Perpetua Titling MT} PilGi {Plantagenet Cherokee}
Playbill PMingLiU {PT Mono} {PT Sans} {PT Sans Caption} {PT Sans Narrow} {PT Serif}
{PT Serif Caption} Raanana Rockwell {Rockwell Extra Bold} Sana Sathu {Savoye LET}
Seravek Silom SimSun {Sinhala MN} {Sinhala Sangam MN} Skia {Snell Roundhand} {Songti SC}
{Songti TC} Stencil STFangsong STHeiti STIXGeneral STIXIntegralsD STIXIntegralsSm
STIXIntegralsUp STIXIntegralsUpD STIXIntegralsUpSm STIXNonUnicode STIXSizeFiveSym
STIXSizeFourSym STIXSizeOneSym STIXSizeThreeSym STIXSizeTwoSym STIXVariants STKaiti
STSong Superclarendon Symbol Tahoma {Tamil MN} {Tamil Sangam MN} TeamViewer8 {Telugu MN}
{Telugu Sangam MN} Thonburi Times {Times New Roman} {Trebuchet MS} {Tw Cen MT} Verdana
Waseem {Wawati SC} {Wawati TC} Webdings {Weibei SC} {Weibei TC} {Wide Latin} Wingdings
{Wingdings 2} {Wingdings 3} {Xingkai SC} {Yuanti SC} YuGothic YuMincho {Yuppy SC}
{Yuppy TC} {Zapf Dingbats} Zapfino {Apple Braille} {Apple Chancery} {Apple Color Emoji}
{Apple LiGothic} {Apple LiSung} {Apple SD Gothic Neo} {Apple Symbols}
AppleGothic AppleMyungjo {Monotype Corsiva} {Monotype Sorts}

วิดเจ็ตรูปภาพใช้ในการสร้างและจัดการรูปภาพ ไวยากรณ์สำหรับการสร้างภาพมีดังนี้ -

image create type name options

ในประเภทไวยากรณ์ด้านบนคือรูปถ่ายหรือบิตแมปและชื่อคือตัวระบุรูปภาพ

ตัวเลือก

ตัวเลือกที่ใช้ได้สำหรับการสร้างภาพแสดงอยู่ด้านล่างในตารางต่อไปนี้ -

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	-file fileName ชื่อของชื่อไฟล์รูปภาพ
2	-height number ใช้เพื่อตั้งค่าความสูงสำหรับวิดเจ็ต
3	-width number ตั้งค่าความกว้างสำหรับวิดเจ็ต
4	-data string รูปภาพในสตริงเข้ารหัสฐาน 64

ตัวอย่างง่ายๆสำหรับวิดเจ็ตรูปภาพแสดงอยู่ด้านล่าง -

#!/usr/bin/wish

image create photo imgobj -file "/Users/rajkumar/Desktop/F Drive/pictur/vb/Forests/
   680049.png" -width 400 -height 400 
pack [label .myLabel]
.myLabel configure -image imgobj

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

ฟังก์ชั่นที่ใช้ได้สำหรับรูปภาพแสดงอยู่ด้านล่างในตารางต่อไปนี้

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	image delete imageName ลบภาพจากหน่วยความจำและวิดเจ็ตที่เกี่ยวข้องด้วยสายตา
2	image height imageName ส่งกลับความสูงของรูปภาพ
3	image width imageName ส่งกลับความกว้างสำหรับรูปภาพ
4	image type imageName ส่งคืนชนิดของรูปภาพ
5	image names ส่งคืนรายการภาพที่อยู่ในหน่วยความจำ

ตัวอย่างง่ายๆสำหรับการใช้คำสั่งวิดเจ็ตรูปภาพด้านบนแสดงไว้ด้านล่าง -

#!/usr/bin/wish

image create photo imgobj -file "/Users/rajkumar/images/680049.png"
   -width 400 -height 400 
pack [label .myLabel]
.myLabel configure -image imgobj
puts [image height imgobj]
puts [image width imgobj]
puts [image type imgobj]
puts [image names]
image delete imgobj

ภาพจะถูกลบออกทางสายตาและจากหน่วยความจำเมื่อคำสั่ง "ลบภาพ imgobj" ดำเนินการ ในคอนโซลผลลัพธ์จะเป็นดังนี้ -

400
400
photo
imgobj ::tk::icons::information ::tk::icons::error ::tk::icons::
warning ::tk::icons::question

เหตุการณ์ในรูปแบบที่ง่ายที่สุดได้รับการจัดการด้วยความช่วยเหลือของคำสั่ง ตัวอย่างง่ายๆสำหรับการจัดการเหตุการณ์คือการจัดการเหตุการณ์ด้วยปุ่มและแสดงไว้ด้านล่าง -

#!/usr/bin/wish

proc myEvent { } {
   puts "Event triggered"
}
pack [button .myButton1  -text "Button 1"   -command myEvent]

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

โปรแกรมง่ายๆในการแสดงเหตุการณ์ภาพเคลื่อนไหวข้อความล่าช้าแสดงอยู่ด้านล่าง -

#!/usr/bin/wish

proc delay {} {
   for {set j 0} {$j < 100000} {incr j} {} 
}

label .myLabel -text "Hello................" -width 25
pack .myLabel
set str "Hello................"
for {set i [string length $str]} {$i > -2} {set i [expr $i-1]} { .myLabel configure -text [string range $str 0 $i]
   update
   delay
}

เมื่อเรารันโปรแกรมเราจะได้ผลลัพธ์ต่อไปนี้ในรูปแบบเคลื่อนไหว -

เหตุการณ์หลังจากล่าช้า

ไวยากรณ์สำหรับเหตุการณ์หลังจากการหน่วงเวลาแสดงไว้ด้านล่าง -

after milliseconds number command

โปรแกรมง่ายๆที่จะแสดงหลังจากเหตุการณ์ล่าช้าแสดงอยู่ด้านล่าง -

#!/usr/bin/wish

proc addText {} {
   label .myLabel -text "Hello................" -width 25
   pack .myLabel
}
after 1000 addText

เมื่อเรารันโปรแกรมเราจะได้ผลลัพธ์ต่อไปนี้หลังจากผ่านไปหนึ่งวินาที -

คุณสามารถยกเลิกกิจกรรมได้โดยใช้คำสั่ง after Cancel ดังที่แสดงด้านล่าง -

#!/usr/bin/wish

proc addText {} {
   label .myLabel -text "Hello................" -width 25
   pack .myLabel
}
after 1000 addText
after cancel addText

การผูกเหตุการณ์

ไวยากรณ์สำหรับการผูกเหตุการณ์มีดังที่แสดงด้านล่าง -

bind arguments

ตัวอย่างเหตุการณ์คีย์บอร์ด

#!/usr/bin/wish

bind .  {puts "Key Pressed: %K "}

เมื่อเรารันโปรแกรมและกดตัวอักษร X เราจะได้ผลลัพธ์ดังนี้ -

Key Pressed: X

ตัวอย่างเหตุการณ์เมาส์

#!/usr/bin/wish

bind .  {puts "Button %b Pressed : %x %y "}

เมื่อเรารันโปรแกรมและกดปุ่มซ้ายของเมาส์เราจะได้ผลลัพธ์ที่คล้ายกันดังต่อไปนี้ -

Button 1 Pressed : 89 90

การเชื่อมโยงเหตุการณ์กับตัวอย่างปุ่ม

#!/usr/bin/wish

proc myEvent { } {
   puts "Event triggered"
}
pack [button .myButton1  -text "Button 1"   -command myEvent]
bind .  ".myButton1 invoke"

เมื่อเรารันโปรแกรมและกด Enter เราจะได้ผลลัพธ์ดังนี้ -

Event triggered

ตัวจัดการหน้าต่างใช้เพื่อจัดการหน้าต่างระดับบนสุด ช่วยในการควบคุมขนาดตำแหน่งและคุณลักษณะอื่น ๆ ของหน้าต่าง ใน Tk,. ใช้เพื่ออ้างอิงหน้าต่างหลัก ไวยากรณ์สำหรับคำสั่ง window แสดงไว้ด้านล่าง -

wm option window arguments

รายการตัวเลือกที่ใช้ได้สำหรับคำสั่ง Tk wm แสดงในตารางต่อไปนี้ -

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	aspect windowName a b c d พยายามรักษาอัตราส่วนของความกว้าง / ความสูงให้อยู่ระหว่าง a / b และ c / d
2	geometry windowName geometryParams ใช้เพื่อกำหนดรูปทรงเรขาคณิตสำหรับหน้าต่าง
3	grid windowName w h dx dy ตั้งค่าขนาดเส้นตาราง
4	group windowName leaderName leaderName ให้ผู้นำของกลุ่มของหน้าต่างที่เกี่ยวข้อง
5	deiconify windowName ทำให้หน้าจอเป็นปกติหากย่อเล็กสุด
6	iconify windowName ย่อขนาดหน้าต่าง
7	state windowName ส่งคืนสถานะปัจจุบันของหน้าต่าง
8	withdraw windowName ยกเลิกการแมปหน้าต่างและลบรายละเอียดในหน่วยความจำ
9	iconbitmap windowName image ตั้งค่าหรือส่งคืนบิตแมปไอคอน
10	iconPhoto windowName image ตั้งค่าหรือส่งคืนรูปภาพไอคอน
11	command windowName commandString บันทึกคำสั่งเริ่มต้นในคุณสมบัติ WM_COMMAND
12	protocol windowName arguments ลงทะเบียนคำสั่งเพื่อจัดการกับชื่อคำขอโปรโตคอลซึ่งอาจเป็น WM_DELETE_WINDOW WM_SAVE_YOURSELF, WM_TAKE_FOCUS เช่น: wm protocol. WM_DELETE_WINDOW ออก
13	minsize windowName size กำหนดขนาดหน้าต่างขั้นต่ำ
14	maxsize windowName size กำหนดขนาดหน้าต่างสูงสุด
15	title windowName titleText กำหนดหัวเรื่องสำหรับหน้าต่าง
16	attributes subOptions มีคุณสมบัติมากมายเช่นอัลฟาแบบเต็มหน้าจอและอื่น ๆ

คำสั่งข้างต้นบางคำใช้ในตัวอย่างต่อไปนี้ -

#!/usr/bin/wish

wm maxsize . 800 800
wm minsize . 300 300
wm title . "Hello"
wm attributes . -alpha ".90" 
wm geometry . 300x200+100+100

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

อย่างที่คุณเห็นอัลฟ่าเป็นหนึ่งในคุณสมบัติที่มีอยู่ รายการคำสั่งย่อยที่ใช้บ่อยแสดงอยู่ด้านล่าง -

ซีเนียร์	ไวยากรณ์และคำอธิบาย
1	-alpha number ตั้งค่าอัลฟาสำหรับหน้าต่าง
2	-fullscreen number ตัวเลขอาจเป็น 0 สำหรับหน้าจอปกติหรือ 1 สำหรับเต็มหน้าจอ
3	-topmost number ตั้งค่าหรือส่งคืนว่าหน้าต่างอยู่บนสุดหรือไม่ค่าสามารถเป็น 0 หรือ 1

กำลังสร้างหน้าต่าง

เราสามารถใช้คำสั่ง toplevel เพื่อสร้างหน้าต่างและตัวอย่างดังแสดงด้านล่าง -

#!/usr/bin/wish

toplevel .t

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

ทำลายหน้าต่าง

เราสามารถใช้คำสั่ง destroy เพื่อทำลายหน้าต่างและตัวอย่างดังแสดงด้านล่าง -

#!/usr/bin/wish

destroy .t

คำสั่งดังกล่าวจะทำลายหน้าต่างที่มีชื่อว่า .t.

เครื่องมือจัดการรูปทรงเรขาคณิตใช้เพื่อจัดการรูปทรงเรขาคณิตของหน้าต่างและกรอบอื่น ๆ เราสามารถใช้เพื่อจัดการกับตำแหน่งและขนาดของหน้าต่างและกรอบ เครื่องมือรูปแบบถูกนำมาใช้เพื่อการนี้

การวางตำแหน่งและขนาด

ไวยากรณ์สำหรับการวางตำแหน่งและขนาดหน้าต่างแสดงอยู่ด้านล่าง -

wm geometry . wxh+/-x+/-y

ในที่นี้ w หมายถึงความกว้างและ h หมายถึงความสูง ตามด้วยเครื่องหมาย '+' หรือ '-' พร้อมตัวเลขถัดจากตำแหน่ง x บนหน้าจอ ในทำนองเดียวกันเครื่องหมาย '+' หรือ '-' ที่มีตัวเลขต่อไปนี้หมายถึงตำแหน่ง y บนหน้าจอ

ตัวอย่างง่ายๆแสดงไว้ด้านล่างสำหรับคำชี้แจงข้างต้น -

#!/usr/bin/wish

wm geometry . 300x200+100+100

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

เรขาคณิตกริด

ไวยากรณ์สำหรับเรขาคณิตกริดแสดงไว้ด้านล่าง -

grid gridName -column number -row number -columnspan number -rowspan number

คอลัมน์แถวคอลัมน์หรือ rowspan ช่วยในการจัดเตรียมรูปทรงเรขาคณิตของกริด

ตัวอย่างง่ายๆแสดงไว้ด้านล่างสำหรับข้อความข้างต้น -

#!/usr/bin/wish

frame .myFrame1 -background red  -height 100 -width 100
frame .myFrame2 -background blue -height 100 -width 50
grid .myFrame1 -columnspan 10 -rowspan 10 -sticky w
grid .myFrame2 -column 10 -row 2

เมื่อเรารันโปรแกรมข้างต้นเราจะได้ผลลัพธ์ดังต่อไปนี้ -