Tcl-Tk - Guida rapida

Tcl è una forma abbreviata di Tool Command Language. John Ousterhout dell'Università della California, Berkeley, lo ha progettato. È una combinazione di un linguaggio di scripting e del suo interprete che viene incorporato nell'applicazione, sviluppiamo con esso.

Tcl è stato sviluppato inizialmente per Unix. È stato quindi portato su Windows, DOS, OS / 2 e Mac OSX. Tcl è molto simile ad altri linguaggi di shell unix come Bourne Shell (Sh), C Shell (csh), Korn Shell (sh) e Perl.

Mira a fornire ai programmi la capacità di interagire con altri programmi e anche di agire come interprete incorporabile. Anche se l'obiettivo originale era quello di consentire ai programmi di interagire, è possibile trovare applicazioni complete scritte in Tcl / Tk.

Caratteristiche di Tcl

Le caratteristiche di Tcl sono le seguenti:

• Tempi di sviluppo ridotti.

• Kit interfaccia utente potente e semplice con integrazione di TK.

• Scrivi una volta, corri ovunque. Funziona su Windows, Mac OS X e quasi su tutte le piattaforme Unix.

• Abbastanza facile da iniziare per programmatori esperti; da allora, la lingua è così semplice che possono imparare Tcl in poche ore o giorni.

• Puoi facilmente estendere le applicazioni esistenti con Tcl. Inoltre, è possibile includere Tcl in C, C ++ o Java in Tcl o viceversa.

• Avere un potente set di funzioni di rete.

• Infine, è un open source, gratuito e può essere utilizzato per applicazioni commerciali senza alcun limite.

Applicazioni

Tcl è un linguaggio generico e puoi trovare Tcl ovunque. Include,

• Siti web scalabili che sono spesso supportati da database.
• Server web ad alte prestazioni costruiti con TclHttpd.
• Tcl con siti Web basati su CGI.
• Applicazioni GUI desktop.
• Applicazioni integrate.

Configurazione dell'ambiente locale

Se sei disposto a configurare il tuo ambiente per Tcl, hai bisogno delle seguenti due applicazioni software disponibili sul tuo computer:

• Editor di testo
• Interprete Tcl.

Editor di testo

Questo verrà utilizzato per digitare il tuo programma. Esempi di pochi editor di testo includono Blocco note di Windows, comando Modifica sistema operativo, Brief, Epsilon, EMACS e vim o vi.

Il nome e la versione di un editor di testo possono variare a seconda dei sistemi operativi. Ad esempio, il Blocco note verrà utilizzato su Windows e vim o vi possono essere utilizzati su Windows e Linux o UNIX.

I file che crei con il tuo editor di testo sono chiamati file sorgente e contengono il codice sorgente del programma. I file sorgente per i programmi Tcl sono denominati con l'estensione".tcl".

Prima di iniziare la programmazione, assicurati di disporre di un editor di testo e di avere esperienza sufficiente per scrivere un programma per computer, salvarlo in un file, crearlo e infine eseguirlo.

L'interprete Tcl

È solo un piccolo programma che ti consente di digitare comandi Tcl e di eseguirli riga per riga. Arresta l'esecuzione di un file tcl, nel caso in cui incontri un errore a differenza di un compilatore che viene eseguito completamente.

Facciamo un file helloWorld.tcl come segue. Lo useremo come primo programma, eseguiamo su una piattaforma che scegli.

#!/usr/bin/tclsh

puts "Hello World!"

Installazione su Windows

Scarica l'ultima versione per il programma di installazione di Windows dall'elenco dei binari Tcl attivi disponibili. L'edizione attiva della comunità Tcl è gratuita per uso personale.

Eseguire l'eseguibile scaricato per installare Tcl, operazione che può essere eseguita seguendo le istruzioni sullo schermo.

Ora, possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando il comando "cd" e quindi eseguire il programma utilizzando i seguenti passaggi

C:\Tcl> tclsh helloWorld.tcl

Possiamo vedere il seguente output.

C:\Tcl> helloWorld

C: \ Tcl è la cartella che sto usando per salvare i miei campioni. Puoi cambiarlo nella cartella in cui hai salvato i programmi Tcl.

Installazione su Linux

La maggior parte dei sistemi operativi Linux viene fornita con Tcl integrato e puoi iniziare subito con quei sistemi. Nel caso in cui non fosse disponibile, puoi utilizzare il seguente comando per scaricare e installare Tcl-Tk.

$ yum install tcl tk

Ora, possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando il comando "cd" e quindi eseguire il programma utilizzando i seguenti passaggi:

$ tclsh helloWorld.tcl

Possiamo vedere il seguente output:

$ hello world

Installazione su sistemi basati su Debian

Nel caso in cui non sia disponibile nel tuo sistema operativo, puoi utilizzare il seguente comando per scaricare e installare Tcl-Tk -

$ sudo apt-get install tcl tk

Ora, possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando il comando "cd" e quindi eseguire il programma utilizzando i seguenti passaggi:

$ tclsh helloWorld.tcl

Possiamo vedere il seguente output:

$ hello world

Installazione su Mac OS X

Scarica l'ultima versione per il pacchetto Mac OS X dall'elenco dei binari Tcl attivi disponibili. L'edizione attiva della comunità Tcl è gratuita per uso personale.

Eseguire l'eseguibile scaricato per installare Active Tcl, operazione che può essere eseguita seguendo le istruzioni sullo schermo.

Ora, possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando "cd" e quindi eseguire il programma utilizzando i seguenti passaggi:

$ tclsh helloWorld.tcl

Possiamo vedere il seguente output:

$ hello world

Installazione da file di origine

È possibile utilizzare l'opzione di installazione dai file di origine quando un pacchetto binario non è disponibile. In genere è preferibile utilizzare i binari Tcl per Windows e Mac OS X, quindi di seguito viene mostrata solo la compilazione dei sorgenti su un sistema basato su unix.

• Scarica i file sorgente.

• Ora, usa i seguenti comandi per estrarre, compilare e costruire dopo essere passato alla cartella scaricata.

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

Note - Assicurati di cambiare il nome del file con la versione che hai scaricato sui comandi 1 e 2 indicati sopra.

In Tcl, classifichiamo alcune delle variabili come variabili speciali e hanno un utilizzo / funzionalità predefinito. L'elenco delle variabili speciali è elencato di seguito.

Sr.No.	Variabile speciale e descrizione
1	argc Si riferisce a una serie di argomenti della riga di comando.
2	argv Si riferisce all'elenco contenente gli argomenti della riga di comando.
3	argv0 Si riferisce al nome del file che viene interpretato o al nome con cui si richiama lo script.
4	env Utilizzato per rappresentare la matrice di elementi che sono variabili ambientali.
5	errorCode Fornisce il codice di errore per l'ultimo errore Tcl.
6	errorInfo Fornisce la traccia dello stack per l'ultimo errore Tcl.
7	tcl_interactive Utilizzato per passare dalla modalità interattiva a quella non interattiva impostandola rispettivamente su 1 e 0.
8	tcl_library Utilizzato per impostare la posizione delle librerie Tcl standard.
9	tcl_pkgPath Fornisce l'elenco delle directory in cui vengono generalmente installati i pacchetti.
10	tcl_patchLevel Si riferisce al livello di patch corrente dell'interprete Tcl.
11	tcl_platform Utilizzato per rappresentare la matrice di elementi con oggetti inclusi byteOrder, machine, osVersion, platform e os.
12	tcl_precision Si riferisce alla precisione, ovvero al numero di cifre da conservare durante la conversione in stringhe da numeri a virgola mobile. Il valore predefinito è 12.
13	tcl_prompt1 Si riferisce al prompt principale.
14	tcl_prompt2 Si riferisce al prompt secondario con comandi non validi.
15	tcl_rcFileName Fornisce il file di avvio specifico dell'utente.
16	tcl_traceCompile Utilizzato per controllare la traccia della compilazione del bytecode. Usa 0 per nessun output, 1 per il riepilogo e 2 per i dettagli.
17	tcl_traceExec Utilizzato per controllare la traccia dell'esecuzione del bytecode. Usa 0 per nessun output, 1 per il riepilogo e 2 per i dettagli.
18	tcl_version Restituisce la versione corrente dell'interprete Tcl.

Le variabili speciali di cui sopra hanno i loro significati speciali per l'interprete Tcl.

Esempi per l'utilizzo di variabili speciali Tcl

Vediamo alcuni esempi per variabili speciali.

Versione Tcl

#!/usr/bin/tclsh

puts $tcl_version

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

8.6

Percorso dell'ambiente Tcl

#!/usr/bin/tclsh

puts $env(PATH)

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

/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/

Percorso pacchetto Tcl

#!/usr/bin/tclsh

puts $tcl_pkgPath

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

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

Libreria Tcl

#!/usr/bin/tclsh

puts $tcl_library

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

/usr/share/tcl8.6

Livello patch Tcl

#!/usr/bin/tclsh

puts $tcl_patchLevel

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

8.6.6

Tcl Precision

#!/usr/bin/tclsh

puts $tcl_precision

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

0

File di avvio Tcl

#!/usr/bin/tclsh

puts $tcl_rcFileName

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito:

~/.tclshrc

Tcl è abbastanza semplice da imparare e iniziamo a creare il nostro primo programma Tcl!

Primo programma Tcl

Scriviamo un semplice programma Tcl. Tutti i file Tcl avranno un'estensione, cioè .tcl. Quindi, inserisci il seguente codice sorgente in un file test.tcl.

#!/usr/bin/tclsh

puts "Hello, World!"

Supponendo che l'ambiente Tcl sia configurato correttamente; eseguiamo il programma dopo essere passati alla directory del file e quindi eseguiamo il programma usando -

$ tclsh test.tcl

Otterremo il seguente output:

Hello, World!

Vediamo ora la struttura di base del programma Tcl, in modo che sarà facile per te comprendere gli elementi costitutivi di base del linguaggio Tcl. In Tcl, usiamo una nuova riga o punto e virgola per terminare la riga di codice precedente. Ma il punto e virgola non è necessario, se stai usando la nuova riga per ogni comando.

Commenti

