Yan Cui
I help clients go faster for less using serverless technologies.
This article is brought to you by
The real-time data platform that empowers developers to build innovative products faster and more reliably than ever before.
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 4 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.
- Do you want to know how to test serverless architectures with a fast dev & test loop? Check out my latest course, Testing Serverless Architectures and learn the smart way to test serverless.
- 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.
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”.