Draw.io- application gratuite, conçu pour modéliser des diagrammes et des organigrammes de processus métier. Il existe une option d'intégration avec Google Docs, Dropbox, OneDrive, JIRA, Confluence, Chrome et GitHub. Les modules complémentaires Confluence Server et JIRA Cloud sont des modules complémentaires payants. La version en ligne pour la synchronisation avec Google Drive est proposée en 2 versions - avec et sans prise en charge de Google Apps. En plus de la version Web, il existe un programme d'installation pour PC qui prend en charge Windows, MacOS et Linux.

L'application sera utile aux managers et dirigeants d'entreprises qui ont besoin d'un outil pour construire des diagrammes de processus métier. Le service s'adresse aux professionnels dont les activités sont liées à la création de présentations et de bases de données, à la construction de schémas d'ingénierie et de réseau, à la conception de logiciels.

À l'aide de l'éditeur, vous pouvez créer des images schématiques - à partir de diagrammes circuits électriques aux structures du modèle d'entreprise. Parmi les possibilités - la construction de diagrammes, de graphiques et de modèles UML. Il existe des dizaines de formes regroupées en catégories dans la bibliothèque de formes. Les objets peuvent être formatés en changeant les polices, la couleur, le dégradé, l'épaisseur de ligne, le niveau de transparence. Grâce à la possibilité de se synchroniser avec Google Drive, plusieurs utilisateurs peuvent travailler sur des documents en même temps. Les images prêtes à l'emploi peuvent être enregistrées sur le disque dur d'un PC ou insérées dans des wikis et des blogs. Les formats d'exportation disponibles sont PDF, GPG, SVG, XML et JPG.

Principales caractéristiques

• Intégration gratuite avec Services Google
• Intégration payante avec Confluence et JIRA Cloud
• Client HTML avec prise en charge d'IE 6-8
• Prise en charge des smartphones et des tablettes
• Exporter des documents vers Formats PDF, GPG, SVG, XML et JPG
• Application hors ligne pour Windows, MacOS et Linux
• Prend en charge 27 langues

J'ai enfin trouvé ce que je cherchais. Un outil de modélisation gratuit qui prend en charge les capacités de description des processus métier - Draw.io

Dessin.io est un outil de création de diagrammes et d'organigrammes en ligne. En même temps, un grand nombre de modèles vous permettent de dessiner tout ce que votre cœur désire. Outils Dessin.io rappelle beaucoup MS Visio et peut-être fait pour cela, cependant, l'application de Programme Microsoft payé, et un service en ligne Dessin.io- totalement gratuit, et surtout ne nécessite pas d'inscription.

Une fonctionnalité similaire est déjà dans la version cloud - c'est un système, cependant ce système payant, bien que l'abonnement soit peu coûteux, mais il est difficile de rivaliser avec la gratuité.

Une opinion à propos Dessin.io

Et bien que cet outil ne soit pas très bon en termes de méthodologie, il est possible de dessiner, notamment en pré-paramétrant une convention de modélisation pour les étudiants du stage. Et bien que l'outil ne soit pas aussi beau que le gratuit, la mise en œuvre du cloud le rend compétitif.

Pour créer un modèle de bloc en ligne, il vous suffit de créer un nouveau document dans la boîte à outils.

Dans le panneau de l'objet, comme dans MS Visio, vous devez sélectionner une catégorie et déplacer l'objet dans le champ du modèle avec le curseur de la souris. Il y a beaucoup d'objets, ils sont donc suffisants pour créer un modèle de processus métier à part entière (contrairement à , dans lequel l'ensemble d'objets et de modèles est sérieusement limité).

Pour connecter des objets de modèle les uns aux autres, vous devez sélectionner un objet et déplacer le pointeur de la souris sur un autre, après quoi un drapeau vert apparaîtra que vous devrez faire glisser sur l'objet.

Plus important encore, après avoir créé un modèle de processus métier, il est possible de l'exporter vers votre ordinateur au format image (PNG, GIF, JPG, PDF) via le menu : Fichier - Exporter.

Et bien sûr, la fonctionnalité cloud - le service Draw.io est synchronisé avec Google Drive, ce qui permet d'enregistrer le projet directement sur Google Drive.

En général, j'ai aimé l'outil, il semble Dessin.io tout à fait approprié pour rendre les processus commerciaux en ligne. Et bien qu'il n'y ait toujours presque pas de concurrence dans les grands projets au niveau fédéral, pour les petites entreprises qui décrivent leurs processus commerciaux, c'est un outil tout à fait approprié.