I commenti sono come aiutare il testo nel tuo programma Tcl e l'interprete li ignora. I commenti possono essere scritti utilizzando un cancelletto _ (#) all'inizio.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello World!

Il commento su più righe o blocco viene scritto utilizzando "if" con la condizione "0". Di seguito è mostrato un esempio.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello World!

I commenti in linea usano; #. Un esempio è dato seguito.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello World!

Identificatori

Un identificatore Tcl è un nome utilizzato per identificare una variabile, una funzione o qualsiasi altro elemento definito dall'utente. Un identificatore inizia con una lettera dalla A alla Z o dalla aaz o un trattino basso (_) seguito da zero o più lettere, trattini bassi, dollari ($) e cifre (da 0 a 9).

Tcl non consente caratteri di punteggiatura come @ e% all'interno degli identificatori. Tcl è un filecase sensitive_ linguaggio. Quindi Manpower e manpower sono due identificatori differenti in Tcl. Ecco alcuni esempi di identificatori accettabili:

mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal

Parole riservate

Il seguente elenco mostra alcune delle parole riservate in Tcl. Queste parole riservate non possono essere utilizzate come costanti, variabili o altri nomi di identificatori.

dopo	aggiungere	Vettore	auto_execok
auto_import	auto_load	auto_load_index	auto_qualify
binario	Bgerror	rompere	catturare
CD	Orologio	vicino	concat
Continua	Dde	predefinito	altro
elseif	Codifica	eof	errore
eval	Exec	Uscita	expr
floccato	Fconfigure	fcopy	file
fileevent	Sciacquone	per	per ciascuno
formato	Prende	glob	globale
storia	Se	Informazioni	interp
aderire	Lappend	lindex	linsert
elenco	Llength	caricare	lrange
sostituire	Lsearch	lsort	spazio dei nomi
Aperto	Pacchetto	pid	pkg_mkIndex
proc	Mette	pwd	leggere
regexp	Regsub	rinominare	risorsa
ritorno	Scansione	cercare	impostato
presa	fonte	Diviso	corda
subst	Interruttore	tclLog	raccontare
tempo	Traccia	sconosciuto	non settato
aggiornare	Livello superiore	upvar	variabile
vwait	Mentre

Spazio bianco in Tcl

Una riga contenente solo spazi bianchi, possibilmente con un commento, è nota come blank line, e un interprete Tcl lo ignora totalmente.

Lo spazio bianco è il termine usato in Tcl per descrivere spazi, tabulazioni, caratteri di nuova riga e commenti. Lo spazio vuoto separa una parte di un'istruzione da un'altra e consente all'interprete di identificare dove un elemento in un'istruzione, come put, finisce e inizia l'elemento successivo. Pertanto, nella seguente dichiarazione:

#!/usr/bin/tclsh

puts "Hello World!"

Deve esserci almeno un carattere di spazio (di solito uno spazio) tra "put" e "Hello World!" affinchè l'interprete possa distinguerli. D'altra parte, nella seguente dichiarazione:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

5

Non sono necessari caratteri di spazio tra 3 e + o tra + e 2; tuttavia, sei libero di includerne alcuni se lo desideri ai fini della leggibilità.

Come sai, Tcl è un linguaggio di comando degli strumenti, i comandi sono la parte più vitale del linguaggio. I comandi Tcl sono incorporati nella lingua e ciascuno ha la propria funzione predefinita. Questi comandi formano le parole riservate della lingua e non possono essere utilizzati per altri nomi di variabili. Il vantaggio di questi comandi Tcl è che puoi definire la tua implementazione per ognuno di questi comandi per sostituire la funzionalità incorporata originale.

Ciascuno dei comandi Tcl convalida l'input e riduce il lavoro dell'interprete.

Il comando Tcl è in realtà un elenco di parole, con la prima parola che rappresenta il comando da eseguire. Le parole successive rappresentano gli argomenti. Per raggruppare le parole in un unico argomento, racchiudiamo più parole tra "" o {}.

La sintassi del comando Tcl è la seguente:

commandName argument1 argument2 ... argumentN

Vediamo un semplice esempio di comando Tcl:

#!/usr/bin/tclsh

puts "Hello, world!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello, world!

Nel codice precedente, "put" è il comando Tcl e "Hello World" è l'argomento1. Come detto prima, abbiamo usato "" per raggruppare due parole.

Vediamo un altro esempio di comando Tcl con due argomenti:

#!/usr/bin/tclsh

puts stdout "Hello, world!"

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello, world!

Nel codice precedente, "put" è il comando Tcl, "stdout" è argomento1 e "Hello World" è argomento2. Qui, stdout fa in modo che il programma stampi nel dispositivo di output standard.

Sostituzione dei comandi

Nelle sostituzioni dei comandi, le parentesi quadre vengono utilizzate per valutare gli script all'interno delle parentesi quadre. Di seguito è mostrato un semplice esempio per aggiungere due numeri:

#!/usr/bin/tclsh

puts [expr 1 + 6 + 9]

Quando il codice sopra viene eseguito, produce il seguente risultato:

16

Sostituzione variabile

Nelle sostituzioni di variabili, $ viene utilizzato prima del nome della variabile e ciò restituisce il contenuto della variabile. Di seguito è mostrato un semplice esempio per impostare un valore su una variabile e stamparlo.

#!/usr/bin/tclsh

set a 3
puts $a

Quando il codice sopra viene eseguito, produce il seguente risultato:

3

Sostituzione barra rovesciata

Questi sono comunemente chiamati escape sequences; con ogni barra rovesciata, seguita da una lettera con un proprio significato. Di seguito è mostrato un semplice esempio di sostituzione di nuova riga:

#!/usr/bin/tclsh

puts "Hello\nWorld"

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello
World

Il tipo di dati primitivo di Tcl è stringa e spesso possiamo trovare virgolette su Tcl come linguaggio solo stringa. Questi tipi di dati primitivi a loro volta creano tipi di dati compositi per elenchi e array associativi. In Tcl, i tipi di dati possono rappresentare non solo i semplici oggetti Tcl, ma possono anche rappresentare oggetti complessi come maniglie, oggetti grafici (principalmente widget) e canali I / O. Diamo un'occhiata ai dettagli su ciascuno dei precedenti.

Oggetti Tcl semplici

In Tcl, se si tratta di un numero intero, booleano, numero in virgola mobile o una stringa. Quando vuoi usare una variabile, puoi assegnarle direttamente un valore, non c'è alcun passo di dichiarazione in Tcl. Possono esserci rappresentazioni interne per questi diversi tipi di oggetti. Può trasformare un tipo di dati in un altro quando richiesto. La sintassi per assegnare il valore alla variabile è la seguente:

#!/usr/bin/tclsh

set myVariable 18
puts $myVariable

Quando il codice sopra viene eseguito, produce il seguente risultato:

18

L'istruzione sopra creerà un nome di variabile myVariable e lo memorizzerà come una stringa anche se non abbiamo usato le virgolette doppie. Ora, se proviamo a fare un'aritmetica sulla variabile, viene automaticamente trasformata in un numero intero. Di seguito viene mostrato un semplice esempio:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

33

Una cosa importante da notare è che queste variabili non hanno valori predefiniti e devono essere assegnate a un valore prima di essere utilizzate.

Se proviamo a stampare usando put, il numero viene trasformato in una stringa appropriata. Avere due rappresentazioni, interna ed esterna, aiuta Tcl a creare strutture di dati complesse facilmente rispetto ad altri linguaggi. Inoltre, Tcl è più efficiente grazie alla sua natura dinamica degli oggetti.

Rappresentazioni di stringa

A differenza di altre lingue, in Tcl, non è necessario includere virgolette doppie quando è solo una singola parola. Un esempio può essere:

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

Quando il codice sopra viene eseguito, produce il seguente risultato:

hello

Quando vogliamo rappresentare più stringhe, possiamo usare virgolette doppie o parentesi graffe. È mostrato di seguito -

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

hello world
hello world

Elenco

L'elenco non è altro che un gruppo di elementi. Un gruppo di parole che utilizza virgolette doppie o parentesi graffe può essere utilizzato per rappresentare un semplice elenco. Di seguito è riportato un semplice elenco:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

blue
green

Array associativo

Gli array associativi hanno un indice (chiave) che non è necessariamente un numero intero. In genere è una stringa che agisce come coppie di valori chiave. Di seguito viene mostrato un semplice esempio:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

80
90

Maniglie

Gli handle Tcl sono comunemente usati per rappresentare file e oggetti grafici. Questi possono includere handle per le richieste di rete e anche altri canali come la comunicazione della porta seriale, socket o dispositivi I / O. Il seguente è un esempio in cui viene creato un handle di file.

set myfile [open "filename" r]

Vedrai maggiori dettagli sui file nel capitolo I / O dei file Tcl .

In Tcl, non esiste il concetto di dichiarazione di variabile. Una volta che si incontra un nuovo nome di variabile, Tcl definirà una nuova variabile.

Denominazione delle variabili

Il nome delle variabili può contenere qualsiasi carattere e lunghezza. Puoi anche avere spazi bianchi racchiudendo la variabile tra parentesi graffe, ma non è preferibile.

Il comando set viene utilizzato per assegnare un valore a una variabile. La sintassi per il comando set è,

set variableName value

Di seguito sono riportati alcuni esempi di variabili:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

10
test

Come puoi vedere nel programma sopra, $ variableName viene utilizzato per ottenere il valore della variabile.

Digitazione dinamica

Tcl è un linguaggio tipizzato dinamicamente. Il valore della variabile può essere convertito dinamicamente nel tipo richiesto quando richiesto. Ad esempio, un numero 5 memorizzato come stringa verrà convertito in numero quando si esegue un'operazione aritmetica. È mostrato di seguito -

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

10
30

Espressioni matematiche

Come puoi vedere nell'esempio sopra, expr è usato per rappresentare un'espressione matematica. La precisione predefinita di Tcl è di 12 cifre. Per ottenere risultati in virgola mobile, dovremmo aggiungere almeno una singola cifra decimale. Un semplice esempio spiega quanto sopra.

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

1
1.1111111111111112
1.1111111111111112

