Page d'Accueil

Rapports conditionnels

 

Opérateurs logiques

 

Introduction

Un des buts de la programmation d'ordinateur indique à l'ordinateur quoi faire quand quelque chose se produit, et comment à la faire. Ceci est exécuté en plaçant des conditions, en les examinant et en énonçant quelles décisions l'ordinateur devrait prendre. Pour exécuter les conditions nécessaires, vous avez deux options principales : Microsoft Access ou de base visuel de Microsoft. Le Microsoft Access est équipé d'une série de fonctions d'andm d'opérateurs destinées pour effectuer de diverses opérations. Pour employer une condition dans le Microsoft Access, si vous connaissez la structure du rapport conditionnel, vous pouvez l'écrire après la dactylographie d'un opérateur de tâche. Puisque la plupart des conditions dans le Microsoft Access sont sous forme de fonctions, nous les étudierons plus tard. Pour maintenant, nous apprendrons comment écrire des conditions dans la langue de base visuelle de Microsoft.

De base visuel de Microsoft vient avec beaucoup de rapports conditionnels pour presque n'importe quelle situation que votre ordinateur peut rencontrer. Comme créateur d'application, il l'appartient toi pour prévoir ces situations et pour faire votre acte de programme en conséquence.

Une comparaison est effectuée entre deux valeurs du même type. Par exemple, vous pouvez comparer deux nombres, deux caractères, ou les noms de deux villes. D'une part, une comparaison entre deux valeurs disparates ne soutient aucune signification. Par exemple, il est difficile de comparer un numéro de téléphone et quelqu'un nom de grand-mère, ou une catégorie de musique et la distance entre deux points. Comme les opérations arithmétiques, les opérations de comparaison sont effectuées sur deux valeurs. À la différence des opérations arithmétiques où des résultats sont changés, une comparaison produit seulement un de deux résultats. Le résultat peut être un vrai logique ou faux.

Pour effectuer les comparaisons nécessaires, le Microsoft Access et l'utilisation de base visuelle par série d'opérateurs logiques et de constantes.

La comparaison pour l'égalité =

Pour comparer deux variables pour l'égalité, employer = opérateur. Sa formule est :

valeur1 = valeur2

L'opération d'égalité est employée pour découvrir si deux variables (ou une variable et une constante) tiennent la même valeur. De notre formule, la valeur de la valeur 1 serait comparée à la valeur de la valeur 2. Si la valeur 1 et la valeur 2 tiennent la même valeur, la comparaison produit un résultat vrai. Si elles sont différentes, la comparaison rend faux ou 0. Après avoir effectué la comparaison et avoir découvert son résultat, vous pouvez porter une tâche. Ceci peut être illustré comme suit :

 

Pas l'opérateur logique

Quand une variable est déclarée et reçoit une valeur (ceci pourrait être fait par l'initialisation ou un changement de valeur) dans un programme, elle devient vivante. Quand une variable n'est pas employée ou n'est pas disponible pour traiter (dans la programmation visuelle, on le considérerait en tant qu'handicapé) pour faire (temporairement) un inutilisable variable, vous pouvez annuler sa valeur. Pour rendre une variable indisponible pendant l'évolution d'un programme, appliquer pas l'opérateur logique. Sa formule est :

Not Value

Il y a deux manières principales que vous pouvez employer pas l'opérateur logique. Car nous apprendrons quand étudiant les rapports conditionnels, la manière la plus classique d'employer le logique pas l'opérateur doit vérifier l'état d'une variable.

Quand une variable tient une valeur, elle est « vivante ». Pour la rendre non disponible, vous pouvez « pas » il. Quand une variable a été « notted », sa valeur logique a changé. Si la valeur logique était vraie, elle serait changée en faux. Par conséquent, vous pouvez inverse la valeur logique d'une variable par « notting » ou « pas notting » le.

Pour le <> d'inégalité

Par opposition à l'égalité, de base visuel de Microsoft fournit un opérateur utilisé pour comparer deux valeurs pour l'inégalité, qui est <>. Sa formule est :

Value1 <> Value2

le <> est un opérateur binaire (comme tous les opérateurs logiques excepté le logique pas, qui est un opérateur unaire) qui est habitué pour comparer deux valeurs. Les valeurs peuvent venir de deux variables comme dans Variable1 le <> Variable2. Lors de comparer les valeurs, si les deux variables tiennent différentes valeurs, la comparaison produit une valeur vraie. Autrement, la comparaison rend faux ou une valeur nulle. Ceci peut être illustré comme suit :

L'inégalité est évidemment l'opposé de l'égalité.

Une valeur plus basse <

Pour découvrir si une valeur est inférieure à des autres, employer < operator="">

Value1 < Value2

La valeur tenue par Value1 est comparée à celle de la valeur 2. Car elle serait faite avec d'autres opérations, la comparaison peut être faite entre deux variables, comme dans Variable1 < Variable2="">vrai. Ceci peut être illustré avec ce qui suit :

 

En combinant l'égalité et abaisser le <= de valeur

Les deux opérations précédentes peuvent être combinées pour comparer deux valeurs. Ceci te permet de savoir si deux valeurs sont identiques ou si le premier est moins que la seconde. L'opérateur utilisé est <= et sa formule est :

