ugrás a tartalomhoz

Javascript IDE - automatikus kód kiegészítés örökléssel is

inf3rno · 2012. Szep. 17. (H), 13.50
Üdv.

Szeretnék egy olyan js IDE-t használni fejlesztéshez, ami egyrészt támogatja a nodejs-t libeket is, másrészt meg lehet használni benne valami hasonló kódot, mint ez:

(function() {
    var core = {
        bind : function(method, scope) {
            if (!( method instanceof Function))
                throw new TypeError("Function needed as method.");
            if ( typeof (scope) != "object")
                throw new TypeError("Object needed as scope.");
            return function() {
                return method.apply(scope, arguments);
            };
        },
        require : function(source) {
            if ( typeof (source) != "object" || !source)
                throw new TypeError("Object needed as source.");
            for (var property in source)
                if (source.hasOwnProperty(property) && !this.prototype.hasOwnProperty(property))
                    this.prototype[property] = source[property];
        },
        override : function(source) {
            if ( typeof (source) != "object" || !source)
                throw new TypeError("Object needed as source.");
            for (var property in source)
                if (source.hasOwnProperty(property))
                    this.prototype[property] = source[property];
        },
        extend : function(source) {
            var superClass = this;
            var newClass = source.hasOwnProperty("constructor") ? source.constructor : function() {
                superClass.apply(this, arguments);
            };
            newClass.superClass = superClass;

            var superClone = function() {
            };
            superClone.prototype = superClass.prototype;
            newClass.prototype = new superClone();
            newClass.prototype.constructor = newClass;

            if (source)
                newClass.override(source);
            return newClass;
        }
    };

    core.require.call(Function, core);
    
    Function.create = function (source){
        var newClass = source.hasOwnProperty("constructor") ? source.constructor : function() {};
        newClass.override(source);
        return newClass;
    };
})(); 

	var Vehicle = Function.create({
		constructor : function(wheels) {
			this.wheels = wheels;
		}
	});

	var Truck = Vehicle.extend({
		constructor : function(hp, wheels) {
			this.horsepower = hp;
			Vehicle.call(this, wheels);
		},
		printInfo : function() {
			console.log('I am a truck and I have ' + this.horsepower + ' hp.');
		}
	});

	var t = new Truck(4, 350);
	t.printInfo();
Na most ez a tű a szénakazalban típusú probléma... A legjobb az lenne, ha valami létező keretrendszert támogatna, amiben megvan ez a fajta öröklődés, és nem kéne semmit csinálnom, minden flottul menne magától... Ha esetleg tudtok ilyet, akkor küldöm is a láda sört... :D

Ami még tetszene, ha viszonylag könnyen lehetne olyan plugin-t írni, ami a fenti kódot értelmezi, és az alapján felindexeli a kód kiegészítőt, hogy tudjon róla melyik prototípus milyen metódusokat tartalmaz, stb... Na ez az, amihez nem tudom, hogy melyik lenne a megfelelő eszköz. Odáig már eljutottam, hogy pl feltettem spket-et vagy aptanát eclipse-hez, de hogy hogyan álljak neki az ilyen pluginek írásának, vagy hogy ezek támogatják e egyáltalán a nodejs-t, az számomra elég homályban van. Ha van köztetek olyan, aki szintén hasonló problémával küzd, és van egyéb hasznosítható ötlete a témában, akkor csapatban is szívesen csinálnám. Az van, hogy ez nekem elég sürgős lenne, és ha rövid időn belül nem találok egy ilyen megoldást sem, akkor inkább nekiállok java-ban fejleszteni.

Ami még szintén beleférne, ha egyesével írnám a prototype-ba a metódusokat, csak azzal meg az a bajom, hogy az öröklésnél ott is probléma lesz a kód kiegészítéssel...
 
1

Utánanézek, hogy nodejs-nél

inf3rno · 2012. Szep. 17. (H), 13.55
Utánanézek, hogy nodejs-nél nincs e valami alap megoldás az öröklődésre, mert ha van, és ahhoz találok IDE-t, akkor valszeg támogatott a dolog kód kiegészítésben is... A gond, hogy külön nodejs-hez csak cloud9-et találtam, ami online IDE, és én meg nem szeretnék online fejleszteni.
2

Object.create

