ugrás a tartalomhoz

Memória kérdés a profiknak

gtoma · 2017. Feb. 14. (K), 20.42
Sziasztok!

A profikhoz lenne kérdésem.

programnyelv: Javascript.

funkció csoportosítása miatt az alább megoldást alkalmaztam (részlet):

var chatManagerInstance = function() {
    this.socketEmulatorProcessor = function() {
        var $this = this;
        return {
            unread: {
                start: function () {
                    $.socketEmulator.register("chatManagerUnread", {
                        api: {Mod: "prextChatManager", Func: "getUnreadMessageCount"},
                        responseProcessor: $this.responseProcessor().unreadCounter
                    });
                },
                stop: function () {
                    $.socketEmulator.unRegister("chatManagerUnread")
                }
            },
            user: {
                start: function () {
                    $.socketEmulator.register("chatManagerUsers", {
                        api: {Mod: "prextChatManager", Func: "getUsers"},
                        responseProcessor: $this.responseProcessor().userRender
                    });
                },
                stop: function () {
                    $.socketEmulator.unRegister("chatManagerUsers")
                }
            }
        }
    };
}
Az ok, hogy így csoportosítva vannak a funkciók, és áttekinthető.

this.socketEmulatorProcessor().unread.start();
this.socketEmulatorProcessor().user.stop();
... stb.

A kérdés apropója: Egy barátom felvetette, hogy szerinte a return miatt (merthogy a deklarációk abban vannak), minden alkalommal mikor meghívok valamit belül, a memóriában létrejön egy újabb bejegyzés. Másképp: folyamatosan zabálja a memóriát, mert nem egy adott változó helyét adja vissza.

Tehát a kérdés, jó - e ez a megoldás, vagy okoz ez valami erőforrás pazarlást?
‹ szövegdoboz setTimeout(fn, 0); ›
 ■
1

Nem

Hidvégi Gábor · 2017. Feb. 15. (Sze), 10.38
Elvileg ez egy inicializációs funkció, amit minden oldalon egyszer kell lefuttatni, nem?
2

nem, nem.

gtoma · 2017. Feb. 15. (Sze), 19.57
A 
$.socketEmulator.register("chatManagerUnread", {  
                        api: {Mod: "prextChatManager", Func: "getUnreadMessageCount"},  
                        responseProcessor: $this.responseProcessor().unreadCounter  
                    });
egy ajaxlekérős cucc. 30mp -ként lekér a szervertől adatokat.
Amikor valaki megnyitja a chat-et, akkor 
this.socketEmulatorProcessor().user.start();
-al elindítom a folyamatos frissítést, majd ha bezárja a chat-et leállítom a 
this.socketEmulatorProcessor().user.stop();
-al.

Tehát ez itt hirtelen olyan, ami többször is lefut. Vagyis hogy többször is hozzányúlok a kérdéses return-os részhez.

Ráadásul elvi kérdés is, mert a kódolást hasznosnak tartom - azt, hogy csoportosítva vannak a funkciók, mert átlátható és érthető. Alkalmaznám több helyen.
4

Változó

Hidvégi Gábor · 2017. Feb. 16. (Cs), 13.07
var user = chatManagerInstance.socketEmulatorProcessor().user;

user.start();

user.stop();
3

Elképzelhető, hogy nem a

smokey · 2017. Feb. 16. (Cs), 00.15
Elképzelhető, hogy nem a kérdésre válaszolok, sőt inkább én is kérdezek, viszont:

1. Olyan furán hangzik ez a "funkciók csoportosítása" kifejezés

2. Igazából nem szól semmi az ellen, hogy használj egy plusz változót:

var processor = this.socketEmulatorProcessor(); //itt egyszer volt csak return, mégis többször használod és futtatod a return által visszaadott erőforrásokat
processor.unread.start();
processor.user.stop();
3. A protoype-al is tök szépen meg tudod oldani, a kérdés részemről is: számít ez valamit a memória kezelésben? - nem mondom, hogy leteszteltem a lenti kódot

var process = function(name, mod, func, responseProcessor){
	this.name = name;
	this.mod = mod;
	this.func = func;
	this.responseProcessor = responseProcessor;
};

process.prototype.start = function() {
	$.socketEmulator.register(this.name, {  
		api: {Mod: this.mod, Func: this.func},  
		responseProcessor: this.responseProcessor  
	}); 
};

process.prototype.stop = function() {
	$.socketEmulator.unRegister(this.name);
};

var socketEmulatorProcessor = function() {
	var $this = this;  
	
	$this.unread = new process("chatManagerUnread", "prextChatManager", "getUnreadMessageCount", $this.responseProcessor().unreadCounter);
	$this.user = new process("chatManagerUsers", "prextChatManager", "getUsers", $this.responseProcessor().userRender);
};  

var chatManager = function() {  
    this.socketEmulatorProcessor = new socketEmulatorProcessor();
} 

var chatManagerInstance = new chatManager();
chatManagerInstance.socketEmulatorProcessor.unread.start();
chatManagerInstance.socketEmulatorProcessor.user.stop();
5

Néhány év tapasztalattal a

inf · 2017. Feb. 16. (Cs), 15.52
Néhány év tapasztalattal a témában azt mondhatom, hogy hibás az az elképzelés, hogy mindent a lehető legkevesebb sorból a lehető legkevesebb változóval kell megoldani. Csinálj neki új változót, tök felesleges mindig újra és újra meghívni, sőt a duplikált kód error prone. Egyébként jelentéktelen mennyiségű erőforrást használ, szóval ez most egy micro-management kategóriájú kérdés, amire feleslegesen pazarlod az idődet, ha az a cél, hogy jelentősen gyorsabb legyen az alkalmazás.

Én személy szerint nem szeretem annyira az ilyen függvény a függvényben jellegű dolgokat meg a closure-t, mert ha nem figyelsz, akkor vezethetnek memory leak-hez, illetve mert a javascript egy prototípus alapú nyelv, amiben talán jobb prototípusokat használni. Bár ez a memory leak dolog érdekes. De persze ez a closure vagy nem closure csak ízlés kérdése, mindenki azt csinál, amit akar, amíg nem kell utána hozzányúlnom a kódjához. :D
6

Köszönöm a válaszokat!

gtoma · 2017. Feb. 20. (H), 10.11
Utána fogok nézni a memory leak dolognak, és egyenlőre inkább változóban deklarálom a dolgot.