Value1 <= Value2

L'opération de <= effectue une comparaison en tant que bout l'un des deux. Si la valeur 1 et la valeur 2 tiennent la même valeur, le résultat est vrai. Si l'opérande gauche, dans ce cas-ci valeur 1, prises une valeur inférieure au deuxième opérande, dans ce cas-ci valeur 2, le résultat est encore vrai. Ceci peut être illustré comme suit:

Le résultat de cette comparaison est faux seulement si la valeur de l'opérande gauche est strictement plus haute que celle du bon opérande.

Une plus grande valeur >

Quand deux valeurs du même type sont distinctes, l'une d'entre elles est habituellement plus haute que l'autre. De base visuel de Microsoft fournit un opérateur logique qui te permet de découvrir si une de deux valeurs est l'autre plus grand que. L'opérateur utilisé pour cette opération est > symbole. Sa formule est :

Value1 > Value2

Les deux opérandes, dans ce cas-ci valeur 1 et valeur 2, peuvent être des variables ou l'opérande gauche peut être une variable tandis que le bon opérande est une constante. Si la valeur du côté gauche de > opérateur est plus grande que la valeur sur le bon côté ou une constante, la comparaison produit une valeur vraie. Autrement, la comparaison rend faux ou nul. Ceci illustré comme suit :

> et le <= sont vis-à-vis des opérateurs.

Un plus grand ou égal >= de valeur

Les opérateurs plus grands qu'ou d'égalité peuvent être combinés pour produire un opérateur comme suit : >=. C'est « supérieur ou égal à » opérateur. Sa formule est :

Value1 >= Value2

Une comparaison est effectuée sur les deux opérandes : Valeur 1 et valeur 2. Si la valeur de la valeur 1 et ce de la valeur 2 sont identique, la comparaison produit une valeur vraie. Si la valeur de l'opérande gauche est plus grande que que du bon opérande, la comparaison produise toujours vrai. Si la valeur de l'opérande gauche est strictement moins que la valeur du bon opérande, la comparaison produit un résultat faux :

Voici un tableau synoptique des opérateurs logiques que nous avons étudiés :

Opérateur Signification Exemple Opposé
= Égalité à a = b Pas
Pas Pas égale à 12 <> 7 =
< Moins que 25 < 84 >=
<= Inférieur ou égal à Étiquette de <= de cabine >
> Plus grand que 248 > 55 <=
>= Supérieur ou égal à Val1 >= Val2 <
 

Si… puis rapport

 

Introduction

Les opérateurs de comparaison que nous avons passés en revue ci-dessus sont habitués pour connaître l'état de deux valeurs mais ils ne fournissent pas un mécanisme à l'exploit là résultent. Après avoir obtenu le résultat d'une comparaison, pour l'employer efficacement, vous pouvez formuler un rapport de condition. Appui de base visuel de Microsoft Access et de Microsoft ceci par de divers mots-clés et fonctions.

Si… alors le rapport examine l'exactitude d'une expression. Structurellement, sa formule est :

If Condition Then Statement

Le programme examinera la condition. Cette condition peut être une expression simple ou une combinaison des expressions. Si la condition est vraie, alors le programme exécutera le rapport. Ceci peut être illustré comme suit :

Il y a deux manières que vous pouvez employer si… puis rapport. Si l'expression conditionnelle est assez courte, vous pouvez l'écrire sur une ligne en utilisant la formule suivante :

If Condition Then Statement

Dans l'exemple suivant, si la boîte des textes appelait le txtGender d'un mâle d'affichages de forme, la couleur de fond de la section de détail serait colorée dans bleu-clair :

Private Sub Form_Current()
    If txtGender = "Male" Then Detail.BackColor = 16772055
End Sub

S'il y a beaucoup de rapports à exécuter comme résultat véridique de la condition, vous devriez écrire les rapports sur les lignes suivantes. Naturellement, vous pouvez employer cette technique même si la condition que vous examinez est courte. Si alors vous employez le rapport sur une ligne différente, vous devez terminer le rapport conditionnel avec l'extrémité si expression. Le formual utilisé est :

If Condition Then
    Statement
End If

L'exemple ci-dessus peut être récrit comme suit :

Private Sub Form_Current()
    If txtGender = "Male" Then
        Detail.BackColor = 16772055
    End If
End Sub

Si la condition doit couvrir beaucoup de lignes de code, la syntaxe à appliquer est :

If Condition Then
    Statement1
    Statement2
    Statement_n
End If

Voici un exemple :

Private Sub Form_Current()
    If Gender = "Male" Then
        Detail.BackColor = 16772055
        FormHeader.BackColor = 16752478
        FormFooter.BackColor = 14511872
    End If
End Sub

Si… Alors-Orientait des fonctions : Nz ()

Le Microsoft Access n'emploie pas des rapports de conditionals comme les langages de programmation traditionnels. Il se fonde sur des fonctions condition-orientées spéciales pour effectuer les mêmes opérations. Une de ces fonctions s'appelle Nz.

La fonction de Nz () est employée pour vérifier la valeur d'une expression ou d'une commande. Sa syntaxe est :