Nell'esempio sopra, puoi vedere tre casi. Nel primo caso, il dividendo e il divisore sono numeri interi e come risultato otteniamo un numero intero. Nel secondo caso, il solo divisore è un numero decimale e nel terzo caso, il dividendo è un numero decimale. Sia nel secondo che nel terzo caso, otteniamo come risultato un numero decimale.

Nel codice precedente, è possibile modificare la precisione utilizzando la variabile speciale tcl_precision. È mostrato di seguito -

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

1.1111

Un operatore è un simbolo che dice al compilatore di eseguire specifiche manipolazioni matematiche o logiche. Il linguaggio Tcl è ricco di operatori incorporati e fornisce i seguenti tipi di operatori:

• Operatori aritmetici
• Operatori relazionali
• Operatori logici
• Operatori bit per bit
• Operatore ternario

Questo capitolo spiegherà uno per uno gli operatori aritmetici, relazionali, logici, bit per bit e ternari.

Operatori aritmetici

La tabella seguente mostra tutti gli operatori aritmetici supportati dal linguaggio Tcl. Supponiamo che la variabile "A" contenga 10 e la variabile "B" contenga 20, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
+	Aggiunge due operandi	A + B darà 30
-	Sottrae il secondo operando dal primo	A - B darà -10
*	Moltiplica entrambi gli operandi	A * B darà 200
/	Divide il numeratore per il de-numeratore	B / A darà 2
%	Operatore modulo e resto di dopo una divisione intera	B% A darà 0

Operatori relazionali

La tabella seguente mostra tutti gli operatori relazionali supportati dal linguaggio Tcl. Assumi variabileA detiene 10 e variabile B detiene 20, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
==	Controlla se i valori di due operandi sono uguali o meno, in caso affermativo la condizione diventa vera.	(A == B) non è vero.
! =	Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera.	(A! = B) è vero.
>	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> B) non è vero.
<	Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <B) è vero.
> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> = B) non è vero.
<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <= B) è vero.

Operatori logici

La tabella seguente mostra tutti gli operatori logici supportati dal linguaggio Tcl. Assumi variabileA detiene 1 e variabile B contiene 0, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
&&	Chiamato operatore AND logico. Se entrambi gli operandi sono diversi da zero, la condizione diventa vera.	(A && B) è falso.
||	Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera.	(A || B) è vero.
!	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	! (A && B) è vero.

Operatori bit per bit

L'operatore bit per bit lavora sui bit ed esegue operazioni bit per bit. Le tabelle di verità per &, | e ^ sono le seguenti:

p	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

Assumiamo se A = 60; e B = 13; ora in formato binario saranno i seguenti -

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

Gli operatori bit per bit supportati dal linguaggio Tcl sono elencati nella tabella seguente. Assumi variabileA detiene 60 e variabile B tiene 13, quindi -

Mostra esempi

Operatore	Descrizione	Esempio
&	L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi.	(A e B) darà 12, che è 0000 1100
|	L'operatore OR binario copia un bit se esiste in uno degli operandi.	(A | B) darà 61, che è 0011 1101
^	L'operatore XOR binario copia il bit se è impostato in un operando ma non in entrambi.	(A ^ B) darà 49, che è 0011 0001
<<	Operatore binario di spostamento sinistro. Il valore degli operandi di sinistra viene spostato a sinistra del numero di bit specificato dall'operando di destra.	Un << 2 darà 240, che è 1111 0000
>>	Operatore binario di spostamento a destra. Il valore dell'operando di sinistra viene spostato a destra del numero di bit specificato dall'operando di destra.	Un >> 2 darà 15, che è 0000 1111

Operatore ternario

Mostra esempi

Operatore	Descrizione	Esempio
? :	Ternario	Se la condizione è vera? Quindi valore X: altrimenti valore Y

Precedenza degli operatori in Tcl

La precedenza degli operatori determina il raggruppamento dei termini in un'espressione. Ciò influisce sul modo in cui viene valutata un'espressione. Alcuni operatori hanno la precedenza maggiore di altri; ad esempio, l'operatore di moltiplicazione ha una precedenza maggiore dell'operatore di addizione.

For example: x = 7 + 3 * 2; qui, x è assegnato 13, non 20 perché l'operatore * ha una precedenza maggiore di +, quindi viene prima moltiplicato per 3 * 2 e poi somma in 7.

Qui, gli operatori con la precedenza più alta vengono visualizzati nella parte superiore della tabella, quelli con la priorità più bassa in fondo. All'interno di un'espressione, verranno valutati per primi gli operatori con precedenza più alta.

Mostra esempi

Categoria	Operatore	Associatività
Unario	+ -	Da destra a sinistra
Moltiplicativo	* /%	Da sinistra a destra
Additivo	+ -	Da sinistra a destra
Cambio	<< >>	Da sinistra a destra
Relazionale	<<=>> =	Da sinistra a destra
Bitwise AND	&	Da sinistra a destra
Bitwise XOR	^	Da sinistra a destra
OR bit per bit	|	Da sinistra a destra
AND logico	&&	Da sinistra a destra
OR logico	||	Da sinistra a destra
Ternario	?:	Da destra a sinistra

Le strutture decisionali richiedono che il programmatore specifichi una o più condizioni che devono essere valutate o testate dal programma, insieme a una o più istruzioni da eseguire se la condizione è determinata essere vera e, facoltativamente, altre istruzioni da eseguire se la condizione è determinato a essere falso.

Di seguito è riportata la forma generale di una tipica struttura decisionale presente nella maggior parte dei linguaggi di programmazione:

Il linguaggio Tcl utilizza internamente il comando expr e quindi non è necessario che utilizziamo esplicitamente l'istruzione expr.

Il linguaggio Tcl fornisce i seguenti tipi di dichiarazioni decisionali:

Sr.No.	Dichiarazione e descrizione
1	istruzione if Un'istruzione "if" consiste in un'espressione booleana seguita da una o più istruzioni.
2	if ... else dichiarazione Un'istruzione "if" può essere seguita da un'istruzione "else" facoltativa, che viene eseguita quando l'espressione booleana è falsa.
3	istruzioni if ​​annidate Puoi utilizzare un'istruzione "if" o "else if" all'interno di un'altra istruzione "if" o "else if".
4	istruzione switch UN switch consente di verificare l'uguaglianza di una variabile rispetto a un elenco di valori.
5	istruzioni switch annidate Puoi usarne uno switch dichiarazione dentro un'altra switch dichiarazione (i).

Il ? : Operatore

Abbiamo coperto conditional operator ? : nel capitolo precedente, che può essere utilizzato per sostituire if...elsedichiarazioni. Ha la seguente forma generale:

Exp1 ? Exp2 : Exp3;

Dove Exp1, Exp2 e Exp3 sono espressioni. Notare l'uso e il posizionamento dei due punti.

Il valore di un '? espressione 'è determinata in questo modo: Exp1 viene valutato. Se è vero, allora Exp2 viene valutato e diventa il valore dell'intero '? espressione.' Se Exp1 è falso, viene valutato Exp3 e il suo valore diventa il valore dell'espressione. Di seguito è mostrato un esempio.

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

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Value of b is 30
Value of b is 20

Potrebbe esserci una situazione in cui è necessario eseguire un blocco di codice più volte. In generale, le istruzioni vengono eseguite in sequenza: la prima istruzione in una funzione viene eseguita per prima, seguita dalla seconda e così via.

I linguaggi di programmazione forniscono varie strutture di controllo che consentono percorsi di esecuzione più complicati.

Un'istruzione loop ci consente di eseguire un'istruzione o un gruppo di istruzioni più volte e la seguente è la forma generale di un'istruzione loop nella maggior parte dei linguaggi di programmazione:

Il linguaggio Tcl fornisce i seguenti tipi di loop per gestire i requisiti di loop.

Sr.No.	Tipo e descrizione del loop
1	while loop Ripete un'istruzione o un gruppo di istruzioni finché una determinata condizione è vera. Verifica la condizione prima di eseguire il corpo del ciclo.
2	per loop Esegue una sequenza di istruzioni più volte e abbrevia il codice che gestisce la variabile del ciclo.
3	loop annidati È possibile utilizzare uno o più cicli all'interno di un altro ciclo while, for o do.. while.

Dichiarazioni di controllo del loop

Le istruzioni di controllo del ciclo cambiano l'esecuzione dalla sua sequenza normale. Quando l'esecuzione esce da un ambito, tutti gli oggetti automatici creati in tale ambito vengono eliminati.

Tcl supporta le seguenti istruzioni di controllo.

Sr.No.	Dichiarazione di controllo e descrizione
1	dichiarazione di interruzione Termina l'istruzione loop o switch e trasferisce l'esecuzione all'istruzione immediatamente successiva al loop o switch.
2	continua dichiarazione Fa sì che il ciclo salti il ​​resto del suo corpo e ritorni immediatamente le sue condizioni prima di ripetere.

Il ciclo infinito

Un ciclo diventa ciclo infinito se una condizione non diventa mai falsa. Ilwhileloop è tradizionalmente utilizzato per questo scopo. Puoi creare un ciclo infinito lasciando l'espressione condizionale su 1.

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

Quando l'espressione condizionale è assente, si presume che sia vera. I programmatori Tcl usano più comunemente il costrutto while {1} per indicare un ciclo infinito.

NOTE - Puoi terminare un ciclo infinito premendo i tasti Ctrl + C.

Un array è una disposizione sistematica di un gruppo di elementi utilizzando indici. La sintassi per l'array convenzionale è mostrata di seguito.

set ArrayName(Index) value

Di seguito è mostrato un esempio per la creazione di un array semplice.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Tcl
C Language

Dimensioni dell'array

La sintassi per il calcolo delle dimensioni dell'array è mostrata di seguito.

[array size variablename]

Di seguito è mostrato un esempio per la stampa delle dimensioni.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

2

Iterazione di array

Tuttavia, gli indici degli array possono essere non continui come i valori specificati per l'indice 1, quindi per l'indice 10 e così via. Ma, nel caso in cui siano continui, possiamo usare l'iterazione dell'array per accedere agli elementi dell'array. Di seguito è mostrata una semplice iterazione dell'array per la stampa degli elementi dell'array.

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Array associativi

In Tcl, tutti gli array per natura sono associativi. Gli array vengono archiviati e recuperati senza alcun ordine specifico. Gli array associativi hanno un indice che non è necessariamente un numero e possono essere scarsamente popolati. Di seguito è mostrato un semplice esempio di matrice associativa con indici non numerici.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Dave
14

