Disegna.io- App gratuita, progettato per la modellazione di diagrammi e diagrammi di flusso dei processi aziendali. C'è un'opzione con cui integrarsi documenti Google, Dropbox, OneDrive, JIRA, Confluence, Chrome e GitHub. Il Confluence Server e il componente aggiuntivo JIRA Cloud sono componenti aggiuntivi a pagamento. La versione online per la sincronizzazione con Google Drive è disponibile in 2 versioni, con e senza il supporto di Google Apps. Oltre alla versione web, c'è un programma di installazione per PC che supporta Windows, MacOS e Linux.

L'applicazione sarà utile per manager e dirigenti di aziende che necessitano di uno strumento per costruire diagrammi di processi aziendali. Il servizio è adatto a professionisti le cui attività sono legate alla creazione di presentazioni e database, alla costruzione di diagrammi ingegneristici e di rete, alla progettazione di software.

Usando l'editor, puoi creare qualsiasi immagine schematica - dai diagrammi circuiti elettrici alle strutture del modello di business. Tra le possibilità - la costruzione di diagrammi, grafici e modelli UML. Ci sono dozzine di forme raggruppate in categorie nella libreria delle forme. Gli oggetti possono essere formattati modificando font, colore, sfumatura, spessore della linea, livello di trasparenza. Grazie alla possibilità di sincronizzarsi con Google Drive, più utenti possono lavorare su documenti contemporaneamente. Le immagini già pronte possono essere salvate su un disco rigido del PC o inserite in wiki e blog. I formati di esportazione disponibili sono PDF, GPG, SVG, XML e JPG.

Caratteristiche principali

• Integrazione gratuita con Servizi Google
• Integrazione a pagamento con Confluence e JIRA Cloud
• Client HTML con supporto per IE 6-8
• Supporto per smartphone e tablet
• Esporta documenti in Formati PDF, GPG, SVG, XML e JPG
• Applicazione offline per Windows, MacOS e Linux
• Supporta 27 lingue

Ho finalmente trovato quello che cercavo. Uno strumento di modellazione gratuito che supporta le capacità di descrizione dei processi aziendali - Draw.io

Disegna.ioè uno strumento per creare diagrammi e diagrammi di flusso online. Allo stesso tempo, un numero enorme di modelli che ti permettono di disegnare tutto ciò che il tuo cuore desidera. Strumenti Disegna.io ricorda molto MS Visio e forse realizzato per esso, tuttavia, l'applicazione da programma Microsoft pagato, e Servizio Online Disegna.io- completamente gratuito e, soprattutto non richiede registrazione.

Funzionalità simili sono già nella versione cloud, tuttavia si tratta di un sistema questo sistema a pagamento, anche se l'abbonamento è economico, ma è difficile competere con il gratuito.

Opinione su Disegna.io

E sebbene questo strumento non sia così buono in termini di metodologia, è possibile disegnare, soprattutto preimpostando una convenzione di modellazione per gli studenti del corso di formazione. E sebbene lo strumento non sia bello come quello gratuito, l'implementazione cloud lo rende competitivo.

Per creare un modello a blocchi online, tutto ciò che devi fare è creare un nuovo documento nel toolkit.

Nel pannello degli oggetti, come in MS Visio, è necessario selezionare una categoria e spostare l'oggetto nel campo del modello con il cursore del mouse. Ci sono molti oggetti, quindi sono abbastanza per creare un modello di processo aziendale completo (a differenza di , in cui l'insieme di oggetti e modelli è seriamente limitato).

Per collegare gli oggetti del modello tra loro, è necessario selezionare un oggetto e spostare il puntatore del mouse su un altro, dopodiché apparirà una bandiera verde che è necessario trascinare sull'oggetto.

Soprattutto, dopo aver creato un modello di processo aziendale, è possibile esportare sul proprio computer in formato immagine (PNG, GIF, JPG, PDF) attraverso il menu: File - Esporta.

E, naturalmente, la funzione cloud: il servizio Draw.io è sincronizzato con Google Drive, il che consente di salvare il progetto direttamente su Google Drive.

In generale, lo strumento mi è piaciuto, a quanto pare Disegna.io abbastanza adatto per il rendering di processi aziendali online. E sebbene non ci sia ancora quasi nessuna concorrenza nei grandi progetti a livello federale, per le piccole aziende che descrivono i loro processi aziendali, è uno strumento abbastanza adatto.

Il lavoro di qualsiasi ingegnere, specialista IT, marketer, analista aziendale, manager è associato alla necessità di creare vari diagrammi, diagrammi di flusso e grafici. Per questi scopi, ottimo il servizio “disegno”, disponibile al link.