Nz(Value, [ValueIfNull])

Les contrôles de fonctionnement la valeur (du premier) argument. Si la valeur est nulle, la fonction renvoie 0 ou une corde vide. Le deuxième argument est facultatif. Vous pouvez le fournir comme alternative à 0 au cas où l'argument de valeur serait nul. Ce les moyens, celui, quand le premier argument est nul, au lieu de renvoyer 0 ou une corde vide, la fonction de Nz () reviendraient à la valeur du deuxième argument.

Étude pratiqueÉtude pratique : Employer la fonction de Nz ()

  1. Commencer le Microsoft Access et ouvrir la base de données Exercise3
  2. Ouvrir le formulaire de demande d'emploi dans la vue de conception et cliquer la boîte supérieure des textes
  3. Dans la fenêtre de propriétés, cliquer le bouton d'événement et double-cliquer sur le foyer perdu
  4. Cliquer son bouton de points de suspension pour ouvrir de base visuel de Microsoft et pour mettre en application son événement de changement comme suit :
     
    Private Sub txtFirstName_LostFocus()
        Dim FirstName As String
        Dim LastName As String
        Dim FullName As String
        
        FirstName = Nz([txtFirstName])
        LastName = Nz([txtLastName])
        
        FullName = LastName & ", " & FirstName
        
        [txtFullName] = FullName
        If LastName = "" Then [txtFullName] = FirstName
    End Sub
  5. Dans la boîte combo d'objet, choisir le txtLastName
  6. Dans la boîte combo de procédé, choisir le changement et mettre en application son événement comme suit :
     
    Private Sub txtLastName_LostFocus()
        Dim FirstName As String
        Dim LastName As String
        Dim FullName As String
        
        FirstName = Nz([txtFirstName])
        LastName = Nz([txtLastName])
        
        FullName = LastName & ", " & FirstName
        
        [txtFullName] = FullName
        If LastName = "" Then [txtFullName] = FirstName
    End Sub
  7. Revenir au Microsoft Access et commuter la forme à la vue de forme
  8. Cliquer la boîte supérieure des textes, dactylographier Julienne et serrer Tableau. Noter que seulement les affichages de prénom dans la boîte des textes de nom et prénoms
     
  9. Dans l'autre boîte des textes, dactylographier le palais et la pression entrent
     
  10. Fermer la forme
  11. Une fois demandé si vous voulez la sauver, cliquer oui

Si… Alors-Orientait des fonctions : IsEmpty ()

Les contrôles de fonctionnement d'IsEmpty (), qu'une variable existante ait été initialisée ou pas. La syntaxe de cette fonction est

IsEmpty(Expression)

Contrôles ce de fonctionnement l'argument d'expression. Si l'argument d'expression tient une valeur, alors la fonction d'IsEmpty () renvoie la valeur fausse. Si l'argument d'expression ne tient pas une valeur, par exemple s'il (encore) n'a pas été initialisé, alors le retour de fonction d'IsEmpty () vrai.

Si… Alors-Orientait des fonctions : IsNull ()

IsNull () est une fonction booléenne qui vérifie si une expression ne tient aucune valeur reconnaissable. Sa syntaxe est :

IsNull(expression)

Une fois appelée, cette fonction évalue la valeur de l'argument d'expression. Si l'argument tient une valeur nulle, alors la fonction d'IsNull () renvoie vrai. Si l'expression peut produire une valeur reconnaissable, alors la fonction renvoie faux.

Étude pratiqueÉtude pratique : Employer la fonction d'IsNull ()

  1. Ouvrir l'application Exercise2. Sur la fenêtre de base de données, au besoin, les formes de clic, droit-cliquent la tâche et cliquent la vue de conception
  2. L'Access le code de la forme et changent l'événement de clic du bouton supérieur comme suit :
     
    Private Sub cmdCreateAccount_Click()
        Dim strFirstName As String
        Dim strMiddleInitial As String
        Dim strLastName As String
        Dim strFullName As String
        Dim strUsername As String
        
        strFirstName = Nz([txtFirstName])
        If Not IsNull(txtMI) Then strMiddleInitial = txtMI & ". "
        strLastName = Nz([txtLastName])
        ' Create a username made of the last name followed by the middle initial
        strUsername = txtLastName & strMiddleInitial
        ' Create a full name as the first name followed by the last name
        strFullName = txtFirstName & " " & strMiddleInitial & txtLastName
        
        txtFullName = strFullName
        txtUsername = strUsername
    End Sub
  3. Fermer la forme
  4. Une fois demandé si vous voulez la sauver, cliquer oui

Si… Alors-Orientait des fonctions : IsNumeric ()

Pour vérifier si une expression peut produire une valeur numérique, vous pouvez appeler la fonction booléenne d'IsNumeric() dont la syntaxe est :

IsNumeric(expression)

Cette fonction est employée pour évaluer l'argument d'expression. Si l'argument peut produire une valeur numérique reconnaissable, la fonction d'IsNumeric () produit une valeur vraie. Si une évaluation de l'expression produit une valeur qui n'est pas clairement un nombre, alors la fonction renvoie faux.

