选择全局范围而不是本地范围

Question

I wonder, If is it any way in Javascript to tell compiler from which scope variable you wanna use.

Like in python appending keyword global and compiler knows that you're using global one.

Is it any way to do same in Javascript, beside using a different name?

(In the sample below I'm trying to reach out for global "red", but it's been shadowing with argument "green".)

 const color = "red" const printColor = (color) => console.log(color) printColor("green")

Answer 1

Attach the global var directly to the window object:

 window.color = "red" const printColor = (color) => console.log(color, window.color) printColor("green")

Update

Alternatively, you could create a "global" object and keep all your global vars in it:

 const global = { color: "red" } const printColor = (color) => console.log(color, global.color) printColor("green")

Answer 2

I like @symlink 's answer, but just as an additional bit of information.

A way to do this would be to bind the context of the appropriate this to the function.

For instance, because var will hoist variables ( outside of strict mode ) to window , you could potentially do something like the following:

 var color = "blue"; const printColor = function() { console.log(this.color) } printColor.bind( window )() printColor.bind({ color: "green" })()

We could also shorthand this to simply accept the scope as the argument.

 var color = "blue"; const printColor = scope => console.log(scope.color) printColor(window); printColor({color: "green"})

Answer 3

The comparison with Python should be done in a fair way.

When in Python you have:

x = 1 # global
def test(x):
    print(x)

... you cannot insert the global keyword to let that print(x) act on the global x , as you already defined that name as a local name (a parameter).

To continue for a moment in the Python world. This will act on the global variable:

x = 1
def test():
    print(x) # global

...but as soon as you have an assignment, the variable will be considered to be local:

x = 1
def test():
    x = 2 # local
    print(x)

To override this behaviour, you use global :

x = 1
def test():
    global x
    x = 2 # global
    print(x) 

Now, back to JavaScript. Here you can play with the word var .

To use the variable within the function, you just omit defining it with let , const or var in there:

var x = 1;

function test() {
    console.log(x); // global
}

To use the variable as local variable, then do use var , let or const :

var x = 1;

function test() {
    var x = 2; // local
    console.log(x);
}

So it is not that different. When in Python you use the global keyword, you don't use var , let or const in JavaScript, and where you omit Python's global , you do use var , let or const in JavaScript.

globals() versus globalThis

Python has globals() with which you can reference a global variable when you also have a local variable with the same name:

x = 1

def test(x = 2):
    globals()['x'] = 3 # modifies the global variable

In JavaScript you would be able to do this via the global object, which is window in a browser context. See also the newer globalThis . So in a browser context you can do this (but it needs var ):

var x = 1;

function test(x = 2) {
    window.x = 3 // modifies the global variable
}

It would be better practice though, to just define your global variable as part of an object:

var myglobals = { x: 1 };

function test(x = 2) {
    myglobals.x = 3 // mutates myglobals
}