Il suo principale vantaggio è che è gratuito. Non ci sono costi per l'utilizzo della risorsa, il che la rende ancora più piacevole. Inoltre, per un lavoro a tutti gli effetti, non è necessario registrarsi e passare attraverso il noioso processo di autorizzazione sul sito.

Entrando pagina iniziale scegli un percorso per salvare il progetto. I risultati finali possono essere archiviati su archiviazione remota - "clouds" ("Google Drive", "Dropbox", "OneDrive"), sulla risorsa "GitHub", sul disco rigido del "Device" o direttamente nell'ambiente per gestione dello sviluppo di applicazioni web e dei programmi Trello.

Per impostazione predefinita, la casella di controllo è selezionata per salvare le impostazioni selezionate in futuro.

Per semplificare il compito di familiarizzare con le funzionalità del servizio online, cambiamo la lingua dell'interfaccia facendo clic su "Lingua".

Dopo aver impostato la lingua richiesta, sarà necessario ricaricare la pagina affinché le modifiche abbiano effetto.

Passiamo ora alla creazione di un nuovo progetto, per il quale clicchiamo sul pulsante "Crea un nuovo diagramma", dopodiché avverrà il passaggio alla parte grafica del lavoro.

Puoi aprire un campo vuoto e creare tu stesso un diagramma, oppure utilizzare una libreria di vari modelli grafici. "Diagrammi di Ishikawa" (alias "coda di pesce"), "Schemi per descrivere i processi aziendali", "Grafici strutturali", "Diagrammi di flusso", " Circuiti elettrici”, “Blocchi di programma” - questa è solo una piccola parte di ciò che è già presente come spazi vuoti.

Di grande interesse per gli utenti è la possibilità di descrivere i processi aziendali utilizzando il servizio draw.io.

Per iniziare, seleziona "Grafico vuoto" dalla categoria del modello "Base".

A titolo di esempio, descriveremo i principali processi aziendali associati al lavoro di un moderno negozio online di piccole dimensioni.

Per la parte grafica del lavoro, abbiamo bisogno delle sezioni "BPMN General" e "BPMN Events".

Quando consideriamo un esempio, non approfondiremo le ristrette specifiche della promozione del negozio, il lavoro di un regista, un ottimizzatore di motori di ricerca, un gestore di contenuti, un amministratore di sistema, che sono anche direttamente coinvolti nella vita di un'impresa, ma per punto di partenza prenderemo in considerazione la ricezione di un ordine da parte del cliente e i passaggi che devono essere eseguiti dal lato dell'elaborazione.

Creiamo un evento sul diagramma: la ricezione di una domanda al gestore che gestisce il negozio online, per la quale trascineremo l'icona della busta che simboleggia la ricezione della domanda (messaggio in arrivo) e il contenitore "Attività" che descrive la reazione a l'appello.

Stabiliamo una connessione posizionando una freccia tra i due blocchi.

Per la comodità di utilizzare lo strumento online draw.io, c'è pannello superiore control, contenente i pulsanti per annullare azioni, ridimensionare, scorrere e gestire i livelli, nonché gli elementi più utilizzati (punti di controllo, frecce di collegamento).

Facendo doppio clic con il tasto sinistro del mouse, modificheremo il testo sul blocco, rinominando “Compito” in “Verifica disponibilità merce ordinata in magazzino”. È da questo passaggio che il gestore del negozio online dovrebbe iniziare l'analisi dell'ordine, poiché da esso dipendono ulteriori passaggi nella comunicazione con il cliente.

È logico presumere che il blocco successivo debba essere una condizione che determina la sequenza di azioni per i diversi risultati del controllo dei saldi di magazzino.

* È importante ricordare che i processi aziendali non sono scritti per la carta, ma per le persone comuni, i dipendenti dell'azienda. Più lo studio è dettagliato e dettagliato, meno errori si verificheranno in futuro. L'80% del successo della sua attuazione dipende dall'impostazione del compito.

Se la merce è in giacenza si può andare su “Verifica della correttezza dei dati inseriti dall'utente”, in caso negativo, su “Specificare la data esatta di consegna”. Per scrivere un commento sopra qualsiasi blocco o freccia, è necessario selezionare la scheda "Generale" e l'elemento "Testo". In questo caso si tratta di indicazioni di direzione "Sì/no".

Analizziamo il ramo negativo e inseriamo nel diagramma tutti gli ulteriori passaggi dell'azione.