Étude pratiqueÉtude pratique : Employer la fonction d'IsNumeric ()

  1. Dans la fenêtre de base de données, double-cliquer la forme de frmProcedures
  2. Sur la forme, cliquer le dessus calculent le bouton et notent que vous recevez une erreur méchante
     
  3. Le clic corrigent pour ouvrir de base visuel de Microsoft et le rédacteur de code
  4. Sur la norme toolbar de de base visuel de Microsoft, cliquer la touche "ARRÊT"
  5. Changer les procédures du module de la forme comme suit:

  6.  
    Option Compare Database
    Option Explicit
    Sub SquareSolution()
        ' Declare the necessary variables for the square
        Dim dblSide As Double
        Dim dblPerimeter, dblArea As Double
        
        ' Retrieve the value of the side
        If IsNumeric([txtSqSide]) Then dblSide = Nz([txtSqSide])
        ' Calculate the perimeter and the are of the square
        dblPerimeter = dblSide * 4
        dblArea = dblSide * dblSide
        ' Prepare to display the result in the appropriate text boxes
        txtSqPerimeter = dblPerimeter
        txtSqArea = dblArea
    End Sub
    Private Sub SolveRectangle()
        ' Declare the necessary variables for the rectangle
        Dim dblLength, dblHeight As Double
        Dim dblPerimeter, dblArea As Double
        
        ' Retrieve the values of the length and height
        If IsNumeric([txtRLength]) Then dblLength = Nz([txtRLength])
        If IsNumeric([txtRHeight]) Then dblHeight = Nz([txtRHeight])
        ' Calculate the perimeter and the area of the rectangle
        dblPerimeter = (dblLength + dblHeight) * 2
        dblArea = dblLength * dblHeight
        ' Prepare to display the result in the appropriate text boxes
        txtRPerimeter = dblPerimeter
        txtRArea = dblArea
    End Sub
    Private Sub cmdBoxCalculate_Click()
        Dim dLen As Double
        Dim dHgt As Double
        Dim dWdt As Double
        Dim Area, Vol As Double
        
        If IsNumeric([txtBoxLength]) Then dLen = Nz([txtBoxLength])
        If IsNumeric([txtBoxHeight]) Then dHgt = Nz([txtBoxHeight])
        If IsNumeric([txtBoxWidth]) Then dWdt = Nz([txtBoxWidth])
        
        Area = BoxArea(dLen, dHgt, dWdt)
        Vol = BoxVolume(dLen, dHgt, dWdt)
        
        txtBoxArea = Area
        txtBoxVolume = Vol
    End Sub
    Private Sub cmdCCalculate_Click()
        txtCircleCircumference = CircleCircumference()
        txtCircleArea = CircleArea()
    End Sub
    Private Sub cmdCubeCalculate_Click()
        Dim dblSide As Double
        Dim dblArea As Double
        Dim dblVolume As Double
        
        If IsNumeric([txtCubeSide]) Then dblSide = Nz([txtCubeSide])
        dblArea = CubeArea(dblSide)
        dblVolume = CubeVolume(dblSide)
        
        txtCubeArea = dblArea
        txtCubeVolume = dblVolume
    End Sub
    Private Sub cmdECalculate_Click()
        Dim Radius1 As Double
        Dim Radius2 As Double
        
        If IsNumeric([txtEllipseRadius1]) Then Radius1 = Nz([txtEllipseRadius1])
        If IsNumeric([txtEllipseRadius2]) Then Radius2 = Nz([txtEllipseRadius2])
        
        SolveEllipse Radius1, Radius2
    End Sub
    Private Sub cmdRCalculate_Click()
        SolveRectangle
    End Sub
    Private Sub cmdSqCalculate_Click()
        SquareSolution
    End Sub
    Function CircleCircumference() As Double
        Dim dblRadius As Double
        
        If IsNumeric([txtCircleRadius]) Then dblRadius = Nz([txtCircleRadius])
        
        CircleCircumference = dblRadius * 2 * 3.14159
    End Function
    Private Function CircleArea() As Double
        Dim dblRadius As Double
        
        If IsNumeric([txtCircleRadius]) Then dblRadius = Nz([txtCircleRadius])
        
        CircleArea = dblRadius * dblRadius * 3.14159
    End Function
    Sub SolveEllipse(SmallRadius As Double, LargeRadius As Double)
        Dim dblCircum As Double
        Dim dblArea As Double
        
        dblCircum = (SmallRadius + LargeRadius) * 2
        dblArea = SmallRadius * LargeRadius * 3.14159
        
        txtEllipseCircumference = dblCircum
        txtEllipseArea = dblArea
    End Sub
    Function CubeArea(Side As Double) As Double
        CubeArea = Side * Side * 6
    End Function
     
    Function CubeVolume(Side As Double) As Double
        CubeVolume = Side * Side * Side
    End Function
    Function BoxArea(dblLength As Double, _
                     dblHeight As Double, _
                     dblWidth As Double) As Double
        Dim Area As Double
        
        Area = 2 * ((dblLength * dblHeight) + _
                    (dblHeight * dblWidth) + _
                    (dblLength * dblWidth) _
                   )
        BoxArea = Area
    End Function
    Function BoxVolume(dblLength As Double, _
                     dblHeight As Double, _
                     dblWidth As Double) As Double
        Dim Volume As Double
        Volume = dblLength * dblHeight * dblHeight
        BoxVolume = Volume
    End Function
  7. Revenir au Microsoft Access

