Lua初识之局部变量与代码块

num = 10  -- 声明全局变量 num
local i = 1  -- 声明局部变量 i

while i <= num do
    local num = i * 2;  -->声明局部变量 num
    print("local num = " .. num) --> 2 4 6 8 ..
    i = i + 1 
end  
--在while语句块内改变的 num 为 local num 的值，全局的num的值不发生变化

print("num = " .. num)  --> 10
--> 11 local i 的值在while发生了变化
print("i = " .. i)  

if ( i > 20) then --> i = 11 条件不成立
    local num
    num = 5
    print("num = " .. num) -->  
else
    print("num  " .. num)  --> 10
end

-- 如果在交互模式下可能不会输出期望的结果，因为第二句的 local num是一个完整的chunk
--在交互模式下执行完这一句后，Lua将开始一个新的chunk，这样第二句的i已经
-- 超出了他的有效范围，可将这句放 do .. end 块中
-- 为了避免调用变量值发生冲突，访问局部变量的速度比全局变量更快


do
    local a1 = 3;
    local a2 = 6;
 
    x1 = a1 * 2  --全局变量 x1
    x2 = a2 * 3  --全局变量 x2
 
    print("x1 = " .. x1) --> 6
    print("x2 = " .. x2) -->18
end

-- 该句报错，因为找不到 a1 的赋值，所以 a1的值为nil
--print("a1 = " .. a1) 

-- 该句报错，同上
--print("a2 = " .. a2) 

print("x1  " .. x1) --> 6
print("x2  " .. x2) --> 18

-- 该例子说明 a1和a2 为局部变量，只在 do .. end 范围内有效，
-- x1 和 x2 为全局变量，在全局都有效
-- 所以想定义一个局部变量最好写在 do .. end 块、 while 、 for 或者 if end等语句块内


使用local创建一个局部变量，与全局变量不同，局部变量只在被声明的那个代码块内有效。代码块：指一个控制结构内，一个函数体，或者一个chunk（变量被声明的那个文件或者文本串）。

x = 10
local i = 1              -- local to the chunk
 
while i<=x do
    local x = i*2        -- local to the while body
    print(x)             --> 2, 4, 6, 8, ...
    i = i + 1
end 
 
if i > 20 then
    local x              -- local to the "then" body
    x = 20
    print(x + 2)
else
    print(x)             --> 10  (the global one)
end
 
print(x)                 --> 10  (the global one)

注意，如果在交互模式下上面的例子可能不能输出期望的结果，因为第二句local i=1是一个完整的chunk，在交互模式下执行完这一句后，Lua将开始一个新的chunk，这样第二句的i已经超出了他的有效范围。可以将这段代码放在do..end（相当于c/c++的{}）块中。

应该尽可能的使用局部变量，有两个好处：


1. 避免命名冲突


2. 访问局部变量的速度比全局变量更快.

我们给block划定一个明确的界限：do..end内的部分。当你想更好的控制局部变量的作用范围的时候这是很有用的。

do
    local a2 = 2*a
    local d = sqrt(b^2 - 4*a*c)
    x1 = (-b + d)/a2
    x2 = (-b - d)/a2
end            -- scope of 'a2' and 'd' ends here
 
print(x1, x2)

原文：LUA一个小巧脚本语言学习笔记

           LUA教程局部变量与代码块（block）-14

1 变量
1.1  概念
可以改变的数，称为变量。在Java语言中，所有的变量在使用前必须声明。

一般通过“变量类型 变量名 = 变量值 ;”这三部分来描述一个变量。如:int a = 3 ;

变量的使用原则：就近原则,即尽量控制变量的使用范围到最小
1.2  局部变量
位置:定义在方法里或者局部代码块中

注意:必须手动初始化来分配内存.如:int i = 5;或者int i; i = 5;

作用域:也就是方法里或者局部代码块中,方法运行完内存就释放了
1.3  成员变量
位置:定义在类里方法外

注意:不用初始化,也会自动被初始化成默认值

作用域:整个类中,类消失了,变量才会释放


1.4  练习：变量的默认值测试
创建包: cn.tedu.basic

创建类: TestVariable1.java
package cn.tedu.design;
/*本类用于测试各种类型变量的默认值*/
public class TestVariable1 {
        static String name;
        static byte b;//整数类型默认值都是0
        static short c;
        static int d;
        static long e;
        static float f;//小数类型的默认值是0.0
        static double g;
        static char j;//char类型的默认值是\u0000
        static boolean h;//boolean类型的默认值是false