Indici di array

La sintassi per il recupero degli indici di array è mostrata di seguito.

[array names variablename]

Di seguito è mostrato un esempio per la stampa delle dimensioni.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Age Name

Iterazione di array associativi

È possibile utilizzare gli indici di array per scorrere l'array associativo. Di seguito è mostrato un esempio.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Il tipo di dati primitivo di Tcl è stringa e spesso possiamo trovare virgolette su Tcl come linguaggio solo stringa. Queste stringhe possono contenere caratteri alfanumerici, solo numeri, booleani o anche dati binari. Tcl utilizza caratteri Unicode a 16 bit e i caratteri alfanumerici possono contenere lettere inclusi caratteri non latini, numeri o punteggiatura.

Il valore booleano può essere rappresentato come 1, sì o vero per vero e 0, no o falso per falso.

Rappresentazioni di stringa

A differenza di altre lingue, in Tcl, non è necessario includere virgolette doppie quando è solo una singola parola. Un esempio può essere:

#!/usr/bin/tclsh

set myVariable hello
puts $myVariable

Quando il codice sopra viene eseguito, produce il seguente risultato:

hello

Quando vogliamo rappresentare più stringhe, possiamo usare virgolette doppie o parentesi graffe. È mostrato di seguito -

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

hello world
hello world

Sequenza di escape delle stringhe

Un carattere letterale può essere un carattere semplice (ad esempio, "x"), una sequenza di escape (ad esempio, "\ t") o un carattere universale (ad esempio, "\ u02C0").

Ci sono alcuni caratteri in Tcl quando sono preceduti da una barra rovesciata avranno un significato speciale e sono usati per rappresentare come una nuova riga (\ n) o una tabulazione (\ t). Qui hai un elenco di alcuni di questi codici di sequenza di escape:

Sequenza di escape	Senso
\\	\ personaggio
\ '	' personaggio
\ "	" personaggio
\?	? personaggio
\un	Allerta o campanello
\ b	Backspace
\ f	Avanzamento modulo
\ n	Nuova linea
\ r	Ritorno in carrozza
\ t	Tab orizzontale
\ v	Scheda verticale

Di seguito è riportato l'esempio per mostrare alcuni caratteri della sequenza di escape:

#!/usr/bin/tclsh

puts "Hello\tWorld\n\nTutorialspoint";

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Hello   World

Tutorialspoint

Comando stringa

L'elenco dei sottocomandi per il comando stringa è elencato nella tabella seguente:

Sr.No.	Metodi e descrizione
1	compare stringa1 stringa2 Confronta lessograficamente stringa1 e stringa2. Restituisce 0 se uguale, -1 se stringa1 viene prima di stringa2, altrimenti 1.
2	first stringa1 stringa2 Restituisce la prima occorrenza dell'indice di stringa1 in stringa2. Se non trovato, restituisce -1.
3	index indice di stringa Restituisce il carattere all'indice.
4	last stringa1 stringa2 Restituisce l'ultima occorrenza dell'indice di stringa1 nella stringa2. Se non trovato, restituisce -1.
5	length corda Restituisce la lunghezza della stringa.
6	match pattern corda Restituisce 1 se la stringa corrisponde al modello.
7	range stringa index1 index2 Restituisce l'intervallo di caratteri in stringa da index1 a index2.
8	tolower corda Restituisce la stringa minuscola.
9	toupper corda Restituisce la stringa maiuscola.
10	trim stringa? trimcharacters? Rimuove i caratteri trim su entrambe le estremità della stringa. I caratteri trim predefiniti sono gli spazi bianchi.
11	trimleft stringa? trimcharacters? Rimuove i caratteri trim all'inizio della stringa a sinistra. I caratteri trim predefiniti sono gli spazi bianchi.
12	trimright stringa? trimcharacters? Rimuove i caratteri trim nell'estremità sinistra della stringa. I caratteri trim predefiniti sono gli spazi bianchi.
13	wordend indice findstring Restituisce l'indice in findstring del carattere dopo la parola contenente il carattere in index.
14	wordstart indice findstring Restituisce l'indice in findstring del primo carattere nella parola contenente il carattere in index.

Di seguito vengono forniti esempi di alcuni comandi secondari di stringhe Tcl di uso comune.

Confronto tra stringhe

#!/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\'.";
}

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Indice di stringa

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Lunghezza della stringa

#!/usr/bin/tclsh

set s1 "Hello World"
puts "Length of string s1"
puts [string length $s1]

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Length of string s1
11

Casi di gestione

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

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

Caratteri di taglio

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

When the above code is compiled and executed, it produces the following result −

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

Matching Strings

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

When the above code is compiled and executed, it produces the following result −

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

Append Command

#!/usr/bin/tclsh

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

When the above code is compiled and executed, it produces the following result −

Hello World

Format command

The following table shows the list of format specifiers available in Tcl −

Specifier	Use
%s	String representation
%d	Integer representation
%f	Floating point representation
%e	Floating point representation with mantissa-exponent form
%x	Hexa decimal representation

Di seguito vengono forniti alcuni semplici esempi:

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

43.500000
4.350000e+01
4 tuts
Tcl Language
28

Comando di scansione

Il comando di scansione viene utilizzato per analizzare una stringa in base all'identificatore di formato. Di seguito sono riportati alcuni esempi.

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

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

1
1
0
1

List è uno dei tipi di dati di base disponibili in Tcl. Viene utilizzato per rappresentare una raccolta ordinata di elementi. Può includere diversi tipi di elementi nello stesso elenco. Inoltre, un elenco può contenere un altro elenco.

Una cosa importante da notare è che questi elenchi sono rappresentati completamente come stringhe ed elaborati per formare singoli elementi quando richiesto. Quindi, evitare elenchi di grandi dimensioni e in questi casi; usa l'array.

Creazione di un elenco

La sintassi generale per l'elenco è fornita di seguito:

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

Di seguito vengono forniti alcuni esempi:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

red green blue
red green blue
red green blue

Aggiunta di un elemento a un elenco

La sintassi per aggiungere un elemento a un elenco è fornita di seguito:

append listName split_character value
# or
lappend listName value

Di seguito vengono forniti alcuni esempi:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

orange blue red green

Lunghezza dell'elenco

La sintassi per la lunghezza dell'elenco è fornita di seguito:

llength listName

Di seguito viene fornito un esempio di lunghezza dell'elenco:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

4

Voce di elenco all'indice

La sintassi per la selezione di una voce di elenco in corrispondenza di un indice specifico è fornita di seguito:

lindex listname index

Di seguito viene fornito un esempio per l'elemento dell'elenco all'indice:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

blue

Inserisci elemento all'indice

Di seguito viene fornita la sintassi per l'inserimento di voci di elenco a un indice specifico.

linsert listname index value1 value2..valuen

Di seguito viene fornito un esempio per l'inserimento di voci di elenco in un indice specifico.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

orange blue red black white green

Sostituisci gli elementi negli indici

Di seguito viene fornita la sintassi per la sostituzione degli elementi dell'elenco in corrispondenza di indici specifici:

lreplace listname firstindex lastindex value1 value2..valuen

Di seguito viene fornito un esempio per la sostituzione degli elementi dell'elenco in corrispondenza di indici specifici.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

orange blue black white

Imposta elemento all'indice

Di seguito viene fornita la sintassi per l'impostazione della voce dell'elenco a un indice specifico:

lset listname index value

Di seguito viene fornito un esempio per l'impostazione della voce dell'elenco in corrispondenza di un indice specifico:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

black blue red green

Trasforma elenco in variabili

Di seguito viene fornita la sintassi per copiare i valori nelle variabili:

lassign listname variable1 variable2.. variablen

Di seguito viene fornito un esempio per trasformare una lista in variabili:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

orange
blue

Ordinamento di un elenco

La sintassi per ordinare un elenco è fornita di seguito:

lsort listname

Di seguito viene fornito un esempio per l'ordinamento di un elenco:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

blue green orange red

Un dizionario è una disposizione per mappare i valori alle chiavi. La sintassi per il dizionario convenzionale è mostrata di seguito:

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

Di seguito sono riportati alcuni esempi per la creazione di un dizionario:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

colour1 red
colour1 red colour2 green
colour1 black colour2 white

Dimensioni di Dict

La sintassi per ottenere la dimensione di dict è mostrata di seguito:

[dict size dictname]

Di seguito è riportato un esempio per la stampa delle dimensioni:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

2

Dizionario iteration

Di seguito è mostrata una semplice iterazione del dizionario per la stampa delle chiavi e del valore del dizionario:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

black
white

Valore per la chiave in Dict

La sintassi per il recupero del valore per la chiave in dict è mostrata di seguito:

[dict get $dictname $keyname]

Di seguito viene fornito un esempio per il recupero del valore per la chiave:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

black

Tutte le chiavi in ​​Dict

La sintassi per il recupero di tutte le chiavi in ​​dict è mostrata di seguito:

[dict keys $dictname]

Di seguito è riportato un esempio per la stampa di tutte le chiavi:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

colour1 colour2

Tutti i valori in Dict

La sintassi per il recupero di tutti i valori in dict è mostrata di seguito:

[dict values $dictname]

Di seguito è riportato un esempio per la stampa di tutti i valori:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

black white

La chiave esiste in Dict

La sintassi per verificare se una chiave esiste in dict è mostrata di seguito:

[dict exists $dictname $key]

Di seguito è mostrato un esempio per verificare se una chiave esiste in dict:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

1

Le procedure non sono altro che blocchi di codice con una serie di comandi che forniscono una specifica funzionalità riutilizzabile. Viene utilizzato per evitare che lo stesso codice venga ripetuto in più posizioni. Le procedure sono equivalenti alle funzioni usate in molti linguaggi di programmazione e sono rese disponibili in Tcl con l'aiuto diproc comando.

La sintassi per creare una procedura semplice è mostrata di seguito:

proc procedureName {arguments} {
   body
}

Di seguito viene fornito un semplice esempio di procedura:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Hello, World!

Procedure con più argomenti

Di seguito è riportato un esempio di procedura con argomenti:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

40

Procedure con argomenti variabili

