Vérification de l'exactitude des paramètres de fonction. Pourquoi la vérification du formulaire est-elle nécessaire ?

L'avant-dernier vendredi, j'ai participé à une discussion intéressante. DANS aperçu général, nous parlions de comment et comment ne pas vérifier les paramètres de fonction. En particulier, les restes mortels des fonctions IsBadReadPtr et IsBadWritePtr ont finalement été piétinés et anathématisés.

Si vous lisez « Dois-je vérifier les paramètres de ma fonction ? " sur le blog de Larry Osterman, et si vous êtes partisan de la deuxième approche, vous n'avez pas besoin de lire plus loin. :-)

Autrefois, les fonctions IsBadReadPtr et IsBadWritePtr étaient utilisées pour vérifier la validité des pointeurs transmis. Cependant, au fil du temps, il s’est avéré que ces fonctions font plus de mal que de bien. Premièrement, plutôt que de détecter les pointeurs invalides (ce qui était le but recherché par leurs créateurs), ces fonctions étaient plus susceptibles de masquer les erreurs. Deuxièmement, même un test réussi d'un pointeur utilisant l'une des fonctions ne garantissait pas le succès de l'opération suivante avec cette mémoire dans un environnement multitâche. Troisièmement, IsBadWritePtr corrompt la mémoire à une adresse pratiquement aléatoire - une garantie que l'application plantera toujours plus tard, mais seulement avec de gros problèmes. Quatrièmement, même IsBadReadPtr peut être à l'origine d'un échec d'application si l'adresse testée tombe sur la page de garde de la pile. En conséquence, le système perdra la capacité d'augmenter la pile selon les besoins et l'application plantera si elle tente de le faire.

Comment vérifier correctement les pointeurs passés ? La règle est simple : toute valeur de pointeur différente de 0 est considérée comme correcte. Si le pointeur pointe réellement dans la mauvaise direction, l'application se terminera par une erreur d'accès, ce qui est généralement mauvais, mais permet de trouver et de corriger les erreurs plus rapidement.

Cette règle ne fonctionne pas dans des cas particuliers, comme un point d'entrée dans le noyau du système d'exploitation ou RPC. Bien que dans le cas de RPC, chaque côté contrôle l'allocation des tampons, la fonctionnalité IsBadXxxPtr n'est toujours pas requise.

Dans le cas d'un appel au noyau, l'exactitude des pointeurs doit être vérifiée, cependant, même dans ce cas, IsBadXxxPtr ne fonctionne pas. Le noyau NT utilise les fonctions ProbeForRead et ProbeForWrite, qui ressemblent beaucoup à IsBadXxxPtr. Bien que similaire, ProbeForXxx vérifie principalement que le tampon transmis se trouve entièrement dans l'espace d'adressage de l'utilisateur, et non que le tampon est alloué à une mémoire valide. Les autres appels au tampon transféré sont dans tous les cas entourés d'un bloc __try - __sauf. En d'autres termes, cette vérification garantit que le code utilisateur ne peut pas amener le code du noyau à accéder à une adresse dans l'espace d'adressage du noyau. Ainsi, la situation d'endommagement de la page de protection de la pile du noyau à la suite d'une demande du code utilisateur n'est pas possible. Il va sans dire que la page de protection de la pile utilisateur peut encore être affectée. Mais ici, c'est l'application elle-même qui est à blâmer.

Cette section est dédiée à la description d’une approche intermédiaire. Basique solutions pratiques présenté dans la conférence 17.

En étudiant l’option d’épinglage, nous avons remarqué que son idée principale était la séparation des ensembles d’entités covariantes et polymorphes. Donc, si l'on prend deux instructions de la forme

chacun d'eux sert d'exemple application correcte mécanismes OO importants : le premier est le polymorphisme, le second est la redéfinition du type. Les problèmes commencent lorsqu’on les combine pour la même entité. De même:

p.add_vertex(...)

les problèmes commencent par la combinaison de deux opérateurs indépendants et totalement innocents.

