Howto move from object based language to server side Node.js Javascript for big projects?

I've decided to get used to using Javascript as my server sided (I'm using Node.js) language to setup a webserver, create server deamons and a lot more. This is a rather big project, which means that I have to get used to the language and get myself an optimal setup before actually starting to avoid overhead and unneeded hassle.

I have been looking for sources that'd explain the basics of functional programming in big projects. Unfortunately, most sources talk only about basic Javascript meant for simple tricks in a browser.

Two helpful links that explained how object creation works in Javascript were http://howtonode.org/object-graphs and http://howtonode.org/object-graphs-2.

In the end, it seems most wise to create an object like:

function MyObject(constructorMemberOne, constructorMemberTwo) {
   this.constructorMemberOne = constructorMemberOne;
   this.constructorMemberTwo = constructorMembertwo;
   this.doSomething = function doSomething() {
       //
   }
}

Now, I'm looking for a complete Javascript language reference. So far, https://developer.mozilla.org/en/JavaScript/Reference seems to be most complete.

Q1: is this the recommended ECMAScript language reference? I'm asking mostly because it's sourced by a company that's mostly working in the browser industry, yet Javascript is not just there for browsers -- maybe there are sources that I'm unaware of.

Secondly, I'm used to creating a new file for every class I create where the file name represents the name of the class. Q2: Is this recommended practice in Javascript (V8, Node.js) too? How would one "import" this class?

This "importing" leads me to my confusingness about Node.js's "require". I know it's not the same. Require basically loads another file which then has it's own namespace, meaning that it's variables are out of the scope of the file that's requireing this file. For my classes however, I want to have methods that are available to the class that is "importing" (quotes as I am not sure whether this is even possible) this class. Eg.:

var utils = require("utils/MainUtils.js");
utils.doSomething();

As far as I know, this doSomething() method is only available if it was set like:

function MainUtils() {
   e开发者_开发问答xports.doSomething = function doSomething() {
      //
   }
}

Q3: Is that correct? Doesn't that seem quite abnormal?

Q4: Are there any other blogs or resources that are helpful in getting my setup working, like howtonode.org?

Finally, Q5: have there been any efforts into making all this inheritance, object creation, project structure, namespacing etc. easier for big projects? Any libraries or something for this purpose?

Hopefully my questions are clear. Any help is appreciated. Thanks.

---

is this the recommended ECMAScript language reference?

Well the official ECMAScript language reference is the ECMA-262 itself. But unfortunately this is completely unreadable even by the standards of standards documents.

ECMA do not produce any materials aimed at end-programmers and there's no one tutorial considered “best”. The MDC link looks decent, at least. (Most JavaScript tutorials are absolutely horrible and full of errors. Which is partly JavaScript's fault for having so many... quirky... features, but still.)

In the end, it seems most wise to create an object like:

There is unfortunately no widely-accepted-‘best’ way to implement a class/instance system in JavaScript. A lot of frameworks have their own systems, or you can brew your own. Your example code creates a new instance of each method for each object instance, which you might consider suboptimal compared to JS's native prototyping. (Normally this approach is used with a var that= this in the closure to avoid this-binding problems in callback code.) You would also need to exercise care in how you create subclasses and initialise them in the constructors.

See this question for a discussion on approaches to class/instance in JS.

I'm used to creating a new file for every class I create

Yeah, that's a Java wart you shouldn't bring to JS.

Keep your source files in manageable chunks of related classes and functions. Sometimes that will be one public class per file, more often it won't be.

How would one "import" this class?

JS itself has no native import functionality. In browsers you do it by inserting <script> tags or eval​ing code fetched by XMLHttpRequest, and have to take care of keeping variables in separate namespaces manually. In Node.js and other places where you're working with CommonJS, you use modules and require().

Is that correct?

Yes.

Doesn't that seem quite abnormal?

I don't think so. It's similar to other scripting languages, where it proves very useful. It's only really Java that forces you to wrap up a compilation unit into a single class.

---

I came up with the following after reading a book called Pro Javascript Design Patterns. However, I've been told that it's not good to think like this (private, public, static, etc.) in Javascript:

var SomeClass = (function() {
    this.prototype.publicStaticMember = "this is a public static variable",

    this.prototype.publicStaticMethod = function() {
        return "this is a public method: cannot access private members/methods, but can access privileged and public members/methods";
    }

    var privateStaticMember = "this is a private static variable";

    function privateStaticMethod() {
        return "this is a private static method: can only access private members/methods";
    }

    //instance part
    return function() {
        this.publicInstanceMember = "this is a public instance variable";

        var privateInstanceMember = "this is a private instance variable";

        this.publicInstanceMethod = function() {
            return "this is a privileged method: can access both public and private members/methods";
        }

        var privateInstanceMethod = function() {
            return "this is a private method: can access both public and private members/methods but is private";
        }
    }
})();

It'd be instantiated like this:

var someInstance = new SomeClass().("param1", "param2");

Any comments? Should I read an other book?

---

If you haven't already, checkout the videos by Douglas Crockford. He has a bunch of videos that talk about the prototypal aspects of JavaScript.

Google for 'Douglas Crockford Java Programming Language Video'. Here is a link to the first part in the series: http://video.yahoo.com/watch/111593/1710507

---

The defineClass npm package provides simple yet powerful OOP for JavaScript with support for traits (mixins) and nested classes. Here is an example of usage:

var defineClass = require("defineClass").defineClass;

var Person = defineClass({
  cash: 0,
  constructor: function (firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  },

  greet: function (name) {
    console.log("Hello " + name + ". My name is " + this.firstName);
  },

  earn: function (amount) {
    this.cash += amount;
  }
});

var Developer = defineClass({
  _super: Person,

  // override a field default value
  cash: 100,

  // override the constructor
  constructor: function (firstName, lastName, language) {
    // you may have code before the base constructor call

    // call the base constructor
    this._super(firstName, lastName);
    this.language = language;
  }

  // override a method
  greet: function (name) {
    console.log("Hey, " + name + ". I'm " + this.firstName)
  },

  // override a method and call its base method
  earn: function (amount) {
    return this._super(amount * 1.2);
  }
});

Read more in the readme: https://github.com/nodirt/defineClass

Installation:

$ npm install defineClass