Poetro · 2012. Szep. 17. (H), 15.48
Miért nem Object.create? Csak mivel az natív támogatott azokban, ahol van ES5 támogatás, és erre gondolom működne is a kódkiegészítés.
3

Kb ugyanazt csinálja a kód.

inf3rno · 2012. Szep. 17. (H), 18.00
Kb ugyanazt csinálja a kód. Találkoztál már olyan IDE-vel, ami támogatja rá az automatikus kiegészítést? Ha igen, akkor teljesen megfelel a célnak.
4

Eclipse-ben nem működik a

Karvaly84 · 2012. Szep. 17. (H), 18.40
Eclipse-ben nem működik a kódkiegészítés ha a prototype-ot nem new kulcsszóval állítod be. Olyat lehet csinálni, hogy dokumentálni az adat tagokat, és megmondani kommentben, hogy egy adott osztályt miből származtatsz, de ez sem működőt nekem minden esetben. Az ilyen factory method operációk se követhetőek le rendesen.

Pl az Eclipse-ben a beépített dokumentációk úgy vannak megoldva, hogy egy külön jsdoc fájlban le van vezetve az osztálynak a váza.

/**
 * @class
 * @constructor
 * @param name Name of person.
 */
function Person(name) {}

/**
 * @param name Name of person.
 */
Person.prototype.setName = function(name) {};

/**
 * @returns String
 */
Person.prototype.getName = function() {};

/**
 * @class
 * @extends Person
 * @constructor
 * @param name Name of employee.
 */
function Employee(name) {}

Employee.prototype = new Person();
Viszont ebben az esetben meg két fájlt kel szinkronban fejleszteni, amivel én inkább felhagytam.
5

2 párhuzamos fájl

inf3rno · 2012. Szep. 17. (H), 20.17
2 párhuzamos fájl szerkesztése semmiképp sem megoldás. Ha a commentet ki akarod szedni, akkor egy deploy-t kellene írni rá, ami kiszűri, esetleg minify-t tol a fájlokra... (na hát ilyet se csináltam még, de nem lehet annyira nehéz...)

Én mondjuk elviselném, ha tudnék olyan plugint írni, ami a saját vagy egy már létező osztály készítő könyvtárra működik. Majd keresgélek, hogy hogyan álljak neki, de ez leginkább dokumentáció kérdése, és félek, hogy nem lesz semmi használható a témában :S
6

Azt nézem, hogy netbeans-hez

inf3rno · 2012. Szep. 17. (H), 20.36
Azt nézem, hogy netbeans-hez elég kevés tutorial van, viszont eclipse-hez egy rakat arról, hogy hogyan kell plugin-t írni. Szóval arra indulok. Spket eddig bejön, megpróbálok ahhoz összehozni valamit, ha nem sikerül, akkor aptana lesz a következő.
7

Ha esetleg sikerül majd

Karvaly84 · 2012. Szep. 17. (H), 21.14
Ha esetleg sikerül majd valami használhatót össze hoznod a problémára, velem is oszd majd meg :)
8

Én egyébként is használok

Karvaly84 · 2012. Szep. 17. (H), 21.18
Én egyébként is használok build toolt js-hez, és lányegében bármit be lehet drótozni a build folyamatba, pl. YUI compressor-t, ami kiszedi a kommenteket.
9

Hmm esetleg meg lehetne

inf3rno · 2012. Szep. 17. (H), 21.26
Hmm esetleg meg lehetne fordítani a dolgot.
Mi lenne, ha alapból prototype-al csinálnánk, és a new kulcsszót használnánk örököltetéshez. Talán van olyan IDE, ami képes ezt kezelni. Ezek után meg buildbe be lehet tenni egy olyat, ami ezt átalakítja egy Object.create-es megoldásra. Így az automatikus kiegészítés is menne, a kimeneti kód meg nem lenne 2x akkora a commentek meg az egyesével hozzáadott metódusok miatt. Az egyedüli gond, hogy minden new-ra meghívja a rendszer a konstruktort, de ha a tesztelés előtt mindig van deploy, és nem a begépelt kóddal tesztelsz, hanem a deploy utánival, akkor működhet. A prototype beírása nem okoz akkora gondot, ha van automatikus kiegészítés rá...