Les mauvais appels entraînent des violations de type. Dans le premier exemple, l'affectation polymorphe attache l'objet BOY à l'entité s, ce qui fait de g un argument non valide à partager car il est associé à l'objet GIRL. Dans le deuxième exemple, un objet RECTANGLE est attaché à l'entité, ce qui exclut add_vertex de l'exportation.

Voici l'idée d'une nouvelle solution : à l'avance - de manière statique, lors de la vérification des types avec un compilateur ou d'autres outils - nous définissons un ensemble de caractères pour chaque entité, y compris les types d'objets auxquels l'entité peut être associée au moment de l'exécution. Ensuite, toujours de manière statique, nous nous assurons que chaque appel est correct pour chaque élément du type cible et des ensembles d'arguments.

Dans nos exemples, l'opérateur s:= b indique que la classe BOY appartient au type défini pour s (car l'instruction create b la fait appartenir au type défini pour b, en vertu de l'instruction create g,). appartient au type défini pour g. Mais alors l'appel à share serait invalide pour une cible de type BOY et un argument de type GIRL . De même, RECTANGLE est dans le type défini pour p en raison d'une affectation polymorphe, cependant, appeler add_vertex pour p de type RECTANGLE ne serait pas valide.

Ces observations nous amènent à réfléchir à la création d’une approche globale basée sur une nouvelle règle de typage :

Règle d'exactitude du système

Un appel à x.f(arg) est correct pour le système si et seulement s'il est correct pour la classe x et arg ayant n'importe quel type dans leurs ensembles de types respectifs.

