JavaScript - Najlepszy sposób na skonstruowanie funkcji pomocników w NodeJS

Question

Próbuję zbudować zestaw narzędzi do mojego projektu NodeJS. Do tych pomocników należą: narzędzia tekstowe (takie jak substring, rejestrowanie konsoli itp.) I bardziej szczegółowe pomocniki, takie jak analizowanie tekstu tweeta.

Próbuję więc podzielić moduł na różne pliki i bardzo jasno określić, co każda z nich ma zrobić.

Na przykład chciałbym aby to osiągnąć:

var helpers = require("helpers"); 

var Utils = new helpers.Utils(); 

// working with text 
Utils.text.cleanText("blahblalh"); 
// working with a tweet 
Utils.twitter.parseTweet(tweet); 

Jak widać używam Utils do różnych rzeczy, wywołując bardzo specyficzne metody i sposoby sub.

Próbowałem zrozumieć, jak działa tutaj dziedzictwo, ale trochę straciłem.

To co robie (trochę szorstki przykładowy kod):

//node_modules/helpers/index.js

var Text = require('./text'); 
var Twitter = require('./twitter'); 

function Utils() { 

} 

Utils.prototype.text = { 
    cleanText: function(text) { 
     Text.cleanText(text); 
    } 
}; 

Utils.prototype.twitter = { 
    parseTweet(tweet) { 
     Twitter.parseTweet(tweet); 
    } 
}; 

//node_modules/helpers/text.js

function Text() { 

} 

Text.prototype.cleanText = function(text) { 
    if (typeof text !== 'undefined') { 
     return text.replace(/(\r\n|\n|\r)/gm,""); 
    } 
    return null; 
}; 

module.exports = Text; 

//node_modules/helpers/twitter.js

function Twitter() { 

}; 

Twitter.prototype.parseTweet = function(data) { 
    return data; 
}; 

module.exports = Twitter 

Czy to jest poprawny sposób. Czy robię coś złego lub może spowolnić występy itp.?

Jestem całkiem nowy dla Node i chcę zacząć we właściwy sposób.

Answer 1

Aby wyjaśnić jak mam zrozumieć swój post, widzę dwa pytania:

• jaki sposób struktura kodu/metod w plikach, pliki, które stanowią kategorię funkcji użytkowych
• Jak zorganizować że te kategoryczne plików w jeden większy biblioteki

metody strukturalny w ramach kategorii

Zamiast tworzyć wszystkie metody funkcji specyficznych dla kategorii obiektów (np. Twitter lub Text), można po prostu wyeksportować funkcje do plików nazwanych za nimi. Ponieważ wydaje się, że przekazujesz dane, których chcesz użyć, nie ma potrzeby tworzenia metod instancji niektórych pustych klas.

Jeśli twoje wzorce użycia Twittera lub Tekstu mają zwykle zmienne klasowe, które chcesz zachować, i chcesz utworzyć instancję Text lub Twitter, aby użyć przykładów, to przypuszczam, że byłoby to odpowiednie. Kiedy instaluję biblioteki w moich projektach, zwykle jest to grupa wyeksportowanych funkcji składających się na moduł, a nie wyeksportowana klasa javascript.

Aby podać przykład tego, co plik text.js składa się z tekstowych funkcji użytkowych może wyglądać następująco:

module.exports = { 
    cleanText:function(text) { 
     // clean it and return 
    }, 

    isWithinRange(text, min, max) { 
     // check if text is between min and max length 
    } 
} 

Alternatywnie, można zrobić to w ten sposób:

exports.cleanText = function(text) { 
    // clean it and return 
} 

exports.isWithinRange = function (text, min, max) { 
    // check if text is between min and max length 
} 

Strukturyzacja plików kategorii narzędziowych w celu utworzenia większej biblioteki narzędziowej

W zakresie organizacji metod użytkowych, exa Luca mple jest miłe. Mam jakiś zorganizowany podobnie jak to:

utils-module/ 
    lib/ 
     text.js <-- this is the example file shown above 
     twitter.js 
    test/ 
    index.js 

Gdzie index.js robi coś

var textUtils = require('./lib/text'); 

exports.Text = textUtils; 

Wtedy gdy chcę użyć util lib powiedzmy jakiś wzór użytkownika w moim węzła API, to po prostu:

/* 
* Dependencies 
*/ 
var textUtils = require('path/to/lib').Text; 

/* 
* Model 
*/ 
function User() {} 

/* 
* Instance Methods 
*/ 
User.prototype.setBio = function(data) { 
    this.bio = textUtils.cleanText(data); 
} 

module.exports = User; 

Nadzieję, że pomaga. Kiedy pierwszy raz się uczyłem, bardzo pomocne było przyjrzenie się popularnym, szanowanym bibliotekom, aby zobaczyć, jak pracują doświadczeni twórcy węzłów/javascript. Jest tak wiele dobrych (i złych) tam!

Best,

Craig

Answer 2

Możesz zobaczyć przykład biblioteki utils z lodash.

Lodash jest biblioteką użytkową podobną do underscore. Ta biblioteka ma strukturę plików sustem, taką jak Twoja.

Dzieli funkcje w kategorie. Każda kategoria to folder z plikiem index.js, który zawiera w przestrzeń nazw (obiekt literalny), z których każdy działa dla tej kategorii!

Lodash/ 
    Objects/ 
     Function1.js 
     Functions2.js 
     .... 
     Index.js 
    Array/ 
     Function1.js 
     ... 
     Index.js 

Następnie w kodzie można to zrobić:

var objectsUtils = require("lodash/objects"); 
var foreach = require("lodash/array/each"); 

Można utworzyć podobną strukturę systemu plików w celu uzyskania większej elastyczności. Możesz zażądać całej biblioteki, tylko jednej przestrzeni nazw lub jednej funkcji.

Jest to lepsze ze względu na wydajność, ponieważ używasz tylko tego, czego potrzebujesz i masz przyrost wykorzystania pamięci.

Answer 3

biblioteki Utility „siła”, aby wyciągnąć dużo kodu kodu nie koniecznie.

Napisałem projekt o otwartym kodzie źródłowym o nazwie Bit, który umożliwia tworzenie komponentów do ponownego użycia podczas pracy nad projektem, a następnie używanie ich pojedynczo w repozytoriach.

Tutaj znajduje się an example collection of Javascript utility functions w lokalnym węźle Bit open source.

Mam nadzieję, że to pomoże.