ecmascript-5

TL;DR: Do we need factories/constructors in prototypical OO? Can we make a paradigm switch and drop them completely? The BackStory: I've been toying with doing prototypical OO in JavaScript lately and find that 99% of OO done in JavaScript is forcing classical OO patterns into it. My take on prototypical OO is that it involves two things. A static prototype of methods (and static data) and a data binding. We don't need factories or constructors. In JavaScript these are Object literals containing functions and Object.create . This would mean we can model everything as a static blueprint

While converting a large number of files to typescript, I have many classes declared this way. function FooClass() { this.bar = 1; // error TS2683: 'this' implicitly has type 'any' // because it does not have a type annotation. } FooClass.prototype.myMethod = function() { // ... } How can I make this work with strict type checking turned on, while avoiding rewriting it all using class syntax? The easiest way to get the above code to work is to add a this parameter to the function, like so: function FooClass(this: {bar: number}) { this.bar = 1; // okay } Unfortunately, you will soon find that

Recently, given the changes to defining properties in ECMAScript 5, I have revisited the question of whether we can safely extend the native JavaScript prototypes. In truth, all along I have extended prototypes like Array and Function, but I avoided doing so with Object, for the obvious reasons. In unit testing with Jasmine, by adding Object.prototype specs to specs for my own personal framework, extending Object.prototype with non-enumerable functions has appeared to be safe. Data properties like a "type" property, however, with getters/setters that do any unusual processing have had

I started to use JS Promises in a project recently. I noticed that every time I use .catch my JS linter complains. It does run and does what it should but I looked up the ECMAScript spec and it really looks like it is right: Since catch is a keyword it can not be used as an identifier. As I understand method names are identifiers, so this is invalid: Promise.reject("Duh").catch(alert); It should be this instead: Promise.reject("Duh")['catch'](alert); What am I missing? Bergi What am I missing? A property name is not an identifier, it can use any identifier name. From the spec on Property

Given an object literal, or jQuery(html, attributes) object, does any specification state that reserved words, or future reserved words MUST be quoted? Or, can, for example, class be set as a property name of an object without using quotes to surround the property name, without the practice being contrary to a specification concerning identifiers, property names, or use of reserved words? Seeking a conclusive answer as to this question to avoid confusion. let objLit = { class: 123, var: "abc", let: 456, const: "def", import: 789 } console.dir(objLit); jQuery("<div>012</div>", { class: "ghi" })

Anyone know the time-complexity of ECMAScript5's Object.keys() in common implementations? Is it O(n) for n keys? Is time proportional to the size of the hash table, assuming a hash implementation? I'm looking for either guarantees by language implementors or some real world benchmarking. It appears to be O(n) in V8 (chrome, node.js) at least: > var hash = {} > , c = 0; > > var s = +new Date();Object.keys(hash);console.log(+new Date() - s); 0 > for(var i=0; i<100000; i++, c++){ hash[c] = 1; } > var s = +new Date();Object.keys(hash);console.log(+new Date() - s); 26 > for(var i=0; i<100000; i++,

I am trying to learn JavaScript from the Rhino book. I was trying to execute the following code from the book with regards to eval() . I am using node.js (v0.10.29) to execute the examples. var geval = eval; // aliasing eval to geval var x = 'global'; // two global variables var y = 'global'; function f () { var x = 'local'; // define a local variable eval('x += "changed";'); // direct eval sets the local variable return x; } function g () { var y = 'local'; // define a local variable geval('y += "changed";'); // indirect eval sets global variable return y; } console.log(f(), x); // =>