Un blocco ausiliario “Contatta il fornitore, richiedi il tempo esatto di consegna”, due principali “Pick up opzioni alternative merce in giacenza e proponibile in sostituzione”, “Verifica della correttezza dei dati utente inseriti” e il blocco di comunicazione con il cliente “Contattare telefonicamente e discutere i dettagli di consegna”. È importante essere preparati in anticipo per qualsiasi risultato e quindi elaborare alternative. Nel nostro caso, abbiamo creato un processo aziendale nel servizio draw.io associato a una selezione di alternative, che aiuterà a fidelizzare il cliente in caso di disaccordo con i tempi di consegna. I blocchi ausiliari vengono visualizzati come una linea tratteggiata, disponibile nella scheda "BPMN General".

Se il negozio sta lavorando sulla fidelizzazione dei propri clienti, è possibile aggiungere un ulteriore blocco relativo all'erogazione di uno sconto personale su un prodotto alternativo, se le scadenze sono ritardate per colpa del negozio online (ad esempio , le merci rimanenti sono state visualizzate in modo errato (sul sito "disponibile" e, infatti, le merci sono terminate)).

Ora resta da aggiungere un'altra condizione: "Il cliente accetta l'ordine". In questa fase si decide l'esito di tutte le attività, oppure l'ordine va in elaborazione per poi passare al "Servizio di Fornitura", oppure il gestore chiude l'ordine, proponendosi di ricevere una notifica di ricevimento della merce in giacenza per il visitatore del sito che ha lasciato l'applicazione.

Pertanto, dopo aver trascorso solo 5 minuti di tempo, abbiamo elaborato i processi aziendali nel servizio draw.io relativo al responsabile vendite. Allo stesso modo, puoi redigere schemi su fogli separati per il resto dei reparti coinvolti nelle attività del negozio online, nonché riassumere tutti i servizi dell'azienda nel suo insieme.

Per aprire un documento in futuro, basta andare sul sito web del servizio e, selezionando "Apri un diagramma esistente", trovare il progetto xml precedentemente salvato.

Oltre ai risultati finali nel formato precedentemente specificato, è possibile esportare diagrammi e diagrammi in formato pdf e documenti html, nonché sotto forma di immagini e grafica vettoriale(SVG).

Recentemente, è diventato possibile scaricare draw.io come programma su un PC (funziona su operation Sistemi Windows, MacOs, Chrome OS, Linux) e installa come app mobile che funziona sia su iOS che su Android.

A tal fine è necessario cliccare sul pulsante "Avanzate" del pannello di controllo e selezionare "Download" nel menu che si apre.

Le informazioni presentate nella recensione sono sufficienti per iniziare a lavorare al tuo progetto, indipendentemente dal settore, dal campo di attività o dalla produzione a cui appartiene, che si tratti di programmazione, amministrazione, progettazione, gestione, distribuzione o fornitura, ecc.

In caso di difficoltà, puoi sempre leggere le istruzioni e la documentazione ufficiale fornite sul sito web del servizio online.

Ciao, caro Habrazhitel. Presento alla vostra attenzione la traduzione dell'articolo From Draw.io to Vue.js app di Francesco Zuppichini.

Questa è la mia prima pubblicazione su Habré e ho deciso di iniziare traducendo un articolo su uno strumento interessante che consente di generare un'applicazione Vue.js da un diagramma UML.
Sorpreso? Sono rimasto solo stupito quando mi sono imbattuto in esso.

Naturalmente, come in ogni versione beta, c'è qualcosa su cui lavorare. Ad esempio, la prima cosa che ho contattato l'autore e detto che voglio apportare correzioni alla struttura del modello del componente e alla denominazione del percorso. L'autore si è messo in contatto entro un'ora, ha pubblicato il codice su GitHub e ha scritto un piccolo tutorial. Dopo aver accettato il PR, è stato ottenuto il permesso di tradurre l'articolo, con un collegamento all'originale.

A chi è interessante - chiedo sotto kat.

Da Draw.io all'app Vue.js

Creare un'app dovrebbe essere facile come disegnare un grafico in draw.io
Francesco Saverio

E se ti dicessi che puoi trasformare questo:

Il risultato è un progetto Vue.js con tutti i file e le importazioni necessarie per iniziare a creare il tuo fantastico prodotto. Bello, sì?

Ho realizzato un breve video dimostrativo che puoi guardare qui:

Un'applicazione web è solo un grafico

Ogni applicazione web può essere espressa come un grafico
Pensiamo un po'. Quando usi un framework come React, Angular o Vue, hai sempre un componente root.

Nel nostro esempio, il componente radice è il componente App, tutto il resto è solo un nodo grafico. Possiamo identificarci al primo livello Casa e nodi di indice come figli diretti App.

Uno standard comune nello sviluppo di applicazioni Web consiste nel memorizzare i componenti in una struttura di directory basata su grafici. Pertanto, di solito viene creata una directory con lo stesso nome per ogni componente, in cui si trovano il componente stesso e tutti i suoi figli.