Kipróbálom, hogy ilyen megoldással működik e az automatikus kiegészítés öröklődésre, meg minden másra. Ha igen, akkor azt hiszem ez lesz, és nem szórakozok plugin írással.
10

Ez azért nem biztos, hogy jó,

Karvaly84 · 2012. Szep. 17. (H), 21.53
Ez azért nem biztos, hogy jó, mert a konstruktorban a this változón keresztül babrálod a keletkező objektumot akkor a kód kiegészítő azt is fel fogja dobni a származtatott osztály példányánál akkor is ha te arra nem is akarod a ős osztály konstruktorát meghívni. Mindezt azért mert a prototype alapján dolgozik az IDE, ha a futó kontextusban ki írod a prototype-ot az ott lessz a kiegészitőben, ha függvényen belül irod ki, mert pl. el akarod kerülni a konstruktor lefutását az uj osztályon akkor meg nem tudja az IDE, hogy az egy factory method, ami az osztályodat csinálja. Szopos téma ez a JS plusz kódkiegészítés :D
11

Így működik:var A = function

inf3rno · 2012. Szep. 18. (K), 03.14
Így működik eclipse-ben:

var A = function (){};
A.prototype.x = function (a){};
var a = new A();
var B = function (){};
B.prototype = new A();
B.prototype.y = function (){};
var b = new B();
//b.<x(a),y()>
B.prototype.z = function (){
	//this.<x(a),y(),z()>
};
Hmm, végülis ez így nem para, mert ha hozzá tudok férni ahhoz a részhez, ahol ez a prototype feldolgozás bent van, akkor 5 perc alatt hozzá tudom írni, hogy Oject.create-et, meg minden hasonlót is elfogadjon...

Kipróbáltam, spket-ben van extjs meg mootools támogatás, de ott sem működnek az örökléssel kapcsolatos dolgok. Egyedül a fenti módszerrel lehet megoldani...


Ez azért nem biztos, hogy jó, mert a konstruktorban a this változón keresztül babrálod a keletkező objektumot akkor a kód kiegészítő azt is fel fogja dobni a származtatott osztály példányánál akkor is ha te arra nem is akarod a ős osztály konstruktorát meghívni. Mindezt azért mert a prototype alapján dolgozik az IDE, ha a futó kontextusban ki írod a prototype-ot az ott lessz a kiegészitőben, ha függvényen belül irod ki, mert pl. el akarod kerülni a konstruktor lefutását az uj osztályon akkor meg nem tudja az IDE, hogy az egy factory method, ami az osztályodat csinálja. Szopos téma ez a JS plusz kódkiegészítés :D


Ezzel egyáltalán nincsen gond, a fenti formában megírom a prototípusokat, aztán csinálok egy deploy-t, ami a new ParentClass() formát átalakítja Object.create(ParentClass.prototype)-ra, vagy amire nekem tetszik, és a deploy-ban elkészült osztályokat használom a tesztekben, nem azokat, amik a kódban vannak. Ami kicsit problémás lehet így, hogy nem fog stimmel debug-nál, hogy melyik sorban van a hiba, ha nagyon átírom az eredeti forrást. Szóval egyedül a new -> Object.create amit érdemes belevinni, mert az ugyanúgy egy sor...

Ez így tűrhető, de attól még örülnék, ha lenne nodejs support is a rendszerben, nem csak extjs, meg hasonlók... Egyelőre a fent leírtak szerint fogom használni a rendszert, aztán ha találok megoldást arra, hogy felvegyem az osztály készítő függvényeket is a rendszerbe, akkor majd megírom.

szerk:
Azt néztem, hogy a legalapabb javascript editor is működik ezzel a megoldással eclipse-ben, szóval ez valami beépített feature...
12

A 8. és 10. sorban az ott mi?

Karvaly84 · 2012. Szep. 18. (K), 03.57
A 8. és 10. sorban az ott mi? Ilyet még nem láttam sehol. :o
13

Az, hogy mit ajánl felkód

inf3rno · 2012. Szep. 18. (K), 04.30
Az, hogy mit ajánl felkód kieg-re :D

http://www.normalesup.org/~simonet/soft/ow/eclipse-closure-javascript.en.html
Ezt érdemes még megnézni, meg találtam egy pár tutorialt, hogy hogyan kell plugint csinálni eclipse-hez. Még keresgélek, hogy melyik a legjobb megoldás, de egyáltalán nem lehetetlen megcsinálni...

