Jinja’s `sameas` Test: Identity Comparisons

nThe Jinja sameas test is a powerful, yet specialized, tool for checking if two variables reference the same object in memory. This is a crucial distinction from the eq test (is ==), which only checks if two objects have the same value. The sameas test is equivalent to Python’s is operator and returns True only if both variables point to the same memory address. It is invaluable for checking against singleton objects like None, True, and False, and for performing strict identity comparisons that prevent unintended behavior in your templates.nn

How the `sameas` Test Works

nThe syntax for the sameas test is straightforward: value is sameas other_value.nnThis test does not compare the contents of the objects; it compares their identities. For example, two different lists with the same elements are not the same object, and sameas would return False. However, if you assign a variable to another, they will both point to the same object, and sameas would return True.nnLet’s look at a basic example to illustrate this point:n

{% set a = [1, 2] %}n{% set b = [1, 2] %}n{% set c = a %}nn{{ a == b }} {# Output: True (values are the same) #}n{{ a is sameas b }} {# Output: False (different objects) #}nn{{ a == c }} {# Output: True #}n{{ a is sameas c }} {# Output: True (same object) #}

nIn this snippet, a and b have the same value, so a == b returns True. However, they are two distinct objects in memory, so a is sameas b returns False. On the other hand, c is assigned directly from a, making them references to the same object, so both == and is sameas return True.nn

Practical Applications of the `sameas` Test

nThe sameas test is particularly useful in situations where a simple value comparison is not sufficient or could be misleading.n

1. Checking Against Singleton Objects

nThe most common and important use of sameas is to check for singleton objects like None, True, and False. In Python, there is only one None object, one True object, and one False object. Using sameas guarantees that you are comparing against the singleton itself, not just an object that evaluates to the same value.n

{% set my_variable = None %}n{% set another_variable = 0 %} {# a falsy value #}nn{% if my_variable is sameas None %}n    <p>The variable is truly None.</p>n{% endif %}nn{% if another_variable is sameas False %}n    <p>This will not be shown, as 0 is not the False singleton.</p>n{% endif %}

nUsing if my_variable would return False and using if not my_variable would return True, but neither definitively tells you that the variable is None versus an empty list or 0. The sameas None check is explicit and unambiguous.n

2. Avoiding Unintended Side Effects with Default Parameters

nWhen defining macros or functions, using a mutable default parameter (like a list or dictionary) can lead to unintended side effects because all calls to the function without a provided value will modify the same object. The sameas test can be used to handle this gracefully.n

{% macro get_list(my_list=None) %}n    {% if my_list is sameas None %}n        {% set my_list = [] %}n    {% endif %}n    ...n{% endmacro %}

nThis pattern ensures that a new list is created only if no list is passed in, avoiding the issue of a shared, mutable default object.n

3. Caching and Performance Optimization

nIn advanced scenarios, you can use sameas to check if a variable has been reassigned. This can be useful for caching complex calculations or conditional logic.n

{% set original_data = big_dataset %}n{% set processed_data = original_data %}nn{% if processed_data is sameas original_data %}n    <p>The data has not been modified.</p>n{% endif %}

nThis could be a quick check to see if a variable has been replaced by a new object, allowing you to skip a potentially expensive re-processing step.nn

`sameas` vs. `eq`

nThe distinction between sameas and eq is critical for writing correct and robust templates.n

sameas (is): Compares identity. Returns True if two variables point to the same object in memory.

eq (==): Compares value. Returns True if two objects have the same value, regardless of whether they are the same object.

Comparison	`[1] == [1]`	`[1] is sameas [1]`	`None == False`	`None is sameas False`
Result	True	False	False	False
Reason	Values are equal	Different objects	Values are not equal	Different objects

Conclusion

nThe Jinja sameas test is a powerful and precise tool for making identity comparisons. It is the definitive method for checking against singleton objects like None, True, and False, and for verifying whether two variables reference the exact same object in memory. While the eq test is sufficient for most value-based comparisons, sameas provides a higher level of certainty and is essential for preventing subtle bugs and writing robust, maintainable templates.

Jinja Test Sameas: checking if two objects are same

Jinja’s sameas Test: Identity Comparisons

How the sameas Test Works

Practical Applications of the sameas Test