Le travail de tout ingénieur, informaticien, spécialiste du marketing, analyste commercial, gestionnaire est associé à la nécessité de créer divers diagrammes, organigrammes et graphiques. À ces fins, le service "tirage", disponible sur le lien, est génial.

Son principal avantage est qu'il est gratuit. L'utilisation de la ressource est gratuite, ce qui la rend encore plus agréable. De plus, pour un travail à part entière, vous n'avez pas besoin de vous inscrire et de passer par le fastidieux processus d'autorisation sur le site.

Lors de l'entrée page d'accueil choisissez un chemin pour enregistrer le projet. Les résultats finaux peuvent être stockés sur un stockage distant - "clouds" (" Google Drive», « Dropbox », « OneDrive »), sur la ressource « GitHub », sur le disque dur de l'appareil « Device » ou directement à l'environnement de gestion du développement d'applications et de programmes web « Trello ».

Par défaut, la case est cochée pour enregistrer les paramètres sélectionnés à l'avenir.

Pour simplifier la tâche de se familiariser avec les fonctionnalités du service en ligne, changeons la langue de l'interface en cliquant sur "Langue".

Après avoir défini la langue requise, vous devrez recharger la page pour que les modifications prennent effet.

Passons maintenant à la création d'un nouveau projet, pour lequel nous cliquons sur le bouton "Créer un nouveau diagramme", après quoi la transition vers la partie graphique du travail aura lieu.

Vous pouvez ouvrir un champ vide et créer vous-même un diagramme, ou utiliser une bibliothèque de divers modèles graphiques. "Diagrammes d'Ishikawa" (alias "queue de poisson"), "Schémas de description des processus métier", "Organigrammes de structure", "Organigrammes", " Circuits électriques", "Blocs de programme" - ce n'est qu'une petite partie de ce qui est déjà présent sous forme de blancs.

La possibilité de décrire les processus métier à l'aide du service draw.io présente un grand intérêt pour les utilisateurs.

Pour commencer, sélectionnez "Graphique vierge" dans la catégorie de modèles "Basique".

À titre d'exemple, nous décrirons les principaux processus commerciaux associés au travail d'une petite boutique en ligne moderne.

Pour la partie graphique du travail, nous avons besoin des sections "BPMN General" et "BPMN Events".

A propos d'un exemple, nous n'aborderons pas les spécificités étroites de la promotion en magasin, le travail d'un directeur, d'un optimiseur de moteur de recherche, d'un gestionnaire de contenu, d'un administrateur système, qui sont eux aussi directement impliqués dans la vie d'une entreprise, mais pour point de départ nous considérerons la réception d'une commande du client et les étapes à suivre du côté du traitement.

Créons un événement sur le diagramme - la réception d'une candidature au gestionnaire qui maintient la boutique en ligne, pour laquelle nous ferons glisser l'icône d'enveloppe symbolisant la réception de la candidature (message entrant) et le conteneur "Tâches" décrivant la réaction à l'appel.

Établissons une connexion en plaçant une flèche entre les deux blocs.

Pour la commodité d'utilisation de l'outil en ligne draw.io, il y a panneau supérieur contrôle, contenant les boutons d'annulation d'actions, d'échelle, de défilement et de gestion des calques, ainsi que les éléments les plus utilisés (points de contrôle, flèches de liaison).

En double-cliquant sur le bouton gauche de la souris, nous modifierons le texte sur le bloc, en renommant «Tâche» en «Vérification de la disponibilité des marchandises commandées en stock». C'est à partir de cette étape que le responsable de la boutique en ligne doit commencer l'analyse de la commande, car d'autres étapes de communication avec le client en dépendent.

Il est logique de supposer que le bloc suivant doit être une condition qui détermine la séquence d'actions pour différents résultats de vérification des soldes des stocks.

* Il est important de se rappeler que les processus métier ne sont pas écrits pour le papier, mais pour les gens ordinaires, les employés de l'entreprise. Plus l'étude est détaillée et détaillée, moins il y aura d'erreurs à l'avenir. 80% du succès de sa mise en œuvre dépend du paramétrage de la tâche.

Si les marchandises sont en stock, vous pouvez aller à "Vérifier l'exactitude des données renseignées par l'utilisateur", sinon, à "Spécifier la date exacte de livraison". Pour écrire un commentaire au-dessus d'un bloc ou d'une flèche, vous devez sélectionner l'onglet "Général" et l'élément "Texte". Dans ce cas, ce sont des indications de directions "Oui/non".

Analysons la branche négative et mettons sur le schéma toutes les autres étapes d'action.

Un bloc auxiliaire "Contacter le fournisseur, demander le délai de livraison exact", deux blocs principaux "Prendre alternatives marchandises en stock et pouvant être proposées en remplacement », « Vérification de l'exactitude des données utilisateur renseignées » et le bloc de communication avec le client « Contacter par téléphone et discuter des détails de livraison ». Il est important d'être préparé à l'avance à tout résultat et donc de trouver des alternatives. Dans notre cas, nous avons créé un processus métier dans le service draw.io associé à une sélection d'alternatives, ce qui permettra de fidéliser le client en cas de désaccord sur le délai de livraison. Les blocs auxiliaires sont affichés sous forme de ligne pointillée, disponible dans l'onglet "BPMN General".

Si le magasin travaille sur la fidélisation de ses clients, alors il est possible d'ajouter un bloc supplémentaire lié à la fourniture d'une remise personnelle sur un produit alternatif, si les délais sont retardés en raison de la faute du magasin en ligne (par exemple , les marchandises restantes étaient affichées de manière incorrecte (sur le site "en stock", et En fait, les marchandises sont terminées)).

Il reste maintenant à ajouter une condition supplémentaire : "Le client accepte la commande." A ce stade, le résultat de toutes les activités est décidé, ou la commande passe en traitement puis passe au "Service d'approvisionnement", ou le responsable clôt la commande, proposant de recevoir une notification concernant la réception des marchandises en stock pour le visiteur du site qui a quitté l'application.

Ainsi, après avoir passé seulement 5 minutes de temps, nous avons élaboré des processus commerciaux dans le service draw.io liés au directeur des ventes. De même, vous pouvez établir des schémas sur des feuilles séparées pour le reste des départements impliqués dans les activités de la boutique en ligne, ainsi que résumer tous les services de l'entreprise dans son ensemble.

Pour ouvrir un document à l'avenir, rendez-vous simplement sur le site Web du service et, en sélectionnant "Ouvrir un diagramme existant", recherchez le projet xml précédemment enregistré.

En plus des résultats finaux dans le format précédemment spécifié, il est possible d'exporter des diagrammes et des schémas au format pdf et document html, ainsi que sous forme d'images et graphiques vectoriels(SVG).

Récemment, il est devenu possible de télécharger draw.io en tant que programme sur un PC (fonctionne sur le fonctionnement Systèmes Windows, MacOs, Chrome OS, Linux) et installer en tant que application mobile qui fonctionne à la fois sur iOS et Android.

À ces fins, vous devez cliquer sur le bouton "Avancé" du panneau de configuration et sélectionner "Télécharger" dans le menu qui s'ouvre.

Les informations présentées dans la revue suffisent amplement pour commencer à travailler sur votre projet, peu importe à quelle industrie, domaine d'activité ou de production il appartient, qu'il s'agisse de programmation, d'administration, de conception, de gestion, de distribution ou d'approvisionnement, etc.

Si vous rencontrez des difficultés, vous pouvez toujours lire les instructions et la documentation officielle fournies sur le site Web du service en ligne.

Bonjour, cher Habrazhitel. Je présente à votre attention la traduction de l'article From Draw.io to Vue.js app par Francesco Zuppichini.

C'est ma première publication sur Habré et j'ai décidé de commencer par traduire un article sur un outil sympa qui permet de générer une application Vue.js à partir d'un diagramme UML.
Surpris? J'étais juste étonné quand je suis tombé dessus.

Bien sûr, comme dans toute version bêta, il y a quelque chose à travailler. Par exemple, la première chose que j'ai contactée l'auteur et dit que je voulais apporter des corrections à la structure du modèle de composant et à la dénomination du chemin. L'auteur a pris contact en moins d'une heure, a posté le code sur GitHub et a écrit un petit tutoriel. Après avoir accepté le PR, la permission a été obtenue de traduire l'article, avec un lien vers l'original.

À qui c'est intéressant - je demande sous kat.

De Draw.io à l'application Vue.js

Construire une application devrait être aussi simple que de dessiner un graphique dans draw.io
Francesco Saverio

Et si je te disais que tu peux transformer ça :

Le résultat est un projet Vue.js avec tous les fichiers et importations dont vous avez besoin pour commencer à créer votre produit sympa. Cool, ouais?

J'ai fait une courte vidéo de démonstration que vous pouvez regarder ici :

Une application Web n'est qu'un graphique

Chaque application Web peut être exprimée sous forme de graphique
Réfléchissons un peu. Lorsque vous utilisez un framework comme React, Angular ou Vue, vous avez toujours un composant racine.

Dans notre exemple, le composant racine est le composant Application, tout le reste n'est qu'un nœud de graphe. On peut identifier au premier niveau Domicile et nœuds d'index comme enfants directs Application.

Une norme courante dans le développement d'applications Web consiste à stocker les composants dans une structure de répertoires basée sur des graphiques. Par conséquent, un répertoire portant le même nom est généralement créé pour chaque composant, où se trouvent le composant lui-même et tous ses enfants.

Par exemple, Indice est la racine du sous-graphe auto-composé, utilisateur et Poste. Par conséquent, il est logique d'imiter cette abstraction dans les structures d'application.

Cela offre deux avantages : l'évolutivité, puisque les sous-graphes sont indépendants, et une compréhension aisée de la structure et de la logique de l'application.

De plus, on peut toujours voir structure globale applications simplement en regardant le graphique.

Du graphique à l'application

Nous avons donc dit que chaque application Web est en fait un graphique, nous pouvons donc les générer à partir de celui-ci.

Après tout, chaque fichier qui commence par un graphique est simple. Il vous suffit de trouver l'intersection de l'arbre et de créer chaque fichier dans son répertoire racine local et vous pouvez le faire de manière récursive.

Le problème est que nous savons que dans les applications Web modernes, les composants importent et utilisent d'autres composants. Par conséquent, nous devons associer chacun d'eux à leurs dépendances et créer un modèle dynamique basé sur le langage de programmation actuel, qui contient la syntaxe correcte pour les importer à l'intérieur.

À Fichiers JavaScript importé comme ceci :

import italy from "italy" // importe le module entier import ( Spaghetti) from "italy" // importe une seule entité en italie

Donc, pour passer du graphique à l'application, nous devons créer chaque fichier, le placer dans la bonne position en fonction du graphique lui-même et afficher le bon modèle d'importation de dépendances.

Drawio2Vuejs

J'ai créé un package qui vous permet de dessiner votre application dans draw.io et d'utiliser le fichier xml exporté pour créer une application Vue.js. On l'appelle graph2app-drawio2vuejs.

Le pack se trouve ici :

En fait, ce n'est pas une idée nouvelle, j'ai développé il y a quelque temps une façon de faire à peu près la même chose en utilisant python:

Mais gardez à l'esprit que cela une nouvelle version le paquet npm est bien meilleur.

Alors tout d'abord, installez le package globalement avec npm :

$ npm i -g graph2app-drawio2vuejs

Vous pouvez maintenant l'utiliser dans le terminal avec la commande :

$drawio2vuejs

Mais bien sûr, vous devez passer plusieurs arguments :

$ drawio2vuejs --help Utilisation : drawio2vuejs scaffold Application Vuejs de Draw.io Options : -V, --version affiche le numéro de version -d, --dist Destination de sortie -x, --xml xmlPath -h, --help affiche les informations d'utilisation

Assurez-vous de transmettre le chemin d'accès au fichier xml draw.io.

Il est temps de peindre ! Allez sur draw.io, sélectionnez UML dans le panneau de gauche et cliquez sur Objet:

Vous pouvez maintenant commencer par créer le premier nœud. N'oubliez pas que ce sera votre composant racine. Pour mes cas, le composant racine toujours le premier nœud qui est représenté sur le schéma.

Ensuite, en fonction de l'application que vous souhaitez créer, vous pouvez ajouter un autre nœud.

Maintenant, nous voulons Domicile a été élément enfant Application. Alors cliquez sur Domicile et utilisez la flèche pour vous connecter à Application.

Et si nous voulions aussi Application importer Domicile comme dépendance ? appuyer sur utiliser la flèche dans la section UML à gauche et placez-le de Application dans Domicile.

D'ACCORD! Vous avez créé votre premier graphique ! Utilisons-le pour créer une application Vuejs basée sur celui-ci.

Nous avons dit que nous avions besoin d'un fichier XML Alors exportez-le sans compression. Cliquez sur Fichier > Exporter sous > XML > Compressé (aucun).

Créez maintenant une application Vue.js de base à l'aide de la ligne de commande Vue :

$ vue init application webpack

Une fois que vous avez fait cela, nous sommes prêts à générer l'application à partir du graphique :

$drawio2vuejs --xml= dist=

Pour moi la commande serait :

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

Si tout fonctionne correctement, vous devriez voir le résultat suivant :

Dossier app.vue sera mis à jour car il était déjà là, en ajoutant l'importation correcte pour Domicile. Un nouveau composant sera également créé Domicile. Si nous ouvrons app.vue, on devrait voir :

Le composant est importé correctement et le dossier Domicile avec fichier home.vue a été créé correctement !

graph2app

Sac plastique drawio2vuejs développé en utilisant un autre package que j'ai développé: graph2app.

Bientôt je vais faire un article à ce sujet, comment appliquer un module en trois parties :

• GraphBuilder

Application, où se trouve la logique principale, crée un répertoire et des fichiers à partir du graphique. Graphique créé à l'aide d'une instance GraphBuilder. Dans notre cas, j'ai créé DrawIoGraphBuilder, qui l'étend pour analyser le fichier XML de draw.io.
graph2app-drawio-graph-builder

Les développeurs pourront étendre l'instance de base pour l'analyse de graphes avec d'autres types d'interfaces.

Dossier est une abstraction de nœuds sur un graphe. Il possède échantillon Le à partir duquel le composant est généré. Ainsi, lorsque graph2app obtient le graphique, il a également besoin d'une instance Dossier pour appeler la méthode de rendu dessus et enregistrer le fichier correctement.

Comme vous pouvez le voir, le package a une structure modulaire. Nous pourrions utiliser le même DrawIoGraphBuilder avec une autre instance Dossier pour créer, par exemple, des applications React à partir du même graphe draw.io.

Production

J'espère que vous apprécierez cet article. Je crois fermement que la visualisation d'une application peut améliorer les performances. La bibliothèque est encore en version bêta et a besoin de quelques améliorations. Je pense que les gens aimeront cette idée et qu'ils contribueront au développement.

S'il te plaît, donnes-moi ton opinion. Merci pour ton intérêt.

Francesco Saverio

Balises : Ajouter des balises

Io - langage de programmation orienté objet compact

Partie 1. Présentation des fonctionnalités et de la syntaxe du langage Io

Série de contenu :

Dans le groupe des langages basés sur le paradigme de la programmation orientée objet, Io se distingue par sa simplicité et sa concision. Il n'existe pas de programmes idéaux totalement exempts de défauts, en particulier lorsqu'il s'agit de l'implémentation d'un langage de programmation. C'est pourquoi il est nécessaire d'étudier suffisamment en détail les capacités et les caractéristiques de tout langage de programmation (dans ce cas, Io), ainsi que les domaines de son application, avant de porter un jugement définitif sur sa nécessité, son efficacité, sa commodité pour le développeur, etc...

L'histoire de l'apparition de la langue Io

Le langage Io est apparu en 2002, lorsque son auteur Steve Dekorte, essayant de mieux comprendre les principes de fonctionnement et de mise en œuvre des langages de programmation, décide d'allier théorie et pratique et d'écrire son propre langage simple et concis. Decort a conçu Io pour être un langage orienté objet pur, basé sur des prototypes et typé dynamiquement, qui élimine la distinction entre "classe" et "instance". Wikipédia note l'influence sur Io de langages tels que Smalltalk (principe du "tout est objet" et typage dynamique), Self et NewtonScript (un modèle objet basé sur des prototypes), Lisp (équivalence des instructions et des données dans code de programme), ainsi que Lua et act1.

informations générales

Le code du programme Io est traduit et exécuté à l'aide d'un système compact et hautement portable machine virtuelle. Les packages Io pour diverses plates-formes se trouvent sur son site Web. Le langage Io est distribué sous les termes de la licence BSD/MIT.

Propriétés principales langue donnée sur lesquels l'auteur lui-même met l'accent sont la simplicité et la brièveté conceptuelles, l'incorporation (la capacité de se combiner avec du code écrit dans d'autres langages) et l'extensibilité, la capacité de modifier dynamiquement des objets internes au moment de l'exécution, l'introspection et la mise en œuvre du concept de parallélisme.