Si… puis… autrement rapport

 

Introduction

Si… alors le rapport offre seulement une alternative : pour agir si la condition est vraie. Toutes les fois que vous voudriez appliquer une expression alternative au cas où la condition serait fausse, employer si… puis… autrement rapport. La formule de ce rapport est:

If ConditionIsTrue Then
    Statement1
Else
    Statement2
End If

La condition, dans ce ConditionIsTrue, serait examinée. Si elle produit un résultat vrai, alors le premier rapport, dans ce cas-ci Statement1, serait exécuté. Si la condition (ConditionIsTrue) est fausse, le deuxième rapport, dans ce cas-ci Statement2, serait exécuté.

Voici un exemple :

Private Sub Form_Current()
    If Gender = "Male" Then
        Detail.BackColor = 16772055
    Else
        Detail.BackColor = 13034239
    End If
End Sub

Si les expressions l'unes des a besoin de plus d'une ligne de code pour avoir une exécution complète, vous pouvez l'inclure dans la section nécessaire avant l'extrémité de la section. Voici un exemple :

Private Sub Form_Current()
    If Gender = "Male" Then
        Detail.BackColor = 16772055
        FormHeader.BackColor = 16752478
        FormFooter.BackColor = 14511872
    Else
        Detail.BackColor = 13034239
        FormHeader.BackColor = 7452927
        FormFooter.BackColor = 29670
    End If
End Sub

Si… puis… fonctions D'autre-Connexes : IIf

Puisque le Microsoft Access ne soutient pas des rapports conditionnels tels que si… puis… autrement la combinaison, sa se fonde sur une fonction telle qu'IIf () mais, naturellement, cette fonction peut être employée dans n'importe quelle base de données ou expression de base visuelle de Microsoft. La syntaxe de la fonction d'IIf () est :

IIf(Condition, WhatToDoIfTrue, WhatToDoIfFalse)

Une fois appelée, cette fonction commence par vérifier la condition. Par conséquent, s'assurer toujours que vous fournissez une condition qui peut produire un vrai ou un résultat faux. Si la condition évalue pour rectifier, l'expression dans le deuxième argument est appliquée. Si la condition produit faux, l'expression du dernier argument s'applique.

Si… puis… rapport d'ElseIf

 

Introduction

Si… alors… le rapport d'ElseIf agit comme si… puis… autrement, sauf qu'il offre autant de choix selon les besoins. La formule est :

If Condition1 Then
    Statement1
ElseIf Condition2 Then
    Statement2
ElseIf Condition_n Then
    Statement_n
End If

Le programme examinera d'abord la première condition, dans ce cas-ci Condition1. Si le Condition1 est vrai, alors le programme exécuterait le premier rapport, dans ce cas-ci Statment1, et des états examinants d'arrêt. Mais si le Condition1 est faux, alors le programme examinerait Condition2 et agirait en conséquence. Toutes les fois qu'une condition est fausse, le programme continuerait d'examiner les conditions jusqu'à ce qu'il trouve un qui est vrai. Une fois qu'un état vrai a été trouvé et son rapport a été exécuté, le programme terminerait l'examen conditionnel à l'extrémité si.

La syntaxe ci-dessus présuppose cela au bail un des conditions produirait un résultat vrai. Parfois, indépendamment combien de conditions vous employez, il est possible qu'aucune de elles ne produirait un résultat vrai. Par conséquent, en prévision d'une telle occurrence, vous devriez fournir un rapport alternatif qui embrasserait n'importe quelle condition qui ne s'adapte pas dans les résultats vrais possibles. Ceci est fait par la combinaison si… puis… autrement et si… puis… des rapports d'ElseIf. La syntaxe résultante à employer est :

If Condition1 Then
    Statement1
ElseIf Condition2 Then
    Statement2
ElseIf Condition3 Then
    Statement3
Else
    Statement_False
End If

Dans ce cas-ci, si ni l'un ni l'autre du si et des états d'ElseIfs étaient validés, puis du dernier rapport, dans ce cas-ci Statement_False, s'exécuterait.

