A Pascal record via JavaScript

... all right, I am off for holidays and I won't have probably time to write the post I have twitted a few days ago since it could take a whole day ... however, I am "cleaning" my good old room here in Italy and I have found an Italian book titled "ALGORITMI IN PASCAL" (Pascal Algorithms) a back in 1987 IT book for secondary school.

I could not resist to read it entirely, just to see what kind of Algo I could have found there ... but "surprise", it was not about algos, more about (T)Pascal itself.

Since at the of the day Pascal is somehow the basis for all we can write today, I thought it would have been a nice experiment to try to reproduce the record concept via JavaScript.

What Is a Record

Nothing different from a predefined structure of types, similar to a classic literal object in JS except the structure defines type hints.

// simple Pascal function example
function personToString(self:person);
begin
    writeln(self.name, ' is ', self.age, ' years old')
end;

// basic record example
type person = record
                  name:string[20];
                  age:integer
              end;

// record usage
var me:person;

begin
    me.name := "Andrea";
    me.age := 32;
    personToString(me)
end.

Please note I don't even know if above program will ever run so take it just as an example.

Record VS Prototype

As we can see the record is not that different from a "class" description via prototype, except rather than values we can specify the type of these values.
This approach may be handy even in JavaScript since there is no type hint but sometimes we may desire to make some behavior consistent and hopefully safer.

A first JavaScript record example

Using some ES5 feature, we could be able to write something like this:

function record(description) {
    // (C) WebReflection - Mit Style License
    var
        shadow = {},
        self = {}
    ;
    Object.keys(description).forEach(function (key) {
        var
            type = description[key],
            check
        ;
        if (!type) {
            throw new TypeError("unable to check a type for property: " + key);
        }
        switch (typeof type) {
            case "string":
                check = function (value) {
                    return typeof value == type;
                };
                break;
            case "function":
                type = type.prototype;
            default:
                check = function (value) {
                    return type.isPrototypeOf(value);
                };
                break;
        }
        this(self, key, {
            get: function () {
                return shadow[key];
            },
            set: function (value) {
                if (!check(value)) {
                    throw new TypeError("type violation for property: " + key);
                }
                shadow[key] = value;
            },
            configurable: false
        });
    }, Object.defineProperty);
    return self;
}

Here a basic usage example for above function:

var person = record({
    name: "string",
    age: "number",
    toString: Function
});

person.name = "Andrea";
person.age = 32;
person.toString = function () {
    return this.name + " is " + this.age + " years old";
};

alert(person);
// Andrea is 32 years old

Following the same concept we may decide to add arbitrary types and relatives checks such "integer", "real", or whatever we need.
Here there is a version compatible with almost all browsers but IE:

function record(description) {
    // (C) WebReflection - Mit Style License
    function getter(key) {
        return function () {
            return shadow[key];
        };
    }
    function setter(key) {
        var
            type = description[key],
            check
        ;
        if (!type) {
            throw new TypeError("unable to check a type for property: " + key);
        }
        switch (typeof type) {
            case "string":
                check = function (value) {
                    return typeof value == type;
                };
                break;
            case "function":
                type = type.prototype;
            default:
                check = function (value) {
                    return type.isPrototypeOf(value);
                };
                break;
        }
        return function (value) {
            if (!check(value)) {
                throw new TypeError("type violation for property: " + key);
            }
            shadow[key] = value;
        };
    }
    var
        shadow = {},
        self = {}
    ;
    for (var key in description) {
        if (description.hasOwnProperty(key)) {
            self.__defineGetter__(key, getter(key));
            self.__defineSetter__(key, setter(key));
        }
    }
    return self;
}


Record And Prototype Problem

Unfortunately we cannot use this strategy to create constructors prototypes since the shared object (singleton) will use a single shadow for every instance.

function Person(name, age) {
    this.name = name;
    this.age = age;
}

Person.prototype = record({
    name: "string",
    age: "number",
    toString: Function
});

Person.prototype.toString = function () {
    return this.name + " is " + this.age + " years old";
};

var me = new Person("Andrea", 32);
var other = new Person("unknown", 29);

alert(me); // unknown is 29 years old

To avoid this problem we should use return this["@" + key]; in the getter and this["@" + key] = value; in the setter, setting if possible the property as enumerable:false if we have an ES5 friendly environment.
This should make the trick but still there is something not that friendly for JS developers.

A Proper JSRecord


A more flexible approach would let us define at the same time both type and default value, so that prototype definition and type hint could be done in one single call.
How could we write something similar? Here my last revision (done while I was writing this post):