Dans Io, toutes les entités sont des objets qui ont la capacité de changer pendant l'exécution du programme. Le code de tout programme est composé d'expressions, qui peuvent également être modifiées lors de l'exécution du programme. Les expressions, à leur tour, sont en fait des instructions de transmission de messages. Implémentation du mécanisme des portées de contexte des objets au niveau des fonctions et des blocs de code. Les acteurs sont utilisés pour gérer le calcul parallèle.

Exécution du programme

Dans les programmes Io, la présence de la fonction n'est pas nécessaire. principale() ou un objet spécial à partir duquel l'exécution doit commencer. Ainsi, les programmes Io peuvent être considérés dans une certaine mesure comme des scripts.

Démarrage du programme à partir de ligne de commande se fait comme suit :

projets io/io/my_first_prog.io

Vous pouvez également travailler en mode interactif de l'interpréteur Io, comme indiqué dans le Listing 1.

Listing 1. Utilisation interactive de l'interpréteur Io

$ io Io 20070410 Io> "C'est l'interpréteur Io" println C'est l'interpréteur Io ==> C'est l'interpréteur Io Io>

En mode interactif, non seulement le résultat de l'exécution de l'expression saisie est affiché, mais également la valeur renvoyée par cette expression, notée par le préfixe " ==> ". Dans ce cas, le résultat de l'exécution de l'expression est identique à la valeur de retour.

