# Or Operator (Visual Basic)

Performs a logical disjunction on two `Boolean`

expressions, or a bitwise disjunction on two numeric expressions.

## Syntax

```
result = expression1 Or expression2
```

## Parts

`result`

Required. Any `Boolean`

or numeric expression. For `Boolean`

comparison, `result`

is the inclusive logical disjunction of two `Boolean`

values. For bitwise operations, `result`

is a numeric value representing the inclusive bitwise disjunction of two numeric bit patterns.

`expression1`

Required. Any `Boolean`

or numeric expression.

`expression2`

Required. Any `Boolean`

or numeric expression.

## Remarks

For `Boolean`

comparison, `result`

is `False`

if and only if both `expression1`

and `expression2`

evaluate to `False`

. The following table illustrates how `result`

is determined.

If `expression1` is |
And `expression2` is |
The value of `result` is |
---|---|---|

`True` |
`True` |
`True` |

`True` |
`False` |
`True` |

`False` |
`True` |
`True` |

`False` |
`False` |
`False` |

Note

In a `Boolean`

comparison, the `Or`

operator always evaluates both expressions, which could include making procedure calls. The OrElse Operator performs *short-circuiting*, which means that if `expression1`

is `True`

, then `expression2`

is not evaluated.

For bitwise operations, the `Or`

operator performs a bitwise comparison of identically positioned bits in two numeric expressions and sets the corresponding bit in `result`

according to the following table.

If bit in `expression1` is |
And bit in `expression2` is |
The bit in `result` is |
---|---|---|

1 | 1 | 1 |

1 | 0 | 1 |

0 | 1 | 1 |

0 | 0 | 0 |

Note

Since the logical and bitwise operators have a lower precedence than other arithmetic and relational operators, any bitwise operations should be enclosed in parentheses to ensure accurate execution.

## Data Types

If the operands consist of one `Boolean`

expression and one numeric expression, Visual Basic converts the `Boolean`

expression to a numeric value (–1 for `True`

and 0 for `False`

) and performs a bitwise operation.

For a `Boolean`

comparison, the data type of the result is `Boolean`

. For a bitwise comparison, the result data type is a numeric type appropriate for the data types of `expression1`

and `expression2`

. See the "Relational and Bitwise Comparisons" table in Data Types of Operator Results.

## Overloading

The `Or`

operator can be *overloaded*, which means that a class or structure can redefine its behavior when an operand has the type of that class or structure. If your code uses this operator on such a class or structure, be sure you understand its redefined behavior. For more information, see Operator Procedures.

## Example 1

The following example uses the `Or`

operator to perform an inclusive logical disjunction on two expressions. The result is a `Boolean`

value that represents whether either of the two expressions is `True`

.

```
Dim a As Integer = 10
Dim b As Integer = 8
Dim c As Integer = 6
Dim firstCheck, secondCheck, thirdCheck As Boolean
firstCheck = a > b Or b > c
secondCheck = b > a Or b > c
thirdCheck = b > a Or c > b
```

The preceding example produces results of `True`

, `True`

, and `False`

, respectively.

## Example 2

The following example uses the `Or`

operator to perform inclusive logical disjunction on the individual bits of two numeric expressions. The bit in the result pattern is set if either of the corresponding bits in the operands is set to 1.

```
Dim a As Integer = 10
Dim b As Integer = 8
Dim c As Integer = 6
Dim firstPattern, secondPattern, thirdPattern As Integer
firstPattern = (a Or b)
secondPattern = (a Or c)
thirdPattern = (b Or c)
```

The preceding example produces results of 10, 14, and 14, respectively.

## See also

## Feedback

https://aka.ms/ContentUserFeedback.

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see:Submit and view feedback for