Per esempio, Indiceè la radice del sottografo autocomposto, utente e Inviare. Pertanto, ha senso imitare questa astrazione nelle strutture dell'applicazione.

Ciò fornisce due vantaggi: scalabilità, poiché i sottografi sono indipendenti e facile comprensione della struttura e della logica dell'applicazione.

Inoltre, si può sempre vedere struttura complessiva applicazioni semplicemente guardando il grafico.

Dal grafico all'applicazione

Quindi abbiamo detto che ogni applicazione web è in realtà un grafico, quindi possiamo generarli da esso.

Dopotutto, ogni file che inizia con un grafico è semplice. Devi solo trovare l'intersezione dell'albero e creare ogni file nella sua directory principale locale e puoi farlo in modo ricorsivo.

Il problema è che sappiamo che nelle moderne applicazioni Web, i componenti importano e utilizzano altri componenti. Pertanto, dobbiamo associare ciascuno di essi alle loro dipendenze e creare un template dinamico basato sul linguaggio di programmazione corrente, che contenga la sintassi corretta per importarli all'interno.

A File JavaScript importato in questo modo:

import italy from "italy" // import intero modulo import (Spaghetti) from "italy" // import una singola entità in italia

Quindi per passare dal grafico all'applicazione, dobbiamo creare ogni file, posizionarlo nella posizione corretta in base al grafico stesso e visualizzare il modello di importazione delle dipendenze corretto

Drawio2Vuejs

Ho creato un pacchetto che ti consente di disegnare la tua app in draw.io e utilizzare il file xml esportato per creare un'app Vue.js. È chiamato graph2app-drawio2vuejs.

Il pacchetto lo trovi qui:

In realtà, questa non è un'idea nuova, ho sviluppato qualche tempo fa un modo per fare più o meno lo stesso usando python:

Ma tieni presente che questo una nuova versione Il pacchetto npm è molto meglio.

Quindi, prima di tutto, installa il pacchetto globalmente con npm:

$ npm i -g graph2app-drawio2vuejs

Ora puoi usarlo nel terminale con il comando:

$drawio2vuejs

Ma ovviamente devi passare più argomenti:

$ drawio2vuejs --help Utilizzo: drawio2vuejs scaffold App Vuejs da Draw.io Opzioni: -V, --version restituisce il numero di versione -d, --dist Destinazione di output -x, --xml xmlPath -h, --help genera informazioni sull'utilizzo

Assicurati di passare il percorso al file xml draw.io.

È ora di disegnare! Vai su draw.io , seleziona UML nel pannello di sinistra e fare clic su Oggetto:

Ora puoi iniziare creando il primo nodo. Ricorda che questo sarà il tuo componente principale. Per i miei casi, il componente root sempre il primo nodo che è mostrato nel diagramma.

Quindi, in base all'applicazione che desideri creare, puoi aggiungere un altro nodo.

Ora vogliamo Casa era elemento figlio App. Quindi clicca su Casa e usa la freccia per connetterti App.

E se lo vogliamo anche noi App importare Casa come dipendenza? Premere usa la freccia nella sezione UML a sinistra e posizionarlo da App in Casa.

Bene! Hai creato il tuo primo grafico! Usiamolo per creare un'app Vuejs basata su di esso.

Abbiamo detto che abbiamo bisogno di un file xml quindi esportalo senza compressione. Clic File > Esporta come > XML > Compresso (nessuno).

Ora crea un'applicazione Vue.js di base usando la riga di comando Vue:

$ vue init webpack app

Fatto ciò, siamo pronti per generare l'applicazione dal grafico:

$drawio2vuejs --xml= dist=

Per me il comando sarebbe:

$ drawio2vuejs --xml=/Utenti/VaeVictis/Desktop/app.xml --dist=/Utenti/VaeVictis/Desktop/app/src

Se tutto funziona correttamente, dovresti vedere il seguente risultato:

File app.vue verrà aggiornato poiché era già presente, aggiungendo l'importazione corretta per Casa. Verrà inoltre creato un nuovo componente Casa. Se apriamo app.vue, dovremmo vedere:

Il componente è importato correttamente e la cartella Casa con file casa.vueè stato creato correttamente!

grafico2app

Pacchetto drawio2vuejs sviluppato utilizzando un altro pacchetto che ho sviluppato: grafico2app.

Presto farò un articolo su come applicare un modulo usando tre parti:

• Costruttore di grafici

App, dove si trova la logica principale, crea una directory e file dal grafico. Grafico realizzato utilizzando l'istanza Costruttore di grafici. Nel nostro caso, ho creato DrawIoGraphBuilder, che lo estende per analizzare il file XML da draw.io.
graph2app-drawio-creatore di grafici

