---
description: TCL is string based scripting language and also a procedural language. It was first created by John Osterhout in 1989. The purpose of developing this language is easy embedded inti ( ) applications. T
title: Tcl/Tk Tutorial
image: https://www.guru99.com/images/tcl-tk-tutorial.png
---

 

[Skip to content](#main) 

**⚡ Smart Summary**

TCL (Tool Command Language) is a string-based scripting and procedural language created by John Osterhout in 1989, widely used for GUIs, rapid prototyping, and testing, where every value is treated as a string by default.

* 🧵 **TCL Defined:** A string-based scripting and procedural language where everything is a string by default.
* ▶️ **Execution:** Run Tcl scripts via the tclsh shell on Windows or Linux, with files using a .tcl extension.
* 🔄 **Substitution:** Supports command (square brackets), variable ($), and backslash substitution.
* 📦 **Variables:** Created with set, read with $, removed with unset, and checked with info exists.
* ➗ **Expressions:** The expr command evaluates arithmetic, relational, logical, bitwise, and other operators.
* 🔀 **Flow Control:** Provides if/else, switch, while, and for for decision making and loops.

[ Read More ](javascript:void%280%29;) 

![TCL/Tk Tutorial](https://www.guru99.com/images/tcl-tk-tutorial.png)

## What is TCL?

TCL is shell application that reads TCL command from its standard input or from a file and gives desired results.

TCL is string based scripting language and also a procedural language. It was first created by John Osterhout in 1989\. The purpose of developing this language is easy embedded into applications. The language is commonly used for GUIs and testing. For instance, rapid prototyping,[ Testing ](https://www.guru99.com/software-testing.html)database interaction, etc. In TCL by default everything is a string.

## How to Execute TCL

There are two ways to execute TCL code:

1. Windows based application is available here [tcltutor exe file](http://tcltutor.software.informer.com/3.0b/)
2. Linux based application

In[ Linux ](https://www.guru99.com/unix-linux-tutorial.html)interactive interpreter, we can execute the TCL scripts as below

To access TCL interactive session, execute the following command

![TCL Tutorial: Tool Command Language](https://www.guru99.com/images/8-2016/081216_0715_TCLTutorial1.png "TCL Tutorial: Tool Command Language")

## TCL scripts

TCL program should have a .tcl extension. Every script in UNIX/LINUX starts with TCL shell path

#!/usr/bin/tclsh

**Example:-**

#!/usr/bin/tclsh
Puts "Hello World"
Script execution:-
$ chmod +x helloworld.tcl
$ ./helloworld.tcl

**Output**: Hello World

In TCL, “Puts” Command is used to print messages to the console. syntax of puts is below

puts ?-nonewline? ?channelId? string

* **Nonewline**: This optional parameter suppresses the newline character by default command. It puts a newline to each string
* **Channelid**: This parameter used for standard input channel (stdin) and standard output channel (stdout).

Ex:-

%puts "Hello World"
% Hello World
%puts stdout  "Hello World"
% Hello World

## TCL Substitution type

There are three kinds of substitutions in TCL

1. Command substitution
2. Variable substitution
3. Backslash substitution

Let’s study one by one

**Command substitution**

Square brackets are used for command substitution.

**Example:-**

% puts [expr 1*3]
% 3

Here the command between the square brackets is evaluated first. The results is returned. “expr” used for performing the arithmetic calculation.

**Variable substitution**

TCL performs variable substitution with the help of **$** sign.

Example:-

#!/usr/bin/tclsh
set  a  10
puts  a
puts  $a

Here we create a variable called “a” and set value “10” to it.

* puts a : It will print string “a” but not the value of ‘a’ to the console
* puts $a : It will print the value of ‘a’ to the console

Let’s execute and verify it. You will get the output as below.

$ ./substitution.tcl

a

10

**Backslash substitution** 

In Tcl, the backslash is used for escaping special characters as well as for spreading long commands across multiple lines. Any character immediately following the backslash will stand without substitution. In the example below, you can see special character ” “, remains after the backslash.

Let’s verify this with an example

#!/usr/bin/tclsh

puts "This  is my  \"car\""

$ ./backslashsubstitution.tcl
This is my "car"

**NOTE: –**To comment any string in TCL “#” is used. All characters after the “#” are ignored by tclsh shell command.

## TCL Variable

A variable is an identifier which holds a value. In other words, a variable is a reference to a computer memory, where the value is stored.

Variables are created by “set command” and all variable names are case sensitive. It means hello, Hello, HELLO all are different in TCL. Look at some example for case sensitive variable.

% set  name  Techoit
% set  Name  Technoit_1
% set  NAME  Technoit_2

**Output:-**

% puts $name
% Technoit

%puts  $Name
%Technoit_1

%puts $NAME
%Technoit_2

**Creating TCL Variables**

To create variables in TCL, you need to use **“set”** command

Set a 10

To obtain the value of variable have to use “$” symbol like

% put $a

% 10

So we get the value of variable ‘a’ as 10.

**TCL Command Info exist**

The “set” command is used to create and read variables as shown above. The unset command is used to destroy a variable. The “info exists” command returns 1 if varName exists as a variable (or an array element) in the current context, otherwise returns 0\. ( see example below).

There are various “info” command in TCL like “info exists”, “info functions”, “info global”, and so on. Here we will see an example of “info exists”.

Ex:-

% set a 20
% puts $a
% 20
% puts [info exists a]
% 1
% unset a
%puts [info exists a]
% 0

**Different braces and their behaviour**

**{} -> Curly braces**

Curly braces in TCL group words together to become arguments. Curly braces are used to define a block that’s deferred – in other words, it may be run AFTER the rest of the command on the current line. Characters within braces are passed to a command exactly as written.

Some points to remember

1. Variable substitution is not allowed inside {} braces
2. It used to create list data type

**Example:-**

% set x 10
% puts {$x}
% $x

%set number {1 2 3 4 5} -> Here number is a list data type

%puts $number

%1 2 3 4 5

**\[\] -> square braces**

Square brackets are used to create nested command. Simply put, output of one command passed as argument to another command. Square brackets are used to define a block that’s run BEFORE the rest of the command on the current line, and the result is substituted into the line.

Ex: –

% set x 10
% puts "y : [set y [set x 10]]"
%y : 10
% puts "x : $x"
%x : 10

**() -> round braces**

This command is used to create array data type and also indicate operator precedence.

% set a(1) 10
% set a(2) 20

Here “a” is an array with value 10 and 20\. See below commands to print keys, key value pairs and values of array.

% 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

For print “Nth” value of array a, we will use Puts $a(N)

**TCL Command-line arguments**

Items of data passed to a script from the command line are known as arguments. The number of command line arguments to a Tcl script is passed as the global variable **argc**. The name of a Tcl script is passed to the script as the global variable **argv0**, and the rest of the command line arguments are passed as a list in **argv**.

TCL has 3 pre-defined variables such as

$argc   -> indicates the number of arguments passed to the script

$argv   -> indicates list of arguments

$argv0  -> indicates the name of script

Ex:–

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

**output**:-

* Number of arguments passed to the scripts: 3
* List of arguments are passed to the script: 10 20 30
* The name of the script is : arg-script.tcl

### RELATED ARTICLES

* [Input Output Redirection in Linux/Unix Examples ](https://www.guru99.com/linux-redirection.html "Input Output Redirection in Linux/Unix Examples")
* [Best Linux Certifications for Beginners (2026 Update) ](https://www.guru99.com/best-linux-certifications.html "Best Linux Certifications for Beginners (2026 Update)")
* [6 Best Free TFTP Server for Windows (Jul 2026 List) ](https://www.guru99.com/free-tftp-server.html "6 Best Free TFTP Server for Windows (Jul 2026 List)")
* [8 BEST Linux Distros (2026) ](https://www.guru99.com/best-linux-distributions.html "8 BEST Linux Distros (2026)")

## TCL Expression and Operator

Expression is constructed from operands and operators. It’s evaluated with “expr” command. Operators are evaluated based on precedence and associativity. TCL language has built-in operators as below

| **Operator Category**      | **Symbol**       | **Precedence/Associativity** |
| -------------------------- | ---------------- | ---------------------------- |
| Arithmetic Operator        | \+ – \* / %      | Left to Right                |
| Relational Operator        | \== != < > <= >= | Left to Right                |
| Logical Operator           | && \|| !         | Left to Right                |
| Bitwise Operator           | & \| ^ \~        | Left to Right                |
| Ternary Operator           | ?:               | Right to Left                |
| Shift Operator             | << >>            | Left to Right                |
| String Comparison Operator | eq ne            | Left to Right                |
| Exponentiation Operator    | \*\*             | Left to Right                |
| List Operator              | In ni            | Left to Right                |

**Arithmetic Operator**

A TCL expression consists of a combination of operands, operators, and parentheses. Let see example of Arithmetic operators in TCL

\+ Add two or more operands

Ex:-

%set a 10
%set b 20
%puts [expr $a + $b]
30

– Subtracts two or more operands

Ex:-

%set a 20
%set b 10
%puts [expr $a - $b]
10

\*Multiply two or more operands

%set a 20
%set b 10
%puts [expr $a * $b]
200

/ Divide numerator by denumerator

%set a 20
%set b 10
%puts [expr $a / $b]
2

% Modulus operator divides numerator by de-numerator but returns reminder

%set a 20
%set b 10
%puts [expr $a % $b]
0

**Relational Operator** 

Checks if the value of left operand is greater than the value of the right operand. If yes, then condition becomes true and return 1 else return 0.

%set a 20
%set b 10
%puts [expr $a > $b]
1

Check if the value of left operand is less than the value of the right operand. If yes, then condition becomes true and return 1 else return 0

%set a 10
%set b 20
%puts [expr $a < $b]
1

\>= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true and return 1 else return 0

%set a 20
%set b 10
%puts [expr $a >= $b]
1

<= Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true and return 1 else return 0

%set a 20
%set b 10
%puts [expr $a <= $b]
0

!= Checks if the values of two operands are equal or not, if values are not equal then condition becomes true and return 1 else return 0

%set a 20
%set b 10
%puts [expr $a != $b]
1

\== Checks if the values of two operands are equal or not, if yes then condition becomes true and return 1 else return 0

%set a 20
%set b 10
%puts [expr $a == $b]
0

**Logical Operator**

&& If both the operands are non-zero, then condition becomes true and return 1 else return 0

%set a 20
%set b 10
%puts [expr $a && $b]
1

|| If any of the two operands is non-zero, then condition becomes true and return 1 else return 0

%set a 0
%set b 10
%puts [expr $a || $b]
1

! Used to reverse the result of any expression. Here in the output, you can see the value of ‘a’ has now become 1 from 0\. While the value of ‘b’ has become 0 from 1.

%set a 0
%set b 1
%puts [expr !$a]
1
%puts [expr !$b]
0

**Bitwise Operator**

& (bitwise and) perform bit by bit operation and follow the below table for operation.

| A | B | A & B |
| - | - | ----- |
| 0 | 0 | 0     |
| 0 | 1 | 0     |
| 1 | 1 | 1     |
| 1 | 0 | 0     |

Ex:-

%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

| (bitwise or) perform bit by bit operation and follow the below table

| A | B | A \| B |
| - | - | ------ |
| 0 | 0 | 0      |
| 0 | 1 | 1      |
| 1 | 1 | 1      |
| 1 | 0 | 1      |

Ex:-

%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

^ (bitwise exclusive or) perform bit by bit operation and follow the below table

| A | B | A ^ B |
| - | - | ----- |
| 0 | 0 | 0     |
| 0 | 1 | 1     |
| 1 | 1 | 0     |
| 1 | 0 | 1     |

Ex:-

%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

\~ (bitwise negation) operator changes each 1 to 0 and 0 to 1, follow the table as reference

| A | \~A |
| - | --- |
| 0 | 1   |
| 1 | 0   |

%set A 7
%puts [expr ~$A]
-8

**Ternary Operator ( ?:)**

Syntax is

condition-expression?  expression_1: expression_2

If condition-exp is true, exp1 is evaluated and the result is returned. If the cond-exp is false, exp2 is evaluated and its result is returned. In our example, exp1 is true as the value of A is greater than 6.

%set A 7
%set result [expr $A > 6 ? true : false]
%puts $result
true

**Shift Operator**

Shift operator is denoted by either << left shift operator, or by the >> right shift operator. For << left shift operator, the left operands value is moved left by the number of bits specified by the right operand.

%set A 7
%set result [expr $A << 2]
%puts $result

For the >> right shift operator, the left operands value is moved right by the number of bits specified by the right operand.

%set A 7
%set result [expr $A >> 2]
%puts $result

**String Comparison Operator**

String comparison operator compares the value of both operands. If the value of operand are same, then it will return 1 else return 0\. In example value for both A and B is 7, therefore result return 1.

Ex:-

%set A 7
%set B 7
%set result [expr $A eq $B]
%puts $result
1

Ne (if value of both operand are different then it will return 1 else return 0)

%set A 7
%set B 8
%set result [expr $A ne $B]
%puts $result
1

**Exponentiation operator**

Pow () and \*\* both are same. It always returns floating value.

\*\* indicates the power to the desired operand.

Ex:-

%set A 7
%set result [expr $A ** 2]
%puts $result
49

**List Operator**

If the required value found in the defined list, it returns 1 else return 0\. In example value 1 exists in variable ‘a’ hence it will return 1.

set a {1 2 3}
if {1 in $a} {
puts "ok"
} else {
puts "fail"
}
Output: ok

ni, if the required value found in the defined list then it will return 0 else return 1.

Ex :-

set a {1 2 3}
if {1 ni $a} {
puts "ok"
} else {
puts "fail"
}
Output: fail

## TCL flow control and decision making

There are various flow control and decision making command which are used to alter the flow of a program. Program executions always start from the top of source file to the bottom.

If statement consists of Boolean expression followed by one or more statements.

**If … statement**

**Syntax:-**

if expr ?then? body

if expr is evaluated to true, then the body of command is executed.

Ex:-

set age 10

if {$age < 20} {
puts "Age is less than 20"
}

Output: Age is less than 20

**If … else statement**

**Syntax :-**

If expression ? then body\_1 else body\_2

If expression is evaluated to true, then it will return body\_1 else it will return body\_2

Ex:–

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

**Nested if..else statement**

It means one if or else..if statement can be put inside another if or else..if statements.

**Syntax:-**

If  {expression_1} {
Body_1
If {expression_2} {
Body_2
}
}

Ex:–

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 statement**

The switch statement enables a variable to be tested for equality against a list of values. It evaluates the list of values and returns the result of that evaluation. If no values matches then default values will be returned.

**Example**:

#!/usr/bin/tclsh

# switch_cmd.tcl

set domain x
switch $domain {

    x { puts "x" }
    y { puts "y" }
    z { puts "z" }
    default { puts "unknown" }
}

**Nested switch** 

Nested switch statement means switch statement inside a switch statement.

**Syntax** :-

switch <switchingstring1> {
   <matchstring1> {
      body1
      switch <switchingstring2> {
        <matchstring2> {
           body2
         }
          ...
    switch <switchingstringN> {
          <matchStringN> {
           bodyN
         }
      }
   }

**Example**: In the following example, value of a is 100, and with the same code we switch statement for another value of b is 200\. The out will show value for both a and 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"
        }
     }
   }
}

**Output:-**

The value of a is 100

The value of b is 200

**TCL Loop statement**

Loop statement allows executing a statement or group of statement multiple times. Tcl provides the following types of looping statement.

**While command**

When a given condition is true then a statement or group of statement repeats which are in the loop body.

**Syntax**:

While  {condition} {
    Statements
}

Ex :-

#!/usr/bin/tclsh

Set a 10

While {$a < 12} {
    Puts "a is $a"
    incr a
}

**Output:-** 

a is 10

a is 11

In the above example, “incr” built-in command is used. It means the value of ‘a’ will be increased by 1 till the maximum value (<12).

**For command**

It executes a sequence of statements multiple times based upon a counter value. It is automatically increased or decreased during each repetition of the loop.

**Syntax** :-

For {start} {test} {next} {
Body
}

**Example**: In below example value of ‘i’ is set to 0 and incremented till value <5.

#!/usr/bin/tclsh

for {set i 0} {$i < 5} {incr i} {
put $i
}

**Output:-**

0
1
2
3
4

## FAQs

🧵 Is Tcl still used today?

Yes. Tcl is still used for automation, testing, EDA tools, network device scripting, and embedding in applications. The Expect tool and many test frameworks rely on Tcl, though it is less common for new web apps.

🖼️ What is the difference between Tcl and Tk?

Tcl is the scripting language, while Tk is its companion graphical toolkit for building GUIs. Together as Tcl/Tk they let you write cross-platform desktop applications with simple commands.

➗ What does the expr command do in Tcl?

The expr command evaluates mathematical and logical expressions in Tcl. Because Tcl treats everything as a string, expr is required to perform arithmetic, comparisons, and boolean operations.

🤖 How can AI help write Tcl scripts?

AI assistants can generate Tcl code, explain commands like set, puts, and expr, convert pseudocode to Tcl, and debug syntax errors, helping beginners learn the language faster.

🧠 Can AI convert Tcl scripts to other languages?

Yes. AI tools can translate Tcl scripts into languages such as Python or Perl, mapping commands and control structures, though developers should review the output for correctness.

#### Summarize this post with:

ChatGPT Perplexity Grok Google AI 

**Stay Updated on AI** **Get Weekly AI Skills, Trends, Actionable Advice.** 

##### Sign up for the newsletter

Subscribe for Free 

You have successfully subscribed.  
Please check your inbox. 

![AI-Newsletter](https://www.guru99.com/images/footer-email-avatar-imges-1.png) Chosen by over **350,000+** professionals 

[Scroll to top ](#wrapper)Scroll to top 

× 

Toggle Menu Close 

Search for: 

Search

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://www.guru99.com/#organization","name":"Guru99","sameAs":["https://www.facebook.com/Guru99Official","https://twitter.com/guru99com"],"logo":{"@type":"ImageObject","@id":"https://www.guru99.com/#logo","url":"https://www.guru99.com/images/guru99-logo-v1-150x59.png","contentUrl":"https://www.guru99.com/images/guru99-logo-v1-150x59.png","caption":"Guru99","inLanguage":"en-US"}},{"@type":"WebSite","@id":"https://www.guru99.com/#website","url":"https://www.guru99.com","name":"Guru99","publisher":{"@id":"https://www.guru99.com/#organization"},"inLanguage":"en-US"},{"@type":"ImageObject","@id":"https://www.guru99.com/images/tcl-tk-tutorial.png","url":"https://www.guru99.com/images/tcl-tk-tutorial.png","width":"700","height":"250","caption":"Tcl/Tk Tutorial","inLanguage":"en-US"},{"@type":"BreadcrumbList","@id":"https://www.guru99.com/tcl-tutorial.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":"1","item":{"@id":"https://www.guru99.com","name":"Home"}},{"@type":"ListItem","position":"2","item":{"@id":"https://www.guru99.com/linux","name":"Linux"}},{"@type":"ListItem","position":"3","item":{"@id":"https://www.guru99.com/tcl-tutorial.html","name":"Tcl/Tk Tutorial"}}]},{"@type":"WebPage","@id":"https://www.guru99.com/tcl-tutorial.html#webpage","url":"https://www.guru99.com/tcl-tutorial.html","name":"Tcl/Tk Tutorial","dateModified":"2026-06-30T15:35:19+05:30","isPartOf":{"@id":"https://www.guru99.com/#website"},"primaryImageOfPage":{"@id":"https://www.guru99.com/images/tcl-tk-tutorial.png"},"inLanguage":"en-US","breadcrumb":{"@id":"https://www.guru99.com/tcl-tutorial.html#breadcrumb"}},{"@type":"Person","@id":"https://www.guru99.com/author/emily","name":"Emily Carter","description":"I'm Emily Carter, a Linux Development Specialist with expertise in kernel development, system architecture, and performance tuning.","url":"https://www.guru99.com/author/emily","image":{"@type":"ImageObject","@id":"https://www.guru99.com/images/emily-carter-author-120x120.png","url":"https://www.guru99.com/images/emily-carter-author-120x120.png","caption":"Emily Carter","inLanguage":"en-US"},"worksFor":{"@id":"https://www.guru99.com/#organization"}},{"articleSection":"Linux","headline":"Tcl/Tk Tutorial","description":"TCL is string based scripting language and also a procedural language. It was first created by John Osterhout in 1989. The purpose of developing this language is easy embedded inti ( ) applications. T","keywords":"bigdata, programming, database, server","speakable":{"@type":"SpeakableSpecification","cssSelector":[".entry-title",".summary"]},"@type":"Article","author":{"@id":"https://www.guru99.com/author/emily","name":"Emily Carter"},"dateModified":"2026-06-30T15:35:19+05:30","image":{"@id":"https://www.guru99.com/images/tcl-tk-tutorial.png"},"copyrightYear":"2026","name":"Tcl/Tk Tutorial","subjectOf":[{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Is Tcl still used today?","acceptedAnswer":{"@type":"Answer","text":"Yes. Tcl is still used for automation, testing, EDA tools, network device scripting, and embedding in applications. The Expect tool and many test frameworks rely on Tcl, though it is less common for new web apps."}},{"@type":"Question","name":"What is the difference between Tcl and Tk?","acceptedAnswer":{"@type":"Answer","text":"Tcl is the scripting language, while Tk is its companion graphical toolkit for building GUIs. Together as Tcl/Tk they let you write cross-platform desktop applications with simple commands."}},{"@type":"Question","name":"What does the expr command do in Tcl?","acceptedAnswer":{"@type":"Answer","text":"The expr command evaluates mathematical and logical expressions in Tcl. Because Tcl treats everything as a string, expr is required to perform arithmetic, comparisons, and boolean operations."}},{"@type":"Question","name":"How can AI help write Tcl scripts?","acceptedAnswer":{"@type":"Answer","text":"AI assistants can generate Tcl code, explain commands like set, puts, and expr, convert pseudocode to Tcl, and debug syntax errors, helping beginners learn the language faster."}},{"@type":"Question","name":"Can AI convert Tcl scripts to other languages?","acceptedAnswer":{"@type":"Answer","text":"Yes. AI tools can translate Tcl scripts into languages such as Python or Perl, mapping commands and control structures, though developers should review the output for correctness."}}]}],"@id":"https://www.guru99.com/tcl-tutorial.html#schema-1126551","isPartOf":{"@id":"https://www.guru99.com/tcl-tutorial.html#webpage"},"publisher":{"@id":"https://www.guru99.com/#organization"},"inLanguage":"en-US","mainEntityOfPage":{"@id":"https://www.guru99.com/tcl-tutorial.html#webpage"}}]}
```