Étude pratiqueÉtude pratique : Employer si… puis… ElseIf

  1. De la section de formes de la fenêtre de base de données, droit-cliquer la forme de livre de paie et cliquer la vue de conception :
     
    Georgetown Cleaning Services - Employee Payroll Design
     
  2. Droit-cliquer le processus il bouton et cliquer l'événement de construction…
  3. Dans la zone de dialogue de constructeur de choix, double-cliquer le constructeur de code
  4. Mettre en application l'événement comme suit :
     
    Private Sub cmdProcessIt_Click()
        Dim monday1 As Double
        Dim tuesday1 As Double
        Dim wednesday1 As Double
        Dim thursday1 As Double
        Dim friday1 As Double
        Dim saturday1 As Double
        Dim sunday1 As Double
        Dim monday2 As Double
        Dim tuesday2 As Double
        Dim wednesday2 As Double
        Dim thursday2 As Double
        Dim friday2 As Double
        Dim saturday2 As Double
        Dim sunday2 As Double
        Dim totalHoursWeek1 As Double
        Dim totalHoursWeek2 As Double
    
        Dim regHours1 As Double
        Dim regHours2 As Double
        Dim ovtHours1 As Double
        Dim ovtHours2 As Double
        Dim regAmount1 As Currency
        Dim regAmount2 As Currency
        Dim ovtAmount1 As Currency
        Dim ovtAmount2 As Currency
        
        Dim regularHours As Double
        Dim overtimeHours As Double
        Dim regularAmount As Currency
        Dim overtimeAmount As Currency
        Dim totalEarnings As Currency
    
        Dim hourlySalary As Currency
    
        ' Retrieve the hourly salary
        hourlySalary = CDbl(Me.txtHourlySalary)
        ' Retrieve the time for each day
        ' First Week
        monday1 = CDbl(Me.txtMonday1)
        tuesday1 = CDbl(Me.txtTuesday1)
        wednesday1 = CDbl(Me.txtWednesday1)
        thursday1 = CDbl(Me.txtThursday1)
        friday1 = CDbl(Me.txtFriday1)
        saturday1 = CDbl(Me.txtSaturday1)
        sunday1 = CDbl(Me.txtSunday1)
        
        ' Second Week
        monday2 = CDbl(Me.txtMonday2)
        tuesday2 = CDbl(Me.txtTuesday2)
        wednesday2 = CDbl(Me.txtWednesday2)
        thursday2 = CDbl(Me.txtThursday2)
        friday2 = CDbl(Me.txtFriday2)
        saturday2 = CDbl(Me.txtSaturday2)
        sunday2 = CDbl(Me.txtSunday2)
        
        ' Calculate the total number of hours for each week
        totalHoursWeek1 = monday1 + tuesday1 + wednesday1 + thursday1 + _
                          friday1 + saturday1 + sunday1
        totalHoursWeek2 = monday2 + tuesday2 + wednesday2 + thursday2 + _
                          friday2 + saturday2 + sunday2
    
        ' The overtime is paid time and half
        Dim ovtSalary As Double
        ovtSalary = hourlySalary * 1.5
    
        ' If the employee worked under 40 hours, there is no overtime
        If totalHoursWeek1 < 40 Then
            regHours1 = totalHoursWeek1
            regAmount1 = hourlySalary * regHours1
            ovtHours1 = 0
            ovtAmount1 = 0
        ' If the employee worked over 40 hours, calculate the overtime
        ElseIf totalHoursWeek1 >= 40 Then
            regHours1 = 40
            regAmount1 = hourlySalary * 40
            ovtHours1 = totalHoursWeek1 - 40
            ovtAmount1 = ovtHours1 * ovtSalary
        End If
        
        If totalHoursWeek2 < 40 Then
            regHours2 = totalHoursWeek2
            regAmount2 = hourlySalary * regHours2
            ovtHours2 = 0
            ovtAmount2 = 0
        ElseIf totalHoursWeek2 >= 40 Then
            regHours2 = 40
            regAmount2 = hourlySalary * 40
            ovtHours2 = totalHoursWeek2 - 40
            ovtAmount2 = ovtHours2 * ovtSalary
        End If
        
        regularHours = regHours1 + regHours2
        overtimeHours = ovtHours1 + ovtHours2
        regularAmount = regAmount1 + regAmount2
        overtimeAmount = ovtAmount1 + ovtAmount2
        totalEarnings = regularAmount + overtimeAmount
    
        Me.txtRegularHours = regularHours
        Me.txtOvertimeHours = overtimeHours
        Me.txtRegularAmount = CCur(regularAmount)
        Me.txtOvertimeAmount = CCur(overtimeAmount)
    
        Me.txtNetPay = CCur(totalEarnings)
    End Sub
  5. Revenir à la forme
  6. Droit-cliquer le bouton étroit et cliquer l'événement de construction…
  7. Dans la zone de dialogue de constructeur de choix, double-cliquer le constructeur de code
  8. Mettre en application l'événement comme suit :
     
    Private Sub cmdClose_Click()
        DoCmd.Close
    End Sub
  9. Revenir à la forme et la commuter à la vue de forme
  10. L'examiner avec quelques valeurs
     
    Georgetown Cleaning Services - Employee Payroll
  11. Fermer la forme
  12. Une fois demandé si vous voulez la sauver, cliquer oui

Le rapport choisi de cas

 

Introduction

Si vous avez un grand nombre de conditions à examiner, si… alors… autrement passera par chacune de elles, qui pourraient prendre longtemps (bien qu'habituellement transparent à l'utilisateur). Offres de base visuelles de Microsoft une alternative de sauter au rapport qui s'applique à l'état de la condition. Ceci est exécuté par le rapport choisi de cas.

La syntaxe du rapport choisi de cas est :

Select Case Expression
    Case Expression1
        Statement1
    Case Expression2
        Statement2
    Case Expression_n
        Statement_n
End Select

