---
title: The “==” Equals Operator
description: "In Assette, expressions are powerful tools used within Data Objects and Data Blocks to manipulate, compare, and evaluate data for client reports and presentations. One of the fundamental comparison operators available is the **`==` Equals Operator**. This operator allows you…"
url: "https://learn.assette.com/docs/the-equals-operator/"
updated: "2024-11-18"
category: Developers / Developer Tools / Data Object Editor / Expressions
---

# The “==” Equals Operator

In Assette, expressions are powerful tools used within Data Objects and Data Blocks to manipulate, compare, and evaluate data for client reports and presentations. One of the fundamental comparison operators available is the **`==` Equals Operator**. This operator allows you to compare two values to determine if they are equal, enabling conditional logic and data filtering within your expressions.

This article provides a comprehensive overview of how the `==` operator works in Assette expressions, including its purpose, syntax, usage examples, and practical applications.

## Purpose of the `==` Equals Operator

The `==` operator is used to compare two values or expressions to check if they are equal. It returns a Boolean result:

- **`True`**: If the values on both sides of the operator are equal.
- **`False`**: If the values are not equal.

This operator is essential for implementing conditional logic, making decisions within expressions, and filtering data based on specific criteria.

## Syntax of the `==` Operator

**`value1`**: The first value or expression to compare.

**`value2`**: The second value or expression to compare.

```
value1 == value2
```

## Understanding How It Works

When you use the `==` operator in an expression, Assette evaluates both `value1` and `value2` and compares their values:

- If `value1` and `value2` are of the same data type and have equal values, the expression returns `True`.
- If they are not equal, or if they are of incompatible data types that cannot be compared, the expression returns `False`.

**Note**: Assette expressions are case-sensitive when comparing strings unless specified otherwise.

## Examples of Using the `==` Operator

### Numeric Comparison

**Evaluation:**

- Both values are numeric and equal.
- **Result:** `True`

```
5 == 5
```

### Case-Sensitive String Comparison

**Evaluation:**

- The strings have different cases.
- **Result:** `False`

```
"Assette" == "assette"
```

## Variable Comparison

Assuming you have variables `status` and `threshold`:

**Evaluation:**

- Compares the value of `status` to the string `"Active"`.
- **Result:** Depends on the value of `status`.

```
status == "Active"
```

## Important Considerations

### Data Types

- **Numeric Comparisons:** Ensure both values are numbers.
- **String Comparisons:** Be mindful of case sensitivity.
- **Date Comparisons:** Dates should be in the same format.

### Null and Undefined Values

- **Null Values:** Comparing a value to `null` using `==` can help identify missing data.

### Case Sensitivity

- To perform a case-insensitive comparison, convert both strings to the same case using functions like `Lower()` or `Upper()`.

### Logical Operators

- Combine the `==` operator with logical operators like `and`, `or`, and `not` for complex conditions.

## Best Practices

1. **Explicit Comparisons:** Always specify both sides of the comparison explicitly.
2. **Consistent Data Types:** Ensure that the values being compared are of compatible data types.
3. **Null Checks:** Use the `HasValue()` function to check for null or undefined values before comparison.
4. **Use Parentheses for Clarity:** Group conditions using parentheses to improve readability.
5. **Case Handling in Strings:** Use case conversion functions for case-insensitive comparisons.