Jak "ukryć" zmienne w JavaScript podczas eksponowania publicznych metod statycznych?

Question

Obecnie przepisuję trochę naukowego kodu C++ za pomocą Javascript i chciałbym zachować tę samą podstawową organizację, jeśli w ogóle jest to możliwe. W kodzie C++ istnieje wiele klas, które zawierają wiele danych z wielu różnych tablic i serii public static metod, które działają na tych danych. Walczę z tym, jak zreplikować coś takiego w JavaScript.

Obecnie używam coś jak następuje:

function mars(){} 

mars.x = [{A:1, B:2, C:3},{A:1, B:2, C:3}]; //... 
mars.y = [{A:1, B:4, C:2},{A:1, B:2, C:3}]; //... 
// ...about 600 lines in total 

mars.doSomething = function(foo){ 
    var result = 0; 
    // Do lots of processing of above arrays 
    return result; 
} 

mars.doSomethingElse = function(bar){ 
    var result = 0; 
    // Do lots of processing of above arrays 
    return result; 
} 

console.log(mars.doSomething(3)) 

To działa, ale naraża mars.x itp do reszty kodu, który naprawdę nie musi o tym wiedzieć. Jeśli użyję metody prototype, metody nie będą już statyczne, a kod będzie zaśmiecony wywołaniami new, czego tak naprawdę nie chcę.

To, o co teraz pytam, to: Jak ukryć zmienne w JavaScript, a jednocześnie wyeksponować metody statyczne na resztę kodu? Czy martwię się czymś, czym nie powinienem być?

Answer 1

Aby ukryć zmienną, można użyć Zamknięcie (zakres funkcji)

function mars() { 
    var staticFunctions = Object.create(null); // the same as {} 
    var x = [{A:1, B:2, C:3},{A:1, B:2, C:3}]; 
    var y = [{A:1, B:4, C:2},{A:1, B:2, C:3}]; 

    staticFunctions.doSomething = function (foo) { 
    return x; 
    }; 

    staticFunctions.doSomethingElse = function (bar) { 
    return y; 
    }; 

    return staticFunctions; 
} 

// you do need to instantiate mars however 
var m = mars(); 
// if you don't want that you can do 
var mars = (function() { 
    // same as above 
}()); // this invokes the function for you 

Answer 2

Po prostu ustaw zmienną lokalną i użyj funkcji getter, aby ją uzyskać. Spróbuj również zachować schemat nazewnictwa. W przypadku konstruktorów nazwa powinna rozpoczynać się od dużej litery.

function Mars(){ 
    var x = [{A:1, B:2, C:3},{A:1, B:2, C:3}]; 
    this.getArr = function(){ 
     return x; 
    } 
} 
var mars = new Mars(); 
mars.x; // undefined 
mars.getArr(); // [Object, Object] 

Answer 3

Jesteś poprawna się o to martwić. Twój kod stanie się niemożliwy do zarządzania, jeśli nie rozwiążesz tego problemu.

Używasz funkcji do kontrolowania zasięgu w JavaScript. JS nie ma klas. ES6 (nie w powszechnym użyciu) ma "klasy", ale tylko tak naprawdę z nazwy.

można spróbować coś takiego:

var myApp = {}; 

(function(namespace){ 

    var X = [{A:1, B:2, C:3},{A:1, B:2, C:3}]; // Capitalized because 'constant'. 
    var Y = [{A:1, B:4, C:2},{A:1, B:2, C:3}]; // Capitalized because 'constant'. 

    function Mars() {} // Capitalized because this is a constructor function. 

    Mars.prototype.doSomething = function(foo) { 
    //do something with X 
    return X[foo]; // For example. 
    } 

    namespace.mars = new Mars(); // Lowercase on 'namespace.mars' because it is an instance. 

}(myApp)) 


// Use... 
myApp.mars.doSomething(foo); // Does something. 
Mars; // undefined 
X; // undefined 
Y; //undefined 

Answer 4

myślę Poniższy przykład może dać wgląd zmiennych i metod prywatnych, publicznych i statycznych.

function Mars(){ 
    // private variables 
    var x = [{A:1, B:2, C:3},{A:1, B:2, C:3}]; 
    var y = [{A:1, B:4, C:2},{A:1, B:2, C:3}]; 

    // public variables 
    this.z = 2; 

    // privileged methods, can access private variables 
    this.getX = function(){ 
     return x; 
    }; 

    this.getY = function(){ 
     return y; 
    }; 
} 

// public prototype method, can not access private variables 
// access private variables through getters 
Mars.prototype.getZ = function(){ 
    return this.z; 
} 

// static variable 
Mars.staticVar = 1; 

// static method 
Mars.staticMethod = function(){ 
    console.log('It is the static method'); 
} 



var marsObj = new Mars(); 
console.log(marsObj.getX()); //Array [ Object, Object ] 
console.log(marsObj.getZ()); //2 

Mars.staticMethod(); // "It is the static method" 
marsObj.staticMethod(); // Exception: mars.staticMethod is not a function 

Aby zrozumieć OOPS w JavaScript, polecam ten poradnik: http://phrogz.net/JS/classes/OOPinJS.html

Answer 5

widzę, że chcesz, aby dać pewną strukturę i organizować swój kod javascript. Najlepiej jest to obsługiwane w JavaScript z tym, co jest powszechnie znany jako Module Pattern

W skrócie, to działa tak:

var MODULE = (function() { 
    var my = {}, 
     privateVariable = 1; 


    function privateMethod() { 
     // ... 
    } 

    my.moduleProperty = 1; 
    my.moduleMethod = function() { 
     // ... 
    }; 

    return my; 
}()); 

ten fragment i dalsze czytanie jest udokumentowana w Ben Cherry's article i Eric Miraglia's artykułu. Istnieje kilka zgrabnych wariacji wzoru modułu, jeden z nich to odsłanianie wzoru modułu przez Christian Heilmann