Di seguito è riportato un esempio di procedura con argomenti:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

65
66

Procedure con argomenti predefiniti

Gli argomenti predefiniti vengono utilizzati per fornire valori predefiniti che possono essere utilizzati se non viene fornito alcun valore. Di seguito è riportato un esempio di procedura con argomenti predefiniti, a volte denominati argomenti impliciti:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

40
110

Procedure ricorsive

Di seguito è riportato un esempio di procedure ricorsive:

#!/usr/bin/tclsh

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

}
puts [factorial 3]
puts [factorial 5]

Quando il codice sopra viene eseguito, produce il seguente risultato:

6
120

I pacchetti vengono utilizzati per creare unità di codice riutilizzabili. Un pacchetto è costituito da una raccolta di file che forniscono funzionalità specifiche. Questa raccolta di file è identificata da un nome di pacchetto e può avere più versioni degli stessi file. Il pacchetto può essere una raccolta di script Tcl, una libreria binaria o una combinazione di entrambi.

Il pacchetto utilizza il concetto di spazio dei nomi per evitare la collisione di nomi di variabili e nomi di procedure. Scopri di più nel nostro prossimo tutorial sullo " spazio dei nomi ".

Creazione del pacchetto

Un pacchetto può essere creato con l'aiuto di almeno due file. Un file contiene il codice del pacchetto. Altro file contiene il file del pacchetto di indice per dichiarare il pacchetto.

Di seguito è riportato l'elenco dei passaggi per la creazione e l'utilizzo del pacchetto.

FASE 1: creazione del codice

Crea codice per il pacchetto all'interno di una cartella, ad esempio HelloWorld. Lascia che il file si chiami HelloWorld.tcl con il codice come mostrato di seguito -

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

PASSAGGIO 2: creazione dell'indice del pacchetto

Apri tclsh. Passa alla directory HelloWorld e usa il comando pkg_mkIndex per creare il file indice come mostrato di seguito -

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

PASSAGGIO 3: aggiunta di directory ad Autopath

Usa il comando lappend per aggiungere il pacchetto all'elenco globale come mostrato di seguito -

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

FASE 4: aggiunta del pacchetto

Quindi aggiungi il pacchetto al programma usando l'istruzione package require come mostrato di seguito -

% package require HelloWorld 1.0

FASE 5: procedura di chiamata

Ora, tutto in fase di configurazione, possiamo richiamare la nostra procedura come mostrato di seguito -

% puts [HelloWorld::MyProcedure]

Otterrai il seguente risultato:

HelloWorld

I primi due passaggi creano il pacchetto. Una volta creato il pacchetto, puoi usarlo in qualsiasi file Tcl aggiungendo le ultime tre istruzioni come mostrato di seguito -

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

Otterrai il seguente risultato:

HelloWorld

Lo spazio dei nomi è un contenitore per un insieme di identificatori utilizzato per raggruppare variabili e procedure. Gli spazi dei nomi sono disponibili dalla versione 8.0 di Tcl. Prima dell'introduzione degli spazi dei nomi, esisteva un unico ambito globale. Ora con gli spazi dei nomi, abbiamo partizioni aggiuntive di ambito globale.

Creazione dello spazio dei nomi

Gli spazi dei nomi vengono creati utilizzando l'estensione namespacecomando. Di seguito è mostrato un semplice esempio per la creazione dello spazio dei nomi:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

33

Nel programma sopra, puoi vedere che c'è uno spazio dei nomi con una variabile myResult e una procedura Add. Ciò rende possibile creare variabili e procedure con gli stessi nomi in spazi dei nomi diversi.

Spazi dei nomi annidati

Tcl consente l'annidamento degli spazi dei nomi. Di seguito viene fornito un semplice esempio per l'annidamento degli spazi dei nomi:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

test1
test2

Importazione ed esportazione dello spazio dei nomi

Come puoi vedere negli esempi precedenti dello spazio dei nomi, usiamo molti operatori di risoluzione dell'ambito ed è più complesso da usare. Possiamo evitarlo importando ed esportando gli spazi dei nomi. Di seguito viene fornito un esempio:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

40

Dimentica lo spazio dei nomi

È possibile rimuovere uno spazio dei nomi importato utilizzando forgetsottocomando. Di seguito viene mostrato un semplice esempio:

#!/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::*

Quando il codice sopra viene eseguito, produce il seguente risultato:

40

Tcl supporta la gestione dei file con l'aiuto dei comandi incorporati open, read, put, gets e close.

Un file rappresenta una sequenza di byte, non importa se si tratta di un file di testo o di un file binario.

Apertura di file

Tcl usa il comando open per aprire i file in Tcl. La sintassi per aprire un file è la seguente:

open fileName accessMode

Qui, filename è una stringa letterale, che verrà utilizzata per denominare il file e accessMode può avere uno dei seguenti valori:

Sr.No.	Modalità e descrizione
1	r Apre un file di testo esistente a scopo di lettura e il file deve esistere. Questa è la modalità predefinita utilizzata quando non è specificato accessMode.
2	w Apre un file di testo per la scrittura, se non esiste, viene creato un nuovo file altrimenti il ​​file esistente viene troncato.
3	a Apre un file di testo per la scrittura in modalità di aggiunta e il file deve esistere. Qui, il tuo programma inizierà ad aggiungere contenuto al contenuto del file esistente.
4	r+ Apre un file di testo per leggere e scrivere entrambi. Il file deve esistere già.
5	w+ Apre un file di testo per leggere e scrivere entrambi. Prima tronca il file a lunghezza zero se esiste, altrimenti crea il file se non esiste.
6	a+ Apre un file di testo per leggere e scrivere entrambi. Crea il file se non esiste. La lettura inizierà dall'inizio, ma la scrittura può essere solo aggiunta.

Chiusura di un file

Per chiudere un file, usa il comando close. La sintassi per la chiusura è la seguente:

close fileName

Qualsiasi file che è stato aperto da un programma deve essere chiuso quando il programma termina di utilizzare quel file. Nella maggior parte dei casi, i file non devono essere chiusi esplicitamente; vengono chiusi automaticamente quando gli oggetti File vengono terminati automaticamente.

Scrivere un file

Il comando Puts viene utilizzato per scrivere su un file aperto.

puts $filename "text to write"

Di seguito è mostrato un semplice esempio per la scrittura su un file.

#!/usr/bin/tclsh

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

Quando il codice precedente viene compilato ed eseguito, crea un nuovo file input.txt nella directory in cui è stato avviato (nella directory di lavoro del programma).

Leggere un file

Di seguito è riportato il semplice comando per leggere da un file:

set file_data [read $fp]

Di seguito è riportato un esempio completo di lettura e scrittura:

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

Quando il codice precedente viene compilato ed eseguito, legge il file creato nella sezione precedente e produce il seguente risultato:

test

Ecco un altro esempio per leggere il file fino alla fine del file riga per riga:

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

Quando il codice precedente viene compilato ed eseguito, legge il file creato nella sezione precedente e produce il seguente risultato:

test
test

La gestione degli errori in Tcl è fornita con l'aiuto di error e catchcomandi. La sintassi per ciascuno di questi comandi è mostrata di seguito.

Sintassi dell'errore

error message info code

Nella sintassi del comando di errore precedente, message è il messaggio di errore, le informazioni sono impostate nella variabile globale errorInfo e il codice è impostato nella variabile globale errorCode.

Sintassi di cattura

catch script resultVarName

Nella sintassi del comando catch sopra, script è il codice da eseguire, resultVarName è la variabile che contiene l'errore o il risultato. Il comando catch restituisce 0 se non ci sono errori e 1 se c'è un errore.

Di seguito è riportato un esempio per la semplice gestione degli errori:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Result = 5

Come puoi vedere nell'esempio sopra, possiamo creare i nostri messaggi di errore personalizzati. Allo stesso modo, è possibile rilevare l'errore generato da Tcl. Di seguito è mostrato un esempio:

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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 fornisce una serie di funzioni (procedure) integrate per varie operazioni. Ciò include:

• Funzioni per la gestione delle liste .

• Funzioni per la gestione delle stringhe .

• Funzioni per la gestione degli array .

• Funzioni per la gestione del dizionario .

• Funzioni per la gestione dell'I / O di file .

• Funzioni per la creazione di spazi dei nomi e pacchetti.

• Funzioni per operazioni matematiche.

• Funzioni per le operazioni di sistema.

Ciascuno dei precedenti, ad eccezione delle funzioni matematiche e di sistema, è stato trattato nei capitoli precedenti. Le funzioni matematiche e di sistema integrate sono spiegate di seguito.

Funzioni matematiche

Le funzioni matematiche disponibili in Tcl sono elencate nella tabella seguente:

Sr.No.	Metodo e descrizione
1	abs arg Calcola il valore assoluto di arg.
2	acos arg Calcola l'arcocoseno di arg.
3	asin arg Calcola l'arcoseno di arg.
4	atan arg Calcola l'arcotangente di arg.
5	atan2 yx Calcola l'arcotangente del quoziente dei suoi argomenti (y / x).
6	ceil arg Calcola il numero intero più piccolo maggiore o uguale a un numero.
7	cos arg Calcola il coseno di arg.
8	cosh arg Calcola il coseno iperbolico di arg.
9	double arg Calcola se arg è un valore a virgola mobile, restituisce arg, altrimenti converte arg in virgola mobile e restituisce il valore convertito.
10	exp arg Calcola una funzione esponenziale (e elevata alla potenza di arg).
11	floor arg Calcola il numero intero più grande minore o uguale a arg.
12	fmod xy Calcola il resto in virgola mobile della divisione di x per y. Se y è 0, viene restituito un errore.
13	hypot xy Calcola la lunghezza dell'ipotenusa di un triangolo rettangolo sqrt (x * x + y * y).
14	int arg Calcola se arg è un valore intero della stessa larghezza della parola macchina, restituisce arg, altrimenti converte arg in un numero intero.
15	log arg Calcola il logaritmo naturale di arg.
16	log10 arg Calcola il logaritmo in base 10 di arg.
17	pow xy Calcola il valore di x elevato alla potenza y. Se x è negativo, y deve essere un valore intero.
18	rand Calcola un numero pseudocasuale compreso tra 0 e 1.
19	round arg Calcola il valore di arg arrotondato al numero intero più vicino.
20	sin arg Calcola il seno di arg.
21	sinh arg Calcola il seno iperbolico di arg.
22	sqrt arg Calcola la radice quadrata di arg. arg deve essere positivo.
23	srand arg Calcola un numero pseudo-casuale compreso tra 0 e 1. L'arg, che deve essere un numero intero, viene utilizzato per reimpostare il seme per il generatore di numeri casuali di rand.
24	tan arg Calcola la tangente di arg.
25	tanh arg Calcola la tangente iperbolica di arg.
26	wide arg Calcola un valore intero di almeno 64 bit (per estensione del segno se arg è un numero a 32 bit) per arg se non lo è già.