L'expression lui est évaluée une fois pour obtenir un résultat général. Alors le résultat de du facteur d'expression est comparé à l'ExpressionX de chaque cas. Une fois qu'il trouve un que les matchs, il exécuteraient le StatementX correspondant.

Voici un exemple :

Private Sub cboMembership_AfterUpdate()
    Dim strMembership As String
    
    strMembership = [cboMembership]
    
    Select Case strMembership
        Case "Teen"
            txtPrice = "$25"
        Case "Adult"
            txtPrice = "$50"
        Case "Senior"
            txtPrice = "$35"
    End Select
End Sub

Si vous prévoyez qu'il ne pourrait y avoir aucun match entre l'expression et celle de l'Expressionn, vous pouvez employer un rapport d'autre de cas à la fin de la liste. Le rapport ressemblerait alors à ceci :

Select Case Expression
    Case Expression1
        Statement1
    Case Expression2
        Statement2
    Case Expression3
        Statement3
    Case Else
        Statement_n
End Select

Choisir… les fonctions Cas-Connexes : Choisir ()

De nouveau, puisque le Microsoft Access ne fournit pas en soi un environnement de programmation, elle se fonde sur des fonctions logiques pour prendre soin de cet aspect. La fonction de choix () est l'une de ceux qui peuvent examiner une condition et fournir des solutions de rechange. La fonction de choix () fonctionne comme des conditions nichées. Elle détermine une condition et fournit différents résultats selon le résultat de l'essai. Sa syntaxe est :

Choose(Condition, Outcome1, Outcome2, Outcome_n)

Le premier argument de cette fonction est la condition qui devrait être examinée. Il devrait fournir un nombre normal. Après cet essai, la condition peut évaluer à 1, 2, 3, options ou plus. Chaque résultats sont alors traités. Le premier, Outcome1, serait employé si la condition produit 1. La seconde, Outcome2, serait employée si la condition produit 2, etc.

Étude pratique Étude pratique : Employer la fonction de choix

  1. De la section de formes de la fenêtre de base de données, droit-cliquer la forme d'intérêt composé et cliquer la vue de conception :
     
  2. Sur le toolbar standard, cliquer le bouton de code
  3. Dans la boîte combo d'objet, choisir le cmdCalculate et mettre en application son événement de clic comme suit :
     
    Private Sub cmdCalculate_Click()
        Dim Principal As Currency
        Dim InterestRate As Double
        Dim InterestEarned As Currency
        Dim FutureValue As Currency
        Dim RatePerPeriod As Double
        Dim Periods As Integer
        Dim CompoundType As Integer
        Dim i As Double
        Dim n As Integer
        
        Principal = CCur(txtPrincipal)
        InterestRate = CDbl(txtInterestRate)
        
        CompoundType = Choose([fraFrequency], 12, 4, 2, 1)
        
        Periods = CInt(txtPeriods)
        i = InterestRate / CompoundType
        n = CompoundType * Periods
        RatePerPeriod = InterestRate / Periods
        FutureValue = Principal * ((1 + i) ^ n)
        InterestEarned = FutureValue - Principal
        
        txtInterestEarned = CStr(InterestEarned)
        txtAmountEarned = CStr(FutureValue)
    End Sub
  4. Revenir au Microsoft Access et commuter la forme à la vue de forme pour l'examiner
     
  5. Fermer la forme
  6. Une fois demandé si vous voulez la sauver, cliquer oui

Choisir… les fonctions Cas-Connexes : Commutateur ()

Nous avons vu que la fonction d'IIf () est employée pour vérifier une condition et peut exécuter un de deux rapports selon le résultat de la condition. Dans quelques expressions, il y aura plus d'une condition à vérifier. Bien que vous puissiez nicher IIf () fonctionne pour créer une expression complexe, Microsoft Access fournit une autre fonction qui peut exécuter ceci chargent. La fonction s'appelle Switch et sa syntaxe est : \

Switch(Expression1, What To Do If Expression1 Is True,
       Expression2, What To Do If Expression2 Is True,
       Expression_n, What To Do If Expression_n Is True)

À la différence d'IIf (), la fonction de commutateur () ne prend pas un nombre fixe d'arguments. Elle prend autant de combinaisons de <Expression -- Statement>s comme vous avez besoin. Chaque expression est évaluée. Si l'expression évalue pour rectifier, le rapport qui la suit s'exécute. Bien que vous puissiez passer beaucoup de temps accordant une expression conditionnelle telle qu'on impliquant une fonction de commutateur (), il est encore possible qu'aucune des expressions n'évalue pour rectifier. Dans ce cas-ci, vous pouvez ajouter une dernière expression en tant que vrai et fournir un rapport suivant à l'utilisation. La syntaxe que vous emploieriez est :

Switch(Expression1, What To Do If Expression1 Is True,
       Expression2, What To Do If Expression2 Is True,
       Expression_n, What To Do If Expression_n Is True,
       True, What To Do With A False Expression)    

