전역 변수를 사용하지 않고 다른 함수의 변수에 액세스

전역 변수를 사용하지 않고 다른 함수의 변수에 액세스

---

여러 곳에서 전역 변수가 본질적으로 고약하고 사악하다는 이야기를 들었지만 객체 지향이 아닌 Javascript를 수행 할 때는이를 피하는 방법을 알 수 없습니다. 난수 등을 사용하여 복잡한 알고리즘을 사용하여 숫자를 생성하는 함수가 있다고 가정 해 보겠습니다.하지만 콜백이나 다른 함수에 해당 특정 숫자를 계속 사용해야하므로 동일한 함수의 일부가 될 수 없습니다.

원래 생성 된 숫자가 지역 변수 인 경우 거기에서 액세스 할 수 없습니다. 함수가 객체 메서드라면 번호를 속성으로 만들 수는 있지만 그렇지 않고 전체 프로그램 구조를 변경하는 것이 다소 복잡해 보입니다. 전역 변수가 정말 그렇게 나쁜가요?

---

함수 A에서 계산 된 변수를 함수 B에 표시하려면 다음 세 가지 선택 사항이 있습니다.

• 글로벌화,
• 객체 속성으로 만들거나
• A에서 B를 호출 할 때 매개 변수로 전달하십시오.

프로그램이 상당히 작 으면 전역이 그렇게 나쁘지 않습니다. 그렇지 않으면 세 번째 방법을 사용하는 것이 좋습니다.

function A()
{
    var rand_num = calculate_random_number();
    B(rand_num);
}

function B(r)
{
    use_rand_num(r);
}

---

여기서 가장 좋은 방법은 단일 전역 범위 변수 를 정의하고 거기에 변수를 덤프하는 것입니다.

var MyApp = {}; // Globally scoped object

function foo(){
    MyApp.color = 'green';
}

function bar(){
    alert(MyApp.color); // Alerts 'green'
} 

누구도 위와 같은 일을했다고 소리를 지르면 안됩니다.

---

네임 스페이스 사용을 고려하십시오.

(function() {
    var local_var = 'foo';
    global_var = 'bar'; // this.global_var and window.global_var also work

    function local_function() {}
    global_function = function() {};
})();

모두 local_function와 global_function모든 로컬 및 글로벌 변수에 액세스 할 수 있습니다.

편집 : 또 다른 일반적인 패턴 :

var ns = (function() {
    // local stuff
    function foo() {}
    function bar() {}
    function baz() {} // this one stays invisible

    // stuff visible in namespace object
    return {
        foo : foo,
        bar : bar
    };
})();

이제 returned 속성은 네임 스페이스 객체 (예 :)를 통해 액세스 할 수 있으며 ns.foo로컬 정의에 대한 액세스는 계속 유지합니다.

---

What you're looking for is technically known as currying.

function getMyCallback(randomValue)
{
    return function(otherParam)
    {
        return randomValue * otherParam //or whatever it is you are doing.
    }

}

var myCallback = getMyCallBack(getRand())

alert(myCallBack(1));
alert(myCallBack(2));

The above isn't exactly a curried function but it achieves the result of maintaining an existing value without adding variables to the global namespace or requiring some other object repository for it.

---

If another function needs to use a variable you pass it to the function as an argument.

Also global variables are not inherently nasty and evil. As long as they are used properly there is no problem with them.

---

Another approach is one that I picked up from a Douglas Crockford forum post(http://bytes.com/topic/javascript/answers/512361-array-objects). Here it is...

Douglas Crockford wrote:

Jul 15 '06

"If you want to retrieve objects by id, then you should use an object, not an array. Since functions are also objects, you could store the members in the function itself."

function objFacility(id, name, adr, city, state, zip) {

    return objFacility[id] = {

        id: id,
        name: name,
        adr: adr,
        city: city,
        state: state,
        zip: zip

    }
}

objFacility('wlevine', 'Levine', '23 Skid Row', 'Springfield', 'Il', 10010);

"The object can be obtained with"

objFacility.wlevine

The objects properties are now accessable from within any other function.

---

I found this to be extremely helpful in relation to the original question:

Return the value you wish to use in functionOne, then call functionOne within functionTwo, then place the result into a fresh var and reference this new var within functionTwo. This should enable you to use the var declared in functionOne, within functionTwo.

function functionOne() {
  var variableThree = 3;
  return variableThree;
}

function functionTwo() {
  var variableOne = 1;
  var var3 = functionOne();

  var result = var3 - variableOne;

  console.log(variableOne);
  console.log(var3);
  console.log('functional result: ' + result);
}

functionTwo();

---

If there's a chance that you will reuse this code, then I would probably make the effort to go with an object-oriented perspective. Using the global namespace can be dangerous -- you run the risk of hard to find bugs due to variable names that get reused. Typically I start by using an object-oriented approach for anything more than a simple callback so that I don't have to do the re-write thing. Any time that you have a group of related functions in javascript, I think, it's a candidate for an object-oriented approach.

---

I don't know specifics of your issue, but if the function needs the value then it can be a parameter passed through the call.

Globals are considered bad because globals state and multiple modifiers can create hard to follow code and strange errors. To many actors fiddling with something can create chaos.

---

You can completely control the execution of javascript functions (and pass variables between them) using custom jQuery events....I was told that this wasn't possible all over these forums, but I got something working that does exactly that (even using an ajax call).

Here's the answer (IMPORTANT: it's not the checked answer but rather the answer by me "Emile"):

How to get a variable returned across multiple functions - Javascript/jQuery

참고URL : https://stackoverflow.com/questions/407048/accessing-variables-from-other-functions-without-using-global-variables