Di seguito vengono forniti alcuni esempi di utilizzo delle funzioni matematiche:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

0.6483608274590866
100.0
11.0
22.360679774997898
0.0003521866166741525
2.302585092994046
0.0003521866166741525

Funzioni di sistema

Le importanti funzioni di sistema in Tcl includono,

• clock - funzione secondi, che restituisce l'ora corrente in secondi.

• clock - funzione di formattazione, che formatta i secondi in data e ora.

• clock - funzione di scansione, che scansiona la stringa di input e la converte in secondi.

• open - funzione, che viene utilizzata per aprire un file.

• exec - funzione, che viene utilizzata per eseguire un comando di sistema.

• close - funzione, che viene utilizzata per chiudere un file.

Alcuni esempi per le funzioni di cui sopra sono elencati di seguito:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

La tabella seguente fornisce le stringhe di elenco che possono essere utilizzate per formattare la data e l'ora.

Sr.No.	Formato e descrizione
1	%a Giorno in forma abbreviata, ad esempio: sole.
2	%A Giorno in forma completa, ad esempio: domenica.
3	%b Mese in forma abbreviata.
4	%B Mese in forma completa.
5	%d Giorno del mese.
6	%j Julian giorno dell'anno.
7	%m Mese in numero.
8	%y Anno in due cifre.
9	%Y Anno in quattro cifre.
10	%H Ora in formato 24 ore.
11	%I Ora in 12 ore.
12	%M Minuti.
13	%S Secondi.
14	%p Antimeridiane o pomeridiane.
15	%D Data in numero, mm / gg / aa.
16	%r Tempo in 12 ore.
17	%R Tempo in 24 ore senza secondi.
18	%T Tempo in formato 24 ore con secondi.
19	%Z Nome del fuso orario come GMT, IST, EST e così via.

Il comando "regexp" viene utilizzato per trovare una corrispondenza con un'espressione regolare in Tcl. Un'espressione regolare è una sequenza di caratteri che contiene un modello di ricerca. Consiste di più regole e la tabella seguente spiega queste regole e il relativo utilizzo.

Sr.No.	Regola e descrizione
1	x Corrispondenza esatta.
2	[a-z] Qualsiasi lettera minuscola da az.
3	. Qualsiasi personaggio.
4	^ La stringa iniziale dovrebbe corrispondere.
5	$ La stringa finale dovrebbe corrispondere.
6	\^ Sequenza di backlash in modo che corrisponda a caratteri speciali ^. Allo stesso modo è possibile utilizzare per altri caratteri.
7	() Aggiungi le sequenze sopra tra parentesi per creare un'espressione regolare.
8	x* Deve corrispondere a 0 o più occorrenze della x precedente.
9	x+ Deve corrispondere a 1 o più occorrenze della x precedente.
10	[a-z]? Deve corrispondere a 0 o 1 occorrenza della x precedente.
11	{digit} Corrisponde esattamente alle occorrenze di cifre della precedente espressione regex. Cifra che contiene 0-9.
12	{digit,} Corrisponde a 3 o più occorrenze di cifre della precedente espressione regex. Cifra che contiene 0-9.
13	{digit1,digit2} Occurrences corrisponde all'intervallo tra digit1 e digit2 occorrenze della precedente espressione regex.

Sintassi

La sintassi per regex è fornita di seguito:

regexp optionalSwitches patterns searchString fullMatch subMatch1 ... subMatchn

Qui, regex è il comando. Vedremo più avanti degli interruttori opzionali. I modelli sono le regole come accennato in precedenza. La stringa di ricerca è la stringa effettiva su cui viene eseguita la regex. La corrispondenza completa è qualsiasi variabile per contenere il risultato del risultato dell'espressione regolare abbinata. Da SubMatch1 a SubMatchn sono variabili subMatch facoltative che contengono il risultato di modelli di corrispondenza secondaria.

Diamo un'occhiata ad alcuni semplici esempi prima di immergerci in quelli complessi. Un semplice esempio per una stringa con qualsiasi alfabeto. Quando qualsiasi altro personaggio incontra la regex, la ricerca verrà interrotta e restituita.

#!/usr/bin/tclsh

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

Full Match: Tcl
Sub Match1: Tcl

Pattern multipli

L'esempio seguente mostra come cercare più modelli. Questo è un modello di esempio per qualsiasi alfabeto seguito da qualsiasi carattere seguito da qualsiasi alfabeto.

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Di seguito è mostrata una versione modificata del codice precedente per mostrare che un sotto pattern può contenere più pattern:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Opzioni per il comando Regex

L'elenco degli interruttori disponibili in Tcl sono,

• nocase - Usato per ignorare le maiuscole.

• indices - Memorizza la posizione dei modelli secondari abbinati invece dei caratteri abbinati.

• line- Nuova corrispondenza sensibile alla linea. Ignora i caratteri dopo la nuova riga.

• start index - Imposta l'offset dell'inizio del modello di ricerca.

• Contrassegna la fine degli interruttori

Negli esempi precedenti, ho usato deliberatamente [AZ, az] per tutti gli alfabeti, puoi facilmente usare -nocase invece di come mostrato di seguito -

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Un altro esempio di utilizzo degli interruttori è mostrato di seguito:

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

Quando il codice sopra viene eseguito, produce il seguente risultato:

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

Tk si riferisce a Toolkit e fornisce widget GUI multipiattaforma, che ti aiutano a costruire un'interfaccia utente grafica. È stato sviluppato come estensione al linguaggio di scripting Tcl da John Ousterhout. Tk è rimasto in sviluppo indipendentemente da Tcl con versioni diverse l'una dall'altra, prima era sincronizzata con Tcl nella v8.0.

Caratteristiche di Tk

È multipiattaforma con supporto per i sistemi operativi Linux, Mac OS, Unix e Microsoft Windows.

• È un open source.
• Fornisce un alto livello di estensibilità.
• È personalizzabile.
• È configurabile.
• Fornisce un gran numero di widget.
• Può essere utilizzato con altri linguaggi dinamici e non solo con Tcl.
• La GUI sembra identica su tutte le piattaforme.

Applicazioni integrate in Tk

Grandi applicazioni di successo sono state costruite in Tcl / Tk.

• Interfaccia utente morbida del dashboard
• Forms GUI per DB relazionale
• GUI ad hoc per DB relazionale
• Progettazione di sistemi software / hardware
• Xtask - Gestione attività
• Musicologia con Tcl e Tk
• App Calendario
• Tk mail
• Tk Debugger

In generale, tutti i Mac e Linux vengono forniti con Tk preinstallato. Nel caso in cui non sia disponibile o sia necessaria la versione più recente, potrebbe essere necessario installarla. Windows non viene fornito con Tcl / Tk e potrebbe essere necessario utilizzare il suo binario specifico per installarlo.

L'interprete Tk

È solo un piccolo programma che ti consente di digitare comandi Tk e di eseguirli riga per riga. Arresta l'esecuzione di un file tcl nel caso in cui incontri un errore a differenza di un compilatore che viene eseguito completamente.

Facciamo un file helloWorld.tcl come segue. Lo useremo come primo programma, eseguiremo sulla piattaforma che scegli.

#!/usr/bin/wish

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

La sezione seguente spiega solo come installare Tcl / Tk su ciascuna delle piattaforme disponibili.

Installazione su Windows

Scarica l'ultima versione per il programma di installazione di Windows dall'elenco dei binari Tcl / Tk attivi disponibili. Active Tcl / Tk community edition è gratuita per uso personale.

Eseguire l'eseguibile scaricato per installare Tcl e Tk, operazione che può essere eseguita seguendo le istruzioni sullo schermo.

Ora possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando cd e quindi utilizzando il passaggio seguente:

C:\Tcl> wish helloWorld.tcl

Premi invio e vedremo un output come mostrato di seguito -

Installazione su Linux

La maggior parte dei sistemi operativi Linux viene fornita con Tk integrato e puoi iniziare subito con quei sistemi. Nel caso in cui non fosse disponibile, puoi utilizzare il seguente comando per scaricare e installare Tcl-Tk.

$ yum install tcl tk

Ora possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando cd command e quindi utilizzando il passaggio seguente:

$ wish helloWorld.tcl

Premi invio e vedremo un output simile al seguente:

Installazione su sistemi basati su Debian

Nel caso in cui non sia disponibile precostruito nel tuo sistema operativo, puoi utilizzare il seguente comando per scaricare e installare Tcl-Tk -

$ sudo apt-get install tcl tk

Ora possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando cd command e quindi utilizzando i seguenti passaggi:

$ wish helloWorld.tcl

Premi invio e vedremo un output simile al seguente:

Installazione su Mac OS X

Scarica l'ultima versione per il pacchetto Mac OS X dall'elenco dei binari Tcl / Tk attivi disponibili. L'edizione della community Active Tcl è gratuita per uso personale.

Eseguire l'eseguibile scaricato per installare Active Tcl, operazione che può essere eseguita seguendo le istruzioni sullo schermo.

Ora possiamo creare ed eseguire un file Tcl, ad esempio helloWorld.tcl, passando alla cartella contenente il file utilizzando cd command e quindi utilizzando il passaggio seguente:

$ wish helloWorld.tcl

Premi invio e vedremo un output come mostrato di seguito -

Installazione da file di origine

È possibile utilizzare l'opzione di installazione dai file di origine quando un pacchetto binario non è disponibile. In genere è preferibile utilizzare i binari Tk per Windows e Mac OS X, quindi di seguito viene mostrata solo la compilazione dei sorgenti su un sistema basato su unix -