Gli sviluppatori potranno estendere l'istanza di base per l'analisi dei grafici con altri tipi di interfacce.

fileè un'astrazione di nodi su un grafo. Lui ha campione Il da cui viene generato il componente. Così, quando grafico2app ottiene il grafico, ha anche bisogno di un'istanza file per chiamare il metodo di rendering su di esso e salvare il file correttamente.

Come puoi vedere, il pacchetto ha una struttura modulare. Potremmo usare lo stesso DrawIoGraphBuilder con un'altra istanza file per creare, ad esempio, applicazioni React dallo stesso grafico draw.io.

Conclusione

Spero che questo articolo ti piaccia. Credo fermamente che la visualizzazione di un'applicazione possa migliorare le prestazioni. La libreria è ancora in versione beta e necessita di alcuni miglioramenti. Penso che alle persone piacerà questa idea e contribuiranno allo sviluppo.

Per favore fatemi sapere la vostra opinione. Grazie per il vostro interesse.

Francesco Saverio

Tag: aggiungi tag

Io - linguaggio di programmazione compatto orientato agli oggetti

Parte 1. Panoramica delle caratteristiche e della sintassi del linguaggio Io

Serie di contenuti:

Nel gruppo di linguaggi basati sul paradigma della programmazione orientata agli oggetti, Io si distingue per la sua semplicità e concisione. Non esistono programmi ideali che siano completamente privi di difetti, soprattutto quando si tratta di implementare un linguaggio di programmazione. Ecco perché è necessario studiare in modo sufficientemente dettagliato le capacità e le caratteristiche di qualsiasi linguaggio di programmazione (in questo caso, Io), nonché le aree della sua applicazione, prima di esprimere un giudizio finale sulla sua necessità, efficienza, convenienza per il sviluppatore, ecc.

La storia dell'aspetto della lingua Io

Il linguaggio Io è apparso nel 2002, quando il suo autore Steve Dekorte, cercando di comprendere meglio i principi di funzionamento e implementazione dei linguaggi di programmazione, ha deciso di unire la teoria alla pratica e di scrivere un proprio linguaggio semplice e conciso. Decort ha progettato Io per essere un linguaggio orientato agli oggetti puro, basato su prototipi e tipizzato dinamicamente che elimina la distinzione tra "classe" e "istanza". Wikipedia rileva l'influenza su Io di linguaggi come Smalltalk (il principio di "tutto è un oggetto" e la tipizzazione dinamica), Self e NewtonScript (un modello a oggetti basato su prototipi), Lisp (equivalenza di istruzioni e dati in codice programma), nonché Lua e act1.

Informazione Generale

Il codice del programma Io viene tradotto ed eseguito utilizzando un dispositivo compatto e altamente portatile macchina virtuale. I pacchetti Io per varie piattaforme si trovano sul suo sito Web. La lingua Io è distribuita secondo i termini della licenza BSD/MIT.

Proprietà principali data lingua che lo stesso autore sottolinea sono la semplicità concettuale e la brevità, l'embeddabilità (la capacità di combinarsi con codice scritto in altri linguaggi) e l'estendibilità, la capacità di modificare dinamicamente gli oggetti interni in fase di esecuzione, l'introspezione e l'implementazione del concetto di parallelismo.

In Io, tutte le entità sono oggetti che hanno la capacità di cambiare durante l'esecuzione del programma. Il codice di qualsiasi programma è composto da espressioni, che possono essere modificate anche durante l'esecuzione del programma. Le espressioni, a loro volta, sono in realtà istruzioni di passaggio di messaggi. Implementato il meccanismo degli ambiti di contesto degli oggetti a livello di funzioni e blocchi di codice. Gli attori vengono utilizzati per gestire il calcolo parallelo.

Esecuzione del programma

Nei programmi Io non è richiesta la presenza della funzione. principale() o qualche oggetto speciale da cui dovrebbe iniziare l'esecuzione. Pertanto, i programmi Io possono essere considerati script in una certa misura.

Avvio del programma da riga di comando si fa come segue:

io progetti/io/il mio_primo_prog.io

Puoi anche lavorare nella modalità interattiva dell'interprete Io, come mostrato nel Listato 1.

Listato 1. Utilizzo interattivo dell'interprete Io

$ io Io 20070410 Io> "È l'interprete di Io" println È l'interprete di Io ==> È l'interprete di Io Io>

In modalità interattiva, viene visualizzato non solo il risultato dell'esecuzione dell'espressione immessa, ma anche il valore restituito da questa espressione, indicato dal prefisso " ==> ". In questo caso, il risultato dell'esecuzione dell'espressione è lo stesso del valore restituito.

