On “lists are never empty”:
So, if you open your console and do:
var a = [1, 2, 3, 4] // a is an array of four items 1 thru 4
var b = [1, 2, 3, 4]
And then you ask, is “a” the equivalent to “b”?
a == b // “==” is the equivalency operator in JS, not to be confused with “=” (the assignment operator).
The result will be
false. Because “a” is one object and “b” is another object. So, while they hold identical values, these can never be the same thing (object).
The only way that
a can be identical to
b is via an object reference:
b = a // we assign b to be the same thing as a
Now b and a refer to the same object (a single instance of the array/object [1, 2, 3, 4] ).
null. As it so happens,
null is also an object (it is not its own data type). It is a unique object that never exists naturally, it can only be called into existence by the programmer and it is a way of saying, while some thing is not undefined, neither does it have any value or any data type beyond object.
Additionally (and this is a feature of all drag & drop programming environments), in Bubble there is no concept of
undefined. For us to reference something in a drag and drop environment, it must have some label, some symbol. And further (if there’s an Issue Checker as in Bubble or we care about data types as does Bubble), there needs to be additionally metadata (e.g., where it’s located, what types of data it can store) about a symbol for it to be useful…
So there’s no such thing as “a thing that is labeled but does not yet exist” in such environments. So “empty” kind of plays a dual role: It represents both
null and in some special circumstances, the state of being
undefined. Nothing is ever
undefined, so we either simply cannot reference it or it is assumed to be
(Example: Try to use the expression builder to reference some custom state that does not exist. You can’t do it. Instead, you would have to define the custom state first (at which point it is empty/null, but it is most definitely not undefined). And, in fact, in such situations, Bubble actually invites you to define a new custom state! That’s the way graphical/drag & drop environments work.)
null is an object, we cannot modify it. We cannot add any additional properties to it, nor does it have any properties.
Null is just…
null. And, in the same way that all instances of the integer 5 are the same, all nulls are the same.
5 == 5,
null == null,
5 !== anything else, similarly
null !== anything else.
And so, because Bubble lists are Arrays, they are also objects. And objects are unique. And some Array object can never be the special object null. (Additionally, null is not an Array, so no Array can ever be
null and no
null can ever be an Array.)
And, thus, an Array (a List in Bubble) is never null (empty in Bubble terms).
var a =  // a is an Array, but it has no elements, its length is 0 (zero).
a is still an object and thus is unique (and it is definitely not
All indexes of
a (the first element of the array) does not exist and thus is undefined. As is
a and on and on and on.
Now, in the same way that our Array
a can have 0 length, Bubble Lists can also have zero length. But they are still objects and thus are not equivalent to empty/null.
So we can’t ask if a List is empty (null), but we can ask if the first item is “empty” (this is one of those cases, where Bubble equates
undefined – technically speaking, the first item in a List with no items is
undefined, but since Bubble can’t have that, it evaluates to
The other thing we can do of course is ask how many elements a List (Array) has. In Bubble terms this is the List’s
A Bubble List without any items in it will have a
NOW, to the question of, “which is better… to test if a Bubble List has a
:count < 1 or if the
:first item is empty”?
In vanilla Bubble, it doesn’t really matter. HOWEVER, in plugin land, where we encounter some Lists (in fact, most of the Lists we encounter) that are themselves objects, it turns out that we can know the
:count of the List (the
.length of the Array of items that List represent) before accessing any of the items in the List.
This is because the results of a Search is a List object – which is a simple JS object with two methods on it: a
.get() method (to retrieve individual items in the List) and a
.length() method (which instantly returns to us the number of items in the List – it doesn’t query the database to know this, the value just travels along with the List).
So, in a plugin, if I want to evaluate whether a List presented to me has any items or not, I’d just look at
List.length() and, if it’s
0, I know that there are no items in the List and do not have to bother to
Anyway, that’s a little story about Lists.
Postscript: The only place I know of where a Bubble programmer can access this same functionality is in my List Shifter plugin. There’s an exposed state in List Shifter named “Item Count”. When List Shifter is first initializing, I inspect the
.length() property of the incoming List and immediately publish it to that output just before fetching the items in the List.
In this way, you might (for example) send List Shifter some giant List, but you can know the size of it well before List Shifter finishes initializing, just by keeping an eye on that exposed state.