• Scarica i file sorgente.

• Ora, usa i seguenti comandi per estrarre, compilare e costruire dopo essere passato alla cartella scaricata.

$ 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 - Assicurati di cambiare il nome del file con la versione che hai scaricato sui comandi 1 e 2 sopra.

In Tk, classifichiamo alcune delle variabili come variabili speciali e hanno un utilizzo / funzionalità predefinito. Di seguito è riportato l'elenco delle variabili speciali.

Sr.No.	Variabile speciale e descrizione
1	tk_library Utilizzato per impostare la posizione delle librerie Tk standard.
2	tk_patchLevel Si riferisce al livello di patch corrente dell'interprete Tk.
3	tk_strictMotif Quando è diverso da zero, Tk cerca di aderire al look and feel di Motif il più fedelmente possibile.
4	tk_version Visualizza la versione Tk.

Le variabili speciali di cui sopra hanno i loro significati speciali per l'interprete Tk.

Esempi di utilizzo di variabili speciali Tk

Vediamo gli esempi per variabili speciali.

VERSIONE TK

#!/usr/bin/wish

puts $tk_version

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito.

8.5

PERCORSO LIBRERIA TK

#!/usr/bin/wish

puts $tk_library

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito.

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

TK PATCH LEVEL

#!/usr/bin/wish

puts $tk_patchLevel

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito.

8.6.1

TK STRICTMOTIF

#!/usr/bin/wish

puts $tk_strictMotif

Quando esegui il programma, otterrai un output simile a quello mostrato di seguito.

0

Il componente di base di un'applicazione basata su Tk è chiamato widget. Un componente è talvolta chiamato anche una finestra, poiché, in Tk, "finestra" e "widget" sono spesso usati in modo intercambiabile. Tk è un pacchetto che fornisce un ricco set di componenti grafici per la creazione di applicazioni grafiche con Tcl.

Tk fornisce una gamma di widget che vanno dai widget GUI di base come pulsanti e menu ai widget per la visualizzazione dei dati. I widget sono molto configurabili in quanto hanno configurazioni predefinite che li rendono facili da usare.

Le applicazioni Tk seguono una gerarchia di widget in cui è possibile posizionare un numero qualsiasi di widget all'interno di un altro widget e questi widget all'interno di un altro widget. Il widget principale in un programma Tk è denominato widget di root e può essere creato creando una nuova istanza della classe TkRoot.

Creazione di un widget

Di seguito viene fornita la sintassi per la creazione di un widget.

type variableName arguments options

Il tipo qui si riferisce al tipo di widget come pulsante, etichetta e così via. Gli argomenti possono essere facoltativi e obbligatori in base alla sintassi individuale di ciascun widget. Le opzioni variano dalla dimensione alla formattazione di ogni componente.

Convenzione di denominazione dei widget

Widget utilizza una struttura simile alla denominazione dei pacchetti. In Tk, la finestra principale è denominata con un punto (.) E un elemento nella finestra, ad esempio button è denominato .myButton1. Il nome della variabile deve iniziare con una lettera minuscola, una cifra o un segno di punteggiatura (tranne un punto). Dopo il primo carattere, altri caratteri possono essere lettere maiuscole o minuscole, numeri o segni di punteggiatura (tranne i punti). Si consiglia di utilizzare una lettera minuscola per iniziare l'etichetta.

Convenzione sulla denominazione dei colori

I colori possono essere dichiarati usando nomi come rosso, verde e così via. Può anche utilizzare la rappresentazione esadecimale con #. Il numero di cifre esadecimali può essere 3, 6, 9 o 12.

Convenzione dimensionale

L'unità predefinita è pixel e viene utilizzata quando non specifichiamo alcuna dimensione. Le altre dimensioni sono i per pollici, m per millimetri, c per centimetri ep per punti.

Opzioni comuni

Ci sono così tante opzioni comuni disponibili per tutti i widget e sono elencate di seguito nella tabella seguente:

Sr.No.	Sintassi e descrizione
1	-background color Utilizzato per impostare il colore di sfondo per il widget.
2	-borderwidth width Utilizzato per disegnare con il bordo negli effetti 3D.
3	-font fontDescriptor Utilizzato per impostare il carattere per il widget.
4	-foreground color Utilizzato per impostare il colore di primo piano per il widget.
5	-height number Utilizzato per impostare l'altezza del widget.
6	-highlightbackground color Utilizzato per impostare il rettangolo di colore da disegnare attorno a un widget quando il widget non ha il focus di input.
7	-highlightcolor color Utilizzato per impostare il rettangolo di colore da disegnare attorno a un widget quando il widget ha il focus di input.
8	-padx number Imposta il padx per il widget.
9	-pady number Imposta il pady per il widget.
10	-relief condition Imposta lo scarico 3D per questo widget. La condizione può essere sollevata, infossata, piatta, cresta, solida o solcata.
11	-text text Imposta il testo per il widget.
12	-textvariable varName Variabile associata al widget. Quando il testo del widget cambia, la variabile viene impostata con il testo del widget.
13	-width number Imposta la larghezza per il widget.

Di seguito è mostrato un semplice esempio di opzioni.

#!/usr/bin/wish

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

Quando eseguiamo il programma sopra, otterremo il seguente output.

L'elenco dei widget disponibili è classificato di seguito:

Widget di base

Sr.No.	Widget e descrizione
1	Label Widget per la visualizzazione di una singola riga di testo.
2	Button Widget cliccabile e che attiva un'azione.
3	Entry Widget utilizzato per accettare una singola riga di testo come input.
4	Message Widget per la visualizzazione di più righe di testo.
5	Text Widget per la visualizzazione e la modifica facoltativa di più righe di testo.
6	Toplevel Finestra con tutti i bordi e le decorazioni fornite dal Window manager.

Widget di layout

Sr.No.	Widget e descrizione
1	Frame Widget contenitore per contenere altri widget.
2	Place Widget per tenere altri widget in un luogo specifico con le coordinate della sua origine e una dimensione esatta.
3	Pack Widget semplice per organizzare i widget in blocchi prima di posizionarli nel widget genitore.
4	Grid Widget per annidare i widget che si impacchettano in direzioni diverse.

Widget di selezione

Sr.No.	Widget e descrizione
1	Radiobutton Widget che ha una serie di pulsanti ed etichette di attivazione / disattivazione, una delle quali può essere selezionata.
2	Checkbutton Widget con una serie di pulsanti ed etichette di attivazione / disattivazione, molti dei quali possono essere selezionati.
3	Menu Widget che funge da supporto per le voci di menu.
4	Listbox Widget che mostra un elenco di celle, una o più delle quali possono essere selezionate.

Mega widget

Sr.No.	Widget e descrizione
1	Dialog Widget per la visualizzazione delle finestre di dialogo.
2	Spinbox Widget che consente agli utenti di scegliere i numeri.
3	Combobox Widget che combina una voce con un elenco di scelte disponibili per l'uso.
4	Notebook Widget a schede che aiuta a passare da una pagina all'altra, utilizzando una scheda indice.
5	Progressbar Widget per fornire un feedback visivo sullo stato di avanzamento di una lunga operazione come il caricamento di file.
6	Treeview Widget per visualizzare e consentire la navigazione attraverso una gerarchia di elementi più sotto forma di albero.
7	Scrollbar Widget a scorrimento senza testo o widget di tela.
8	Scale Widget di scala per scegliere un valore numerico tramite i cursori.

Altri widget

Sr.No.	Widget e descrizione
1	Canvas Widget di disegno per la visualizzazione di grafici e immagini ..

Tratteremo ciascuno di questi widget nei prossimi capitoli.

I widget di base sono widget comuni disponibili in quasi tutte le applicazioni Tk. Di seguito è riportato l'elenco dei widget di base disponibili:

Sr.No.	Widget e descrizione
1	Etichetta Widget per la visualizzazione di una singola riga di testo.
2	Pulsante Widget cliccabile e che attiva un'azione.
3	Iscrizione Widget utilizzato per accettare una singola riga di testo come input.
4	Messaggio Widget per la visualizzazione di più righe di testo.
5	Testo Widget per la visualizzazione e la modifica facoltativa di più righe di testo.
6	Toplevel Widget utilizzato per creare una cornice che è una nuova finestra di primo livello.

Di seguito viene mostrato un semplice esempio di Tk utilizzando i widget di base:

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

I widget di layout vengono utilizzati per gestire i layout per l'applicazione Tk. Il widget Frame viene utilizzato per raggruppare altri widget e luogo, pacchetto e griglia sono gestori di layout per darti il ​​controllo totale sull'aggiunta a Windows. L'elenco dei widget di layout disponibili è mostrato di seguito:

Sr.No.	Widget e descrizione
1	Telaio Widget contenitore per contenere altri widget.
2	Posto Widget per tenere altri widget in un luogo specifico con le coordinate della sua origine e una dimensione esatta.
3	Confezione Widget semplice per organizzare i widget in blocchi prima di posizionarli nel widget genitore.
4	Griglia Widget per annidare i widget che si impacchettano in direzioni diverse.

Di seguito viene mostrato un semplice esempio di Tk per i widget di layout:

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

I widget di selezione vengono utilizzati per selezionare diverse opzioni in un'applicazione Tk. L'elenco dei widget di selezione disponibili è mostrato di seguito.

Sr.No.	Widget e descrizione
1	Radiobutton Widget che ha una serie di pulsanti ed etichette di attivazione / disattivazione, una delle quali può essere selezionata.
2	Pulsante di spunta Widget con una serie di pulsanti ed etichette di attivazione / disattivazione, molti dei quali possono essere selezionati.
3	Menù Widget che funge da supporto per le voci di menu.
4	Listbox Widget che mostra un elenco di celle, una o più delle quali possono essere selezionate.

Di seguito viene mostrato un semplice esempio di Tk utilizzando i widget di selezione:

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

La tela viene utilizzata per fornire aree di disegno. La sintassi per il widget canvas è mostrata di seguito:

canvas canvasName options

Opzioni

Le opzioni disponibili per il widget canvas sono elencate di seguito nella tabella seguente:

