Why is Javascript not handling these reserved words like a string key in this array?

Question

I have the following test case in a coding kata for javascript:

*word-count_test.js

var words = require('./word-count');

describe("words()", function() {

  it("handles properties that exist on Object’s prototype", function() {
    var expectedCounts = { reserved: 1, words : 1, like :1,  prototype: 1, and : 1, toString: 1,  "ok?": 1};
    expect(words("reserved words like prototype and toString ok?")).toEqual(expectedCounts);
  });
});

The following code will not pass this:

code v1

var words = function(phrase) {
    var wordCountAry = {};
    // split on whitespace, including newline
    phrase.split(/\s/).forEach(function(oneWord) {
        if (!wordCountAry[oneWord]) {
            wordCountAry[oneWord] = 1;
        } else {
            wordCountAry[oneWord]++;
        }
    });
    return wordCountAry;
};

module.exports = words;

But something like the following counter line will not trigger the error:

code v2

wordCountary[word] = (+wordCountary[word] || 0) + 1

So what is so special about that unary "+" operator?

you're not being clear here. What exactly are you trying to do? I don't see anywhere where you're restricting reserved words.. also +(Object) would be `NaN` so, it will always be `0 + 1` — Amit Joki, Apr 20 '15 at 05:54
Change `if (!wordCountAry[oneWord])` to `if (!wordCountAry.hasOwnProperty(oneWord))` — doog abides, Apr 20 '15 at 06:02
@royhowie: and `wordCountary[word]` is shorter than `+wordCountary[word]`. — zerkms, Apr 20 '15 at 06:10

Ja͢ck · Answer 1 · 2015-04-20T06:24:14.787

A standard JavaScript object prototype has predefined properties, such as:

toString()
constructor()

When you test those property names using typical conditional logic, they will appear as existent, e.g.

var x = {};
if (x['toString']) {
  // this gets executed
}

The second code sample works around that issue with two tricks:

+x['toString'] || 0;

First, the property is coerced into a numeric value by using the unary plus operator. For functions or undefined values, the coercion yields NaN.

Secondly, the logical or operator is used to coalesce the left hand and right hand expression; if the right hand operand evaluates to false (that includes NaN) it will yield the right hand operand, otherwise it returns the left hand operand.

In this manner, either an undefined property value or a function value will yield 0 and therefore it will work as expected.

Touffy · Answer 2 · 2015-04-20T06:25:09.947

It's not really about "reserved" names (those are another matter in JavaScript, e.g. class although it's not reserved anymore in ES6), but about inherited properties.

wordCountAry is an object, so it already has a toString method. So when you test

if (!wordCountAry[oneWord])

with the words "toString" the condition will be false (because wordCountAry["toString"] is trueish (it's a function).

So you need to use a condition that will work when the property is not a number (which is the case with the Number coercion of a function with unary +), or, to be safer, also check if it is inherited (hasOwnProperty).

score 0 · Answer 3 · answered May 09 '15 at 05:08

0

When you are creating your wordCountAry object, you can can pass null as the prototype, and this should solve your problem. So, instead of initializing it to {}, see how you can set it's prototype to null.

answered May 09 '15 at 05:08

SherMM

619
6
14

Why is Javascript not handling these reserved words like a string key in this array?

3 Answers3