A noter qu'en mode interactif, les expressions saisies sont exécutées dans le contexte général de niveau supérieur correspondant à l'objet nommé Lobby.

Listing 2. Contenu du contexte de niveau supérieur du programme Io

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

En mode interactif, vous pouvez également exécuter des programmes stockés dans fichiers séparés comme ci-dessous :

doFile("my_first_prog.io")

Le programme spécifié sera exécuté par défaut dans le contexte du même objet hall. S'il est nécessaire d'exécuter le programme chargé dans le contexte d'un autre objet, le nom de cet objet est spécifié avant d'appeler la méthode doFile(), et au niveau du langage Io, un message est transmis à l'objet :

monObjetPrincipal doFile("my_first_prog.io")

Syntaxe du langage Io

La première chose qui attire votre attention lorsque vous vous familiarisez avec la syntaxe du langage Io est l'absence de mots-clés réservés et d'opérateurs familiers dans d'autres langages. Le code source de tout programme est écrit uniquement à l'aide d'expressions composées de messages, dont chacun est un objet disponible (et modifiable) à tout moment de l'exécution du programme.

Pour plus de clarté, vous pouvez utiliser la notation de forme Backus-Naur non stricte (les littéraux sont écrits entre guillemets), présentée dans le Listing 3.

Listing 3. Notation du langage Io

