Template:RelationalOperationsPlugin: Difference between revisions

From QB64 Phoenix Edition Wiki
Jump to navigation Jump to search
No edit summary
No edit summary
Tag: Manual revert
 
(12 intermediate revisions by the same user not shown)
Line 1: Line 1:
{{FixedStart}}
{{FixedStart}}
    In this table, '''A''' and '''B''' are the values to compare. Both must be of the
        Table 3: The relational operations for condition checking.
      same general type, i.e. either numerical values or [[STRING]] values.
 
In this table, '''A''' and '''B''' are the [[Expression|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]]'''                          │
  │                          '''[[Relational Operations]]'''                          │
Line 7: Line 11:
  │ '''Operation'''  │                '''Description'''                │ '''Example usage'''  │
  │ '''Operation'''  │                '''Description'''                │ '''Example usage'''  │
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  │  '''A''' [[Equal|=]] '''B'''   │ Tests if '''A''' is equal to '''B'''.                │ [[IF]] '''A''' = '''B''' [[THEN]]  │
  │  A [[Equal|=]] B    │ Tests if A is '''equal''' to B.                │ [[IF]] A [[Equal|=]] B [[THEN]]  │
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  │  '''A''' [[Not Equal|<>]] '''B'''   │ Tests if '''A''' is not equal to '''B'''.            │ [[IF]] '''A''' <> '''B''' [[THEN]] │
  │  A [[Not Equal|<>]] B  │ Tests if A is '''not equal''' to B.            │ [[IF]] A [[Not Equal|<>]] B [[THEN]] │
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  │  '''A''' [[Less Than|<]] '''B'''   │ Tests if '''A''' is less than '''B'''.                │ [[IF]] '''A''' < '''B''' [[THEN]]  │
  │  A [[Less Than|<]] B    │ Tests if A is '''less than''' B.                │ [[IF]] A [[Less Than|<]] B [[THEN]]  │
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  │  '''A''' [[Greater Than|>]] '''B'''   │ Tests if '''A''' is greater than '''B'''.            │ [[IF]] '''A''' > '''B''' [[THEN]]  │
  │  A [[Greater Than|>]] B    │ Tests if A is '''greater than''' B.            │ [[IF]] A [[Greater Than|>]] B [[THEN]]  │
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  │  '''A''' [[Less Than Or Equal|<=]] '''B'''   │ Tests if '''A''' is less than or equal to '''B'''.    │ [[IF]] '''A''' <= '''B''' [[THEN]] │
  │  A [[Less Than Or Equal|<=]] B  │ Tests if A is '''less than or equal''' to B.    │ [[IF]] A [[Less Than Or Equal|<=]] B [[THEN]] │
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  ├────────────┼───────────────────────────────────────────┼────────────────┤
  │  '''A''' [[Greater Than Or Equal|>=]] '''B'''   │ Tests if '''A''' is greater than or equal to '''B'''. │ [[IF]] '''A''' >= '''B''' [[THEN]] │
  │  A [[Greater Than Or Equal|>=]] B  │ Tests if A is '''greater than or equal''' to B. │ [[IF]] A [[Greater Than Or Equal|>=]] B [[THEN]] │
  └────────────┴───────────────────────────────────────────┴────────────────┘
  └────────────┴───────────────────────────────────────────┴────────────────┘
   The operation should be very obvious for numerical values. For strings,
   The operations should be very obvious for numerical values. For strings
the equal/not equal check is also pretty much straight forward, but for the
  be aware that all checks are done '''case sensitive''' (i.e. "Foo" <> "foo").
   less/greater checks the [[ASCII]] value of the first different character is
  The '''equal'''/'''not equal''' check is pretty much straight forward, but for the
                          used for the decision:
   '''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 (3rd char)
  '''E.g.''' "abc" is '''less''' than "abd", because in the first difference (the 3rd
      the "c" has a lower [[ASCII]] value than the "d".
        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
   This behavior may give you some subtle results, if you are not aware of
                   the [[ASCII]] values and the written case:
                   the [[ASCII]] values and the written case:
                 
 
e.g. "abc" is greater than "abD", because small letters have higher [[ASCII]]
  '''E.g.''' "abc" is '''greater''' than "abD", because the small letters have higher
      values than capital letters, hence "c" > "D". You may use either the
        [[ASCII]] values than the capital letters, hence "c" > "D". You may use
      [[LCASE$]] or [[UCASE$]] function to make sure both strings use the same case.
        [[LCASE$]] or [[UCASE$]] to make sure both strings have the same case.
{{FixedEnd}}
{{FixedEnd}}

Latest revision as of 18:19, 15 December 2022

         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.
Retrieved from "https://qb64phoenix.com/qb64wiki/index.php?title=Template:RelationalOperationsPlugin&oldid=5337"