        public static void main(String[] args) {
            System.out.println(name);//null,引用类型的默认值
            System.out.println(b);
            System.out.println(c);
            System.out.println(d);
            System.out.println(e);
            System.out.println(f);
            System.out.println(g);
            System.out.println(h);
            System.out.println(j);
            System.out.println(h);
        }
    }

1.5  练习：局部变量与成员变量测试
创建包: cn.tedu.basic

创建类: TestVariable2.java
package cn.tedu.oop;
/**本类用于测试变量的使用*/
public class TestVariable2 {
    //2.定义成员变量:
    //1)位置:类里方法外
    //2)无需手动初始化,会自动赋予对应类型的默认值
    //3)作用域:在整个类中生效,类消失,变量才会消失
    static int count;
   
    //3.变量有一个使用的原则:就近原则
    static int sum = 200;
    public static void main(String[] args) {
        //1.定义局部变量:
        //1)位置:在方法里/局部代码块里
        //2)必须手动初始化
        //3)作用域:在方法/局部代码块中,对应的代码执行完局部变量就被释放
        int sum = 100;//定义在方法中的局部变量sum
        System.out.println(sum);//变量的就近原则:使用的都是自己附近的变量,100
        System.out.println(count);
       
        for (int i = 0; i < 10; i++) {//局部变量i只能在循环中使用
            System.out.println(i);
        }
        //System.out.println(i);//报错:无法引用变量i:i cannot be resolved to a variable
    }
}

2 方法
2.1  概述
被命名的代码块,方法可以含参数可以不含参数,可以提高代码的复用性。
2.2  方法定义的格式

2.3 方法调用顺序图
顺序执行代码,调用指定方法,执行完毕,返回调用位置


2.4 练习:测试方法的调用顺序/参数/返回值
创建包:cn.tedu.method

创建类:TestMethod .java
package cn.tedu.method;
/**本类用于测试方法*/
public class TestMethod {
	//1.创建程序的入口函数main()
	public static void main(String[] args) {
		System.out.println(1);
		/**2.我们通过方法名+参数列表的方式来调用方法的功能*/
		method1();//调用method1()
		System.out.println(2);
		method2(3);//调用method2()
		int result = method3(1,2);//调用method3()
		System.out.println(result);
	}

	/**3.如果方法想要返回值,必须修改返回值类型
	 * 并且return对应类型的结果
	 * 如果方法的返回值类型是void,不允许有返回值
	 * */
	/*本方法用来测试方法的返回值类型*/
	public static int method3(int i, int j) {
		/**4.通过return关键字将方法结果返回到调用位置*/
		return i+j;
	}

	/**1.方法的修饰符 方法的返回值类型 方法名(方法参数){方法体}*/
	/*method1()想测试方法的调用顺序*/
	public static void method1() {
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
	}
	
	/*本方法用来测试方法的参数,参数的位置在小括号里*/
	public static void method2(int a) {
		System.out.println("海绵宝宝今年:"+ a +"岁啦~");
	}	
}

2.5 方法的重载
方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同(也就是指参数的个数和类型不同),程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.
2.6 练习：测试方法的重载
创建包: cn.tedu.method

创建类: TestMethodOverload.java
package cn.tedu.method;
/**本类用于测试方法的重载*/
public class TestMethodOverload {
	public static void main(String[] args) {
		/**1.我们根据方法名+参数列表确定具体调用哪个方法*/
		/**2.方法的重载:
		 * 在同一个类中,存在方法名相同,但参数列表不同的方法
		 * 如果在同类中,同名方法的参数个数不同,一定构成重载
		 * 如果在同类中,同名方法的参数个数相同,
		 * 需要查看对应位置上参数的类型,而不是参数名,与参数名无关
		 * (int a,String b)与(int b,String a)--不构成重载
		 * (int a,String b)与(String a,int b)--构成重载
		 * */
		//2.调用method()
		method();
		//4.调用method(int)
		method(666);
		//6.调用method(int,String)
		method(888,"泡泡");
	}

	//1.创建一个无参的method()
	public static void method() {
		System.out.println("哈哈哈哈我没参数");
	}
	//3.创建一个method(int n)
	public static void method(int n) {
		System.out.println("哈哈哈哈我的参数是:"+n);
	}
	//5.创建一个method(int n,String s)
	public static void method(int a,String b) {
		System.out.println(b+"今晚要干他"+a+"碗大米饭");
	}
	public static void method(String a,int b) {
		System.out.println(b+"今晚要干他"+a+"碗大米饭");
	}
}

局部变量：在函数内部（代码块内部）声明的变量，也称为“自动变量”，进入代码块创建，退出代码块销毁
#include<stdio.h>
int fun()
{
	int a = 19;
	{
		int a = 20;
		{
			int a = 21;
			printf("%d\n", a);    //21，局部优先，但只在当前代码块起作用，出代码块就销毁。
		}
		printf("%d\n", a);     //20，局部优先，但只在当前代码块起作用，出代码块就销毁。

		return a;
	}
}
int main()
{
	int word = 0;
	int a=0;
	word = fun(a);
	system("pause");
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
int main()
{
	printf("hello\n");
	int num = 20;       //（不同平台下可能会）出现error，C语言中变量声明必须放在在当前代码块的最前面，不是所有代码块的最前面
	printf("%d", num);
	system("pause");
	return 0;
}
在局部变量之前加上static（静态变量）放在不同的位置：
#include<stdio.h>
void fun()
{
	int i = 0;
	static int num = 0;
	for (i = 0; i < 10; i++)
	{
		num++;
		printf("%d\n", num);  //1,2,3,4,5,6,7,8,9,10
	}
}
int main()
{
	fun();
	system("pause");
	return 0;
}
#include<stdio.h>
void fun()
{
	int i = 0;
	
	for (i = 0; i < 10; i++)
	{
		static int num = 0;  //初始化num，只执行一次，num是一个静态变量，创建后不再销毁，直到程序当前代码块结束
		num++;
		printf("%d\n", num);  //1,2,3,4,5,6,7,8,9,10
	}
}
int main()
{
	fun();
	system("pause");
	return 0;
}
<pre class="objc" name="code">#include<stdio.h>
void fun()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		int num = 0;     num是局部变量，每次进入循环时创建，出代码块时销毁
		num++;
		printf("%d\n", num); //1,1,1,1,1,1,1,1,1,1
	}
}
int main()
{
	fun();
	system("pause");
	return 0;
}


#include<stdio.h>
void fun()
{
	int i = 0;
	static int num = 0;
	for (i = 0; i < 10; i++)
	{
		num = 0;   //赋值，不管num的值是多少，进入循环后，每次都会被赋值为0.
		num++;
		printf("%d\n", num); 1,1,1,1,1,1,1,1,1,1
	}
}
int main()
{
	fun();
	system("pause");
	return 0;
}
#include<stdio.h>
int main()
{
	void fun(void);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		fun();   //调用fun函数，j是局部变量，调用一次，销毁一次，每次调用，重新创建
	}
	printf("\n");
	system("pause");
	return 0;
}
void fun(void)
{
	int j = 0;
	j++;
	printf("%d ", j);   //1,1,1,1,1,1,1,1,1,1
}
#include<stdio.h>
int main()
{
	void fun(void);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		fun();  //j是一个静态变量，创建后，直到程序当前代码块结束时销毁
	}
	printf("\n");
	system("pause");
	return 0;
}
void fun(void)
{
	static int j = 0;
	j++;
	printf("%d ", j);  //1,2,3,4,5,6,7,8,9,10
}
#include<stdio.h>
int main()
{
	void fun(void);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		fun();
	}
	printf("\n");
	system("pause");
	return 0;
}
static int j = 0;
void fun(void)
{
	j = 0;   //赋值，每次调用都会给j赋值为1
	j++;
	printf("%d ", j);    //1,1,1,1,1,1,1,1,1,1
}   


形式参数：把定义声明在函数参数里面,也相当于局部变量，只对当前代码块起作用。使用完成后自动销毁
#include<stdio.h>
int is_in(char *s, char c)  //*s和c都属于形式参数
{
	while (*s)
	if (*s == c)
	{
		printf("exist");
		return 1;
	}	
	else
	{
		s++;
	}
		
	return 0;
}
int main()
{
	char *p = "abcdef";
	char c = 'd';
	is_in(p, c);
	system("pause");
	return 0;
}

全局变量：所有在代码块之外（{}大括号之外）定义的变量，当全局变量与局部变量冲突时，局部优先。
#include<stdio.h>
int a = 20;
int b;    //声明
int fun1()
{
	printf("b=%d", b);  //20
	return 0;
}
int b = 30;  //定义，b在所有代码块的外部，是一个全局变量，对程序所有代码块起作用，所以fun1可以调用，但需要提前声明
int fun2()
{
	return 1;
}
int main()
{
	fun1();
	system("pause");
	return 0;
}