Javascript - Immutable types | theburningmonk.com

Yan Cui

I help clients go faster for less using serverless technologies.

This article is brought to you by

Don’t reinvent the patterns. Catalyst gives you consistent APIs for messaging, data, and workflow with key microservice patterns like circuit-breakers and retries for free.

Try the Catalyst beta

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

Whenever you’re ready, here are 3 ways I can help you:

Production-Ready Serverless: Join 20+ AWS Heroes & Community Builders and 1000+ other students in levelling up your serverless game. This is your one-stop shop for quickly levelling up your serverless skills.
I help clients launch product ideas, improve their development processes and upskill their teams. If you’d like to work together, then let’s get in touch.
Join my community on Discord, ask questions, and join the discussion on all things AWS and Serverless.

1 thought on “Javascript – Immutable types”

picky
November 8, 2011 at 11:52 pm

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”.

References:

1 thought on “Javascript – Immutable types”

Leave a Comment