Machine virtuelle exécuter des scripts dans le langage 1C:Enterprise.

En d'autres termes, il s'agit de la possibilité d'écrire des programmes en langage 1C sans utiliser la plateforme 1C:Enterprise.

Et cela nous permet finalement de prendre des morceaux de code prêts à l'emploi écrits dans le configurateur et de les transférer vers un programme OneScript avec une adaptation minimale.

Et même si, selon les développeurs, ce n'est pas l'objectif principal du projet, je vois l'intérêt de se connecter d'un programme OneScript à la base de données 1C via une connexion externe et d'exécuter du code utile.

Vous vous demandez peut-être : pourquoi est-ce nécessaire ? Pourquoi ne pas écrire le même code lors du traitement et l'exécuter via 1c de la manière standard ?

Mais nous parlons d’automatisation et il y a ici des problèmes fondamentaux :

• il n'y a aucun moyen de garantir que la base de données démarrera et qu'un code de traitement externe y sera exécuté (ceux qui ont rencontré cela dans la pratique savent que trop de choses peuvent mal tourner, à commencer par le fait que le traitement ne sera tout simplement pas terminé en raison d'une fenêtre modale)
• Non manière simple générer un tel traitement par programme, mais nous pourrions en avoir besoin si nous parlons d'exécuter du code utile sur un groupe de bases de données
• il n'existe pas de moyen simple de consigner l'exécution de ce traitement

OneScript résout tous ces problèmes.

Pourquoi écrire et exécuter ces scripts dans le programme de mise à jour ?

Parce que le programme de mise à jour entreprend un certain nombre de choses difficiles pour simplifier l'écriture de tels scripts en termes d'interaction avec les bases de données.

À savoir.

Liste des bases de données à traiter

Directement dans le programme de mise à jour, nous sélectionnons le nombre de bases de données dont nous avons besoin pour exécuter le script que nous avons écrit :

Passer les paramètres de la base de données

Lors de l'exécution du script, le programme de mise à jour lui-même lui transmet les paramètres nécessaires avec des informations sur la base de données actuelle :

Nous pouvons utiliser tous ces paramètres dans notre script, le rendant universel pour une exécution sur un nombre illimité de bases de données sélectionnées.

Nous pouvons trouver des exemples de tels scripts dans la liste des modèles de mise à jour :

Archivage préliminaire de la base de données

Si nécessaire, le programme de mise à jour veillera à ce qu'une copie de sauvegarde soit créée avant d'exécuter le script :

Cette sauvegarde sera cohérente avec système commun l'archivage, c'est-à-dire qu'il peut également être soumis à un « réglage » paramètres additionnels programme de mise à jour. Une telle copie portera toujours la mention « avant opération dangereuse ».

Verrouillage, déverrouillage de la base

Si nécessaire, le programme de mise à jour bloquera complètement la base de données avant d'exécuter votre script et la déverrouillera après :

Et c'est l'une des "fonctionnalités" clés du programme de mise à jour - après tout, par exemple, bloquer correctement une base de serveurs dans le cas général est une tâche plutôt non triviale.

Il faut "s'installer" connexions actuelles utilisateurs, connexions administratives, réalisation de tâches en arrière-plan. Et tout cela grâce à une communication directe avec le cluster 1c.

Enregistrement des rapports

Le programme de mise à jour enregistre l'historique d'exécution de ces scripts dans le gestionnaire de rapports.

De façon générale:

Donc en détail :

Notification par email

Si vous avez configuré des notifications par e-mail (toutes ou uniquement pour les erreurs)...

Il s'agit d'informations sur l'exécution du script (y compris rapports détaillés) vous parviendra de la même manière que les informations sur l'exécution d'autres opérations provenant du programme de mise à jour :

Exécuter un script selon un planning

Surveillance du cloud

Lors de l'enregistrement du script, nous avons également la possibilité de surveiller son travail dans le cloud - une fonctionnalité absolument étonnante à mon avis. Il s'agit de surveillance du cloud.

Exécution de script multithread

Comment exécuter un script en parallèle pour plusieurs bases de données est décrit en détail.

Qu'est-ce qu'il est utile d'apprendre d'autre avant d'écrire des scripts ?

Et bien sûr, le langage 1C lui-même. Où serions-nous sans lui...

Tout d'abord, il y a cet ouvrage de référence du langage 1C avec des exemples : .

Il convient également de passer en revue les différences entre OneScript et le langage standard 1C. Il y en a quelques-uns (lien).

Comment puis-je créer mes propres scripts ?

Pour vous inspirer, je vous conseille d'abord d'analyser et de comprendre les scripts des modèles de mise à jour. Cela vous apportera déjà beaucoup.

Et si vous avez besoin d'une idée pour écrire un script qui sera utile à des centaines d'autres utilisateurs, alors je vous le demande : écrivez-moi à ce sujet de la manière qui vous convient. J’ai énormément d’idées, mais je n’ai pas assez de temps et d’opportunités.

Pour ce faire, j'ai lancé un projet spécial sur github, où je collecte des scripts utiles auprès des utilisateurs de la mise à jour, afin que le plus possible grande quantité les gens pouvaient les utiliser dans leur travail.

Souhaitez-vous m'envoyer votre scénario ? Je te demande de .

Cordialement, Vladimir Milkin (enseignant et développeur).

Dans cet article:

• Placer PHP sur une page HTML
• Commentaires dans les scripts
• Affichage du texte
• Variables et constantes en PHP
• Opérateur d'assignation
• À propos des types de données

N'importe quel éditeur de texte (par exemple Notepad++) est adapté pour écrire du code en PHP.

Placer PHP sur une page HTML

Code Script PHP peut être placé directement sur une page HTML. Pour voir comment cela se fait, regardons l'exemple simple suivant :

Ceci est un document HTML normal

À première vue, l'exemple ressemble à fichier régulier HTML. La seule innovation ici est le design.

Tout ce qui est entre est interprété comme du code Langage PHP. Ici, nous voyons également un exemple d'utilisation de la commande echo, l'une des commandes les plus importantes et fréquemment utilisées lors de la programmation dans ce langage. La commande echo est utilisée lorsque vous devez écrire quelque chose dans le document actuel. Alors le nôtre petit programme en PHP dans un document HTML affiche la phrase « Et ceci est PHP ». Tout ce qui se trouve en dehors du processeur PHP est transféré sans modification directement vers la page web dynamique.

Au lieu d'une balise spéciale, les balises suivantes peuvent également être utilisées :

Code PHP

Notre premier scénario

Les textes des scripts (programmes php) doivent être stockés dans des fichiers avec l'extension php.

Le code PHP se compose d'instructions individuelles, dont chacune se termine par un point-virgule (l'absence d'un point-virgule entraînera un message d'erreur).