http://plugins.netbeans.org/plugin/39133/javascript-rhino-content-assist
Ez netbeans-hez van, és elvileg tud osztályokat, meg hasonlókat. Érdemes lenne megnézni. Egyelőre gyűjtögetek, aztán majd döntök, hogy melyiket használom, vagy írok e sajátot... Az eclipse így külsőre sokkal szimpatikusabb nekem, mint a netbeans..

nb code assist plugin fejlesztés

Most feltettem Aptanát, mint eclipse plugint, de egyáltalán nem világos, hogy mit csinál. Mármint nem látok olyat, hogy aptana text editor a js fájlok megnyitásánál a listában, pedig lennie kéne, nem? Amit írtak még róla, hogy szétcseszi az egész eclipse-t, mondjuk nekem ez most nem akkora gond, mert csak tesztelgetek, szóval meg tudom csinálni, hogy törlöm, és másolok egy új példányt a helyére.

Na megvan, hogy a "javascript source editor"-nak nevezett valami az övé. A gond vele, hogy pl a függvény paramétereket ki sem tölti, az osztályok meg ugyanúgy nem mennek vele. Szóval szerintem még rosszabb, mint a beépített megoldás.

http://www.viplugin.com/scripteclipse/
Ez se rossz, olyan, hogy javascriptben lehet írni eclipse plugin-t. Mondjuk annyira nem ódzkodom java-tól, de ha ebben is meg lehet oldani, akkor miért ne! Próbálom valahogy elérni a cucc szerzőjét, hátha meg tudja mondani, hogy lehetséges e ilyesmi. Elvileg a code completion gombnyomásra van bindelve, szóval bele lehet nyúlni az alap viselkedésére. Én úgy sejtem, hogy a doksikat felindexeli valami a code completion meg ettől kéri el a lehetőségeket, szóval az indexelőbe kéne inkább belenyúlni, de ha az nem megy, akkor a code completion-höz kell betenni egy decoratort, ami feldobja egy kicsit.

http://planetorion.org/news/2012/01/writing-a-content-assist-plugin-for-orion/
Van egy ilyen is, hogy eclipse orion, ebben példa is van code assistant írására, viszont nekem az feküdne jobban, ha megmaradna az eredeti, és csak néhány módosítást végeznék rajta. Kisebb munka...

http://www.vogella.com/articles/EclipsePlugIn/article.html
A ScriptEclipse-hez képest pár oldallal bonyolultabb java-ban megírni a plugint :D Mondjuk az eredmény biztos, hogy gyorsabb, mint egy scriptelt cucc... Megpróbálom elérni a ScriptEclipse szerzőjét, aztán megkérdezni, hogy szerinte lehetséges e megírni a plugint a programjával, vagy inkább csináljam java-ban... Utánanézek még, hogy van e lehetőség a kód indexelésbe belenyúlni.
http://www.eclipse.org/articles/Article-PDE-does-plugins/PDE-intro.html
Azért van plugin fejlesztésre hasonló rövidségű megoldás is java-ban... :-) Az előnye, hogy elég jól dokumentált, és gondolom a kód kiegészítés is rendesen működik nála, nem úgy, mint a scriptes megoldásban, ahol lövésem sincs, hogy milyen csomagok, meg milyen elérhető funkciók vannak...

http://docs.huihoo.com/eclipse/How-to-Write-Your-Own-Eclipse-Plug-ins-OSCON-2009.pdf
Találtam használható leírást plugin készítésről. Mondjuk van egy sereg tutorial, de azért mégsem ennyire részletesek. Találtam még olyat, hogy nodeclipse, ami nodejs plugin eclipse-hez. Meg fogom kérdezni annak a fejlesztőjét, hátha tud segíteni.

Van még egy VJET nevű cucc, amit érdemes lehet kipróbálni, de nem sikerült telepítenem.
14

Közben megtaláltam, hogy ebbe

inf3rno · 2012. Szep. 18. (K), 15.47
Közben megtaláltam, hogy ebbe kell beletákolni:
Package org.eclipse.wst.jsdt.web.core.javascript.search

