Comment passer du langage basé sur les objets au serveur Node.js Javascript pour les grands projets?

Question

J'ai décidé de m'habituer à utiliser Javascript comme mon serveur (j'utilise Node.js) pour configurer un serveur web, créer des serveurs de serveur et beaucoup plus. C'est un projet plutôt important, ce qui signifie que je dois m'habituer à la langue et obtenir moi-même une configuration optimale avant de réellement commencer à éviter les tracas inutiles et inutiles.

Je cherchais des sources qui expliqueraient les bases de la programmation fonctionnelle dans les grands projets. Malheureusement, la plupart des sources ne parlent que de Javascript de base pour des astuces simples dans un navigateur.

Deux liens utiles expliquant comment la création d'objets fonctionne en Javascript étaient http://howtonode.org/object-graphs et http://howtonode.org/object-graphs-2.

En fin de compte, il semble plus judicieux de créer un objet comme:

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

Maintenant, je suis à la recherche d'une référence linguistique complète Javascript. Jusqu'à présent, https://developer.mozilla.org/en/JavaScript/Reference semble être le plus complet.

Q1: est-ce la référence de langage ECMAScript recommandée? Je demande surtout parce que c'est une entreprise qui travaille principalement dans l'industrie du navigateur, mais Javascript n'est pas seulement là pour les navigateurs - peut-être y a-t-il des sources que je ne connais pas.

Deuxièmement, je suis habitué à créer un nouveau fichier pour chaque classe que je crée où le nom du fichier représente le nom de la classe. Q2: Est-ce une pratique recommandée en Javascript (V8, Node.js) aussi? Comment "importer" cette classe? Cette «importation» m'amène à ma confusion au sujet de «require» de Node.js. Je sais que ce n'est pas pareil. Exiger fondamentalement charge un autre fichier qui a alors son propre espace de noms, ce qui signifie que ses variables sont hors de la portée du fichier qui nécessite ce fichier. Pour mes classes cependant, je veux avoir des méthodes qui sont disponibles pour la classe qui "importe" (des citations comme je ne suis pas sûr que ce soit même possible) cette classe. Par exemple .:

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

Pour autant que je sache, cette méthode doSomething() est disponible uniquement si elle a été définie comme:

function MainUtils() { 
    exports.doSomething = function doSomething() { 
     // 
    } 
} 

Q3: Est-ce exact? Cela ne semble-t-il pas tout à fait anormal?

Q4: Y at-il d'autres blogs ou ressources qui sont utiles pour faire fonctionner mon installation, comme howtonode.org? Enfin, Q5: Y a-t-il eu des efforts pour rendre tout cet héritage, création d'objet, structure de projet, espace de nommage etc. plus facile pour les grands projets? Des bibliothèques ou quelque chose dans ce but?

J'espère que mes questions sont claires. Toute aide est appréciée. Merci.

Answer 1

est-ce la référence de langage ECMAScript recommandée?

Bien la référence officielle du langage ECMAScript est la ECMA-262 elle-même. Mais malheureusement, cela est complètement illisible, même par les normes des documents de normes.

ECMA ne produit aucun matériel destiné aux programmeurs finaux et il n'y a pas un seul tutoriel considéré comme "meilleur". Le lien MDC semble décent, au moins. (Tutoriels La plupart JavaScript sont absolument horrible et plein d'erreurs. Ce qui est en partie la faute de JavaScript pour avoir tant ... excentriques ... caractéristiques, mais quand même.)

En fin de compte, il semble plus judicieux de créer un objet tel que:

Il n'existe malheureusement pas de méthode 'acceptée' pour implémenter un système de classe/instance en JavaScript. Beaucoup de cadres ont leurs propres systèmes, ou vous pouvez broyer les vôtres. Votre exemple de code crée une nouvelle instance de chaque méthode pour chaque instance d'objet, que vous pourriez considérer comme sous-optimale par rapport au prototypage natif de JS. (Normalement, cette approche est utilisée avec un var that= this dans la fermeture pour éviter les problèmes de liaison dans le code de rappel.) Vous devrez également faire attention à la manière de créer des sous-classes et de les initialiser dans les constructeurs.

Voir this question pour une discussion sur les approches de classe/instance dans JS.

Je suis habitué à la création d'un nouveau fichier pour chaque classe I créer

Ouais, c'est une verrue Java vous ne devriez pas apporter à JS.

Conservez vos fichiers source dans des blocs gérables de classes et de fonctions connexes. Parfois, ce sera une classe publique par dossier, le plus souvent ce ne sera pas le cas.

Comment "importer" cette classe?

JS lui-même n'a aucune fonctionnalité d'importation native. Dans les navigateurs, vous le faites en insérant des balises <script> ou eval récupérées par le code XMLHttpRequest, et vous devez prendre soin de conserver les variables dans des espaces de noms distincts manuellement. Dans Node.js et d'autres endroits où vous travaillez avec CommonJS, vous utilisez des modules et require().

Est-ce correct?

Oui.

Cela ne semble-t-il pas anormal?

Je ne pense pas. C'est similaire à d'autres langages de script, où cela s'avère très utile. C'est vraiment Java qui vous oblige à emballer une unité de compilation en une seule classe.

Answer 2

Je suis arrivé avec ce qui suit après avoir lu un livre intitulé Pro JavaScript Design Patterns. Cependant, on m'a dit que ce n'est pas bon de penser comme ça (privé, public, statique, etc.) en 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"; 
     } 
    } 
})(); 

Ce serait instancié comme ceci:

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

Des commentaires? Dois-je lire un autre livre?

Answer 3

Si ce n'est pas déjà fait, regardez les vidéos de Douglas Crockford. Il a un tas de vidéos qui parlent des aspects prototypiques de JavaScript.

Google pour 'Vidéo en langage de programmation Java de Douglas Crockford'. Voici un lien vers la première partie de la série: http://video.yahoo.com/watch/111593/1710507

Answer 4

Le package npm defineClass fournit une OOP JavaScript simple mais puissante avec prise en charge des traits (mixins) et des classes imbriquées. Voici un exemple d'utilisation:

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); 
    } 
}); 

En savoir plus dans le readme: https://github.com/nodirt/defineClass

Installation:

$ npm install defineClass