Briefly, you can look at it through the prism of equality.<p>In javascript, 1 === 1, and &quot;foo&quot; === &quot;foo&quot;. However, [] !== [] and {} !== {}. This is because in Javascript, like in Java, there is a distinction between <i>value types</i> (essentially, simple primitive values like numbers and strings) and <i>reference types</i> (collections - arrays and objects). When you assign an array to a variable, you are actually pointing the variable to a reference to the array. As a mutable data structure, its identity is more important than its value: it is expected that you shall be calling push, etc, and thus changing its value in place.<p>In Clojure (for example), (= 1 1) and (= &quot;foo&quot; &quot;foo&quot;) <i>and</i> (= [] []) <i>and</i> (= {} {}). Because Clojure&#x27;s data structures are immutable, the idea of checking for identity is almost meaningless (although you can, with the identical? function). In an FP style, with generic but immutable data structures, we are more interested in value equality, since we are not concerned so much with objects with a long lifecycle over which the values of their fields may change.<p>Javascript is in an odd position - it has enough features for both traditional OO and functional programming styles to be possible, but the two do not easily co-exist. Compromises are necessary. So, if our program is composed of mostly pure functions operating on generic data structures, we must do a lot of defensive copying, and use library functions for deep equality, because the data structures are not designed for this usage.<p>This is not to say it&#x27;s infeasible to program in this way in Javascript: it is, and I try to. But a language designed from the ground up for functional programming will point you more enthusiastically in that direction than JS does.<p>On topic: like the syntax!