A dolgot bonyolítja, hogy azt írják, hogy ez még jelentősen változni fog a közeljövőben, úgyhogy ha nem akarom, hogy használhatatlan legyen nagyon hamar a módosításom, akkor jobb megkeresni a fejlesztőket, és megdumálni velük, hogy tegyék bele a következő release-be.

update:
Unlike Java, the javascript imports aren't stored in the model. JSDT uses
the classpath mechanism from the JDT to represent javascript's Global Scope.
Imports are added / removed from the Global Scope.

Have a look at the JSPTranslation.java class in the
org.eclipse.wst.jsdt.web.core plugin. The imports are parsed in the
translator, stored in the translation, then passed to the
DocumentContextFragmentRoot (o.e.w.jsdt.core) for inclusion in the Global
Scope.


Asszem vicces lesz ezt meghaxolni, elég érdekes logikája van... Mondjuk nagyjából el tudom képzelni, hogy egy fát alkotnak global scope-on az osztályok, aztán ha scope-ot váltasz, akkor ehhez ad hozzá dolgokat, vagy vesz el belőle... Legalábbis valami ilyesmi lehet a leírás alapján. Majd írok a szerzőknek, hogy szerintük mennyire lehetséges amit akarok.
15

http://www.eclipse.org/forums

inf3rno · 2012. Szep. 19. (Sze), 10.38
http://www.eclipse.org/forums/index.php/m/665434/

Itt írnak arról, hogy hogyan lehet az alap beállításokkal meg jsdoccal megoldani a modul pattern-nél a kód kiegészítést.
Arra gondoltam, hogy lehet, hogy szimplán jsdoccal megoldható az örökléses probléma is... Ennek még jobban utánajárok.
16

jsdoc lehetőségek eclipseben

inf3rno · 2012. Szep. 19. (Sze), 11.12
Nézzük mik a lehetőségek eclipse-ben:

alap osztályok:

var T = function() {
};
T.prototype = {
	x : function() {
	}
};
var A = function() {
};
A.prototype = {
	/** @type T */
	t : undefined,
	w : function() {
		this.t.x(); // "t"-t és "x()"-et is felhozza
	}
};
var a = new A();
A.prototype.q = function() {
};
a.q(); // "q()"-t felhozza
öröklődés:

var B = function (){};
B.prototype = new A();
var b = new B();
b.q(); // "t","w()","q()" -t felhozza
ellenben ezzel már gond van (pedig ugyanúgy logikus lenne):

var B = function (){};
/** @type A*/
B.prototype = Object.create(A.prototype);
var b = new B();
b.q(); //ez már nem hoz fel semmit
modul minta:

/**
 * @type module
 * @memberOf __module
 */
var module = (/** @constructor */ function () {
	function innerFunc() {
		
	}
	
	return {
		/**
		 * @memberOf module
		 * @returns String
		 */
		method: function() {
			return "hello";
		}
	};
})();
Itt van egy jquery-hez való plugin, ezen látszik, hogy nagyjából mikhez kell hozzányúlni. Mondjuk bármelyik másik libnek jobban örültem volna, mert ha jól tudom ebben nincsen semmilyen osztályokkal kapcsolatos megoldás.
17

PHPStorm vagy WebStorm

blacksonic · 2012. Szep. 19. (Sze), 11.27
a Netbeans javascriptes kodkiegesziteset a hajaba is kenheti az ember...
PHP/Webstorm nem ingyenes de elerheto aron merfoldekkel jobb es gyorsabb

oroklodesnel lesd meg John Resig peldajat, az tamogatja a parent fuggvenyeinek is a meghivasat, nekem bevalt link
18

Amit fentebb bemásoltam

inf3rno · 2012. Szep. 19. (Sze), 11.31
Amit fentebb bemásoltam ugyanúgy támogatja, csak nem ennyire gányolt.

Amivel nekem bajom van, hogy az IDE nem hoz fel a parent függvényeire automatikus kódkiegészítést. Netbeans-ben neki sem álltam, mert nem valami stabil Eclipse-hez képest, és már meguntam, hogy napi 10x omlik össze... Webstorm nem hiszem, hogy bármivel jobb lenne Eclipse-nél, de javíts ki, ha tévedek. Ha van rajta nodejs támogatás meg a szülő osztályokat is mutatja az automatikus kódkiegészítés, akkor szívesen megveszem...
19

alapbol