Si noti che in modalità interattiva, le espressioni inserite vengono eseguite nel contesto generale di primo livello corrispondente all'oggetto denominato Lobby.

Listato 2. Contenuti del contesto di primo livello del programma Io

$io Io 20070410 Io> print Object_0x9898a88: Lobby = Object_0x9898a88 Protos = Object_0x9898550 args = metodo(...) exit = metodo(...) forward = metodo(...) launchPath = "/home/alexs/projects/io " ==> Object_0x9898a88: Lobby = Object_0x9898a88 Protos = Object_0x9898550 args = metodo(...) exit = metodo(...) forward = metodo(...) launchPath = "/home/alexs/projects/io" Io>

In modalità interattiva, puoi anche eseguire programmi che sono memorizzati in file separati come sotto:

doFile("my_first_prog.io")

Il programma specificato verrà eseguito per impostazione predefinita nel contesto dello stesso oggetto atrio. Se è necessario eseguire il programma caricato nel contesto di qualche altro oggetto, il nome di questo oggetto viene specificato prima di chiamare il metodo doFile(), e in termini di linguaggio Io, viene trasmesso un messaggio all'oggetto:

myMainObject doFile("my_first_prog.io")

Sintassi del linguaggio Io

La prima cosa che cattura la tua attenzione quando conosci la sintassi del linguaggio Io è l'assenza di parole chiave riservate e di operatori familiari da altri linguaggi. Il codice sorgente di qualsiasi programma viene scritto utilizzando esclusivamente espressioni composte da messaggi, ognuno dei quali è un oggetto disponibile (e modificabile) in ogni momento in cui il programma è in esecuzione.

Per maggiore chiarezza, puoi usare la notazione non rigida della forma Backus-Naur (i letterali sono scritti tra virgolette), mostrata nel Listato 3.

Listato 3. Notazione del linguaggio Io

espressione::= ( messaggio | terminatore ) terminatore::= "\n" | ";" messaggio::= simbolo [ argomenti ] simbolo::= identificatore | numero | argomenti stringa::= "(" [espressione [ ( "," espressione ) ] ] ")"

Io supporta i tre formati di commento più utilizzati: //, /* */ e # . Le modalità della loro applicazione pratica sono ovvie.

Il messaggio può includere un elenco di argomenti, che vengono passati come espressioni ordinarie e valutati dall'oggetto che riceve il messaggio.

Listato 4. Utilizzo di un messaggio in loop

Io> for(i, 1, 5, i println) 1 2 3 4 5 ==> 5 Io>

Le espressioni condizionali possono anche essere incluse nell'elenco degli argomenti, come mostrato nel Listato 5.

Listato 5. Utilizzo dei condizionali in un messaggio

Io> beta:= 7 ==> 7 Io> alfa:= se(beta > 5, beta, 5) ==> 7 Io>

Va notato ancora una volta che nel primo caso il letterale per e nel secondo caso il letterale Se non sono moduli speciali o parole chiave riservate, ma sono semplicemente messaggi.

Operatori disponibili in lingua Io

Un operatore è un messaggio il cui nome non contiene caratteri alfanumerici (ad eccezione dei segni di punteggiatura e del trattino basso). Gli operatori includono anche i letterali: e, o, ritorno. Esempio di utilizzo dell'operatore:

1 + 2

Secondo il concetto del linguaggio Io, questa espressione si compila in un messaggio:

1 +(2)

Cioè, il valore numerico 1 il messaggio viene inviato" + "con argomentazione 2 .

Nelle espressioni complesse, la precedenza degli operatori aritmetici standard corrisponde alla precedenza di analoghi operatori aritmetici C.

Le istruzioni definite dall'utente vengono eseguite da sinistra a destra.

Ci sono tre operatori di assegnazione in Io:

• ::= crea uno slot, crea un setter per quello slot e assegna un valore allo slot;
• := crea uno slot e gli assegna un valore;
• = se lo slot esiste, gli viene assegnato un valore, altrimenti viene generata un'eccezione.

Gli operatori di assegnazione vengono convertiti in messaggi appropriati durante la compilazione, come mostrato di seguito:

beta::= 7 compila in newSlot("beta", 7) beta:= 7 compila in setSlot("beta", 7) beta = 7 compila in updateSlot("beta", 7)

I metodi dei messaggi sopra elencati possono essere sovrascritti (ovvero sostituiti con i propri metodi). In particolare, per gli oggetti locali, i metodi aggiornamentoSlot() vengono riscritti in modo tale che non vengano generate eccezioni quando vengono assegnati valori agli slot di questi oggetti locali esplicitamente specificati.

Lavorare con le stringhe

