Clojure examples compared to JavaScript counterparts.

Defining vars:

``(def age 100)``
``````// JavaScript
var age = 100;``````

Creating maps:

``{:foo 0 :bar {:car "far"}}``
``````// JavaScript
{foo: 0, bar: {car: "far"}}``````

Maps are functions:

``````({:foo 0 :bar {:car "far"}} :foo)
;; ⇒ 0``````
``````// JavaScript
var o = {foo: 0, bar: {car: "far"}};
o.foo
// ⇒ 0``````

Functions are values:

``````(map inc [1 2 3])
;; ⇒ [2 3 4]``````
``````// With Underscore.js
_.map([1, 2, 3], function (n) { return n + 1; });
// ⇒ [2 3 4]``````

Defining and using functions:

``````(defn square [x] (* x x))

(square 3)
;; ⇒ 9``````
``````// JavaScript
function square(x) { return x * x; }

square(3);
// ⇒ 9``````

Defining and using anonymous functions:

``````((fn [x] (* x x)) 3)
;; ⇒ 9

;; % represents the first argument to the anonymous function.
;; We could have also used %1 to get at the first argument.
;; This function is the same as function above.
(#(* % %) 3)
;; ⇒ 9``````
``````// JavaScript
(function (x) { return x * x; })(3);
// ⇒ 9``````

Clojure sequences are lazy:

``````;; Take the first ten even numbers from a list of size one billion.
;; List is lazily built, so it never builds all billion elements.
(take 10 (filter even? (range 1000000000)))
;; ⇒ (0 2 4 6 8 10 12 14 16 18)``````

The JavaScript counterpart may crash your browser:

``````// With Underscore.js
_.chain(_.range(1000000000))
.filter(function (n) { return n % 2 == 0; })
.take(10)
.value();
// ⇒ ?``````

Defining and using functions, with a destructured map in function argument:

``````(defn my-function
[{:keys [name occupation]}]
(println name "is a" occupation))

(my-function {:name  "Elben"
:phone "5555555"
:occupation "Farmer"})
;; ⇒ Elben is a Farmer``````

JavaScript doesn’t support destructuring:

``````var myFunction = function(map) {
console.log(map.name + " is a " + map.occupation);
};

myFunction({name:  "Elben",
phone: "5555555",
occupation: "Farmer"});
// ⇒ Elben is a Farmer``````

If you’re interested in learning more, I recommend Joy of Clojure.