variables used in functions

[drpelz]

I have a stupid question. I got this variable:

    var type:int;

and this function:

    private function test(type:int):void {
    }

when i call the function and throw in my variable type

    test(type));

is there a possibility that the compiler gets confused because my variable has the same name like the functions's parameter (type = type)? i'm not certain about this topic. Normally I'd write my function's parameter like this (if such a case occurs):

    private function test(_type:int):void

just to make sure the names do not exactly match (well I hope you know what I mean).

[5Five555]

Well I'm assuming you mean something like this

var awd:int;

test (awd);

function test (awd:int) {
    awd = 1;
} 

I don't know what would happen, you could just test it easily. I just add an underscore or capitalize the first letter of the argument name if this happens.

[5TonsOfFlax]

The narrow scope of the function takes precedence over the bigger scope of the frame or class. The compiler won't get confused. But you might.

To reference the instance-scoped variable within the function, use "this.type". If it isn't a property of the instance (such as a variable declared in another enclosing function), you can't reference it directly, you'd have to save it to another variable.

public class ScopeTest{

  private var foo:String;

  private function ScopeTest(){
     foo = "instance value";
  }

  private function testMethod(foo:String):void{
    trace("testMethod result: "+foo);
  }

  private function testNested(foo:String):void{
     trace("outer testNested value: "+foo);
     var bar:String = foo;
     trace("class value is still: "+this.foo);
     function nested(foo:String):void{
        trace("inner testNested foo value: "+foo);
        trace("inner testNested bar value: "+bar);
     }
     nested("nested inner value");
  }

  public function test():void{
     trace("class instance value: "+foo);
     testMethod("method param value");
     testNested("nested outer value");
  }
}

invoke as such:

var st:ScopeTest = new ScopeTest();
st.test();

should output:

class instance value: instance value
testMethod result: method param value
outer testNested value: nested outer value
class value is still: instance value
inner testNested foo value: nested inner value
inner testNested bar value: nested outer value

[drpelz]

Thanks for your answers! Finally I got it now.