Sr.No.	Sintassi e descrizione
1	-background color Utilizzato per impostare il colore di sfondo per il widget.
2	-closeenough distance Imposta la vicinanza del cursore del mouse a un elemento visualizzabile. L'impostazione predefinita è 1.0 pixel. Questo valore può essere una frazione e deve essere positivo.
3	-scrollregion boundingBox Il riquadro di delimitazione per l'area totale di questa tela.
4	-height number Utilizzato per impostare l'altezza del widget.
5	-width number Imposta la larghezza per il widget.
6	-xscrollincrement size La quantità da scorrere orizzontalmente quando si richiede lo scorrimento.
7	-yscrollincrement size La quantità da scorrere verticalmente quando lo scorrimento è richiesto.

Di seguito è mostrato un semplice esempio di widget canvas:

#!/usr/bin/wish

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

Widget per disegnare su tela

Di seguito è riportato l'elenco dei widget disponibili per il disegno su tela:

Sr.No.	Widget e descrizione
1	Linea Disegna una linea.
2	Arco Disegna un arco.
3	Rettangolo Disegna un rettangolo.
4	Ovale Disegna un ovale.
5	Poligono Disegna un poligono.
6	Testo Disegna un testo.
7	Bitmap Disegna una bitmap.
8	Immagine Disegna un'immagine.

Di seguito è mostrato un esempio che utilizza diversi widget canvas:

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

I mega widget includono molti widget complessi che sono spesso richiesti in alcune applicazioni Tk su larga scala. L'elenco dei mega widget disponibili è mostrato di seguito:

Sr.No.	Widget e descrizione
1	Dialogo Widget per la visualizzazione delle finestre di dialogo.
2	Spinbox Widget che consente agli utenti di scegliere i numeri.
3	Combo box Widget che combina una voce con un elenco di scelte disponibili per l'uso.
4	Taccuino Widget a schede che aiuta a passare da una pagina all'altra, utilizzando una scheda indice.
5	Barra di avanzamento Widget per fornire un feedback visivo sullo stato di avanzamento di una lunga operazione come il caricamento di file.
6	Visualizzazione ad albero Widget per visualizzare e consentire la navigazione attraverso una gerarchia di elementi più sotto forma di albero.
7	Barra di scorrimento Widget a scorrimento senza testo o widget di tela.
8	Scala Widget di scala per scegliere un valore numerico tramite i cursori.

Di seguito viene mostrato un semplice esempio di Tk utilizzando alcuni mega widget.

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

Esistono numerosi widget che supportano la visualizzazione del testo. La maggior parte di questi fornisce l'opzione dell'attributo font. La sintassi per la creazione di un carattere è mostrata di seguito:

font create fontName options

Opzioni

Le opzioni disponibili per la creazione del carattere sono elencate di seguito nella tabella seguente:

Sr.No.	Sintassi e descrizione
1	-family familyName Il nome della famiglia di caratteri.
2	-size number La dimensione del carattere.
3	-weight level Il peso per il carattere.

Di seguito è mostrato un semplice esempio per la creazione di un carattere:

#!/usr/bin/wish

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

Per ottenere tutti i caratteri disponibili, possiamo utilizzare il seguente comando:

#!/usr/bin/wish

puts [font families]

Quando eseguiamo il comando precedente, otterremo il seguente output:

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

Il widget immagine viene utilizzato per creare e manipolare le immagini. La sintassi per la creazione dell'immagine è la seguente:

image create type name options

Nella sintassi precedente il tipo è foto o bitmap e il nome è l'identificatore dell'immagine.

Opzioni

Le opzioni disponibili per la creazione dell'immagine sono elencate di seguito nella tabella seguente:

Sr.No.	Sintassi e descrizione
1	-file fileName Il nome del nome del file di immagine.
2	-height number Utilizzato per impostare l'altezza del widget.
3	-width number Imposta la larghezza per il widget.
4	-data string Immagine in stringa codificata in base 64.

Di seguito è mostrato un semplice esempio di widget immagine:

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

Le funzioni disponibili per l'immagine sono elencate di seguito nella tabella seguente:

Sr.No.	Sintassi e descrizione
1	image delete imageName Elimina visivamente l'immagine dalla memoria e dai widget correlati.
2	image height imageName Restituisce l'altezza dell'immagine.
3	image width imageName Restituisce la larghezza dell'immagine.
4	image type imageName Restituisce il tipo di immagine.
5	image names Restituisce l'elenco delle immagini dal vivo in memoria.

Di seguito è mostrato un semplice esempio per l'utilizzo dei comandi del widget immagine sopra:

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

L'immagine verrà cancellata visivamente e dalla memoria una volta eseguito il comando "image delete imgobj". In console, l'output sarà il seguente:

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

Gli eventi nella loro forma più semplice vengono gestiti con l'aiuto di comandi. Un semplice esempio per la gestione degli eventi è la gestione degli eventi con il pulsante ed è mostrato di seguito:

#!/usr/bin/wish

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

Di seguito è mostrato un semplice programma per mostrare l'evento di animazione del testo di ritardo:

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

Quando eseguiamo il programma, otterremo il seguente output in modo animato:

Evento dopo ritardo

La sintassi per l'evento dopo il ritardo è mostrata di seguito:

after milliseconds number command

Di seguito è mostrato un semplice programma da mostrare dopo un evento di ritardo:

#!/usr/bin/wish

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

Quando eseguiamo il programma, dopo un secondo otterremo il seguente output:

È possibile annullare un evento utilizzando il comando after cancel come mostrato di seguito:

#!/usr/bin/wish

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

Associazione di eventi

La sintassi per l'associazione di eventi è la seguente:

bind arguments

Esempio di eventi da tastiera

#!/usr/bin/wish

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

Quando eseguiamo il programma e premiamo una lettera X, otterremo il seguente output:

Key Pressed: X

Esempio di eventi del mouse

#!/usr/bin/wish

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

Quando eseguiamo il programma e premiamo il pulsante sinistro del mouse, otterremo un output simile al seguente:

Button 1 Pressed : 89 90

Esempio di collegamento di eventi con pulsante

#!/usr/bin/wish

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

Quando eseguiamo il programma e premiamo Invio, otterremo il seguente output:

Event triggered

Il gestore delle finestre viene utilizzato per gestire la finestra di primo livello. Aiuta a controllare le dimensioni, la posizione e altri attributi della finestra. In Tk,. viene utilizzato per fare riferimento alla finestra principale. La sintassi per il comando della finestra è mostrata di seguito:

wm option window arguments

L'elenco delle opzioni disponibili per il comando Tk wm è mostrato nella seguente tabella:

Sr.No.	Sintassi e descrizione
1	aspect windowName a b c d Cerca di mantenere il rapporto larghezza / altezza compreso tra a / be c / d.
2	geometry windowName geometryParams Utilizzare per impostare la geometria per la finestra.
3	grid windowName w h dx dy Imposta la dimensione della griglia.
4	group windowName leaderName leaderName fornisce il leader di un gruppo di finestre correlate.
5	deiconify windowName Riporta lo schermo alla normalità se ridotto a icona.
6	iconify windowName Riduce a icona la finestra.
7	state windowName Restituisce lo stato corrente della finestra.
8	withdraw windowName Annulla la mappatura della finestra e rimuove i suoi dettagli in memoria.
9	iconbitmap windowName image Imposta o restituisce l'icona bitmap.
10	iconPhoto windowName image Imposta o restituisce la foto dell'icona.
11	command windowName commandString Registra il comando di avvio nella proprietà WM_COMMAND.
12	protocol windowName arguments Registra un comando per gestire il nome della richiesta di protocollo, che può essere WM_DELETE_WINDOW, WM_SAVE_YOURSELF, WM_TAKE_FOCUS. Ad esempio: protocollo wm. WM_DELETE_WINDOW Esci.
13	minsize windowName size Determina la dimensione minima della finestra.
14	maxsize windowName size Determina la dimensione massima della finestra.
15	title windowName titleText Determina il titolo per la finestra.
16	attributes subOptions Sono disponibili molti attributi come alpha, schermo intero e così via.

Alcuni dei comandi precedenti vengono utilizzati nel seguente esempio:

#!/usr/bin/wish

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

Quando eseguiamo il programma sopra, otterremo il seguente output:

Come puoi vedere alpha è uno degli attributi disponibili. Di seguito è riportato l'elenco dei sottocomandi di uso comune:

Sr.No.	Sintassi e descrizione
1	-alpha number Imposta l'alfa per la finestra.
2	-fullscreen number Il numero può essere 0 per lo schermo normale o 1 per lo schermo intero.
3	-topmost number Imposta o restituisce se la finestra è in primo piano. Il valore può essere 0 o 1.

Creazione della finestra

Possiamo usare il comando toplevel per creare la finestra e un esempio è mostrato sotto -

#!/usr/bin/wish

toplevel .t

Quando eseguiamo il programma sopra, otterremo il seguente output:

Finestra di distruzione

Possiamo usare il comando distruggi per distruggere la finestra e un esempio è mostrato sotto:

#!/usr/bin/wish

destroy .t

Il comando precedente distruggerà la finestra denominata .t.

Il gestore della geometria viene utilizzato per gestire la geometria della finestra e di altri telai. Possiamo usarlo per gestire la posizione e le dimensioni della finestra e dei telai. A tale scopo vengono utilizzati i widget di layout .

Posizionamento e dimensionamento

La sintassi per il posizionamento e la finestra di dimensionamento è mostrata di seguito:

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

Qui, w si riferisce alla larghezza e h si riferisce all'altezza. È seguito da un segno "+" o "-" con il numero successivo che fa riferimento alla posizione x sullo schermo. Allo stesso modo il seguente segno "+" o "-" con numero si riferisce alla posizione y sullo schermo

Di seguito viene mostrato un semplice esempio per la dichiarazione precedente -.

#!/usr/bin/wish

wm geometry . 300x200+100+100

Quando eseguiamo il programma sopra, otterremo il seguente output:

Geometria della griglia

La sintassi per la geometria della griglia è mostrata di seguito:

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

La colonna, la riga, l'intervallo di colonna o l'intervallo di righe aiuta a fornire la geometria della griglia.

Di seguito è mostrato un semplice esempio per la dichiarazione di cui sopra:

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

Quando eseguiamo il programma sopra, otterremo il seguente output: