精华内容
下载资源
问答
  • JS 变量的作用域

    2017-02-22 11:16:00
    变量的作用域,是指变量的作用范围。...局部变量:只能在此变量声明语句所属的函数内部使用,局部变量的作用域仅为该函数体。 声明变量时,要根据编程的目的决定将变量声明为全局变量还是局部变量。一般...


    变量的作用域,是指变量的作用范围。也就是说,变量只在特定范围有效,超出该范围无效。

    在JavaScript中,有两种变量,全局变量和局部变量:

    • 全局变量:可以在脚本中的任何位置被调用,全局变量的作用域是当前文档中整个脚本区域。
    • 局部变量:只能在此变量声明语句所属的函数内部使用,局部变量的作用域仅为该函数体。


    声明变量时,要根据编程的目的决定将变量声明为全局变量还是局部变量。一般而言,保存全局信息(如用户信息、菜单选项等)的变量需声明为全局变量,而保存临时信息(如待输出的格式字符串、数学运算中间变量等)的变量则声明为局部变量。

    举例说明变量作用域

    【例2-1】考察如下代码:

    1. <html>
    2. <head>
    3. <title>局部变量和全局变量</title>
    4. </head>
    5. <body>
    6. <script type="text/javascript">
    7. var total=100; //全局变量
    8. function add(num){
    9. var total; // 局部变量
    10. total=2*num;
    11. return total;
    12. }
    13. </script>
    14. <p onclick="alert(add(100));">显示局部变量</p>
    15. <p onclick="alert(total);">显示全局变量</p>
    16. </body>
    17. </html>

    保存并运行代码,点击第一段文本,显示 200;点击第二段文本,显示 100。

    分析:点击第一段文本,运行add()函数,对total变量赋值。这时,JavaScript会寻找total变量,如果在函数内部找到,就赋值;找不到,就到函数外部寻找。显然,在函数内部已经找到,赋值后它的值为200。这里的total变量就是局部变量。

    点击第二段文本,JavaScript会在全局内寻找total变量,如果找到,就返回它的值;找不到,将会引发错误。显然,已经找到,它的值是100。这里的total变量就是全局变量。

    可以发现,在add()函数内部对total变量赋值,并未影响外部的total变量。

    【例2-2】对【例2-1】稍作修改,去掉add()函数内部对total变量的声明。如下所示:

    1. <html>
    2. <head>
    3. <title>局部变量和全局变量</title>
    4. </head>
    5. <body>
    6. <script type="text/javascript">
    7. var total=100; //全局变量
    8. function add(num){
    9. total=2*num;
    10. return total;
    11. }
    12. </script>
    13. <p onclick="alert(add(100));">这已不是局部变量</p>
    14. <p onclick="alert(total);">显示全局变量</p>
    15. </body>
    16. </html>

    保存并运行代码,点击两段文本,都显示 200 。

    上述结果表明,JavaScript在add()函数内部没有找到total变量,又到函数外部寻找,找到后对它赋值,覆盖掉了原来的值。

    说明:JavaScript是从小范围到大范围寻找变量的。如果在当前范围内没有找到相应的变量,就会一级一级向上级范围去寻找,找到后,就对它进行操作,找不到将会引发错误。

    注意:任何情况下,JavaScript绝对不会从大范围向小范围寻找变量。如果在函数外部没有找到变量,绝对不会去函数内部寻找。

    在函数内部声明全局变量

    前面已经讲到,声明变量时要使用 var 关键字;但是,也可以不使用。

    无论在函数外部还是内部,不使用 var 关键字声明的变量都为全局变量

    这就给我们提供了两种声明全局变量的方法:

    • 在函数外部使用 var 关键字声明;
    • 在任何地方不使用 var 关键字声明。

    【例2-3】对【例2-2】稍作修改,去掉add()函数外部对total变量的声明。如下所示:

    1. <html>
    2. <head>
    3. <title>局部变量和全局变量</title>
    4. </head>
    5. <body>
    6. <script type="text/javascript">
    7. function add(num){
    8. total=2*num; // total 为全局变量
    9. return total;
    10. }
    11. </script>
    12. <p onclick="alert(add(100));">这已不是局部变量</p>
    13. <p onclick="alert(total);">显示全局变量</p>
    14. </body>
    15. </html>

    保存并运行代码,点击两段文本,都显示 200 。

    上述结果表明,在add()函数内部声明的total变量,已不再是局部变量,它在全局范围内都是有效的。

    注意:

    • 声明变量时请尽量使用 var 关键字,这对程序结构有很大的帮助。
    • 尽量不要在函数内部声明全局变量,也不要在函数内部和外部声明同名变量,这两种情况都会造成变量的混淆。

    只有在函数内使用 var 关键字声明的变量为局部变量

    这里需要强调的是,只有在函数内部使用 var 关键字声明的变量才是局部变量,在其它“语句块”内使用 var 关键字声明变量一般是全局变量,if...else...选择结构和for循环结构都是如此。

    【例2-4】在for循环内部声明变量。

    1. <html>
    2. <head>
    3. <title>在for循环内部声明变量</title>
    4. </head>
    5. <body>
    6. <script type="text/javascript">
    7. for(var i=0;i<=5;i++){
    8. var x=100;
    9. }
    10. </script>
    11. <p onclick="alert(i);">显示 i 变量的值</p>
    12. <p onclick="alert(x);">显示 x 变量的值</p>
    13. </body>
    14. </html>

    点击第一段文本,显示 6 ;点击第二段文本,显示 100 。

    上述结果表明,在for循环内部声明的 i 和 x 并不是局部变量,而是全局变量。

    总结:除了函数,JavaScript是没有块级作用域的。

    转载于:https://www.cnblogs.com/2260827114com/p/6428010.html

    展开全文
  • python中变量的作用域

    2018-01-31 22:16:12
    变量的作用域:全局变量的作用域、局部变量的作用域 全局变量:一般在函数、代码块外部声明的变量,被称为全局变量,作用范围,是从声明的位置往下,一直到文件的末尾都可以使用 局部变量:一般在函数内部或代码块...

    什么是作用域?就是指一个变量产生作用的范围,在哪一个范围内可以被使用

    变量的作用域:全局变量的作用域、局部变量的作用域

    全局变量:一般在函数、代码块外部声明的变量,被称为全局变量,作用范围,是从声明的位置往下,一直到文件的末尾都可以使用

    局部变量:一般在函数内部或代码块内部声明的变量,被称为局部变量,这类变量只能在函数或代码块内部使用,超出范围不可用

    #如下:b为全局变量,a为局部变量
    b=10
    if 1==1:
        a=10
    #代码块 对a是重新引用了一次(不是创建),会改变a的值
    a=20
    if 1==1:
        a=10
    print(a)
    运行结果:a=10
    
    #函数  重新创建了一个变量来指向另外一个值,以下两个c是不同的c,占用不同的内存空间,函数里的c是局部变量
    c=20
    def eat():
        c=10
    eat()
    print(c)
    运行结果:20
    
    全局变量如何在函数内部进行赋值操作?
    #全局变量name
    name='张三'
    #默认情况下,如果全局变量的名称和局部变量名称相同,例如:都是name,在函数中,局部变量会将全局变量覆盖掉
    def change_name():
        #如果不使用global引用全局变量,是可以获取这个全局变量值得  例如s=name
        #但是不能修改全局变量,一旦修改,相当于创建了一个和全局变量同名的局部变量
        #局部变量name
        # name='李四'
        #global:全局  引用一个全局变量,避免出现一个和全局变量同名的局部变量
        #告诉这个函数,在函数内部使用的name变量是一个全局的变量
        global name
        name='李四'
        #在这里输出name='李四'
       print(name)
    change_name() 
    #在这里nmae也是李四,因为在函数里用global调用了全局变量并且进行了修改
    print(name)



    展开全文
  • 作用域全局变量局部变量静态变量外部变量常量 volatile变量 作用域作用域规则告诉我们一个变量的有效范围,它在哪儿创建,在哪儿销毁(也就是说超出作用域)。变量的有效作用域从它的定义点开始,到...

    作用域 全局变量 局部变量 静态变量 外部变量 常量 volatile变量

    作用域:作用域规则告诉我们一个变量的有效范围,它在哪儿创建,在哪儿销毁(也就是说超出了作用域)。变量的有效作用域从它的定义点开始,到和定义变量之前最邻近的开括号配对的第一个闭括号。也就是说,作用域由变量所在的最近一对括号确定。

    全局变量:全局变量是在所有函数体的外部定义的,程序的所在部分(甚至其它文件中的代码)都可以使用。全局变量不受作用域的影响,问题可以使用的(也就是说,全局变量的生命期一直到程序的结束)。如果在一个文件中使用extern关键字来声明另一个文件中存在的全局变量,那么这个文件可以使用这个数据。

    局部变量:局部变量出现在一个作用域内,它们是局限于一个函数的。局部变量经常被称为自动变量,因为它们在进入作用域时自动生成,离开作用域时自动消失。关键字auto可以显式地说明这个问题,但是局部变量默认为

    auto,所以没有必要声明为auto

    寄存器变量 寄存器变量是一种局部变量。关键字register告诉编译器尽可能快地访问这个变量。加快访问速度取决于现实,但是,正如名字所暗示的那样,这经常是通过在寄存器中放置变量来做到的。这并不能保证将变置在寄存器中,甚至也不能保证提高访问速度。这只是对编译器的一个暗示。

    使用register变量是有限制的。不可能得到或计算register 变量的地址。register变量只能在一个块中声明(不可能有全局的或静态的register变量)。然而可以在一个函数中(即在参数表中)使用register变量作为一个形式参数。

    一般地,不应当推测编译器的优化器,因为它可能比我们做得更好。因此,最好避免使用关键字register

    静态变量

    关键字static有一些独特的意义。通常,函数中定义局部变量在函数中作用域结束时消失。当再次调用这个函数时,会重新创建变量的存储空间,其值会被重新初始化。如果想使局部变量的值在程序的整个生命期里仍然存在,我们可以定义函数的局部变量为static(静态的),并给它一个初始化。初始化只在函数第一次调用时执行,函数调用之间变量的值保持不变,这种方式,函数可以记住函数调用之间的一些信息片断。

    我们可能奇怪为什么不使用全局变量。static变量的优点是在函数范围之外它是不可用的,所以它不可能被轻易改变。这会使错误局部化。

    外部变量

    extern告诉编译器存在着一个变量和函数,即使编译器在当前的文件中没有看到它。这个变量或函数可能在一个文件或者在当前文件的后面定义。例如extern int i;编译器会知道i肯定作为全局变量存在于某处。当编译器看到变量i的定义时,并没有看到别的声明,所以知道它在文件的前面已经找到了同样声明的i

    常量

    const告诉编译器这个名字表示常量,不管是内部的还是用户定义的数据类型都可以定义为const。如果定义了某对象为常量,然后试图改变它,编译器将会产生错误。在C++中一个const必须有初始值。

    volatile变量

    限定词const告诉编译器这是不会改变的(这就是允许编译器执行额外的优化);而限定词volatile则告诉编译器不知道何时变化,防止编译器依据变量的稳定性作任何优化。

    参考《Thinking in C++》第一卷第三章

     ——————————————————————————————————————

     

     char a = 'A'; // global variable
    void msg()
    {
    printf("Hello/n");
    }

     

     int main(void)
    {
    extern char a; // extern variable must be declared before use
    printf("%c ", a);
    (void)msg();
    return 0;
    }

     

     #include <stdio.h>
    int fun(void){
    static int count = 10; // 事实上此赋值语句从来没有执行过
    return count--;
    }
    int count = 1;
    int main(void)
    {
    printf("global/t/tlocal static/n");
    for(; count <= 10; ++count)
    printf("%d/t/t%d/n", count, fun());
    return 0;
    }

     

    #include <stdio.h>
    int a;
    int main(void)
    {
    int i;
    static char str[10];
    printf("integer: %d; string: (begin)%s(end)", a, str);
    return 0;
    }

     

    ——————————————————————————————————————

     

    代码区

    全局数据区

    堆区

    栈区

     

    C语言中,static的作用

     

    C语言中,static的字面意思很容易把我们导入歧途,其实它的作用有三条。
    1先来介绍它的第一条也是最重要的一条隐藏
    当我们同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话,我举例来说明。我们要同时编译两个源文件,一个是a.c,另一个是main.c
    下面是a.c的内容
    #include<cstdio>
    增加这条语句
    char a = 'A'; // global variable
    void msg()
    {
         printf("Hello/n");
    }
    你可能会问:为什么在a.c中定义的全局变量a和函数msg能在main.c中使用?前面说过,所有未加static前缀的全局变量和函数都具有全局可见性,其它的源文件也能访问。此例中,a是全局变量,msg是函数,并且都没有加static前缀,因此对于另外的源文件main.c是可见的。
    如果加了static,就会对其它源文件隐藏。例如在amsg的定义前加上staticmain.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量,而不必担心命名冲突。Static可以用作函数和变量的前缀,对于函数来讲,static的作用仅限于隐藏,而对于变量,static还有下面两个作用。
    2static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化。共有两种变量存储在静态存储区:全局变量和static变量,只不过和全局变量比起来,static可以控制变量的可见范围,说到底static还是用来隐藏的。
    3static的第三个作用是默认初始化为0。其实全局变量也具备这一属性,因为全局变量也存储在静态数据区。在静态数据区,内存中所有的字节默认值都是0x00,某些时候这一特点可以减少程序员的工作量。
    最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏,其次因为static变量存放在静态存储区,所以它具备持久性和默认值0
    下面是main.c的内容
    除了头文件,需要声明函数:void msg();
    int main(void)
    {   
        extern char a;    // extern variable must be declared before use
         printf("%c ", a);
         (void)msg();
        return 0;
    }

      一般程序的由new产生的动态数据存放在堆区,函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现,Example 1中的代码中将 

     static int n; //定义静态全局变量

    改为 

     int n; //定义全局变量

    程序照样正常运行。
    的确,定义全局变量就可以实现变量在文件中的共享,但定义静态全局变量还有以下好处:  

    ·                                 静态全局变量不能被其它文件所用;  

    ·                                 其它文件中可以定义相同名字的变量,不会发生冲突;  

    您可以将上述示例代码改为如下:

    //Example 2

    //File1

    #include <iostream.h>

    void fn();

    static int n; //定义静态全局变量

    void main()

    {

     n=20;

     cout<<n<<endl;

     fn();

    }

    //File2

    #include <iostream.h>

    extern int n;

    void fn()

    {

     n++;

     cout<<n<<endl;

    }

    编译并运行Example 2,您就会发现上述代码可以分别通过编译,但运行时出现错误。试着将  

    static int n; //定义静态全局变量

    改为  

    int n; //定义全局变量

    再次编译运行程序,细心体会全局变量和静态全局变量的区别。  

    2、静态局部变量

    在局部变量前,加上关键字static,该变量就被定义成为一个静态局部变量。 

    我们先举一个静态局部变量的例子,如下: 

    //Example 3

    #include <iostream.h>

    void fn();

    void main()

    {

     fn();

     fn();

     fn();

    }

    void fn()

    {

     static n=10;

     cout<<n<<endl;

     n++;

    }

      通常,在函数体内定义了一个变量,每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体,系统就会收回栈内存,局部变量也相应失效。
      但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来,变量已经不再属于函数本身了,不再仅受函数的控制,给程序的维护带来不便。
      静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区,而不是保存在栈中,每次的值保持到下一次调用,直到下次赋新值。  

    静态局部变量有以下特点

    ·                                 该变量在全局数据区分配内存;  

    ·                                 静态局部变量在程序执行到该对象的声明处时被首次初始化,即以后的函数调用不再进行初始化;  

    ·                                 静态局部变量一般在声明处初始化,如果没有显式初始化,会被程序自动初始化为0  

    ·                                 它始终驻留在全局数据区,直到程序运行结束。但其作用域为局部作用域,当定义它的函数或语句块结束时,其作用域随之结束;  

    3、静态函数

      在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同,它只能在声明它的文件当中可见不能被其它文件使用

    静态函数的例子: 

    //Example 4

    #include <iostream.h>

    static void fn();//声明静态函数

    void main()

    {

     fn();

    }

    void fn()//定义静态函数

    {

     int n=10;

     cout<<n<<endl;

    }

    定义静态函数的好处:  

    ·                                 静态函数不能被其它文件所用;  

    ·                                 其它文件中可以定义相同名字的函数,不会发生冲突;  

    二、面向对象的static关键字(类中的static关键字)

    1、静态数据成员

    在类内数据成员的声明前加上关键字static,该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。 

    //Example 5

    #include <iostream.h>

    class Myclass

    {

    public:

     Myclass(int a,int b,int c);

     void GetSum();

    private:

     int a,b,c;

     static int Sum;//声明静态数据成员

    };

    int Myclass::Sum=0;//定义并初始化静态数据成员

    Myclass::Myclass(int a,int b,int c)

    {

     this->a=a;

     this->b=b;

     this->c=c;

     Sum+=a+b+c;

    }

    void Myclass::GetSum()

    {

     cout<<"Sum="<<Sum<<endl;

    }

    void main()

    {

     Myclass M(1,2,3);

     M.GetSum();

     Myclass N(4,5,6);

     N.GetSum();

     M.GetSum();

    }

    可以看出,静态数据成员有以下特点:  

    ·                                 对于非静态数据成员,每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个,静态数据成员在程序中也只有一份拷贝,由该类型的所有对象共享访问。也就是说,静态数据成员是该类的所有对象所共有的。对该类的多个对象来说,静态数据成员只分配一次内存,供所有对象共用。所以,静态数据成员的值对每个对象都是一样的,它的值可以更新;  

    ·                                 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间,所以不能在类声明中定义。在Example 5中,语句int Myclass::Sum=0;是定义静态数据成员;  

    ·                                 静态数据成员和普通数据成员一样遵从public,protected,private访问规则;  

    ·                                 因为静态数据成员在全局数据区分配内存,属于本类的所有对象共享,所以,它不属于特定的类对象,在没有产生类对象时其作用域就可见,即在没有产生类的实例时,我们就可以操作它;  

    ·                                 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为:
    <数据类型><类名>::<静态数据成员名>=<值>  

    ·                                 类的静态数据成员有两种访问形式:
    <类对象名>.<静态数据成员名>  <类类型名>::<静态数据成员名>
    如果静态数据成员的访问权限允许的话(即public的成员),可在程序中,按上述格式来引用静态数据成员   

    ·                                 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类,每个实例的利息都是相同的。所以,应该把利息设为存款类的静态数据成员。这有两个好处,第一,不管定义多少个存款类对象,利息数据成员都共享分配在全局数据区的内存,所以节省存储空间。第二,一旦利息需要改变时,只要改变一次,则所有存款类对象的利息全改变过来了;  

    ·                                 同全局变量相比,使用静态数据成员有两个优势:  

    1.        静态数据成员没有进入程序的全局名字空间,因此不存在与程序中其它全局名字冲突的可能性;  

    2.        可以实现信息隐藏。静态数据成员可以是private成员,而全局变量不能;

    2、静态成员函数  

      与静态数据成员一样,我们也可以创建一个静态成员函数,它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样,都是类的内部实现,属于类定义的一部分。普通的成员函数一般都隐含了一个this指针,this指针指向类的对象本身,因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下,this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比,静态成员函数由于不是与任何的对象相联系,因此它不具有this指针。从这个意义上讲,它无法访问属于类对象的非静态数据成员,也无法访问非静态成员函数,它只能调用其余的静态成员函数。下面举个静态成员函数的例子。 

    //Example 6

    #include <iostream.h>

    class Myclass

    {

    public:

     Myclass(int a,int b,int c);

     static void GetSum();/声明静态成员函数

    private:

     int a,b,c;

     static int Sum;//声明静态数据成员

    };

    int Myclass::Sum=0;//定义并初始化静态数据成员

    Myclass::Myclass(int a,int b,int c)

    {

     this->a=a;

     this->b=b;

     this->c=c;

     Sum+=a+b+c; //非静态成员函数可以访问静态数据成员

    }

    void Myclass::GetSum() //静态成员函数的实现

    {

    // cout<<a<<endl; //错误代码,a是非静态数据成员

     cout<<"Sum="<<Sum<<endl;

    }

    void main()

    {

     Myclass M(1,2,3);

     M.GetSum();

     Myclass N(4,5,6);

     N.GetSum();

     Myclass::GetSum();

    }

     

     

    关于静态成员函数,可以总结为以下几点:  

     

    ·                                 出现在类体外的函数定义不能指定关键字static  

    ·                                 静态成员之间可以相互访问,包括静态成员函数访问静态数据成员和访问静态成员函数;  

    ·                                 非静态成员函数可以任意地访问静态成员函数和静态数据成员;  

    ·                                 静态成员函数不能访问非静态成员函数和非静态数据成员;  

    ·                                 由于没有this指针的额外开销,因此静态成员函数与类的全局函数相比速度上会有少许的增长;  

    ·                                 调用静态成员函数,可以用成员访问操作符(.)(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以直接使用如下格式:
    <类名>::<静态成员函数名>(<参数表>)
    调用类的静态成员函数。  

    ————————————————————————————————

     C++static有两种用法:面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类;后者主要说明static在类中的作用。

    一、面向过程设计中的static

    1、静态全局变量

    在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子,如下: 

    //Example 1

    #include <iostream.h>

    void fn();

    static int n; //定义静态全局变量

    void main()

    {

     n=20;

     cout<<n<<endl;

     fn();

    }

    void fn()

    {

     n++;

     cout<<n<<endl;

    }

    静态全局变量有以下特点:  

    ·                                

    该变量在全局数据区分配内存;  

    ·                                

     未经初始化的静态全局变量会被程序自动初始化为0(自动变量的值是随机的,除非它被显式初始化);  

    ·                                

     静态全局变量在声明它的整个文件都是可见的,而在文件之外是不可见的;   

    静态变量都在全局数据区分配内存,包括后面将要提到的静态局部变量。对于一个完整的程序,在内存中的分布情况如下图:
       

    程序的运行结果如下integer: 0; string: (begin)(end)

    最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏,其次因为static变量存放在静态存储区,所以它具备持久性默认值0.

    4. 用static声明的函数和变量小结

    static 声明的变量在C语言中有两方面的特征:

    1)、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别
    2)、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别

     
    Tips:
    A.若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度;
    B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度;
    C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题;
    D.
    如果我们需要一个可重入的函数,那么,我们一定要避免函数中使用static变量(这样的函数被称为:带内部存储器功能的的函数)
    E.
    函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时,则必须是static的局部变量的地址作为返回值,若为auto类型,则返回为错指针。

        函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。

    扩展分析:

          术语static有着不寻常的历史.起初,在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后,staticC中有了第二种含义:用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字,所以仍使用static关键字来表示这第二种含义。最后,C++重用了这个关键字,并赋予它与前面不同的第三种含义:表示属于一个类而不是属于此类的任何特定对象的变量和函数(Java中此关键字的含义相同)

    全局变量、静态全局变量、静态局部变量和局部变量的区别

    变量可以分为:全局变量、静态全局变量、静态局部变量和局部变量。

       

        全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序, 当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。 静态全局变量则限制了其作用域, 只在定义该变量的源文件内有效 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用, 因此可以避免在其它源文件中引起错误。

    从以上分析可以看出, 局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域 限制了它的使用范围

    static 函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static),内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数,应该在一个头文件中说明,要使用这些函数的源文件要包含这个头文件

    static全局变量与普通的全局变量有什么区别:static全局变量只初始化一次,防止在其他文件单元中被引用;
    static局部变量和普通局部变量有什么区别:static局部变量只被初始化一次,下一次依据上一次结果值;

    static
    函数与普通函数有什么区别:static函数在内存中只有一份,普通函数在每个被调用中维持一份拷贝
        
    全局变量和静态变量如果没有手工初始化,则由编译器初始化为0。局部变量的值不可知。

    存储区域分,全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域,局部变量存放在内存的栈区
    作用域分,全局变量在整个工程文件内都有效;静态全局变量只在定义它的文件内有效;静态局部变量只在定义它的函数内有效,只是程序仅分配一次内存,函数返回后,该变量不会消失;局部变量在定义它的函数内有效,但是函数返回后失效

    程序的运行结果是:

    global local static
    1  10
    2   9
    3   8
    4   7
    5   6
    6   5
    7   4
    8   3
    9   2
    10  1

     

    3. static的第三个作用是默认初始化为0.其实全局变量也具备这一属性,因为全局变量也存储在静态数据区

         在静态 数据区,内存中所有的字节默认值都是0x00,某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵,我们可以一个一个地把所有元素都置0, 然后把不是0的几个元素赋值。如果定义成静态的,就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用,但又觉得每次在字符数组末尾加‘/0’ 太麻烦。如果把字符串定义成静态的,就省去了这个麻烦,因为那里本来就是‘/0’。不妨做个小实验验证一下。

    程序的运行结果是:

     

     

    展开全文
  • js中变量的作用域

    2018-08-25 15:51:59
    变量定义:可以使用var定义变量,变量如果没有赋值,那变量的初始值为undefined。 全局变量:全局变量也称为外部变量,定义在所有函数之外的变量,不属于哪个函数。其作用域是整个源程序。 局部(函数级)变量: ...

    变量定义:可以使用var定义变量,变量如果没有赋值,那变量的初始值为undefined。
    全局变量:全局变量也称为外部变量,定义在所有函数之外的变量,不属于哪个函数。其作用域是整个源程序。
    局部(函数级)变量:
    使用var定义在函数体内部的变量,只在函数内部有作用,他只能在定义他的函数中使用,超出函数体的范围不能进行使用。
    块级变量:
    let/const 定义变量。
    let定义的是变量,即以后还可以修改变量中的值。
    const定义的是常量,即一旦变量中的值被确定,则以后不能再修改。
    Js 变量声明提升和函数声明提升
    1.变量声明提升

    下面将以一个例子来说明这个问题
            function test() {
                        console.log("循环前:" + i);//undefined
                        for (var i = 5; i >= 0; i--) {
                            console.log("循环中:" + i);//分别输出5 4 3 2 1 0
                        }
                        console.log("循环后:" + i);//-1
                    }
    
                    test();
    
    注:其实变量声明提升就是将所有使用 var 定义的变量声明部分提升到对应作用域的最顶部,变量赋值位置不变。
    提升后的代码为:
            function test() {
                        var i;
                        console.log("循环前:" + i);//undefined
                        for ( i = 5; i >= 0; i--) {
                            console.log("循环中:" + i);//分别输出5 4 3 2 1 0
                        }
                        console.log("循环后:" + i);//-1
                    }
    
                    test();
    
     注:因为变量只声明没有赋值,所以一开始会输出undefined

    函数声明提升:函数分为函数声明方式和函数表达式两种声明方式。即函数也有函数声明提升方式和函数表达式声明提升两种。

      1.函数声明提升:
            var num = 15;
                    changeNum();
                    function changeNum() {
                        console.log(num); // undefined
                        num = 99;
                        console.log(num); // 99
                        var num = 1;
                        console.log(num); // 1
                    }
                        console.log(num); // 15
    
      注:函数声明方式定义的函数,将整体都提升到对应作用域的最顶部。
    2.函数表达式声明提升:
                    var changeNum;
                    var num = 15;
                    changeNum = function () {
                    console.log(num); // undefined
                    num = 99;
                    console.log(num); // 99
                    var num = 1;
                    console.log(num); // 1
                }
    
                changeNum();
                console.log(num); // 15
    
       注:函数表达式的方式定义的函数,则只将变量声明提升到对应作用域的最顶部,变量赋值部分位置不动。
    展开全文
  • '''print(c) print(a)均报错,因为a,c超出了起作用的范围(超出作用域)''' name='杨老师' #name的作用范围为函数内部和外部都可以使用,成为全局变量 print(name) def fun2(): print(name) # 调用函数 fun2() ...
  • Java之路:变量作用域

    千次阅读 多人点赞 2018-12-15 09:50:01
    一旦超出变量的作用域,就无法再使用这个变量。 按作用域范围划分,变量分为成员变量和局部变量。 (1)成员变量 在类体内定义的变量称为成员变量,它的作用域是整个类,也就是说在这个类中都可以访问到定义的这个...
  • 引用变量是一个别名,也就是说,它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量,就可以使用该引用名称或变量名称来指向变量。 引用和指针的区别 引用很容易与指针混淆,它们之间有三个主要的不同: ...
  • 详细内容python全局变量和局部变量的区别全局变量和局部变量的区别在于作用域,全局变量在整个py文件中声明,全局范围内可以使用;局部变量是在某个函数内部声明的,只能在函数内部使用,如果超出使用范围(函数外部)...
  • python全局变量和局部变量的区别全局变量和局部变量的区别在于作用域,全局变量在整个py文件中声明,全局范围内可以使用;局部变量是在某个函数内部声明的,只能在函数内部使用,如果超出使用范围(函数外部),则会...
  • > 局部变量表中的Slot是可重用的,方法体中定义的变量,其作用域并不一定会覆盖整个方法,如果当前字节码PC计算器的值已经超出了某个变量的作用域,那么这个变量对应的Slot就可以交给其它变量使用。 求大神解释下,...
  • 前言学过编程的人应该对全局变量与局部变量这两个名词并不陌生,Python也同多数编程语言一样,也有全局变量与局部变量的概念但是与其他编程语言又有所不同全局变量与局部变量两者的本质区别就是在于作用域用通俗的话...
  • 在方法中使用变量时,如果不指明使用成员变量还是局部变量,那么默认使用局部变量(就近原则),但是如果局部变量超出了它本身的作用域范围则会失效,被JVM垃圾回收,那么则可以重复命名此变量。 public class Test...
  • Python中的全局变量与局部变量的区别 全局变量与局部变量两者的本质区别就是在于作用域 用通俗的话来理解的话, 全局变量是在整个py文件中声明,全局范围内都可以访问 局部变量是在某个函数中声明的,只能在该函数中...
  • 全局变量和局部变量的区别在于作用域,全局变量在整个py文件中声明,全局范围内可以使用;局部变量是在某个函数内部声明的,只能在函数内部使用,如果超出使用范围(函数外部),则会报错。 推荐:Python教程 #!/usr...
  • 任何编程中范围都是程序一个区域,其中定义变量可以存在,并且超出该范围,无法访问它。有三个地方可以用C编程语言声明变量 l 在函数或块内部,称为局部变量。 l 在所有函数之外,称为全局变量。 l 在函数...
  • 全局变量与局部变量两者本质区别就是在于作用域 用通俗话来理解话,全局变量是在整个py文件中声明,全局范围内都可以访问。 局部变量是在某个函数中声明,只能在该函数中调用它,如果试图在超出范围地方...
  • 全局变量与局部变量两者本质区别就是在于作用域 用通俗话来理解话,全局变量是在整个py文件中声明,全局范围内都可以访问。 局部变量是在某个函数中声明,只能在该函数中调用它,如果试图在超出范围地方...
  • 全局变量与局部变量两者本质区别就是在于作用域。 用通俗话来理解话,全局变量是在整个py文件中声明,全局范围内都可以访问。局部变量是在某个函数中声明,只能在该函数中调用它,如果试图在超出范围地方...
  • 前言:Python也同多数编程语言一样,也有全局变量与局部变量的概念, 但是与其他编程语言又有所不同: 全局变量与局部变量两者的本质区别就是在于作用域—— 用通俗的话来理解的话,全局变量是在整个py文件中声明,...

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

局部变量的作用域可以超出