Étude pratique Étude pratique : Employer la fonction de commutateur

  1. De la section de formes de la fenêtre de base de données, droit-cliquer la forme d'opérations et cliquer la vue de conception :
     
  2. Sur le toolbar standard, cliquer le bouton de code
  3. Dans la boîte combo d'objet, choisir les fraOperations
  4. Dans la boîte combo de procédé, choisir le clic et mettre en application l'événement comme suit :
     
    Private Sub fraOperations_Click()
        txtResult = Switch([fraOperations] = 1, Nz([txtNumber1]) + Nz([txtNumber2]), _
                           [fraOperations] = 2, Nz([txtNumber1]) - Nz([txtNumber2]), _
                           [fraOperations] = 3, Nz([txtNumber1]) * Nz([txtNumber2]), _
                           [fraOperations] = 4, Nz([txtNumber1]) / Nz([txtNumber2]))
    End Sub
  5. Revenir à la forme dans le Microsoft Access et le commuter à la vue de forme pour l'examiner :
     
  6. Économiser et fermer la forme

Faire une boucle et compter

 

Faire tandis que… boucle

Des boucles sont employées pour répéter une action et elles emploient font le mot-clé en combination avec d'autres mots-clés pour exécuter et rapport conditionnel. Il y a de diverses variations de font des boucles.

La syntaxe du font tandis que la boucle est :

Do While Condition
    Statement(s)
Loop

Le programme examinera d'abord la condition. Si la condition est vraie, le programme exécuterait le rapport ou les rapports et aller de nouveau au font tandis que rapport et examinent la condition encore. Cette expression exécutera le rapport ou les rapports TANT QUE la condition est vraie, autant de fois car la condition sera visitée et fonder vrai. Si la condition est fausse, le programme en sautera font tandis que rapport et n'exécutera pas.

Voici un exemple :

Private Sub cmdCounter_Click()
    Dim Number As Integer
        
    Do While Number < 46
        MsgBox CStr(Number)
        Number = Number + 4
    Loop

    MsgBox "Counting Stopped at " & CStr(Number)
End Sub

… la boucle tandis que

Puisque faire tandis que le rapport examine la condition d'abord avant d'exécuter le rapport, parfois vous voudrez que le programme exécute le rapport d'abord, allez alors en arrière et examinez la condition. Offres de base visuelles un inverse à la syntaxe, qui est :

Do
  Statement(s)
Loop While Condition

Dans ce cas-ci, la volonté de base visuelle exécutent le rapport ou des rapports d'abord, alors il examinera la condition. Si la condition est vraie, le programme exécutera le rapport encore. Le programme continuera cette examen-exécution tant que la condition est vraie. La grande différence ici est que même si la condition est fausse, le programme aura exécuté la condition au moins une fois.

Voici un exemple :

Private Sub cmdCounter_Click()
    Dim Answer As String

    Do
        Answer = CStr(InputBox("Are we there yet (1=Yes/0=No)?", "Counter", "1"))
    Loop While Answer <> "1"

    MsgBox "Wonderful, we have arrived"
End Sub

Voici un exemple de courir le code :

 

Jusque… à la boucle

Une alternative au font tandis que la boucle est jusqu'à la boucle. Sa syntaxe est :

Do Until Condition
    Statement(s)
Loop

Cette boucle examinera d'abord la condition, au lieu d'examiner si la condition est vraie, il examinera si la condition est fausse.

Voici un exemple :

Private Sub cmdCounter_Click()
    Dim Answer As String

    Do Until (Answer = "1")
        Answer = InputBox("Are we there yet (1=Yes/0=No)?", "Counter", "1")
    Loop

    MsgBox "Wonderful, we have arrived"
End Sub

… la boucle jusqu'à

L'autre côté du jusqu'à ce que la boucle exécute le rapport d'abord, alors il examinerait la condition. La syntaxe utilisée est:

Do
    Statement(s)
Loop Until Condition

Pour… après

Si vous ne savez pas combien de fois un rapport doit être exécuté, vous pouvez employer un de faites des boucles. Mais toutes les fois que vous voulez commander combien de fois un rapport devrait être exécuté, pour… après la boucle offre une meilleure alternative. La syntaxe utilisée est :

For Counter = Start To End
  Statement(s)
Next

Utilisé pour compter, pour… après la boucle commence à compter au point de début. Alors il examine si la valeur courante (après avoir commencé à compter) est extrémité plus grande que ; si c'est le cas, le programme sort la boucle. Il exécute alors le rapport ou les rapports. Après, il des incréments la valeur du compteur par 1 et examine la condition encore. Ce processus continue jusqu'au compteur = à l'extrémité.

The syntax above will increment the counting by 1 at the end of each statement. If you want to control how the incrementing processes, you can set your own, using the Step option. Here is the syntax you would use:

For Counter = Start To End Step Increment
  Statement(s)
Next Counter

You can set the incrementing value to your choice. If the value of Increment is positive, the Counter will be added its value. This means that you can give it a negative value, in which case the Counter would be subtracted the set value.

Counting and Looping: For...Each

Since the For...Next loop is used to execute a group of statements based on the current result of the loop counting from Start to End, an alternative is to state various steps in the loop and execute a group of statements for each one of the elements in the group. This is mostly used when dealing with a collection of items.

The syntax used is:

For Each Element In Group
    Statement(s)
Next Element

The loop will execute the Statement or Statement(s) for each Element in the Group.

 


Précédent Copyright © Yevol, 2007 Suivant