function JSRecord(description) {
    // (C) WebReflection - Mit Style License
    var
        self = {},
        cDONTwe = {configurable: true, writable: false, enumerable: false},
        hasOwnProperty = self.hasOwnProperty,
        defineProperty = Object.defineProperty
    ;
    Object.keys(description).forEach(function (key) {
        var
            current = description[key],
            type = hasOwnProperty.call(current, "type") ? current.type : current,
            enumerable = hasOwnProperty.call(current, "enumerable") ? current.enumerable : true,
            $key = "@" + key,
            check
        ;
        if (!type) {
            throw new TypeError("unable to check a type for property: " + key);
        }
        switch (typeof type) {
            case "string":
                check = function (value) {
                    return typeof value == type;
                };
                break;
            case "function":
                type = type.prototype;
            default:
                check = function (value) {
                    return type.isPrototypeOf(value);
                };
                break;
        }
        defineProperty(self, key, {
            get: function () {
                return this[$key];
            },
            set: function (value) {
                if (!check(value)) {
                    throw new TypeError("type violation for property: " + key);
                }
                cDONTwe.value = value;
                defineProperty(this, $key, cDONTwe);
            },
            configurable: false,
            enumerable: enumerable
        });
        if (hasOwnProperty.call(current, "value")) {
            self[key] = current.value;
        }
    });
    return self;
}

How things changed:

// we can have defaults
function Person(name, age) {
    this.name = name;
    if (age)  this.age  = age;
}

// we can define a type hint
// or we can define both hint
// and value plus enumerable

Person.prototype = JSRecord({
    name: "string",
    age: {
        type: "number",
        value: 0
    },
    toString: {
        enumerable: false,
        type: Function,
        value: function () {
            return this.name + " is " + this.age + " years old";
        }
    }
});

// we can test everything now
var me = new Person("Andrea", 32);
var other = new Person("unknown");

alert(me);    // Andrea is 32 years old
alert(other); // unknown is 0 years old

alert(me instanceof Person); // true

for (var key in me) alert(key);
// name, age

What do you think? Here my partial list of pros and cons:

Pros

  • easy type hint implementation
  • safer objects, properties and methods
  • usable as record or prototype without shared vars problems


Cons

  • requires ES5 compatible environment
  • getters and setters are slower than direct access due function overload
  • type hint is slower due checks for each set

Comments

Post a Comment

Popular posts from this blog

8 Things you should not be afraid of as a Developer

Change In Software Development there is no such thing as stagnancy. Everything you develop now is just another version of a component that will probably change in the future. Change is the most common thing in Software Development, and you're better of accepting it as a fact. Expect future changes to everything you develop, and therefor design your Code more modular. This makes changes more easy and increases the Quality at the same time. Adapt the concepts of DRY and YAGNI . You will often come to the Situation, where you look at your Code and imagine that you could have done that "better". Don't let this thought prevent you from sleeping. Take action immediately and Refactor ! If you don't do it now, you will probably never do it. The longer you wait, the harder and more costly it gets. And you slowly grow up a mess you cant deal with anymore. "Good code is code that is easy to change. Code tends to change until it is no longer easy to change. All code bec...
Read more

News

So we just got back from a little Canadian weekend with Thee Oh Sees. We had a blast. There is a lot going on in our world at the moment so we've been a bit busy - sorry for the lack of updates here. We have a whole bunch of upcoming shows, check out the shows section to your right - these include shows with SEX CHURCH, a mini-tour with PYGMY SHREWS, a couple of shows with RUSSIAN CIRCLES, and a little European tour in December. If any of you euros cant make it to see us in December, we will be back in January for a little over a month, and we are very excited. We have a new LP done, it will be out in March on Sacred Bones Records and much touring in support of it shall follow. We have also been informed that Karmic Swamp Records is repressing the "Think" 7" that came out last year. There were only a handful of those pressed so hopefully people that missed out on getting them can grab one now. We will post here when it is available. Also, thanks to everyone who has o...
Read more

Why REST is so important

Image
This post is dedicated to REST, an architectural style of shaping webservices and the most misunderstood concept in the history of IT. This post is addressed to you who is designing webservice apis not being fully aware what REST actually means. I'm trying to give you the idea. This post is also addressed to you who think to know what REST means, when in reality you have no clue, just yet. Yes i have met such people in the past - plenty of them. It's not going into the details of the Richardson Maturity Model , and it's not gonna make you a REST expert. There are plenty of guides on the web for that: slides, youtube videos, blogposts, books and more. Rather than going into the details, i'm going to link some good resources at the end of this post. So lets start with The meaning of REST Representational State Transfer. This sentence is not only what REST stands for, it is also the tiniest possible description of what REST actually means. Didn't get it? Read it aga...
Read more