blacksonic · 2012. Szep. 19. (Sze), 11.36
PHPStorm meg alapbol tamogatja mindenfele allitgatas nelkul, nekem megert 50 ropogos zoldhasut
22

WebStorm

Poetro · 2012. Szep. 19. (Sze), 13.33
Akkor már PHPStorm helyett inkább WebStorm, főleg mivel nem kellenek gondolom a PHP specifikus dolgok.
20

30 nap

blacksonic · 2012. Szep. 19. (Sze), 12.14
probald ki 30 napig ingyenes es utana is el tudod inditani csak fel ora utan kilep
21

Nem kell bemutatni őket.

inf3rno · 2012. Szep. 19. (Sze), 13.17
Nem kell bemutatni őket. Azért kipróbálom, hátha mégis támogatják (bár erős kétségeim vannak).

NodeJS van benne.
Az öröklődésnél ugyanaz a helyzet, bár ez legalább tud róla, hogy van olyan, hogy Object.create, csak képtelen felfogni a jelentését. Megnézem a bővíthetőségét, de ha manuálisan kell indexelni, akkor inkább írok plugint eclipse-hez, mint ehhez. Az legalább ingyen nyújtja ugyanezt.
23

Teszteltem az Extjs-el megy

inf3rno · 2012. Szep. 19. (Sze), 14.17
Teszteltem az Extjs-el megy az öröklődés az Ext.extend-el. Az interface tőlem maradhat ugyanaz, majd beteszem a saját osztályomat a helyére, aztán annyi. Annak még utánanézek, hogy esetleg megoldható e saját interface-el, vagy hogy hogyan lehet saját libet írni hozzá... Gondolom van valami API, amit lehet barmolni...

Ami még mindig zavaró, hogy a metódusoknál nem teszi ki alapból a paramétereket mint bármelyik másik IDE...
24

A végén rájöttem, hogy a

inf3rno · 2012. Szep. 19. (Sze), 15.39
A végén rájöttem, hogy a legnagyobb gond itt az volt, hogy a jsDoc nincs megfelelően dokumentálva. Ami azért elég abszurd, mert ugye dokumentáláshoz találták ki :D
Mondjuk talán nem wikipedián kellett volna néznem...

Az van, hogy Aptana, Netbeans, Eclipse - egyik sem támogatja a jsDoc 3-at. Ami érdekes, hogy nem tudtam visszanézni, hogy melyik előző verziót támogatják, mert sehol nincs fent a jsDoc története a neten. Egyedül a WebStorm (meg a többi Jetbrains termék), ami támogatja a jsDoc 3-at.

A fenti példa jsDoc 3-al:

/** @class*/
var Vehicle = Function.create(
    /** @lends Vehicle.prototype */
    {
    /** @constructs */
    constructor : function(wheels) {
        this.wheels = wheels;
    },
    countWheels: function (){
        return this.wheels;
    }
});

/** @class*/
/** @extends Vehicle */
var Truck = Vehicle.extend(
    /** @lends Truck.prototype */
    {
    /** @constructs */
    constructor : function(hp, wheels) {
        this.horsepower = hp;
        Vehicle.call(this, wheels);
    },
    printInfo : function() {
        console.log('I am a truck and I have ' + this.horsepower + ' hp.');
    }
});

var t = new Truck(4, 350);
t. //printInfo és a countWheels is ugyanúgy megjelenik WebStorm alatt
Bár nekem a WebStorm-nál több dolog nem áll annyira kézre, mint a többi IDE-nél, de a kód kiegészítés kétségtelenül ennél a legjobb, szóval megéri megvenni.
25

Újabb problémába ütköztem,

inf3rno · 2012. Szep. 28. (P), 06.43
Újabb problémába ütköztem, ahogy az lenni szokott :D NodeJS-el csinálok modulokat, de nem működik külön fájlokban az automatikus kiegészítés (webstorm ide).

Gyakorlatilag ennyiről van szó:

test.js
/** @module test*/
module.exports = {
    run: function () {}
};
main.js
var test = require(__dirname+"/test.js");
test. //code completion does not offer "run"
Van ötletetek, hogyan lehetne ledokumentálni, hogy menjen?
26

Szerintem ha csak nincs a

