IF...THEN

From QB64 Phoenix Edition Wiki
(Redirected from END IF)
Jump to navigation Jump to search

IF...THEN statements make boolean (true or false) evaluations to automate program decision making.


Syntax

Single-line

IF conditionStatement THEN {code} ELSE {alternativeCode}
IF conditionStatement GOTO lineLabel

Block

IF conditionStatement THEN
{code}
⋮
ELSEIF conditionStatement2 THEN
{code}
⋮
ELSE
{code}
⋮
END IF


Description

  • The conditionStatement evaluation by IF must be true (-1) or a non-zero numerical value for the THEN {code} to be executed.
  • Multiple conditional evaluations can be made using inclusive AND or alternative OR conditional expressions.
  • THEN is not required when GOTO is used to send program flow to a line number or label.
  • IF statements can also have alternative evaluations using ELSEIF and ELSE conditions.
  • When the IF statement and/or code to be run is more than code line, an END IF statement must be used.
  • With multiple code lines to run, end the IF statement with THEN and place all of the code on lines below that line.
  • Multiple code line block statements require that the IF...THEN, ELSEIF, ELSE and END IF be on separate lines.
  • The IDE may return an error of NEXT without FOR or LOOP without DO when END IF does not end a statement block.
  • The QB64 IDE will indicate an error in the IF statement line until END IF closes the statement block.
  • Use colons to execute multiple statements in a single-line IF statement.
  • An underscore can be used anywhere after the code on a single-line to continue it to the next line in QB64.
  • NOTE: STRING values can only be evaluated in an IF statement if a value is compared to a literal or CHR$ string value. QB64 may not compile literal IF string statements or indicate an IDE coding error. Use LEN or ASC to compare strings numerically.


         Table 3: The relational operations for condition checking.

 In this table, A and B are the Expressions to compare. Both must represent
 the same general type, i.e. they must result into either numerical values
 or STRING values. If a test succeeds, then true (-1) is returned, false (0)
     if it fails, which both can be used in further Boolean evaluations.
 ┌─────────────────────────────────────────────────────────────────────────┐
 │                          Relational Operations                          │
 ├────────────┬───────────────────────────────────────────┬────────────────┤
 │ Operation  │                Description                │ Example usage  │
 ├────────────┼───────────────────────────────────────────┼────────────────┤
 │   A = B    │ Tests if A is equal to B.                 │ IF A = B THEN  │
 ├────────────┼───────────────────────────────────────────┼────────────────┤
 │   A <> B   │ Tests if A is not equal to B.             │ IF A <> B THEN │
 ├────────────┼───────────────────────────────────────────┼────────────────┤
 │   A < B    │ Tests if A is less than B.                │ IF A < B THEN  │
 ├────────────┼───────────────────────────────────────────┼────────────────┤
 │   A > B    │ Tests if A is greater than B.             │ IF A > B THEN  │
 ├────────────┼───────────────────────────────────────────┼────────────────┤
 │   A <= B   │ Tests if A is less than or equal to B.    │ IF A <= B THEN │
 ├────────────┼───────────────────────────────────────────┼────────────────┤
 │   A >= B   │ Tests if A is greater than or equal to B. │ IF A >= B THEN │
 └────────────┴───────────────────────────────────────────┴────────────────┘
   The operations should be very obvious for numerical values. For strings
   be aware that all checks are done case sensitive (i.e. "Foo" <> "foo").
   The equal/not equal check is pretty much straight forward, but for the
   less/greater checks the ASCII value of the first different character is
                          used for decision making:

   E.g. "abc" is less than "abd", because in the first difference (the 3rd
        character) the "c" has a lower ASCII value than the "d".

   This behavior may give you some subtle results, if you are not aware of
                   the ASCII values and the written case:

   E.g. "abc" is greater than "abD", because the small letters have higher
        ASCII values than the capital letters, hence "c" > "D". You may use
        LCASE$ or UCASE$ to make sure both strings have the same case.


Boolean Conditional Operators:


  • AND (boolean) can be used to add extra conditions to a boolean statement evaluation.
  • OR (boolean) can be used to add alternate conditions to a boolean statement evaluation.
  • Parenthesis are allowed inside of boolean statements to clarify an evaluation.


