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):
  1. var chatManagerInstance = function() {  
  2.     this.socketEmulatorProcessor = function() {  
  3.         var $this = this;  
  4.         return {  
  5.             unread: {  
  6.                 start: function () {  
  7.                     $.socketEmulator.register("chatManagerUnread", {  
  8.                         api: {Mod: "prextChatManager", Func: "getUnreadMessageCount"},  
  9.                         responseProcessor: $this.responseProcessor().unreadCounter  
  10.                     });  
  11.                 },  
  12.                 stop: function () {  
  13.                     $.socketEmulator.unRegister("chatManagerUnread")  
  14.                 }  
  15.             },  
  16.             user: {  
  17.                 start: function () {  
  18.                     $.socketEmulator.register("chatManagerUsers", {  
  19.                         api: {Mod: "prextChatManager", Func: "getUsers"},  
  20.                         responseProcessor: $this.responseProcessor().userRender  
  21.                     });  
  22.                 },  
  23.                 stop: function () {  
  24.                     $.socketEmulator.unRegister("chatManagerUsers")  
  25.                 }  
  26.             }  
  27.         }  
  28.     };  
  29. }  
Az ok, hogy így csoportosítva vannak a funkciók, és áttekinthető.
  1. this.socketEmulatorProcessor().unread.start();  
  2. 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?
 
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
  1. $.socketEmulator.register("chatManagerUnread", {    
  2.                         api: {Mod: "prextChatManager", Func: "getUnreadMessageCount"},    
  3.                         responseProcessor: $this.responseProcessor().unreadCounter    
  4.                     });  
egy ajaxlekérős cucc. 30mp -ként lekér a szervertől adatokat.
Amikor valaki megnyitja a chat-et, akkor
  1. this.socketEmulatorProcessor().user.start();  
-al elindítom a folyamatos frissítést, majd ha bezárja a chat-et leállítom a
  1. 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:
  1. 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  
  2. processor.unread.start();  
  3. 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
  1. var process = function(name, mod, func, responseProcessor){  
  2.     this.name = name;  
  3.     this.mod = mod;  
  4.     this.func = func;  
  5.     this.responseProcessor = responseProcessor;  
  6. };  
  7.   
  8. process.prototype.start = function() {  
  9.     $.socketEmulator.register(this.name, {    
  10.         api: {Mod: this.mod, Func: this.func},    
  11.         responseProcessor: this.responseProcessor    
  12.     });   
  13. };  
  14.   
  15. process.prototype.stop = function() {  
  16.     $.socketEmulator.unRegister(this.name);  
  17. };  
  18.   
  19. var socketEmulatorProcessor = function() {  
  20.     var $this = this;    
  21.       
  22.     $this.unread = new process("chatManagerUnread""prextChatManager""getUnreadMessageCount", $this.responseProcessor().unreadCounter);  
  23.     $this.user = new process("chatManagerUsers""prextChatManager""getUsers", $this.responseProcessor().userRender);  
  24. };    
  25.   
  26. var chatManager = function() {    
  27.     this.socketEmulatorProcessor = new socketEmulatorProcessor();  
  28. }   
  29.   
  30. var chatManagerInstance = new chatManager();  
  31. chatManagerInstance.socketEmulatorProcessor.unread.start();  
  32. 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.