Karvaly84 · 2012. Szep. 28. (P), 08.20
Szerintem ha csak nincs a webstorm-hoz ilyen plugin sehogy. Itt már megint a szokásos probléma áll fen, hogy egy függvény adja a vissza az objektumot. Lehet hogy van erre valamilyen speciális komment annotáció, de hogy az is müködjön akkor meg a nodejs modulokhoz fog kelleni egy komplett api doc amit be kel húznod a projektbe. A jQuery alá már láttam ilyet egyszer valahol, de node-hoz nem hiszem h van.
27

Van egy NodeJs Core Modules

inf3rno · 2012. Szep. 28. (P), 08.26
Van egy NodeJs Core Modules nevű lib, amit hozzá lehet csapni a kód kiegészítéshez. Gondolom erre gondolsz. Szerintem kell lennie valami áthidaló megoldásnak, amivel megoldható...

Amúgy nincs valami más módja, hogy beszúrjak egy js fájlt, csak a require? Ez a fájlokra darabolás nekem csak arra kell, hogy átláthatóbb legyen a kód... Mondjuk a deploy-nál összeraknám őket nagyobb fájlokba, vagy bármi ilyesmi (egyelőre csak próbálgatom, hogy mik a lehetőségek).
28

Nem tudtam, h van ilyen, de

Karvaly84 · 2012. Szep. 28. (P), 08.36
Nem tudtam, h van ilyen, de akkor sztem az lesz az. Azt behúztad már? Már csak annak kéne utána nézni, hogy doc commentben meg lehet e adni az objektumok típúsát. Pl JSDoc-ot szoktam használni. De a IDE nem tud vele mit kezdeni csak ha legenerálom a doksit akkor abban már szépen mutatja minek milyen felülete van illetve mi miből származik.

Amit ez Eclipse ismer (és gondolom akkor a webstorm is esetleg) az a @extends annotáció.
29

van egy build tool amit a

Karvaly84 · 2012. Szep. 28. (P), 08.40
van egy build tool amit a nodejs guruk tolnak, grunt néven. Ebben van asszem olyan task ami összefűzi a fájlokat, nem használtam még csak olvastam. Nodejs-be bele akartam menni egyszer de annyi benne a spanyolviassz, hogy ink nem érdekel. Egy sima Makefile sztem jobb megoldás lehet.
30

Webstorm alapból támogatja a

inf3rno · 2012. Szep. 28. (P), 08.49
Webstorm alapból támogatja a jsdoc 3-at. Az @extends osztály örököltetésre való. Köszi, majd megnézem ezt a gruntot, végső soron akár én is tudok egy saját deploy-t írni, ami összefűzi őket, nem nagy kunszt... Ami kicsit zavaró, hogy a fejlesztésnél arra van nyomás, hogy minél kevesebb fájl legyen, én viszont úgy próbáltam mindig fejleszteni, mint java-ban, hogy sok kicsi osztály és mind külön fájlban... Valszeg majd kiteszek minden fájl elejére vidámságokat commentbe, hogy milyen névtérben van és miket használ, hogy könnyebb legyen az összefűzés. (Nyilván használati sorrendben kell összefűzni a dolgokat a modulokon belül.)
31

Egyébként az Ant még mindig

Karvaly84 · 2012. Szep. 28. (P), 08.54
Egyébként az Ant még mindig nem érdekel? Javahoz mit használsz?
32

Még semmit, egyelőre csak

inf3rno · 2012. Szep. 28. (P), 09.43
Még semmit, egyelőre csak tanulom a java-t, majd ha már tudom, akkor írok kódot. Puppetről mi a véleményed, ha jól tudom az is egy deploy rendszer. (Nagyon nem értek ezekhez, még sosem használtam.)
33

A Puppetről semmit az ég

Karvaly84 · 2012. Szep. 28. (P), 10.17
A Puppetről semmit az ég világon :D

Láttam már emlegetve de nem vettem még a fáradtságot, hogy ránézzek egyáltalán. Én konzervatív vagyok, "bash forever" ;). Ha IDE-zek akkor Ant, egyébként meg make, nincs igényem többre/másra :)
34

Közben azt találtam, hogy

inf3rno · 2012. Okt. 1. (H), 05.54
Közben azt találtam, hogy akkor működik az automatikus kiegészítés, ha a __dirname helyett "./"-el adom meg a fájl útvonalát.