Le stringhe in Io sono rappresentate come sequenze di caratteri racchiuse tra virgolette. Se il carattere di virgolette stesso è contenuto in una stringa, allora deve essere preceduto da una barra rovesciata, ad esempio:

string:= "Io manca il concetto di \" parola chiave\", come tale."

La riga può contenere caratteri Esc standard (\n, \t, \a, ecc.):

string:= "Questa è la prima riga.\nQuesta è la seconda riga.\nQuesta è la terza riga."

Per evitare caratteri di escape e per scrivere blocchi di testo multilinea nella loro forma naturale, è necessario iniziare e terminare tale blocco con tre virgolette doppie, come mostrato di seguito:

longstring:= """Il linguaggio Io si basa sul concetto di "tutto è un oggetto". Il codice sorgente sono espressioni composte da messaggi. Anche gli operatori sono messaggi."""

Valori numerici

Quando si scrivono numeri, sono consentiti quasi tutti i formati standard e Io supporta anche la scrittura di valori numerici in notazione esadecimale.

Listato 6. Formati numerici supportati in Io

Io> 12 + 18 ==> 30 Io> 3.14 * 2 ==> 6.28000000000000002 Io> .987 + 11.003 ==> 11.9900000000000002 Io> 2e4 - 2e3 ==> 18000 Io> 1.655e-3 - 5.112e-4 Io> 0xFF + 0x3 ==> 258 Io> 0XE - 0xa ==> 4 Io>

Le espressioni aritmetiche vengono valutate secondo il metodo tradizionale, nonostante gli operatori che denotano operazioni aritmetiche vengano convertiti all'interno dell'interprete in chiamate ai metodi corrispondenti (questo meccanismo è nascosto all'utente):

Io> (9+5)*10-(2+3)*5 ==> 115

Per trasferire il risultato dei calcoli su qualche oggetto, viene utilizzato il metodo doString(), come mostrato nel Listato 7.

Listato 7. Utilizzo del metodo doString()

Io> myNewObject:= Object clone ==> Object_0x99336f0: Io> myNewObject doString("(18+25)*33") ==> 1419 Io>

Se prima di chiamare il metodo doString() il nome dell'oggetto non è specificato, quindi il calcolo e l'output del risultato vengono eseguiti nel contesto corrente.

Esempio di programma Io

Nella maggior parte dei casi, il codice sorgente del programma, di dimensioni non molto grandi e senza inutili complessità logiche, aiuta a comprendere meglio la sintassi di un linguaggio di programmazione. Imitazione semplificata delle transazioni con il personale conto bancario abbastanza adatto per la prima esperienza. Il codice sorgente è mostrato nel Listato 8.

Listato 8. Transazioni del conto personale

Conto:= Clona oggetto Saldo conto:= 0 Deposito conto:= metodo(importo, saldo = saldo + importo) Prelievo conto:= metodo(importo, saldo = saldo - 1.005 * importo) conto:= Deposito conto clone conto(5000.00) prelievo conto(250.00) saldo conto printlnIo> doFile("my_acc.io") 4748.75 ==> 4748.75 Io>

Questo programma utilizza quasi tutti gli elementi di sintassi descritti nelle sezioni precedenti: messaggi, operatori di assegnazione e operatori aritmetici, valori numerici. La creazione e l'uso di oggetti, slot e metodi sarà discussa nel secondo articolo del ciclo, e in questo momento basta capirli a livello intuitivo.

Strutture di controllo

Per garantire il funzionamento delle strutture di controllo logico nel linguaggio Io, vengono definiti singleton speciali (singleton) VERO(vero) e falso(falso) così come uno speciale singleton zero, che denota un valore non definito ("nessun valore").
Le operazioni di confronto logico vengono eseguite utilizzando i metodi: ==!=><>=<= , che ritornano VERO o falso. Inoltre, c'è un metodo confrontare(), che restituisce valori -1 (meno), 0 (uguale) o 1 (maggiore di) e utilizzato per implementare metodi specializzati di confronto dei valori.

Metodo Se() viene utilizzato nella forma seguente:

Se(<условие>, [, altro ]) if(denominatore == 0, "Errore" println)

Ecco la parte opzionale altro omesso. Un'espressione condizionale è considerata vera se il suo risultato lo è VERO e se l'espressione condizionale fornisce il risultato falso o zero, allora è falso.

Metodo Se() restituisce come valore il messaggio calcolato dal risultato del controllo, quindi le espressioni seguenti sono equivalenti:

se (somma< 100, x:= sum, x:= 100) x:= se(somma< 100, sum, 100)

Le espressioni condizionali possono anche essere scritte in una forma più estesa:

se (somma< 100) then(x:= sum) else(x:= 100)

Inoltre, è supportato un metodo per la nidificazione di espressioni condizionali altrimenti():

se (somma< 10) then(x:= 0) elseif(sum < 10) then(x:= 1) else (x:= sum)

Sono supportati anche i metodi in stile Smalltalk: se è vero(), se Falso(), seNil() e ifNonNil(), permettendoti di scrivere espressioni nella forma:

(somma< 100) ifTrue(x:= sum) ifFalse(x:= 100)

Qui dovresti prestare particolare attenzione al fatto che l'espressione condizionale iniziale deve essere scritta tra parentesi.

Cicli

Il tipo più semplice di ciclo è un ciclo infinito incondizionato, implementato utilizzando il metodo ciclo continuo():

loop("ciclo infinito" println)

Se il ciclo deve essere ripetuto un numero rigorosamente definito di volte senza verificare alcuna condizione, viene applicato il metodo ripetere(), come mostrato nel Listato 9.

Listato 9. Utilizzo del metodo repeat()

Io> 3 repeat("Attenzione!" println) Attenzione! Avvertimento! Avvertimento! ==> Attenzione! Io>

Un ciclo, il cui numero esatto di ripetizioni non è noto in anticipo, ma è specificata una certa condizione in base alla quale devono essere eseguite le iterazioni, viene scritto utilizzando il metodo mentre():

mentre(<условное_выражение>, <сообщение>)

Una caratteristica di questo ciclo è che se è necessario registrare più di un messaggio nel corpo del ciclo, questi messaggi dovrebbero essere separati l'uno dall'altro dal simbolo di transizione a nuova linea, non una virgola, altrimenti il ​​ciclo non verrà eseguito correttamente. Inoltre, è consigliabile lasciare l'espressione condizionale sulla prima riga e scrivere ogni messaggio nel corpo del ciclo su una riga separata. Questo modulo, mostrato nel Listato 10, avrà un aspetto più familiare.

Listato 10. Esempio di un ciclo while

Io> a:= 10 ==> 10 Io> mentre(a< 20,)->a println)-> a = a + 2)->) 10 12 14 16 18 ==> 20 Io>

