Contrôl de format / propos de sortie (string & integer)

Soyez le premier à donner votre avis sur cette source.

Vue 4 349 fois - Téléchargée 173 fois

Description

####################
DELPHI 6 LIBRARY
####################
UNIT : CHCKENTRY
FUNCTION : CHKCHCKOP
####################

========================
Description
===
Cette fonction contrôle la validité d'une entrée,
ainsi, elle formatte la valeur de retour suivant l'opérande souhaité.
La valeur "sa4lut' renvoie donc 'salut' si le paramètre 's' est passé
Si le paramètre 'i' est spécifié, la valeur de retour sera donc '4'.

========================
Paramètre de la fonction
===
Description Type Exemple
Contenu du texte string 'sal4ut'
Opérande Char 'i'

A noter les éléments suivants:
's' >> Contrôle sur le string
'i' >> Contrôle sur l'entier

========================
Retour de la fonction
===
Variables ... Type Exemple
chkop(param1,param2) Boolean True (-1)
strTextFinal String '4'

========================
Exemple d'utilisatation de la fonction
===

{Déclaration des variables}
var
strText:string; {Contenu dans champs texte ....}
chrOperande:Char; {Caractère qui spécifie l'opérande}
begin
{Initialisation des variables}
strText:=Input1.Text;
chrOperande := 'i'; {Integer}

{apelle de function : verification de l'opérande}
{le retour de la fonction est traitée comme un accusé de récpetion}
if chckop(strText, chrOperande)=true then begin
{Type entré correct - valeurs entières}
messagedlg('Le type entré est correct',mtInformation,[mbOk],0);
end
else begin
{Type entré incorrect - valeur textes ou symboles ...}
messagedlg('Seuls les nombres caractères sont pris en compte', mtWarning,

[mbOk],0);
end;

{Suggerer la valeur possible ... Reporter les entiers}
Input1.Text:=strTextFinal;
end;

________________
Crée le : 25.04.2002
Maj le : 26.04.2002
Auteur : Zechs Merquise :: vivien.steffen@urbanet.ch

Source / Exemple :


unit chckentry;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, StrUtils;

  function chckop(strText_:string; chrOperande:Char):boolean;

type
  TForm1 = class(TForm)
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form1: TForm1;
  {Globale}
  strVectInput : array [1..255] of string;      {compteur de vecteur}
  iCountVect : integer;                         {compteur de vecteur}
  strTextFinal:string;                          {Valeur du texte traité}

implementation

{$R *.dfm}

function chckop(strText_:string; chrOperande:Char):boolean;
{Déclaration des variables}
var
        i:integer;      {compteur de boucle}
        chrAsci:string; {caractère asci}
        strChr:string;  {caractère en cours de traitement}

        bReturn:boolean;        {Retour de fonction}

        iLenText:integer;       {Longueur du texte passé en paramètre}
begin

                for i:=1 to iCountVect do begin
                        strVectInput[i]:='0';
                end;
                iCountVect:=0;          {Compteur de vecteur - GLOBALE}
                strTextFinal:='';       {Texte traité}
                iLenText:=length(strText_);

                {Convertion du charactère en asci}
                for i:=1 to iLenText do begin

                        {Initialisation des variables }
                        bReturn:=true;   {Retour de fonction}
                        chckop:=bReturn;

                        strChr:=midstr(strText_,i,1);
                        chrAsci:=IntToStr(ord(strChr[1]));

                        {Controle sur le cacartère ASCII}
                        {Si c'est un nombre, donc entre 48 et 57}

                        case chrOperande of
{============================================================================================= INTEGER}
                                'i':begin{correspobd à Entier : integer}

                                        {Controle sur le cacartère ASCII}
                                        {Si c'est un nombre, donc entre 48 et 57}
                                        if (StrToInt(chrAsci)>47) and (StrToInt(chrAsci)<58) or (StrToInt(chrAsci)=46) then begin
                                                {Initialisation du vecteur suivant i}

                                                if (StrToInt(chrAsci)=46) then begin
                                                end
                                                else begin
                                                        iCountVect:=iCountVect+1;
                                                        strVectInput[iCountVect]:=chr(StrToInt(chrAsci));
                                                end; {end if}
                                        end
                                        else begin {Si le caractère est valide}
                                                {Resultat: opérande non-valide}
                                                bReturn:=false;
                                        end; {End If}

                                        {Si il y'a un caractère point (virgule), donc le laisser dans la suggestion}
                                        if (iCountVect>1) and (StrToInt(chrAsci)=46) then begin
                                                iCountVect:=iCountVect+1;
                                                strVectInput[iCountVect]:='.';
                                        end

                                end;{fin case 'i':}
{============================================================================================= FIN INTEGER}

{>> opérandes: Integer, String}

{============================================================================================ STRING}
                                's':begin{correspond à Chaîne de caractères : string}

                                        if (StrToInt(chrAsci)<65) then begin
                                                {faux}
                                                if (StrToInt(chrAsci)=32) then begin
                                                        bReturn:=true; {barre d'espace}
                                                end
                                                else begin
                                                        bReturn:=false;
                                                end;
                                        end
                                        else if (StrToInt(chrAsci)>90) then begin
                                                if (StrToInt(chrAsci)<97) then begin
                                                        {faux}
                                                        bReturn:=false;
                                                end;
                                                if (StrToInt(chrAsci)>122) then begin
                                                        {faux}
                                                        bReturn:=false;
                                                end;
                                        end;

                                        if bReturn=true then begin
                                                iCountVect:=iCountVect+1;
                                                strVectInput[iCountVect]:=chr(StrToInt(chrAsci));
                                        end;

                                {Si il y'a un caractère point (virgule), donc le laisser dans la suggestion}
                                if (StrToInt(chrAsci)=46) then begin
                                        iCountVect:=iCountVect+1;
                                        strVectInput[iCountVect]:='.';
                                        bReturn:=true;
                                end;
                                end;{fin case 's':}
{============================================================================================= FIN STRING}
                        end;

                chckop:=bReturn;
                end; {End For}

        {Ajouter un 0 après la virgule si c'est un nombre}
        if chrOperande='i' then begin
                if (strVectInput[iCountVect])='.' then begin
                        iCountVect:=iCountVect+1;
                        strVectInput[iCountVect]:='0';
                end;
        end;

        {Renvoie de la valeur obtenue}
        for i:=1 to iCountVect do begin
                strTextFinal:=strTextFinal + strVectInput[i];
        end;

end; {End Function}

end.

Conclusion :


Une mise à jour est prévue, mais je ne saurais vous dire quand, car j'ai des études axés Intelligence Artificielle en ce moment.
Je reste ouvert à toutes remarques et suggestions.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
2
Date d'inscription
jeudi 2 mai 2002
Statut
Membre
Dernière intervention
3 mai 2002

Merci pour tes commentaires Nono, je trouve ça très sympathique, ça va m'aider à avancer.

Je vais donc revoir l'unité dans le courrant de la semaine prochaine.


Cordialement, Zechs Merquise
Messages postés
962
Date d'inscription
mercredi 3 avril 2002
Statut
Membre
Dernière intervention
12 septembre 2006
2
Il ya aussi un bug sur le résultat de ta fonction : dans le cas d'un test avec 's', si la chaine est terminée par '.' ou ' ' alors elle renvoie TRUE dans tous les cas même si il y a des caractère exclus.
Messages postés
962
Date d'inscription
mercredi 3 avril 2002
Statut
Membre
Dernière intervention
12 septembre 2006
2
Arf, j'ai oublié de mettre Result:='' juste avant le For...
Messages postés
962
Date d'inscription
mercredi 3 avril 2002
Statut
Membre
Dernière intervention
12 septembre 2006
2
Plusieurs petites remarques :
- Plutôt que de caser ta fonction dans un Unit avec fiche, intègre-la dans une Unité simple. ( le TForm ne sert à rien ici )
- ChrAscii serait plus simple de type CHAR, car tu peux alors écrire
If (ChrAscii>='A') And (ChrAscii<='Z) Then ...
Le source serait alors plus facile à lire pour ceux qui ne connaissent pas les codes Ascii.
- Ensuite avec un type char tu peux utiliser facilement des ensembles :
If ChrAscii in ['A'..'Z','a'..'z','.'] then ...
- Tu pourrais renvoyer le résultat sous forme de chaine :
Function chckop(strText_:string; chrOperande:Char):String et donc ne pas utiliser le tableau StrVectInput mais la variable Result de type String. Car celui-ci est limité à 255 caractères or un String n'est pas limité en longueur. Il est permi d'ajouter un CHAR à un String.

Function chckop(strText_:string; chrOperande:Char):String
Var i:Integer;
Begin
Result:='';
For i:=1 to Length(StrText_) Do
Begin
ChrAscii:=StrText_[i]; // tu peux aussi utiliser une chaine en tant que tableau de caractère
Case ChrOperande Of
'i':If ChrAscii in ['0'..'9','.'] then Result:=Result+ChrAscii;
's':If ChrAscii in ['A'..'Z','a'..'z','.'] then Result:=Result+ChrAscii;
End;
If (ChrOperande='i')
And(Length(Result)>0) // toujours être sûr que l'on accède à un string par index correct, car si length(Result) était nul, alors erreur.
And(Result[Length(Result)]='.')
Then Result:=Result+'0';
End;

Voili, c'est juste pour donner des idées.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.