Le premier script PHP (fichier index.php) sera assez simple, mais il démontrera déjà partage HTML et PHP.

Premier exemple

Le programme PHP se compose de deux instructions d'affectation, définissant la valeur d'une constante et imprimant le texte et la date actuelle dans la fenêtre du navigateur à l'aide de la commande echo.

Ce texte peut être saisi dans n'importe quel éditeur de texte, par exemple, dans NotePad++, et enregistrez-le sous le nom index.php. Vous devez vous assurer que le fichier est enregistré en tant que fichier php, dans sinon il ne sera pas traité correctement par PHP.

Quand travail local vous devez copier le fichier index.php dans le répertoire de documents du serveur Web. Pour Denver, il s'agit de home/localhost/www (sauf indication contraire dans les paramètres). Après quoi, vous pouvez procéder directement à l’exécution du script.

Pour exécuter le script index.php, ouvrez votre navigateur Web puis saisissez dans la barre d'adresse chemin completà ce script. Quand installation locale l'adresse sera comme ceci :

Si tout est fait correctement, nous verrons à l'écran :

Fichier Styles.css (feuille de style) :

/* Styles d'affichage du contenu de la page */ * ( margin : 0 ; padding : 0 ; ) body ( font-family : Verdana, Arial, sans-serif ; color : #14556b ; background-color : #f2f2f2 ; margin : 20px ; ) h3, p ( margin: 6px 0; /* Marges de titre et de paragraphe */ )

Directement depuis le navigateur, nous pouvons visualiser le code de cette page généré par le serveur web :

Ainsi, le nom de la variable est remplacé par sa valeur, qui est placée au même endroit, où se trouvait le nom de cette variable dans le programme.

Ainsi, les fichiers PHP sont généralement un mélange de HTML, CSS et PHP. Dans ce cas, le code PHP est toujours contenu dans le fichier . Le serveur web envoie le code HTML au navigateur sans modification. Le code PHP est exécuté, et s'il génère des balises et du texte à afficher, ce texte est inséré à cet endroit, où se trouvait le code PHP. Le navigateur interprète les balises HTML de la page et affiche le résultat à l'écran.

Le code PHP peut être localisé n’importe où et être inclus plusieurs fois dans le texte du script. Il peut également être utilisé pour générer des balises HTML, comme le montre notre exemple.

Commentaires dans les scripts

Il existe trois types de commentaires en PHP. La première permet de placer des commentaires sur plusieurs lignes, commençant par /* (écrit sans espace) et se terminant par */, par exemple :

Il faut garder à l'esprit que Les commentaires imbriqués ne peuvent pas être écrits.

Les commentaires multilignes peuvent être utiles lorsque vous devez insérer une quantité importante de texte. De plus, une technique courante lors du débogage d’un programme consiste à commenter une partie du code (pour l’empêcher de s’exécuter).

Les deux autres types de commentaires commencent par le symbole // ou # et se poursuivent uniquement jusqu'à la fin de la ligne dans laquelle ils sont écrits. Ce type de commentaire est pratique car il peut être placé à droite des affirmations, par exemple :

Très souvent un commentaire est ajouté au début du script pour donner des informations à son sujet. information brève et indiquer les fonctions qu'il remplit. Par exemple:

Affichage du texte

L'opérateur echo, conçu pour afficher du texte arbitraire sur une page Web, est peut-être l'opérateur PHP le plus couramment utilisé. Dans le cas le plus simple, après echo, vous devez placer une ligne entre guillemets. Le texte peut être entouré comme double citation, et entre guillemets simples ( apostrophes). Pour afficher des nombres, les guillemets sont facultatifs, par exemple :

En général, après echo, vous pouvez écrire plusieurs lignes de sortie, séparées par des virgules.

Si nécessaire, une longue ligne peut être placée sur plusieurs lignes du texte du script, par exemple :

Des chaînes individuelles peuvent être concaténées à l'aide de l'opérateur de concaténation "." -- point. Le résultat est une chaîne unique transmise à l’opérateur echo. Par exemple:

ce qui est équivalent

Pour afficher un guillemet, faites-le précéder d'une barre oblique inverse, par exemple :

Note. S'il y en a un qui s'affiche chaîne de texte, alors au lieu de l'opérateur echo, vous pouvez utiliser la fonction d'impression. Dans ce cas, il n'y a pas de différence entre echo et print. Cependant, en écho, nous pouvons ajouter d'autres lignes à la première ligne, séparées par des virgules.

Affichage d'un texte volumineux

Lorsque vous utilisez echo pour afficher une grande quantité de texte, cela peut être écrit comme ceci : nous mettons d'abord les caractères .

Variables, opérateur d'affectation

Comme dans tout langage de programmation, les variables sont conçues pour stocker des données. En PHP, les noms de variables commencent toujours par un signe dollar $, suivi d'une lettre ou d'un trait de soulignement, et peuvent être suivis de n'importe quel nombre de lettres, de chiffres ou de traits de soulignement. Gardez à l’esprit que les noms de variables ont des lettres majuscules et minuscules différentes. Par exemple, $var et $Var sont des variables différentes.

Après création variable (suite à l'attribution d'une valeur), l'accès à cette variable est possible n'importe où dans le script. Dans ce cas, une même variable peut contenir des valeurs de types différents tout au long du programme.

La variable existe tant que le programme est exécuté.

Pour attribuer une valeur à une variable en PHP, utilisez opérateur d'assignation, désigné par le signe égal =. Voici des exemples d'opérateurs d'affectation :

$température = 24 ;

$number_of_earths = 1 ;

$pi = 3,1415926535 ;

$message = « Bonjour ! » ;

Veuillez noter que certaines variables se voient attribuer des numéros et d'autres des chaînes.

Exercice . Affichez toutes les valeurs de ces variables dans le navigateur : (1) chaque valeur – dans nouvelle ligne; (2) –– toutes les valeurs –– sur une seule ligne.

Constantes

Parfois, il n'est pas nécessaire de modifier une seule fois la valeur spécifiée dans le programme. A cet effet, ils sont utilisés constantes- leurs valeurs ne changent pas lors de l'exécution du script.

Pour décrire une constante, utilisez la fonction de définition, à laquelle est transmis le nom de la constante et sa valeur. Il existe une convention selon laquelle les noms de constantes sont toujours écrits en majuscules ( en majuscule), Par exemple:

définir ("PI", 3.1415926535);

Attention, lors de la définition d'une constante, celle-ci n'est pas précédée du signe dollar. Essayer de modifier la valeur d'une constante à l'aide de l'opérateur d'affectation entraînera une erreur.

Les constantes ne peuvent pas recevoir de noms qui sont des mots de fonction PHP (puisque le nom de la constante n'est pas précédé d'un signe dollar).

Mots (de service) réservés de RHP :

et	tableau	comme	casser	défaut
mourir	faire	écho	fin si	interrupteur de fin de course
finir pendant	mondial	si	inclure	imprimer
exiger	évaluer	linclude_onc e	Demandez une fois	retour
cas	avec fonction	classe	const	continuer
déclarer	autre	sinon	vide	findeclarer
finpour	fin pour chaque	exception	sortie	s'étend
pour	pour chaque	fonction	isset	liste
nouveau	ancienne_fonction	ou	php_user_filter	statique
changer	désarmé	utiliser	alors que	xor

Le langage PHP définit de nombreuses constantes intégrées pouvant être utilisées dans les scripts. Ces constantes commencent par deux traits de soulignement et se terminent par deux traits de soulignement. Par exemple:

__CLASSER__

__DÉPOSER__

__FONCTION__

__DOUBLER__

__MÉTHODE__

Abandon de l'exécution du script

Le moyen le plus courant d'arrêter l'exécution d'un script est exit(). Un autre fonction utile is die (« Message »), qui permet également d'afficher un message d'erreur. Cela vous permet d'indiquer à l'utilisateur pourquoi le script a échoué.

Détruire une variable

Parfois, vous devez forcer la destruction d’une variable. La fonction unset() est conçue pour cela.

Si nous essayons de faire écho à « $variable » après avoir appelé la fonction unset, nous obtiendrons un message d'erreur : la variable $variable n'existera plus.

Vous pouvez détruire plusieurs variables à la fois :

unset($variable, $nom);

Vous pouvez sauter le texte suivant en première lecture

Types de données

En PHP, le type d'une variable est déterminé automatiquement lorsqu'une variable est créée en fonction de sa valeur. Cependant, vous devez être conscient des types de données qui peuvent être utilisées. Il y en a huit au total :

• De type booléen, contient les valeurs VRAI ou FAUX.
• Entier.
• Nombre réel.
• Texte de longueur arbitraire.
• Tableau.
• Un objet.
• Ressource (par exemple, fichier).
• NULL La valeur est NULL.

Par exemple:

$variable = VRAI ;

Dans ce cas, le type de variable est déterminé de manière unique. La difficulté commence lors du mélange de différents types de données dans une expression, par exemple lors de l'ajout d'un entier et d'une chaîne représentant un nombre. Voici quelques exemples de telles expressions :

Pour éviter des problèmes potentiels, ne mélangez pas Divers types données. Malgré cela, PHP effectue une conversion de type implicite. Si vous devez effectuer une conversion de type explicite, le type requis doit être indiqué à gauche du nom de la variable entre parenthèses. Voici quelques exemples de conversion de type explicite :

$int_variable = (entier) $variable ;

$float_variable = (float) $variable ;

$string_jyariable = (chaîne) $variable ;

Une fois converties en booléen, les valeurs suivantes sont converties en FALSE.

• Entier 0.
• Nombre réel 0,0.
• Chaîne vide et chaîne « 0 ».
• Un tableau avec zéro élément.
• Un objet qui n'a aucune propriété.
• Type spécial NULL.

Lors de la conversion en type valeur entière, les autres types sont convertis comme suit :

• Le FAUX logique est converti en entier 0, le VRAI logique est converti en entier 1.
• Les chiffres réels sont arrondis à l’inférieur. Lors de la conversion en nombre réel, la conversion en valeur entière est d'abord effectuée.

Il est également possible de convertir des valeurs de chaîne en types numériques données, mais il existe un certain nombre de fonctionnalités.

Toutes les autres valeurs, y compris toutes les ressources, sont converties en TRUE.

Résultats

Le langage PHP est conçu pour créer des pages Web dynamiques.

• Le code PHP est contenu entre les balises.
• L'instruction echo est conçue pour afficher du texte.
• Il est possible d'inclure de gros blocs de texte dans le code PHP
• PHP utilise trois types de commentaires : /* ... */, // et #.
• Le nom de la variable est précédé du signe dollar $, commence par une lettre ou un trait de soulignement et peut être suivi d'un nombre quelconque de lettres, de chiffres ou de traits de soulignement.

Aussi simple soit-il Interface graphique sous Linux et quel que soit le nombre de fonctions disponibles, il existe toujours des tâches plus pratiques à résoudre via le terminal. D'une part parce qu'il est plus rapide, et d'autre part, toutes les machines ne disposent pas d'une interface graphique, par exemple, sur les serveurs, toutes les actions sont effectuées via le terminal afin d'économiser des ressources informatiques.

Si tu as déjà fini utilisateur avancé, alors vous effectuez probablement souvent diverses tâches via le terminal. Il existe souvent des tâches pour lesquelles vous devez exécuter plusieurs commandes à tour de rôle, par exemple, pour mettre à jour le système, vous devez d'abord mettre à jour les référentiels, puis télécharger de nouvelles versions de packages. Ceci n'est qu'un exemple et il existe de nombreuses actions de ce type, même sauvegarde et télécharger les fichiers copiés sur serveur distant. Ainsi, afin de ne pas taper plusieurs fois les mêmes commandes, vous pouvez utiliser des scripts. Dans cet article, nous examinerons l'écriture de scripts dans Bash, les opérateurs de base et leur fonctionnement, pour ainsi dire. scripts bash de zéro.

Un script, ou comme on l'appelle aussi, un script, est une séquence de commandes qui sont lues tour à tour et exécutées par un programme interpréteur, dans notre cas c'est un programme ligne de commande- bash.

Un script est un fichier texte ordinaire qui répertorie les commandes habituelles que nous avons l'habitude de saisir manuellement, ainsi que le programme qui les exécutera. Le chargeur qui exécutera le script ne sait pas comment travailler avec les variables d'environnement, il doit donc lui transmettre le chemin exact du programme à lancer. Et puis il transférera votre script vers ce programme et l'exécution commencera.

Un exemple simple de script shell Bash :

!/bin/bash
faire écho à "Bonjour tout le monde"

L'utilitaire echo affiche la chaîne qui lui est transmise en tant que paramètre à l'écran. La première ligne est spéciale, elle précise le programme qui va exécuter les commandes. D'une manière générale, on peut créer un script dans n'importe quel autre langage de programmation et spécifier l'interpréteur souhaité, par exemple en python :

!/usr/bin/env python
print("Bonjour tout le monde")

Ou en PHP :

!/usr/bin/envphp
echo "Bonjour tout le monde" ;

Dans le premier cas, nous avons directement pointé vers le programme qui exécutera les commandes ; dans les deux suivants, nous ne connaissons pas l'adresse exacte du programme, nous demandons donc à l'utilitaire env de le trouver par son nom et de l'exécuter. Cette approche est utilisée dans de nombreux scripts. Mais ce n'est pas tout. DANS Système Linux Pour que le système exécute le script, vous devez définir l'indicateur exécutable sur le fichier avec celui-ci.

Cet indicateur ne change rien dans le fichier lui-même, il indique seulement au système qu'il ne s'agit pas simplement d'un fichier texte, mais d'un programme et qu'il doit être exécuté, ouvrir le fichier, reconnaître l'interpréteur et l'exécuter. Si aucun interpréteur n'est spécifié, l'interpréteur de l'utilisateur sera utilisé par défaut. Mais comme tout le monde n’utilise pas bash, vous devez le spécifier explicitement.

Faire:

chmod ugo+x fichier_script

Lançons maintenant notre petit premier programme :

./Fichier de script

Tout fonctionne. Vous savez déjà comment écrire un petit script, par exemple pour une mise à jour. Comme vous pouvez le voir, les scripts contiennent les mêmes commandes que celles exécutées dans le terminal, et ils sont très simples à écrire. Mais maintenant, nous allons rendre les choses un peu plus compliquées. Puisqu'un script est un programme, il doit prendre certaines décisions par lui-même, stocker les résultats de l'exécution des commandes et exécuter des boucles. Le shell Bash vous permet de faire tout cela. C'est vrai, tout est beaucoup plus compliqué ici. Commençons par quelque chose de simple.

Variables dans les scripts

L'écriture de scripts dans Bash est rarement complète sans sauvegarder des données temporaires, ce qui signifie créer des variables. Aucun langage de programmation ne peut se passer de variables, y compris notre langage primitif de shell de commande.

Vous avez peut-être déjà rencontré des variables d'environnement. Ce sont donc les mêmes variables et elles fonctionnent de la même manière.

Par exemple, déclarons une variable chaîne :

string="Bonjour tout le monde"

La valeur de notre chaîne est entre guillemets. Mais en réalité, les guillemets ne sont pas toujours nécessaires. Le principe principal de bash reste ici : un espace est Caractère spécial, un délimiteur, donc si vous n'utilisez pas de guillemets, world sera déjà considéré comme une commande distincte, pour la même raison nous ne mettons pas d'espaces avant et après le signe égal.

Le symbole $ est utilisé pour afficher la valeur d'une variable. Par exemple:

Modifions notre script :

!/bin/bash
string1="bonjour"
chaîne2=monde
chaîne=$chaîne1$chaîne2
écho $chaîne

Et on vérifie :

Bash ne fait pas de distinction entre les types de variables de la même manière que les langues haut niveau Par exemple, en C++, vous pouvez attribuer à la fois un nombre et une chaîne à une variable. De même, tout cela sera considéré comme une chaîne. Le shell ne prend en charge que la fusion de chaînes ; pour ce faire, écrivez simplement les noms des variables dans une ligne :

!/bin/bash
string1="bonjour"
chaîne2=monde
string=$string1$string2\ et\ moi
string3=$string1$string2" et moi"
écho $string3

Nous vérifions:

Veuillez noter que comme je l'ai dit, les guillemets sont facultatifs s'il n'y a pas de caractères spéciaux dans la chaîne. Examinez de plus près les deux méthodes de fusion de chaînes, elles démontrent également le rôle des guillemets. Si tu as besoin de plus des moyens complexes traitement de chaîne ou opérations arithmétiques, cela n'est pas inclus dans les capacités du shell, des utilitaires réguliers sont utilisés pour cela.

Variables et sortie de commande

Les variables ne seraient pas aussi utiles si elles ne pouvaient pas stocker les résultats des utilitaires en cours d'exécution. La syntaxe suivante est utilisée pour cela :

$(commande)

Avec cette conception, la sortie de la commande sera redirigée directement vers l'endroit d'où elle a été appelée, plutôt que vers l'écran. Par exemple, l'utilitaire de date renvoie date actuelle. Ces commandes sont équivalentes :

Est-ce que tu comprends? Écrivons un script qui affiche hello world et la date :

string1="bonjour tout le monde"
chaîne2=$(date)

chaîne=$chaîne1$chaîne2

Vous en savez maintenant suffisamment sur les variables pour être prêt à créer un script bash, mais il y a bien plus à venir. Nous examinerons ensuite les paramètres et les structures de contrôle. Permettez-moi de vous rappeler que ce sont toutes des commandes bash classiques et que vous n'avez pas besoin de les enregistrer dans un fichier ; vous pouvez les exécuter immédiatement, lors de vos déplacements.

Paramètres des scripts

Il n'est pas toujours possible de créer un script bash qui ne dépend pas des entrées de l'utilisateur. Dans la plupart des cas, vous devez demander à l'utilisateur quelle action entreprendre ou quel fichier utiliser. Lors de l'appel d'un script, nous pouvons lui transmettre des paramètres. Tous ces paramètres sont disponibles sous forme de variables nommées sous forme de nombres.

Une variable nommée 1 contient la valeur du premier paramètre, la variable 2 contient la valeur du second, et ainsi de suite. Ce script bash imprimera la valeur du premier paramètre :

!/bin/bash
écho 1 $

Constructions de contrôle dans les scripts

Créer un script bash ne serait pas aussi utile sans la capacité d'analyser certains facteurs et d'effectuer les actions nécessaires en réponse à ceux-ci. C'est un sujet assez complexe, mais il est très important pour créer un script bash.

Dans Bash, il existe une commande pour vérifier les conditions. Sa syntaxe est la suivante :

si condition_commande
alors
équipe
autre
équipe
Fi

Cette commande vérifie le code de sortie de la commande condition, et si 0 (succès) exécute alors la commande ou plusieurs commandes après le mot alors, si le code de sortie est 1, le bloc else est exécuté, fi signifie la fin du bloc de commande .

Mais comme nous ne nous intéressons le plus souvent pas au code retour de la commande, mais à la comparaison de chaînes et de nombres, la commande [[ a été introduite, qui permet d'exécuter diverses comparaisons et émettez un code retour en fonction du résultat de la comparaison. Sa syntaxe est :

[[ paramètre1 opérateur paramètre2 ]]

A titre de comparaison, nous utilisons les opérateurs déjà familiers ,=,!=, etc. Si l'expression est vraie, la commande renverra 0, sinon 1. Vous pouvez tester un peu son comportement dans le terminal. Le code retour de la dernière commande est stocké dans la variable $? :

Maintenant, en combinant tout cela, nous obtenons un script avec une expression conditionnelle :

!/bin/bash
si [[ $1 > 2 ]]
alors
echo $1" est supérieur à 2"
autre
echo $1" est inférieur à 2 ou 2"
Fi

Bien sûr, cette conception a des capacités plus puissantes, mais il est trop complexe pour les aborder dans cet article. Peut-être que j'écrirai à ce sujet plus tard. Pour l'instant, passons aux cycles.

Boucles dans les scripts

L'avantage des programmes est que l'on peut indiquer en quelques lignes quelles actions doivent être effectuées plusieurs fois. Par exemple, il est possible d'écrire des scripts bash composés de quelques lignes seulement, mais exécutés pendant des heures, analysant les paramètres et effectuant les actions nécessaires.

Regardons d'abord pour la boucle. Voici sa syntaxe :

pour la variable dans la liste
faire
équipe
fait

Parcourt toute la liste et attribue un par un valeur variable dans la liste, après chaque affectation, exécute les commandes situées entre do et done.

Par exemple, regardons cinq nombres :

pour index en 1 2 3 4 5
faire
écho $index
fait

Ou vous pouvez lister tous les fichiers du répertoire actuel :

pour le fichier dans $(ls -l); faire echo "$fichier" ; fait

Comme vous l'avez compris, vous pouvez non seulement afficher les noms, mais également effectuer les actions nécessaires, ce qui est très utile lors de la création d'un script bash.

Le deuxième cycle que nous examinerons est boucle while, elle est exécutée tant que la commande condition renvoie le code 0, succès. Regardons la syntaxe :

condition de commande while
faire
équipe
fait

Regardons un exemple :

!/bin/bash
indice=1
tandis que [[ $index< 5 ]]
faire
écho $index
laissez "index=index+1"
fait

Comme vous pouvez le voir, tout est fait, la commande let effectue simplement l'opération mathématique spécifiée, dans notre cas augmentant la valeur de la variable de un.

Je voudrais souligner encore une chose. Les constructions telles que while, for, if sont conçues pour être écrites sur plusieurs lignes, et si vous essayez de les écrire sur une seule ligne, vous obtiendrez une erreur. Mais cela est néanmoins possible : pour ce faire, là où il doit y avoir un saut de ligne, mettez un point avec une virgule ";". Par exemple, la boucle précédente pourrait être exécutée sur une seule ligne :

indice=1 ; tandis que [[ $index< 5 ]]; do echo $index; let "index=index+1"; done;

Tout est très simple, j'ai essayé de ne pas compliquer l'article avec des termes et capacités supplémentaires de bash, juste les choses les plus élémentaires. Dans certains cas, vous devrez peut-être créer une interface graphique pour un script bash, vous pourrez alors utiliser des programmes tels que zenity ou kdialog, avec l'aide d'eux, il est très pratique d'afficher des messages à l'utilisateur et même de lui demander des informations.

conclusions

Vous comprenez maintenant les bases de la création d'un script sous Linux et pouvez écrire le script dont vous avez besoin, par exemple, pour la sauvegarde. J'ai essayé de revoir les scripts bash à partir de zéro. Tous les aspects n’ont donc pas été pris en compte. Peut-être reviendrons-nous sur ce sujet dans l’un des articles suivants.

À l'aide de scripts (scénarios), nous traitons divers événements (par exemple, un clic de souris), analysons les entrées de l'utilisateur, modifions apparence une partie de la page ou même la page entière.

Comme indiqué à plusieurs reprises, le script est inséré dans le code HTML à l'aide de la balise, qui est généralement placée à l'intérieur de la balise head. Ceci est fait pour garantir que le code du script est chargé avant que la page ne soit affichée à l'écran. Vous pouvez également placer un script à la fin d'un document HTML afin que les éléments du document soient chargés avant que les opérations de script ne leur soient appliquées.

Utilisez l'attribut LANGUAGE pour spécifier le langage de script. Si le script est écrit en JavaScript, alors l'attribut LANGUAGE peut être omis, puisque JavaScript est considéré comme le langage standard (par défaut). Dans le navigateur Internet Explorer Des versions 4.0 à 6.0, vous pouvez également utiliser des scripts écrits en VBScript. Si vous écrivez en VBScript, l'argument de l'attribut LANGUAGE doit être soit VBScript, soit VBS.

L'insertion d'un script dans du code HTML se fait généralement selon le schéma suivant :

...


...

...

L'option typique utilisée ici est celle où le script est inséré à l'intérieur de la balise head, bien qu'il puisse être situé n'importe où dans le code HTML. Parfois, cela nécessite même que le script soit chargé après le chargement de certains éléments de la page.

L'attribut LANGUAGE de la balise peut accepter les arguments JavaScript, JScript, VBScript et VBS. Si l'attribut n'est pas spécifié, JavaScript est supposé.

Symboles< ! - и //-->former une balise de commentaire. Il est recommandé de les utiliser au cas où le navigateur de l'utilisateur ne serait pas en mesure d'interpréter le script. Par exemple, les navigateurs Netscape n'acceptent pas les scripts VBScript. Veuillez noter que la balise de commentaire dans ce cas est différente de la balise de commentaire habituelle.< ! >, utilisé en dehors d'un script pour insérer un texte explicatif qui n'est pas affiché à l'écran.

Il n'est pas nécessaire que le script soit placé au même endroit Document HTML là où cela peut être nécessaire. Il peut être placé dans un dossier régulier séparé fichier texte, mais avec l'extension js, et dans le document HTML, écrivez les instructions suivantes :

Par exemple:

Pour être précis, cela ne ferait pas de mal d'insérer l'attribut LANGUAGE= "JScript" dans la balise.

Lier des scripts aux éléments de la page
Le programme de script lui-même se trouve à l'intérieur de la balise. Ce programme peut faire tout ce que veut son auteur. Cependant, il contient généralement description des fonctions, qui doit être appelée lorsque des événements se produisent tels qu'un clic de souris, une touche enfoncée sur le clavier, le chargement d'une page, etc. De telles fonctions sont appelées gestionnaires d'événements. Pour que les fonctions de script soient appelées lorsqu'un événement particulier se produit, vous devez lier l'événement et sa fonction correspondante à un élément de page.

La connexion entre un événement et une fonction s'effectue au format :

événement="fonction"

Par exemple, si nous voulons associer un événement de clic de souris à une fonction MyfuncQ que nous définissons, nous utiliserions une notation telle que :

onclick="Monfonctionnement()"

Si cette fonction doit être appelée lors du chargement de la page dans le navigateur, alors vous devez écrire :

onload=IMyfunc()I

Nous avons examiné la connexion événement-fonction. Cependant, le même événement peut être perçu divers éléments pages. Par exemple, lorsqu'un bouton de la souris est cliqué, un bouton, une image et un titre peuvent répondre. Pour former une relation événement-fonction-élément, vous devez insérer un enregistrement de type event="function" dans la balise de l'élément de page, de la même manière que vous insérez un attribut. Par exemple, si nous voulons que la fonction Myfunc() soit appelée lorsque nous cliquons sur du texte à l'intérieur d'une balise, nous écrirons :

Du texte

La connexion entre un événement et une fonction peut être écrite dans la plupart des balises, par exemple dans, , , et etc.

Un autre est possible, manière non standard connexions « événement-fonction-élément ». Cela consiste dans le fait que l'attribut ID est spécifié dans la balise de l'élément de page (un identifiant qui fait office de NOM de cet élément, destiné à y accéder depuis le programme). Ensuite, le script définit une fonction dont le nom est formé selon la règle :

element_id.event()

Par exemple, si nous voulons qu'une fonction soit exécutée lorsque la souris est cliqué sur du texte entouré d'une balise, nous écrirons quelque chose comme ceci :

....
Du texte
....

....
fonction Mon.onclick()
....

....

Notez la relation entre la valeur de l'attribut ID dans la balise de l'élément de page et le nom de la fonction définie à l'intérieur de la balise de script : la valeur de l'ID et le nom de l'événement sont spécifiés dans le nom de la fonction. En JScript, ces composants de nom sont écrits avec un point et en VBScript, avec un trait de soulignement. L'extrait ci-dessus dans VBScript ressemble à ceci :

....
Du texte
....

....
Sous My_onclick()
....

Les connexions entre les événements et les fonctions définies dans le script, ainsi que la liaison de ces connexions aux éléments de la page, sont discutées en détail ci-dessous à l'adresse exemples spécifiques. Maintenant, donnons-le recommandations générales sur la création de gestionnaires d'événements.

Gestionnaires d'événements

Les gestionnaires d'événements doivent être écrits sous forme de fonctions ou de procédures. JScript utilise uniquement des fonctions, tandis que VBScript utilise principalement des procédures. Une fonction diffère d'une procédure uniquement en ce qu'elle renvoie une valeur. Il faut faire la distinction entre la description (définition) d'une fonction et son appel.

La description de la fonction dans JScript ressemble à ceci :

fonction nom_fonction (liste_paramètres)
{
... // code de fonction (corps)
};

Le mot-clé function indique à l'interpréteur (navigateur) que ce qui suit est une déclaration de fonction. La liste des paramètres, si elle est présente, est une séquence d'identifiants séparés par des virgules. Les identifiants sont simplement des désignations symboliques de paramètres, commençant par une lettre ou un trait de soulignement. Le code (corps) de la fonction est mis en évidence accolades. Les expressions dans le code, s'il y en a plusieurs, sont séparées par des points-virgules. Les commentaires commencent par une double barre oblique //. Si vous devez indiquer explicitement ce que la fonction doit renvoyer exactement, utilisez la commande

retour retour_result

Si la commande return n'est pas spécifiée, la valeur de la dernière expression évaluée est renvoyée. L'exemple suivant décrit une fonction de calcul de l'aire d'un rectangle :

fonction S_rectangle (a,b)
{
S=a*b;
Retour
};

Pour calculer la valeur de la fonction, utilisez l'appel :

nom_fonction (list_of_parameter_values)

Par exemple, pour calculer l'aire d'un rectangle de côtés 5 et 20, écrivez l'expression suivante :

S = S_rectangle(5,20)

Ici, la valeur renvoyée par la fonction S_rectangle est affectée à la variable S. Dans les appels de fonction, vous pouvez remplacer des variables, des fonctions et des expressions par des valeurs spécifiques. Voici un exemple :

x = 5 ;
S = S_rectangle(x,4+16)

Parce qu'une fonction renvoie une valeur, son appel peut participer à des expressions. Par exemple, pour calculer l'aire d'un triangle rectangle avec les pattes a et b, vous pouvez écrire le code suivant :

une = 5 ;
b = 20 ;
S_tr = 0,5*S_rectangle(a,b)

Cependant, nous pourrions déterminer fonction spéciale, qui calcule l'aire d'un triangle rectangle à partir de ses jambes :

fonction S_tr(a,b)
{
renvoie 0,5*S rectangle (a,b)

Variables

Lors du développement de programmes, en règle générale, des variables sont utilisées pour stocker les données initiales, ainsi que les résultats intermédiaires et finaux des calculs. Une variable est créée à l'endroit du programme où l'expression dans laquelle une valeur lui a été attribuée est apparue pour la première fois. Si une variable est créée dans le corps d'une fonction, elle ne sera accessible qu'au sein de cette fonction. Regardons un exemple :

// Calculez l'aire d'un triangle rectangle en utilisant
// fonctions pour l'aire d'un rectangle
une = 5 ;
b = 20 ;
S_tr = 0,5*S_rectangle (a,b) // Calcul de surface
// triangle rectangle.
fonction S_rectangle (a,b) // Description de la fonction
// calcule l'aire du rectangle.
{
S=a*b;
Retour
}

Ici, toutes les variables sont disponibles dans la fonction S_rectangle(), mais la variable S n'est pas disponible en dehors de celle-ci. Pour rendre la variable S disponible n'importe où dans le script, il vous suffit de la créer en dehors de la fonction. Par exemple, vous pouvez écrire l'expression S = 0 ; à l'endroit du script où les variables a et b sont définies.

Tout débutant Administrateur du système Linux rencontre tôt ou tard un concept tel que « scénario», que ce soit l'un des scripts de démarrage comme /etc/rc.d/rc ou un script de configuration écrit par le développeur du logiciel configurer. Dans cet article, je vais essayer de montrer qu'écrire des scripts dans coquille n'est pas quelque chose d'extraordinaire et est tout à fait réalisable même pour un débutant dans le monde de Linux.

Commençons par regarder ce qui se cache derrière les termes anglais. coquille Et scénario. Coquille, ou shell, comme le terme est parfois traduit, est un interpréteur de commandes, une interface entre l'utilisateur et le système d'exploitation, son noyau. Mais plus que cela, c’est aussi un puissant langage de programmation et de script. Il contient ses propres mots de fonction et structures de contrôle et vous permet d'y écrire des programmes. Ce programme de langage de script s'appelle scénario, peut combiner appels système et les équipes système opérateur, ainsi que des utilitaires externes, créant un outil puissant pour l'administration du système.

L'une des tâches de l'administration du système est la sauvegarde une information important. Par conséquent, regardons un exemple de script qui implémente des informations de sauvegarde.

Le début du temps

Donc, tout d’abord, nous devons comprendre la structure du script. Ce n’est rien de compliqué. Dans l'ensemble, scénario simple- juste une liste commandes système. Par exemple:

Echo Ceci est juste un exemple
qui suis je
uname -a

Ces commandes sont combinées dans un seul fichier. Mais le shell doit savoir qu’il doit traiter ce fichier, et pas seulement lire son contenu. Il existe une construction spéciale pour cela : #!

Cette conception s'appelle " sha-bang" En fait, # spécifie un commentaire, mais dans ce cas, sha-bang signifie qu'après cela, le chemin vers le gestionnaire de script ira. Par exemple:

#!/bin/bash
#!/bin/sh
#!/usr/bin/perl

Nous nous en tiendrons au shell Bash, Bourne-Again. Ce shell est installé par défaut sur presque tous les systèmes Linux et /bin/sh y renvoie. La fin du script est indiquée par le mot de service exit.

Forts de ces connaissances, écrivons notre premier script :

#!/bin/bash
echo Script simple # La commande echo affiche un message à l'écran
fais écho à toi :
whoami #whoami affiche le nom de l'utilisateur enregistré
echo Votre système a démarré
uptime # uptime indique l'heure à laquelle la machine a été allumée
écho aujourd'hui
date # date affiche la date et l'heure actuelles
echo C'est tout pour l'instant
sortie

Sauvegardons ce fichier sous le nom tutor1.sh. Exécutons la commande pour rendre le script exécutable.

Chmod + rx tuteur1.sh

Le résultat de l'exécution du script sera :

Voland@superstar:~/Doc/Open Source$ ./tutor1.sh
Script simple
Toi:
Voland
Votre système a démarré
14:38:46 jusqu'à 1:48, 2 utilisateurs, charge moyenne : 0,47, 0,43, 0,41
Aujourd'hui
Dim 26 février 14:38:46 MSK 2006
C'est tout pour le moment

Passons à quelque chose de plus sérieux.

Maintenant que nous avons appris à écrire des scripts de base, il est temps de passer aux choses sérieuses : écrire un script de sauvegarde.

Tout d'abord, il faut déterminer - copie de sauvegarde Qu'allons nous faire? Par conséquent, notre script doit pouvoir fonctionner avec la ligne de commande. Les arguments de ligne de commande sont spécifiés après le nom du script, séparés par un espace : somescript arg1 arg2 arg3. Le script perçoit les arguments par leurs numéros de séquence, nous utiliserons donc des constructions de la forme $argument_number, c'est-à-dire 1 $, 2 $, 3 $. $ est un caractère générique dont nous aurons également besoin lorsque nous travaillerons avec des variables. Les variables du script sont spécifiées sous la forme nom_variable=valeur. Nous utiliserons les variables MAXPARAMS pour définir le nombre maximum de paramètres de ligne de commande, BACKUPFILE pour définir le nom de l'archive, BACKUPDIR pour le dossier que nous sauvegarderons et ARCHIVEDIR pour le dossier où nous placerons l'archive. La partie la plus importante du script sera les commandes permettant de rechercher et d'archiver tous les fichiers et dossiers trouvés dans celui spécifié :

Trouver. -type f -print0 | xargs -0 tar rvf "$archive.tar" > /dev/null
gzip $archive.tar

Voyons ce que font ces commandes. find recherche dans le répertoire actuel (cela est indiqué par le premier argument ".") tous les fichiers et renvoie le chemin complet d'accès à ceux-ci (print0). Ces chemins sont redirigés vers la commande tar, qui rassemble tous les fichiers en un seul. Ensuite, à l'aide de la commande gzip, nous archivons le fichier tar résultant. Équipe > /dev/null pratique si vous archivez un grand nombre de des dossiers. Dans ce cas, leurs noms et leur chemin complet ne sont pas affichés sur la console.

L'étape suivante consiste à fournir des conseils à l'utilisateur sur la façon d'utiliser le script s'il commet des erreurs.

Par exemple, cette conception

Si [ $# -lt "$MAXPARAMS" ];
alors
écho

écho
sortie 0
Fi

indiquera que l'utilisateur n'a pas spécifié suffisamment d'arguments de ligne de commande. Si [condition]...fi spécifie une construction conditionnelle. $# -lt "$MAXPARAMS" vérifie le nombre de paramètres saisi et si ce nombre est inférieur à MAXPARAMS, l'utilisateur recevra un message indiquant une saisie erronée. La sortie 0 entraînera la fin du script sans spécifier de code d'erreur. Le dépassement du nombre autorisé de paramètres est vérifié de la même manière, seulement au lieu de ls (moins de - inférieur à), vous devez spécifier gt (supérieur à - supérieur à). Maintenant que les principaux points du script sont expliqués, nous pouvons passer à sa version complète :

#!/bin/bash
# Description:
#+ Fait une copie de sauvegarde de tous les fichiers du répertoire spécifié
#+ dans "tarball" (archive tar.gz).
#+ Utilisation :
#+ sh backup.sh archive_name dossier source dossier de destination
#+

# Quantité maximale options de ligne de commande
MAXPARAMS=3

si [ $# -lt "$MAXPARAMS" ];
alors
écho
echo "Utilisation : sh `basename $0` archive_name dossier source dossier de destination"
écho
sortie 0
Fi

si [ $# -gt "$MAXPARAMS" ];
alors
écho
echo "Ce script nécessite uniquement des arguments de ligne de commande $MAXPARAMS !"
écho
sortie 0
Fi

# Variables que nous utilisons dans le script
BACKUPFILE=$1-sauvegarde-$(date +%m-%d-%Y)
archive=$BACKUPFILE
RÉIR SAUVEGARDE=2 $
RECHERCHE ARCHIVE=$3

# Vérifiez s'il existe un dossier source et un dossier de destination
si [! -e $BACKUPDIR ];
alors
écho
echo "\"$BACKUPDIR\" n'existe pas !"
écho
sortie 0
Fi

si [! -e $ARCHIVEDIR ];
alors
écho
echo "\"$ARCHIVEDIR\" n'existe pas, création..."
mkdir $ARCHIVEDIR
echo "Terminé".
Fi

# Vérifiez s'il y a des archives dans la source et la destination.
cd $ARCHIVEDIR
si [ -e $archive.tar.gz ];
puis rm $archive.tar.gz
Fi

cd $REPRISE DE SAUVEGARDE
si [ -e $archive.tar.gz ];
puis rm $archive.tar.gz
Fi

# La partie principale du script...
echo "Faire une copie de sauvegarde de \"$BACKUPDIR\" dans le fichier \"$archive.tar.gz\"..."
trouver . -type f -print0 | xargs -0 tar rvf "$archive.tar" > /dev/null
gzip $archive.tar
echo "\"$BACKUPDIR\" a été archivé avec succès dans le fichier \"$archive.tar.gz\"."

# Déplacez l'archive dans le dossier ARCHIVEDIR
echo "Déplacement de l'archive \"$archive.tar.gz\" vers le dossier \"$ARCHIVEDIR\"."
mv $archive.tar.gz $ARCHIVEDIR/$archive.tar.gz
echo "Terminé".

J'espère avoir commenté les points principaux de manière suffisamment détaillée. Si vous avez des questions, vous pouvez me contacter au [email protégé] Je recommande également le merveilleux livre Advanced Bash-Scripting Guide de Mendel Cooper, qui m'a beaucoup aidé lorsque je commençais tout juste à me familiariser avec les scripts. Bonne programmation.

P.S. Un grand merci à mar pour ses commentaires et conseils.