Jak zadeklarować zmienną globalną w pliku .js.

Question 1

Potrzebuję kilku zmiennych globalnych, których potrzebuję we wszystkich .jsplikach.

Na przykład rozważ następujące 4 pliki:

global.js
js1.js
js2.js
js3.js

Czy istnieje sposób, w jaki mogę zadeklarować 3 zmienne globalne w programie global.jsi uzyskać do nich dostęp w dowolnym z pozostałych 3 .jsplików, biorąc pod uwagę, że załaduję wszystkie powyższe 4 pliki do dokumentu HTML?

Czy ktoś może mi powiedzieć, czy jest to możliwe, czy też jest jakiś sposób, aby to osiągnąć?

Question 2

Po prostu zdefiniuj swoje zmienne w global.js poza zakresem funkcji:

// global.js
var global1 = "I'm a global!";
var global2 = "So am I!";

// other js-file
function testGlobal () {
    alert(global1);
}

Aby upewnić się, że to zadziała, musisz dołączyć / link do global.js przed próbą uzyskania dostępu do jakichkolwiek zmiennych zdefiniowanych w tym pliku:

<html>
    <head>
        <!-- Include global.js first -->
        <script src="/YOUR_PATH/global.js" type="text/javascript"></script>
        <!-- Now we can reference variables, objects, functions etc. 
             defined in global.js -->
        <script src="/YOUR_PATH/otherJsFile.js" type="text/javascript"></script>
    </head>
    [...]
</html>

Możesz oczywiście umieścić link w tagach skryptu tuż przed zamykającym tagiem <body>, jeśli nie chcesz, aby ładowanie plików js przerywało początkowe ładowanie strony.

Question 3

Zalecane podejście to:

window.greeting = "Hello World!"

Następnie możesz uzyskać do niego dostęp w dowolnej funkcji:

function foo() {

   alert(greeting); // Hello World!
   alert(window["greeting"]); // Hello World!
   alert(window.greeting); // Hello World! (recommended)

}

Takie podejście jest preferowane z dwóch powodów.

Zamiar jest wyraźny. Użycie varsłowa kluczowego może łatwo doprowadzić do zadeklarowania jako globalne vars, które miało być lokalne lub odwrotnie. Ten rodzaj określania zakresu zmiennych jest powodem zamieszania dla wielu programistów JavaScript. Dlatego z zasady upewniam się, że wszystkie deklaracje zmiennych są poprzedzone słowem kluczowym varlub prefiksem window.
Standaryzujesz tę składnię do odczytywania zmiennych w ten sposób, co oznacza, że zakres lokalny varnie blokuje globalnego varlub odwrotnie. Na przykład to, co się tutaj dzieje, jest niejednoznaczne:

 greeting = "Aloha";

 function foo() {
     greeting = "Hello"; // overrides global!
 }

 function bar(greeting) {
   alert(greeting);
 }

 foo();
 bar("Howdy"); // does it alert "Hello" or "Howdy" ?

Jest to jednak znacznie czystsze i mniej podatne na błędy (tak naprawdę nie musisz pamiętać wszystkich reguł określania zakresu zmiennych):

 function foo() {
     window.greeting = "Hello";
 }

 function bar(greeting) {
   alert(greeting);
 }

 foo();
 bar("Howdy"); // alerts "Howdy"

Question 4

Próbowałeś tego?

Jeśli zrobisz:

var HI = 'Hello World';

W global.js. A następnie wykonaj:

alert(HI);

W js1.jsnim ostrzeże go dobrze. Musisz tylko dołączyć global.jsprzed resztą w dokumencie HTML.

Jedynym haczykiem jest to, że musisz zadeklarować to w zakresie okna (a nie wewnątrz żadnych funkcji).

Możesz po prostu usunąć varczęść i utworzyć ją w ten sposób, ale to nie jest dobra praktyka.

Question 5

Jak wspomniano powyżej, występują problemy z używaniem najwyższego zakresu w pliku skryptu. Oto kolejny problem: plik skryptu może być uruchamiany z kontekstu, który nie jest kontekstem globalnym w niektórych środowiskach wykonawczych.

Zaproponowano bezpośrednie przypisanie globalnego do window. Ale jest to również zależne od czasu wykonania i nie działa w Node itp. Pokazuje, że przenośne globalne zarządzanie zmiennymi wymaga dokładnego rozważenia i dodatkowego wysiłku. Może naprawią to w przyszłych wersjach ECMS!

Na razie polecałbym coś takiego, aby wspierać właściwe zarządzanie globalne dla wszystkich środowisk wykonawczych:

/**
 * Exports the given object into the global context.
 */
var exportGlobal = function(name, object) {
    if (typeof(global) !== "undefined")  {
        // Node.js
        global[name] = object;
    }
    else if (typeof(window) !== "undefined") {
        // JS with GUI (usually browser)
        window[name] = object;
    }
    else {
        throw new Error("Unkown run-time environment. Currently only browsers and Node.js are supported.");
    }
};


// export exportGlobal itself
exportGlobal("exportGlobal", exportGlobal);

// create a new global namespace
exportGlobal("someothernamespace", {});

To trochę więcej pisania, ale sprawia, że globalne zarządzanie zmiennymi jest przyszłościowe.

Zastrzeżenie: Część tego pomysłu przyszła mi do głowy podczas przeglądania poprzednich wersji stacktrace.js .

Myślę, że można również użyć Webpacka lub innych narzędzi, aby uzyskać bardziej niezawodne i mniej hakerskie wykrywanie środowiska wykonawczego.

Question 6

Tak, masz do nich dostęp. Powinieneś zadeklarować je w `` przestrzeni publicznej '' (poza żadnymi funkcjami) jako:

var globalvar1 = 'value';

Możesz uzyskać do nich dostęp później, także w innych plikach.