expression ::= ( message | terminateur ) terminateur ::= "\n" | ";" message ::= symbole [ arguments ] symbole ::= identificateur | nombre | arguments de chaîne ::= "(" [expression [ ( "," expression ) ] ] ")"

Io prend en charge les trois formats de commentaires les plus largement utilisés : //, /* */ et # . Les voies de leur application pratique sont évidentes.

Le message peut inclure une liste d'arguments, qui sont passés comme des expressions ordinaires et sont évalués par l'objet recevant le message.

Listing 4. Utiliser un message pour boucler

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

Les expressions conditionnelles peuvent également être incluses dans la liste des arguments, comme indiqué dans le Listing 5.

Listing 5. Utiliser des conditions dans un message

Io> beta:= 7 ==> 7 Io> alpha:= if(beta > 5, beta, 5) ==> 7 Io>

Il convient de noter encore une fois que dans le premier cas, le littéral pour et dans le second cas le littéral si ne sont pas des formulaires spéciaux ou des mots-clés réservés, mais sont simplement des messages.

Opérateurs disponibles dans le langage Io

Un opérateur est un message dont le nom ne contient pas de caractères alphanumériques (à l'exception des signes de ponctuation et du trait de soulignement). Les opérateurs incluent également des littéraux : et, ou, retourner. Exemple d'utilisation de l'opérateur :

1 + 2

Selon le concept du langage Io, cette expression se compile en un message :

1 +(2)

c'est-à-dire la valeur numérique 1 le message est envoyé " + " avec arguments 2 .

Dans les expressions complexes, la priorité des opérateurs arithmétiques standard correspond à la priorité des opérateurs arithmétiques C analogues.

Les instructions définies par l'utilisateur sont exécutées de gauche à droite.

Il y a trois opérateurs d'affectation dans Io :

• ::= crée un emplacement, crée un setter pour cet emplacement et attribue une valeur à l'emplacement ;
• := crée un emplacement et lui attribue une valeur ;
• = si le slot existe, une valeur lui est affectée, sinon une exception est levée.

Les opérateurs d'affectation sont convertis en messages appropriés lors de la compilation, comme indiqué ci-dessous :

beta::= 7 compile vers newSlot("beta", 7) beta:= 7 compile vers setSlot("beta", 7) beta = 7 compile vers updateSlot("beta", 7)

Les méthodes des messages répertoriés ci-dessus peuvent être remplacées (c'est-à-dire remplacées par vos propres méthodes). En particulier, pour les objets locaux, les méthodes updateSlot() sont réécrits de manière à ce qu'aucune exception ne soit levée lorsque des valeurs sont affectées aux slots de ces objets locaux qui sont explicitement spécifiés.

Travailler avec des chaînes

Les chaînes dans Io sont représentées comme des séquences de caractères entre guillemets doubles. Si le guillemet lui-même est contenu dans une chaîne, il doit être échappé avec une barre oblique inverse, par exemple :

string:= "Io manque le concept de \" mot-clé\", En tant que tel."

La ligne peut contenir des caractères Esc standard (\n, \t, \a, etc.) :

string := "Ceci est la première ligne.\nCeci est la deuxième ligne.\nCeci est la troisième ligne."

Pour éviter les caractères d'échappement et pour écrire des blocs de texte multilignes dans leur forme naturelle, vous devez commencer et terminer un tel bloc par trois guillemets doubles, comme indiqué ci-dessous :

longstring:= """Le langage Io est basé sur le concept de "tout est un objet". Le code source est constitué d'expressions composées de messages. Les opérateurs sont également des messages."""

Valeurs numériques

Lors de l'écriture de nombres, presque tous les formats standard sont autorisés, et Io prend également en charge l'écriture de valeurs numériques en notation hexadécimale.

Listing 6. Formats numériques pris en charge dans Io

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

Les expressions arithmétiques sont évaluées selon la méthode traditionnelle, malgré le fait que les opérateurs dénotant les opérations arithmétiques sont convertis à l'intérieur de l'interpréteur en appels aux méthodes correspondantes (ce mécanisme est caché à l'utilisateur) :

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

Pour transférer le résultat des calculs vers un objet, la méthode est utilisée doString(), comme indiqué dans le Listing 7.

Listing 7. Utilisation de la méthode doString()

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

Si avant d'appeler la méthode doString() le nom de l'objet n'est pas spécifié, alors le calcul et la sortie du résultat sont effectués dans le contexte courant.

Exemple de programme Io

Dans la plupart des cas, le code source du programme, qui n'est pas très volumineux et sans complexités logiques inutiles, aide à mieux comprendre la syntaxe d'un langage de programmation. Imitation simplifiée de transactions avec des particuliers compte bancaire tout à fait approprié pour la première expérience. Le code source est présenté dans le Listing 8.

Listing 8. Transactions du compte personnel

Compte := Objet clone Solde du compte := 0 Dépôt du compte := méthode(montant, solde = solde + montant) Retrait du compte := méthode(montant, solde = solde - 1,005 * montant) compte := Dépôt du compte clone du compte(5000,00) retrait du compte (250,00) solde du compte printlnIo> doFile("mon_acc.io") 4748.75 ==> 4748.75 Io>

Ce programme utilise presque tous les éléments de syntaxe décrits dans les sections précédentes - messages, opérateurs d'affectation et opérateurs arithmétiques, valeurs numériques. La création et l'utilisation d'objets, de slots et de méthodes seront abordées dans le deuxième article du cycle, et dans ce moment il suffit de les comprendre à un niveau intuitif.

Structures de contrôle

Pour assurer le fonctionnement des structures de contrôle logiques dans le langage Io, des singletons spéciaux sont définis (singleton) vrai(vrai) et faux(faux) ainsi qu'un singleton spécial néant, désignant une valeur indéfinie ("pas de valeur").
Les opérations de comparaison logique sont effectuées à l'aide des méthodes : ==!=><>=<= , qui reviennent vrai ou alors faux. De plus, il existe une méthode comparer(), qui renvoie des valeurs -1 (moins), 0 (égal) ou 1 (supérieur à) et utilisé pour mettre en œuvre des méthodes de comparaison de valeurs spécialisées.

Méthode si() est utilisé sous la forme suivante :

si(<условие>, [, autre ]) if(dénominateur == 0, "Erreur" println)

Voici la partie optionnelle autre omis. Une expression conditionnelle est considérée comme vraie si son résultat est vrai, et si l'expression conditionnelle donne le résultat faux ou alors néant, alors c'est faux.

Méthode si() retourne comme valeur le message calculé à partir du résultat de la vérification, donc les expressions ci-dessous sont équivalentes :

si (somme< 100, x:= sum, x:= 100) x:= si(somme< 100, sum, 100)

Les expressions conditionnelles peuvent également être écrites sous une forme plus développée :

si (somme< 100) then(x:= sum) else(x:= 100)

De plus, une méthode est prise en charge pour l'imbrication des expressions conditionnelles sinon():

si (somme< 10) then(x:= 0) elseif(sum < 10) then(x:= 1) else (x:= sum)

Les méthodes de style Smalltalk sont également prises en charge : si vrai(), siFaux(), siNil() et ifNonNil(), permettant d'écrire des expressions sous la forme :

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

Ici, vous devez porter une attention particulière au fait que l'expression conditionnelle initiale doit être écrite entre parenthèses.

Cycles

Le type de boucle le plus simple est une boucle infinie inconditionnelle, implémentée à l'aide de la méthode boucler():

loop("boucle infinie" println)

Si la boucle doit être répétée un nombre strictement défini de fois sans vérifier aucune condition, alors la méthode est appliquée répéter(), comme indiqué dans le Listing 9.

Listing 9. Utilisation de la méthode repeat()

Io> 3 répétition("Attention !" println) Attention ! Avertissement! Avertissement! ==> Attention ! Io>

Une boucle, dont le nombre exact de répétitions n'est pas connu à l'avance, mais une certaine condition est spécifiée sous laquelle les itérations doivent être effectuées, est écrite à l'aide de la méthode tandis que():

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

Une caractéristique de ce cycle est que s'il est nécessaire d'enregistrer plus d'un message dans le corps du cycle, ces messages doivent être séparés les uns des autres par le symbole de transition vers nouvelle ligne, pas une virgule, sinon la boucle ne fonctionnera pas correctement. De plus, il est conseillé de laisser l'expression conditionnelle sur la première ligne et d'écrire chaque message dans le corps de la boucle sur une ligne distincte. Ce formulaire, présenté dans le Listing 10, vous semblera plus familier.

Listing 10. Exemple de boucle while

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

Méthode pour() permet d'organiser un cycle avec certaines valeurs limites et avec un pas de compteur donné. La forme générale de cette boucle ressemble à ceci :

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

Si le pas de changement de compteur n'est pas spécifié, alors la valeur de pas égale à 1 est supposée par défaut.

Listing 11. Un exemple d'organisation d'une boucle for

//dans cette boucle, le pas de changement de compteur n'est pas spécifié Io> for(i, 0, 3, i println) 0 1 2 3 ==> 3 //dans cette boucle, le pas de changement de compteur est spécifié Io> for(i, 0, 10, 3, i println) 0 3 6 9 ==> 9 Io>

Dans le corps de l'une des boucles ci-dessus, vous pouvez utiliser des méthodes pour modifier l'ordre d'exécution : Continuez vous permet d'ignorer le reste du corps de la boucle et de commencer une nouvelle itération, et Pause termine la boucle entière immédiatement.

Listing 12. Contrôler l'ordre d'exécution de la boucle

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

Il est à noter qu'en cas de terminaison non standard de la boucle (utilisation du Pause) la valeur de retour est considérée comme indéfinie (notée néant).

Méthode retour vous permet de quitter n'importe quelle partie d'un bloc de code ou d'un corps de méthode avec la valeur de retour requise, par exemple :

Listing 13. Utilisation de la méthode return pour renvoyer une valeur à partir d'une méthode

Io> test:= method("first" println; "second" println; return "exit"; "third" println) ==> method("first" println; "second" println; return "exit"; "third" println) Io> tester la première seconde ==> quitter Io>

Le langage Io implémente également une boucle pour chaque, mais son application pratique est quelque peu différente de l'utilisation des cycles traditionnels, donc ce cycle sera considéré dans de futurs articles.

Conclusion

Le langage Io est un langage objet pur, c'est-à-dire une implémentation du concept "tout est un objet". Sa syntaxe est simple et claire, même si à première vue elle peut sembler inhabituelle. Io implémente toutes les constructions et opérateurs standard de facto.

Le premier article de la série décrit Caractéristiques générales et la syntaxe du langage de programmation Io. Le deuxième article examinera le système d'objets du langage et le troisième article examinera les fonctionnalités et capacités supplémentaires d'Io.