Mathematical Logical operators:
* Truth table of the 6 BASIC Logical Operators:


               Table 4: The logical operations and its results.

       In this table, A and B are the Expressions to invert or combine.
              Both may be results of former Boolean evaluations.
  ┌────────────────────────────────────────────────────────────────────────┐
  │                           Logical Operations                           │
  ├───────┬───────┬───────┬─────────┬────────┬─────────┬─────────┬─────────┤
  │   A   │   B   │ NOT B │ A AND B │ A OR B │ A XOR B │ A EQV B │ A IMP B │
  ├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
  │ true  │ true  │ false │  true   │ true   │  false  │  true   │  true   │
  ├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
  │ true  │ false │ true  │  false  │ true   │  true   │  false  │  false  │
  ├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
  │ false │ true  │ false │  false  │ true   │  true   │  false  │  true   │
  ├───────┼───────┼───────┼─────────┼────────┼─────────┼─────────┼─────────┤
  │ false │ false │ true  │  false  │ false  │  false  │  true   │  true   │
  └───────┴───────┴───────┴─────────┴────────┴─────────┴─────────┴─────────┘
   Note: In most BASIC languages incl. QB64 these are bitwise operations,
         hence the logic is performed for each corresponding bit in both
         operators, where true or false indicates whether a bit is set or
         not set. The outcome of each bit is then placed into the respective
         position to build the bit pattern of the final result value.

   As all Relational Operations return negative one (-1, all bits set) for
    true and zero (0, no bits set) for false, this allows us to use these
    bitwise logical operations to invert or combine any relational checks,
    as the outcome is the same for each bit and so always results into a
            true (-1) or false (0) again for further evaluations.
* Note that Basic returns -1 for True and 0 for False.


Examples

Example 1: In a one line IF statement, only REM can be used to comment out the action without an END IF error: 

INPUT "Enter a number over or under 100: ", x
IF x > 100 THEN PRINT x
IF x > 100 THEN REM PRINT x  '


Example 2: IF statement blocks require that the IF THEN and END IF statements be separate from the code executed. 

INPUT "Enter a number over or under 100: ", x
IF x > 100 THEN
  y = 200
  PRINT y
  PRINT x
END IF


Example 3: True or False evaluation of a numerical value executes only when the value is not 0. Cannot evaluate STRING values. 

INPUT "Enter a number or just hit Enter: ", x
IF x THEN PRINT x
Example will only print if a numerical value is True (positive or negative). (Equivalent to: IF x > 0 OR x < 0 THEN evaluation)


Example 4: Multiple evaluations using parenthesis to determine the order. 

INPUT "Enter a number over or under 100 or 50: ", value
IF (value% > 100 AND value% < 200) OR value% = 50 THEN PRINT "OK"


Example 5: Using multiple IF options in a one line statement. 

INPUT "Enter a number over or under 200: ", x
IF x > 200 THEN PRINT "High" [[ELSEIF|ELSEIF]] x < 0 THEN PRINT "Low" [[ELSE|ELSE]] PRINT "OK"


Example 6: STRING values can be compared using greater than, less than, not equal to or equal to operators only. 

PRINT "Press a letter key: ";
Key$ = INPUT$(1)
PRINT Key$
IF Key$ >= CHR$(65) AND Key$ <= CHR$(90) THEN PRINT "A to Z"
Explanation: Long STRING expression values are compared by their cumulative ASCII code values.


QBasic decimal point value comparison errors
  • Floating decimal point numerical values may not be compared as exactly the same value. QB64 will compare them the same.
Example: QBasic would print unequal in the IF comparison code below even though it is exactly the same value printed.
x# = 5 / 10
y# = 6 / 10
z# = x# + y#
PRINT x#, y#, z#
IF x# + y# = z# THEN PRINT "equal" ELSE PRINT "unequal"
Note: QB64 will make the calculation correctly and print equal. Change older program code that relies on the error accordingly.


See also


Navigation:
Main Page with Articles and Tutorials
Keyword Reference - Alphabetical
Keyword Reference - By usage
Retrieved from "https://qb64phoenix.com/qb64wiki/index.php?title=IF...THEN&oldid=8134"