Javascript – Immutable types

In C# and other similar general purpose languages, there are access modifiers which allow you to specify whether a particular property can be accessed/modified by everyone (public), only subclasses (protected) or only from within the same class (private).

In these languages, creating an immutable type usually involves:

  • making all properties publicly gettable
  • making all properties privately settable
  • constructor takes in all the necessary parameters to initialize the properties

Here’s an example of an immutable class in C#:

public sealed class Dog
{
    public Dog(string name, string breed, int age)
    {
        Name = name;
        Breed = breed;
        Age = age;
    }

    public string Name { get; private set; }

    public string Breed { get; private set; }

    public int Age { get; private set; }
}

Javascript, however, do not have an equivalent of the private keyword, in fact, all the members of an object are public. So, to achieve the same effect in javascript you can use local variables instead and create an accessor method (i.e. getters) for each.

Here’s the equivalent object in javascript:

function Dog(name, breed, age) {
    // use local variables so that they can't be access from outside
    var _name = name, _breed = breed, _age = age;

    // define accessor methods
    this.getName = function () {
        return _name;
    }

    this.getBreed = function () {
        return _breed;
    }

    this.getAge = function () {
        return _age;
    }
}

And to use it:

var obj = new ImmutableObject("Dusty", "Highland Terrier", 2);
alert("Name: " + obj.getName() + ", Age: " + obj.getAge() + ", Breed: " + obj.getBreed());

Have a read through Douglas Crockford‘s article on private members in javascript (see reference below), it goes into much more depth to explain the object model of javascript and the patterns for producing public, private and privileged members.

References:

Douglas Crockford – private members in JavaScript

  • picky

    Hi, probably being picky here but I would not say this is the best example for an “immutable” type. This shows nicely how to define private members with only getters in javascript but doesn’t demonstrate immutability as I understand it.

    In javascript a string is a good example of an immutable object …

    var str = “foo”

    “foo” + “bar”

    console.log(str) //= “foo”

    In this case doing an add operation on the string does not alter the original, instead it returns a new string “foobar”.