Metodo per() permette di organizzare un ciclo con determinati valori al contorno e con un dato contropasso. La forma generale di questo ciclo è simile a questa:

per(<счётчик>, <начальное_значение>, <конечное_значение>, [<шаг>,] <сообщение>).

Se il passo di modifica del contatore non è specificato, per impostazione predefinita viene assunto il valore del passo uguale a 1.

Listato 11. Un esempio di organizzazione di un ciclo for

//in questo ciclo, la fase di modifica del contatore non è specificata Io> for(i, 0, 3, i println) 0 1 2 3 ==> 3 //in questo ciclo, la fase di modifica del contatore è specificata Io> for(i, 0, 10, 3, io println) 0 3 6 9 ==> 9 Io>

Nel corpo di uno qualsiasi dei cicli precedenti, puoi utilizzare i metodi per modificare l'ordine di esecuzione: Continua ti consente di ignorare il resto del corpo del ciclo e iniziare una nuova iterazione, e rompere termina immediatamente l'intero ciclo.

Listato 12. Controllo dell'ordine di esecuzione del ciclo

Io> for(i, 1, 10,)-> if(i == 2, continue))-> if(i > 7, break))-> i print)->) 134567==> nil Io>

Si precisa che in caso di terminazione non standard del loop (utilizzando il rompere) il valore di ritorno è considerato indefinito (indicato come zero).

Metodo Restituzione consente di uscire da qualsiasi parte di un blocco di codice o corpo del metodo con il valore di ritorno richiesto, ad esempio:

Listato 13. Utilizzo del metodo return per restituire un valore da un metodo

Io> test:= metodo("primo" println; "secondo" println; return "exit"; "terzo" println) ==> metodo("primo" println; "secondo" println; return "exit"; "terzo" println) Io> test primo secondo ==> uscita Io>

Il linguaggio Io implementa anche un ciclo per ciascuno, ma la sua applicazione pratica è alquanto diversa dall'uso dei cicli tradizionali, quindi questo ciclo sarà preso in considerazione nei prossimi articoli.

Conclusione

Il linguaggio Io è un linguaggio ad oggetti puro, ovvero un'implementazione del concetto "tutto è un oggetto". La sua sintassi è semplice e chiara, anche se a prima vista può sembrare insolita. Io implementa tutti i costrutti e gli operatori standard de facto.

Il primo articolo della serie descritto Caratteristiche generali e la sintassi del linguaggio di programmazione Io. Il secondo articolo esaminerà il sistema di oggetti del linguaggio e il terzo articolo esaminerà le funzionalità e le capacità aggiuntive di Io.