Dans cette définition, un appel est considéré comme correct de classe s'il ne viole pas la règle d'invocation de composant, qui stipule : si C est la classe de base de typex, composantf doit être exporté par C et le type arg doit être compatible avec le type de le paramètre formelf. (Rappelez-vous : par souci de simplicité, nous supposons que chaque routine n'a qu'un seul paramètre, mais il n'est pas difficile d'étendre la règle à un nombre arbitraire d'arguments.)

L'exactitude du système d'un appel est réduite à l'exactitude de la classe, à l'exception du fait qu'elle n'est pas vérifiée. éléments individuels, et pour toutes les paires d'ensembles d'ensembles. Ici

règles de base pour créer un ensemble de types pour chaque entité : 1 Pour chaque entité kit de démarrage types est vide.

2 Après avoir rencontré l'instruction suivante comme create (SOME_TYPE) a , nous ajoutons SOME_TYPE à l'ensemble des types pour a . (Pour plus de simplicité, nous supposerons que toute instruction create a sera remplacée par create (ATYPE) a , où ATYPE est le type d'entité a .)

3 Après avoir rencontré l'affectation suivante de la forme a:= b , nous ajoutons à l'ensemble des types pour a tous les éléments de l'ensemble des types pour b .

4 Si a est un paramètre formel du sous-programme, alors, après avoir rencontré le prochain appel avec un paramètre réel b, nous ajouterons tous les éléments du type défini pour b à l'ensemble des types pour a.

5 Nous répéterons les étapes (3) et (4) jusqu'à ce que les ensembles de types cessent de changer. Cette formulation ne prend pas en compte le mécanisme de l'universalité, mais élargit

règle de la bonne manière possible sans problèmes particuliers. L'étape (5) est nécessaire en raison de la possibilité de chaînes d'affectations et de transferts (de b vers ka, de c vers b, etc.). Il n’est pas difficile de comprendre qu’après un nombre fini d’étapes, ce processus s’arrêtera.

|Le nombre d'étapes est limité par la longueur de la chaîne maximale de connexions ; autrement dit, le maximum est égal à n si le système contient des connexions de x i+1 à x i pour l ii=1, 2, ... n-1. La répétition des étapes (3) et (4) est connue sous le nom de méthode du « point fixe ». |

Comme vous l’avez peut-être remarqué, la règle ne prend pas en compte la séquence d’instructions. Au cas où

créer(TYPE1)t; s:=t; créer (TYPE2)t

l'ensemble de types pour s comprendra à la fois TYPE1 et TYPE2, bien que s, étant donné la séquence d'instructions, ne puisse accepter que les valeurs du premier type. La prise en compte de l'emplacement des instructions nécessitera du compilateur une analyse approfondie du flux d'instructions, ce qui entraînera une augmentation excessive du niveau de complexité de l'algorithme. Au lieu de cela, des règles plus pessimistes s'appliquent : la séquence des opérations est la suivante :

seront déclarés système incorrects, malgré le fait que la séquence de leur exécution ne conduit pas à une violation de type.

Une analyse globale du système a été présentée (plus en détail) au chapitre 22 de la monographie. Dans le même temps, le problème de la covariance et le problème des restrictions à l'exportation lors de l'héritage ont été résolus. Cependant, cette approche présente un défaut pratique gênant, à savoir : elle est censée vérifier le système dans son ensemble, et non chaque classe séparément. Le tueur s'avère être la règle (4), qui, lors de l'appel d'un sous-programme de bibliothèque, prendra en compte tous ses appels possibles dans d'autres classes.

Bien que des algorithmes permettant de travailler avec des classes individuelles aient ensuite été proposés, leur valeur pratique n'a pas pu être établie. Cela signifiait que dans un environnement de programmation prenant en charge la compilation incrémentielle, l'ensemble du système devrait être testé. Il est conseillé d'introduire le contrôle comme un élément de traitement local (rapide) des modifications apportées par l'utilisateur à certaines classes. Bien que des exemples d'approche globale

connu - par exemple, les programmeurs C utilisent l'outil lint pour rechercher des incohérences dans le système que le compilateur ne détecte pas - cela ne semble pas très attrayant.

En conséquence, à ma connaissance, le contrôle de l’exactitude du système n’a été mis en œuvre par personne. (Une autre raison de ce résultat pourrait être la complexité des règles de vérification elles-mêmes.)

L'exactitude de la classe implique une vérification limitée à la classe et est donc possible avec une compilation incrémentielle. L'exactitude du système présuppose une vérification globale de l'ensemble du système, ce qui entre en conflit avec la compilation incrémentielle.

Cependant, malgré son nom, il est en réalité possible de vérifier l'exactitude du système en utilisant uniquement la vérification incrémentielle des classes (lors de l'exécution d'un compilateur standard). Ce sera la dernière contribution à la résolution du problème.

Résumé : Les systèmes logiciels sont dans de nombreux cas vitaux systèmes importants, depuis bon fonctionnement dont le bien-être et même la vie peuvent dépendre personne individuelle ou toute une équipe. Tout le monde devrait maîtriser les éléments de la programmation fondée sur des données probantes programmeur professionnel. Cette conférence aborde également les questions de style professionnel de développement de projets logiciels. La conférence est accompagnée de problèmes.

Vous pouvez télécharger le projet de cette conférence.

Exactitude et stabilité

L'exactitude et la stabilité sont les deux qualités principales d'un système logiciel, sans lesquelles tous ses autres avantages n'ont pas beaucoup de sens.

L'exactitude est la capacité d'un système logiciel à fonctionner en stricte conformité avec ses spécifications. Le débogage est un processus visant à atteindre l'exactitude.

Le concept d'exactitude d'un système logiciel n'a de sens que lorsque sa spécification est donnée. Selon la manière dont la spécification est formalisée, la notion d'exactitude est clarifiée.

Pendant le fonctionnement du système, des situations peuvent survenir en dehors des limites des spécifications. De telles situations sont dites exceptionnelles.

La résilience est la capacité d'un système logiciel à répondre de manière appropriée à des situations exceptionnelles. La gestion des exceptions est un processus visant à atteindre la robustesse.

Pourquoi est-il si difficile de créer des systèmes logiciels corrects et stables ? Tout dépend de la complexité des systèmes développés. Lorsqu'IBM a créé le système d'exploitation OS-360 dans les années 60 du siècle dernier, sa création a nécessité 5 000 années-homme et la complexité du projet a été comparée à celle de l'atterrissage du premier homme sur la Lune. La complexité des réseaux actuels systèmes d'exploitation, les systèmes de gestion du stockage et les systèmes de programmation d'applications sont d'un ordre de grandeur plus complexes que l'OS-360, de sorte que malgré les progrès réalisés dans la technologie de programmation, les problèmes auxquels sont confrontés les développeurs ne sont pas devenus plus faciles.

Cycle de vie d'un système logiciel

Sous " cycle de vie" fait référence à la période allant de la conception produit logiciel jusqu'à sa « mort ». Les phases suivantes de ce processus sont généralement considérées :

Conception Développement Déploiement et maintenance

Tout cela s’appelle un cycle, puisqu’après chaque phase il est possible de revenir aux étapes précédentes. Dans la technologie objet, ce processus est transparent et toutes les étapes sont étroitement liées. Il ne faut pas le considérer comme unidirectionnel – de la conception à la maintenance. Le plus souvent, la situation est inverse : l'implémentation déjà existante du système, qui a été maintenue, et les bibliothèques de composants existantes ont une influence décisive sur ce que sera le nouveau système et quelles seront ses spécifications.

En voici quelques-uns règles standards, caractéristique du processus de développement logiciel.

• Portez une attention particulière à la phase de conception. Le succès de l’entreprise est largement déterminé par la première étape. Il ne sert à rien de se précipiter dans les étapes suivantes tant que des spécifications claires et précises ne sont pas mises en place. Les erreurs à ce stade sont les plus coûteuses et les plus difficiles à corriger.
• N'oubliez pas ceux pour qui le produit logiciel est développé. Allez parmi les gens pour comprendre ce qui doit être fait. Dans le même temps, vous ne devez pas vous fier entièrement aux utilisateurs - leur expérience est conservatrice, les nouvelles idées peuvent souvent venir des développeurs et non des utilisateurs.
• Le développement ne part pas de zéro. Ce n'est qu'en utilisant des composants prêts à l'emploi que vous pouvez créer en temps opportun nouveau système. Lorsque vous travaillez sur un projet, pensez à l'avenir et créez des composants pouvant être réutilisés dans d'autres projets.
• Créez un prototype de votre système le plus tôt possible et transférez-le aux utilisateurs dans opération d'essai. Cela contribuera à éliminer de nombreuses lacunes et erreurs dans la version finale du produit logiciel.
• Peu importe bonnes spécifications n'ont pas été écrits, peu importe comment bonnes technologies et les développeurs n'ont pas utilisé les outils, aussi professionnels soient-ils - cela ne suffit pas au succès de l'entreprise. Une condition nécessaire c'est la gestion de projet, la disponibilité moyens spéciaux gestion. Mais cela ne suffit pas. Troisième facteur important c'est l'existence d'une équipe. L'équipe de développement doit être une seule équipe. La capacité à travailler en équipe est aussi importante que les compétences de développeur professionnel.

Trois lois du génie logiciel La première loi (loi du développeur)

L’exactitude du système est inaccessible. Chaque dernière erreur trouvée est l'avant-dernière.

Cette loi reflète la complexité des systèmes non triviaux. Le développeur doit toujours être préparé au fait qu'il existe des situations dans un système en cours d'exécution dans lesquelles le système ne fonctionne pas exactement selon ses spécifications, de sorte qu'il peut être amené à apporter une autre modification au système ou à ses spécifications. En conséquence, cela implique l’importance d’assurer la stabilité du système.

Deuxième loi (loi de l'utilisateur)

Il n'y a pas de systèmes incorrects. Chaque erreur qui apparaît pendant le fonctionnement du système est une conséquence de la méconnaissance des spécifications du système..

Il y a deux explications à la validité de la deuxième loi. Une explication non sérieuse est que tout système, quoi qu’il fasse, est correct quelle que soit la postcondition par rapport à la précondition False, puisqu’il est impossible de trouver un ensemble d’entrées satisfaisant cette précondition. Ainsi, tous les systèmes sont corrects s’ils sont définis sur False comme condition préalable. Si vous rencontrez un système dont la précondition est proche de False , alors la meilleure chose à faire est de le mettre de côté et d'en trouver un autre.

Plus instructive est une situation réelle qui confirme la deuxième loi et qui m'a été racontée dans le passé par Vitaly Kaufman, spécialiste des tests de traducteurs. Une organisation sérieuse a développé un sérieux système de candidature avoir pour eux grande valeur. Malheureusement, lors de son fonctionnement, des erreurs se produisaient souvent, obligeant l'organisation à abandonner l'utilisation du système. Les développeurs se sont tournés vers lui pour obtenir de l'aide. En explorant le système, il n’y a pas ajouté une seule ligne de code. La seule chose qu'il a fait a été, avec les développeurs, de décrire les spécifications exactes du système, grâce auxquelles un fonctionnement normal est devenu possible.

Notez la philosophie derrière ces lois : lorsqu'une erreur se produit, le développeur et l'utilisateur doivent se blâmer et non se blâmer mutuellement. D’où les phrases fréquemment rencontrées : « Oh, cette société Cheytosoft, elle fait toujours des erreurs ! » caractérise, pour le moins, le manque de professionnalisme de l’utilisateur.

Troisième loi (loi chechako)

Si une spécification peut être rompue, elle le sera. Un débutant (chechako) est capable de « suspendre » n’importe quel système.

Quel que soit le contexte, un utilisateur non qualifié est toujours capable de choisir l'action la moins appropriée, qui ne satisfait manifestement pas au cahier des charges orienté vers un comportement « raisonnable » de l'utilisateur. Une conséquence pratique utile de cette loi est l'implication d'un utilisateur non qualifié - un « homme de la rue » - dans la phase de test du système.

Code fiable

Que faut-il faire pour créer un produit logiciel correct et stable ? Au minimum, il faut :

• créer du code qui devrait être correct dès le début ;
• déboguer ce code ;
• prévoir le traitement des situations d’exception.

Créer un code fiable

La plupart des questions soulevées dans cette conférence, y compris les problèmes de création de code fiable, méritent un examen séparé et approfondi. Malheureusement, nous devrons nous limiter à exprimer quelques thèses.

Pour améliorer la fiabilité, la complexité du système doit être réduite et la clé de ce processus est la réutilisation. Idéalement la plupart le système doit être assemblé à partir de composants prêts à l'emploi. La technologie de conception basée sur les objets contribue à améliorer la fiabilité du code. L'héritage et l'universalisation permettent sans déjà changer cours existants, créez de nouvelles classes, de nouveaux types de données qui donnent au système conçu de nouvelles propriétés lorsque ajouts minimes nouveau code. La vérification de type statique permet de détecter de nombreuses erreurs au stade de la compilation. La liaison dynamique et le polymorphisme permettent aux objets des classes descendantes d'être automatiquement inclus dans les modèles de travail existants - les méthodes parents peuvent appeler des méthodes descendantes sans connaître l'apparence de ces nouveaux descendants. Assemblage automatique garbage permet de décharger le développeur de la responsabilité de gérer la libération de la mémoire et d'éviter l'apparition d'erreurs extrêmement désagréables et dangereuses associées à suppression incorrecte objets.

Les spécifications des méthodes d’une classe, d’une classe dans son ensemble et d’un système de classes jouent un rôle extrêmement important dans la création d’un code fiable. Les spécifications font partie de la documentation intégrée au projet et en constituent généralement une partie importante. Leur existence facilite non seulement la création d'un code correct et conforme à la spécification, mais également la création d'un système de tests vérifiant l'exactitude du code. Il y a des spéciaux outils, soutenant création automatique tests basés sur des spécifications. Le rôle du cahier des charges au stade de l'accompagnement et réutilisation composants. Il est impossible de réutiliser un composant sans une spécification claire et complète.

Écrire système logiciel pas difficile. N'importe qui peut faire ça. Il est beaucoup plus difficile de l’écrire pour qu’il résolve correctement les problèmes de l’utilisateur. L’exactitude d’un système n’est pas un concept interne à définir en termes du système lui-même. L'exactitude est déterminée par rapport à spécifications externes systèmes. S'il n'y a pas de spécifications, alors il est « incorrect » de parler d'exactitude.

Exactitude des méthodes

Les spécifications de méthode peuvent être spécifiées de différentes manières. Définissons-les ici à travers les concepts de préconditions et postconditions de la méthode, en utilisant la symbolique des triades de Hoare, introduite par Charles Anthony Hoare, programmeur et scientifique hors pair.

Soit P(x,z) une méthode P avec des arguments d'entrée x et des arguments de sortie z. Soit Q(y) un condition logique(prédicat) sur les variables y. La précondition de la méthode P(x,z) sera le prédicat Pre(x) spécifié aux entrées de la méthode. La postcondition de la méthode P(x,z) sera le prédicat Post(x,z) qui relie les entrées et sorties de la méthode. Pour simplifier, nous supposerons que la méthode P ne modifie pas ses entrées x pendant son fonctionnement. Maintenant quelques définitions :

Définition 1 ( exactitude partielle). La méthode P(x,z) est correcte (partiellement ou conditionnellement) par rapport à la précondition Pre(x) et à la postcondition Post(x,z) si la vérité du prédicat Pre(x) implique que pour la méthode P( x,z) , exécuté sur l'entrée x , est assuré d'exécuter le prédicat Post(x,z) à condition que la méthode se termine sur cette entrée.

La condition d'exactitude partielle s'écrit sous la forme d'une triade de Hoare, reliant une méthode à sa précondition et sa postcondition :

P(x,z)

Définition 2 ( exactitude complète). La méthode P(x,z) est correcte (complètement ou totalement) par rapport à la précondition Pre(x) et à la postcondition Post(x,z) si la vérité du prédicat Pre(x) implique que pour la méthode P(x ,z) , exécuté sur l'entrée x , est assuré de compléter et d'exécuter le prédicat Post(x,z) au point de terminaison de la méthode.

La condition d'exactitude complète est écrite sous la forme d'une triade de Hoare, reliant le programme à sa précondition et sa postcondition :

(Pré(x))P(x,z)(Post(x,z))

Une preuve d'exactitude complète se compose généralement de deux étapes indépendantes : une preuve d'exactitude partielle et une preuve de fin de programme. A noter qu'un programme tout à fait correct lancé sur une entrée qui ne satisfait pas sa précondition a le droit de tourner en boucle et de renvoyer n'importe quel résultat. Tout programme est correct par rapport à la condition préalable donnée par le prédicat identiquement faux False . Tout programme de fin est correct par rapport à la postcondition spécifiée par le prédicat identiquement vrai True.

Un programme correct dit à ses clients : si vous souhaitez m'appeler et attendez une garantie que la postcondition sera satisfaite après mon achèvement, alors ayez la gentillesse de garantir que la précondition sera satisfaite à l'entrée. La définition des préconditions et des postconditions des méthodes est la même partie importante le travail d'un programmeur, ainsi que l'écriture de la méthode elle-même. En C#, les conditions préalables et postérieures sont généralement spécifiées dans la balise récapitulative précédant la méthode et font partie du rapport XML. Malheureusement, la technologie permettant de travailler dans Visual Studio n'offre pas la possibilité contrôle automatique conditions préalables avant d'appeler une méthode et vérifier les postconditions après son achèvement, en lançant des exceptions si elles ne sont pas remplies. Les programmeurs, pour qui l'exigence d'exactitude est la condition la plus importante pour la qualité de leur travail, intègrent eux-mêmes un tel contrôle dans leurs programmes. En règle générale, une telle vérification est requise au stade du débogage et peut être désactivée dans un système fini, dont le programmeur est déjà sûr de l'exactitude. Mais il est important de laisser la vérification des conditions préalables dans le système fini, car la véracité des conditions préalables doit être garantie non pas par le développeur de la méthode, mais par le client, méthode d'appel. Les clients ont tendance à faire des erreurs et à appeler une méthode dans des conditions inappropriées.

Prouver formellement l’exactitude d’une méthode n’est pas plus simple que d’écrire un programme correct. Mais voici le paradoxe. Comment méthode plus compliquée, son algorithme, et donc la preuve elle-même, plus il est important d'utiliser les notions de préconditions et de postconditions, les notions d'invariants de boucle dans le processus d'élaboration de la méthode. La prise en compte de ces concepts parallèlement au développement d’une méthode peut grandement faciliter la construction d’une méthode correcte.

Invariants et variantes de boucle

Les boucles, en règle générale, constituent la partie la plus complexe de la méthode ; la plupart des erreurs y sont associées. Lors de l’écriture de boucles qui fonctionnent correctement, il est essentiel de comprendre et d’utiliser les concepts d’invariant de boucle et de variante de boucle. Une preuve formelle de l'exactitude des cycles est indispensable sans ces concepts. Mais la compréhension informelle du bon fonctionnement du programme repose sur ces concepts.

Considérons un cycle sous une forme à laquelle tous les types de cycles peuvent être réduits :

Init(x,z); tandis que(B)S(x,z);

Ici B est la condition boucle while, S est son corps et Init est un groupe d'instructions précédentes qui spécifie l'initialisation de la boucle. En réalité, aucun cycle ne peut se passer d’une partie initialisation. Syntaxiquement, il serait correct qu'Init soit une partie formelle de l'instruction de boucle. DANS pour déclaration ceci est partiellement fait - l'initialisation des compteurs fait partie de la boucle.

Définition 3 ( invariant de cycle). Le prédicat Inv(x, z) est appelé invariant de boucle while si la triade de Hoare suivante est vraie :

(Inv(x, z)& B)S(x,z)(Inv(x,z))

Pour n'importe quel cycle, vous pouvez écrire autant d'invariants que vous le souhaitez. Toute condition identique (2*2 =4) est un invariant de tout cycle. Par conséquent, parmi les invariants, on distingue les invariants dits de cycle approprié. Ils sont appelés appropriés car ils nous permettent de prouver l’exactitude d’un cycle par rapport à ses pré- et postconditions. Comment prouver l’exactitude d’un cycle ? Considérons la triade correspondante :

(Pré(x)) Init(x,z); tandis que(B)S(x,z);(Post(x,z))

La preuve est divisée en trois étapes. Nous prouvons d’abord la vérité de la triade :

(*) (Pré(x)) Init(x,z)(RealInv(x,z))

(**) (RéelInv(x, z)& B) S(x,z)( RéelInv(x,z))

À la dernière étape, nous prouvons que notre invariant fournit une solution au problème une fois la boucle terminée :

pour (je = 1; je

Les deux premières lignes chargent le fichier de configuration et le fichier de fonction. Ensuite, nous définissons la variable logique $fakelink - elle fonctionne comme un « drapeau » qui sera levé en cas d'état incorrect de l'URL. Ensuite, nous commençons une série de contrôles.

La première condition vérifie quand le mode de traduction d'URL statique est activé (la variable $urlmode n'est pas vide et n'est pas égale à "none"). La variable d'environnement REQUEST_URI prend l'URL initialement demandée (non traduite) et vérifie l'absence de point d'interrogation. Si les liens sont statiques, ils ne devraient pas être là : les URL statiques n'ont pas de paramètres.

Deuxième condition :

• s'il existe des paramètres GET (dans le cas de liens statiques, ils apparaissent après la traduction de l'URL), le tableau $_GET est itéré en boucle. Lors de la recherche, le nom de chaque paramètre est vérifié pour la présence d'un tel nom dans le tableau de ceux autorisés (le tableau est défini dans le fichier de configuration). Un nom de paramètre inconnu provoque la définition de l'indicateur $fakelink sur TRUE et quitte la boucle. En cours de route, des variables sont créées avec les mêmes noms et les mêmes valeurs que les paramètres. Possible caractères d'espacement dans les valeurs sont coupées.
• S'il n'y a pas de paramètres GET, nous supposons que la racine du site a été accédée. À carreaux variable d'environnement QUERY_STRING - dans ce cas, il doit être vide. Mais il peut y avoir des appendices ridicules à la requête racine qui ne rentrent pas dans $_GET - comme http://domain.ru/?=

Après les deux premières vérifications, vous devez arrêter le script si l'URL demandée est incorrecte. C'est ce que nous faisons : lorsque le drapeau $fakelink est levé, la transmission du statut « 404 » commence Introuvable" avec l'achèvement du scénario.

Ensuite, si l'URL est au format correct, la structure du site est lue et un tableau de sections est formé. Et puis suit la troisième vérification - si l'alias de la section demandée n'est pas trouvé dans le tableau des sections, alors une demande est arrivée avec le format correct, mais la page demandée n'existe pas. Dans ce cas, un statut 404 est également émis et le script se termine.

Si toutes les vérifications sont réussies et que la section demandée existe, vous pouvez enfin sélectionner le contenu, créer un menu et assembler la page.

Ce tutoriel décrit comment créer Formulaire Javascript, qui vérifie que le visiteur a correctement rempli les champs avant d'envoyer les données au serveur. Nous expliquerons d’abord pourquoi la validation de formulaire est une technique utile, puis nous créerons un exemple simple pour expliquer son fonctionnement.

Pourquoi dois-je vérifier que le formulaire est rempli ?

La validation du formulaire est un processus dans lequel les données du formulaire sont vérifiées avant leur traitement. Par exemple, si votre formulaire comporte un champ dans lequel l'utilisateur doit saisir adresse email, vous souhaiterez peut-être vérifier que le champ est complet avant de poursuivre le traitement du formulaire.

Il existe deux méthodes principales pour vérifier la complétion d'un formulaire : côté serveur (avec en utilisant CGI scripts, ASP, etc.) et côté client (on utilise généralement JavaScript). La validation côté serveur est plus sécurisée, mais nécessite dans la plupart des cas un code plus complexe, tandis que la validation côté client est plus simple et plus rapide (le navigateur n'a pas besoin de se connecter au serveur pour valider le formulaire, l'utilisateur reçoit donc une réponse immédiate si champs manquants à remplir).

Validation du formulaire côté client. Généralement effectué à l'aide d'un script JavaScript intégré.

Validation du formulaire côté serveur. Généralement effectué à l'aide d'un script CGI ou ASP.

DANS cette leçon nous allons construire forme simple avec validation côté client avec en utilisant Javascript. Vous pourrez ensuite l'adapter à vos besoins.

Un formulaire simple avec vérification.

Créons un formulaire simple avec vérification du remplissage à l'aide d'un script. Ce formulaire a un champ de texte "Votre nom" et un bouton pour envoyer des données. Notre script vérifie que l'utilisateur a saisi son nom avant d'envoyer les données au serveur.

Ouvrez le formulaire et voyez-le en action. Essayez de cliquer sur le bouton « Soumettre les données » sans rien saisir dans le champ « Votre nom ».

La page contient une fonction JavaScript appelée validate_form(). Il vérifie que le formulaire est complet. regardons d'abord la forme.

Formulaire

La première partie du formulaire est la balise form

Le formulaire s'appelle contact_form. Avec son aide, nous aurons accès au formulaire de Fonctions JavaScript chèques.

Le formulaire utilise une post-méthode pour envoyer des données vers un fichier stub htm, qui affiche simplement un message. En fait, vous pouvez envoyer des données vers votre script CGI, votre page ASP, etc. (par exemple pour envoyer du courrier).

La balise form contient également un attribut onsubmit pour Appel JavaScript fonctions de validation validate_form() lorsque vous cliquez sur le bouton Soumettre les données. La fonction renvoie une valeur booléenne, pour laquelle vrai signifie « la vérification a réussi » et faux signifie « les données sont en attente ». De cette façon, nous pouvons empêcher la soumission des données du formulaire si l'utilisateur ne les a pas remplis correctement.

Le reste du code du formulaire ajoute le champ de saisie contact_name et le bouton « Soumettre les données » :

Veuillez entrer votre nom.

Votre nom :

Fonction validate_form()

La fonction de validation de formulaire validate_form() est intégrée dans la section head au début de la page :

La première ligne () indique au navigateur ce qui va suivre Code JavaScript, et le commentaire HTML (