[日积月累]：对变量、函数、局部、全局等概念的肤浅认识

snoopychen

对变量、函数、局部、全局等概念的肤浅认识
qjchen
前段时间论坛有过一个函数变量的讨论，让我感触颇深
最近又编了一个很长很长的代码，
因此对变量，函数，局部，全局等概念觉得有必要比较认真的反思一下

于是，做了如下的一些测试，得到了一些体会
由于我是业余编程，本来就是靠蛮劲在编程的，二来Lisp这种语言的函数和变量是同一概念，搞得自己也比较模糊
因此得到的这些看法很肤浅，各位可能早就思考过了，见笑见笑
各位可以先看代码，估算一下结果，假如各位估算全对的话，就完全不用看了，都是很简单的东西

1）当一个函数没有终结的时候，这个函数内的局部变量可以被其他子程序所调用。
这个问题的范例代码是：

2. 
   
3. (defun c:test (/ a b)
   
4.   (setq a 1
   
5.             b 2
   
6.   )
   
7.   (fun 0 1)
   
8. )
   
9. 
   
10. (defun fun (x y)
    
11.   (+ (+ x a) (+ y b))
    
12. )
    

<br /> (defun c:test (/ a b)<br />   (setq a 1<br />             b 2<br />   )<br />   (fun 0 1)<br /> )<br /> <br /> (defun fun (x y)<br />   (+ (+ x a) (+ y b))<br /> )<br />

我原来一直以为中途跑出test去fun中，局部变量会丢失，现在看起来是错误的。
只要这个程序没有终结，里面的各种变量都存在内存空间，只有程序终结了，变量才被清空。

2）在defun里面的定义为局部变量的defun函数不能被其他函数调用
这个问题的范例代码是：

2. 
   
3. (defun c:test ()
   
4.   (setq x (ee 2))
   
5. )
   
6. 
   
7. (defun fun1 ()
   
8.   (defun ee (x)
   
9.     (+ x 6)
   
10.   )
    
11. )
    

<br /> (defun c:test ()<br />   (setq x (ee 2))<br /> )<br /> <br /> (defun fun1 ()<br />   (defun ee (x)<br />     (+ x 6)<br />   )<br /> )<br />

可以看出是没有结果的，以前不大明白为什么要把一段那么长的defun写在别的defun里面，
现在觉得可能有些作用，起码这些函数不会和别的变量或者函数同名，而且可能也起到节省内存空间的作用。
这个可以通过在命令行输入!fun1和!ee来认知

3）其实Lisp里面的函数和变量几乎都是一样的，可能这就是Lisp的本质吧，一种表结构的语言

2. 
   
3. (defun c:test (/ x)
   
4.   (setq x (fun1 5))
   
5. (princ "\n               x = ") (princ x);Erase_DV
   
6. (getstring "\nPress Enter to continue...");Erase_DV
   
7.   (setq xx (eee 6))
   
8. (princ "\n              xx = ") (princ xx);Erase_DV
   
9. (getstring "\nPress Enter to continue...");Erase_DV
   
10. )
    
11. 
    
12. (defun fun1 (y)
    
13.   (defun eee (x)
    
14.     (+ x 6)
    
15.   )
    
16.   (eee y)
    
17. )
    

<br /> (defun c:test (/ x)<br />   (setq x (fun1 5))<br /> (princ "\n               x = ") (princ x);Erase_DV<br /> (getstring "\nPress Enter to continue...");Erase_DV<br />   (setq xx (eee 6))<br /> (princ "\n              xx = ") (princ xx);Erase_DV<br /> (getstring "\nPress Enter to continue...");Erase_DV<br /> )<br /> <br /> (defun fun1 (y)<br />   (defun eee (x)<br />     (+ x 6)<br />   )<br />   (eee y)<br /> )<br />

可以看出，是都有结果的，所以呢，刚才（2）中提到的defun中的defun不能被其他程序调用的情况要加适用条件了
这个适用条件就是“局部变量”
在这个例子中，假如先调用eee的话是不行的，但是先调用了fun1之后，eee由于不是fun1的局部变量，
就存在了内存空间了，没有被清除

4）传递变量在函数终结时被清空

2. 
   
3. ;;---------------------------------
   
4. (defun c:test ()
   
5.   (setq a 5
   
6.         b 6
   
7.   )
   
8.   (setq c (fun2 1 2))
   
9. (princ "\n               a = ") (princ a);Erase_DV
   
10. (princ "\n               b = ") (princ b);Erase_DV
    
11. (getstring "\nPress Enter to continue...");Erase_DV
    
12.   
    
13. )
    
14. (defun fun2 (a b)
    
15. (princ "\n               a = ") (princ a);Erase_DV
    
16. (princ "\n               b = ") (princ b);Erase_DV
    
17. (getstring "\nPress Enter to continue...");Erase_DV
    
18.   (list (+ a 1) (+ b 2))
    
19. )
    

<br /> ;;---------------------------------<br /> (defun c:test ()<br />   (setq a 5<br />         b 6<br />   )<br />   (setq c (fun2 1 2))<br /> (princ "\n               a = ") (princ a);Erase_DV<br /> (princ "\n               b = ") (princ b);Erase_DV<br /> (getstring "\nPress Enter to continue...");Erase_DV<br />   <br /> )<br /> (defun fun2 (a b)<br /> (princ "\n               a = ") (princ a);Erase_DV<br /> (princ "\n               b = ") (princ b);Erase_DV<br /> (getstring "\nPress Enter to continue...");Erase_DV<br />   (list (+ a 1) (+ b 2))<br /> )<br />

可以看出fun2中的a b在fun2结束之后就不复存在了，所以传递变量只是临时存在这个引用函数中，与其他变量同名也无妨


5）总结
在写了上面一堆东西之后，好像突然间想通了，又好像白写了，这个应该就是认知的曲折过程吧
只要掌握了－－－Lisp中变量和函数是等同的，局部变量（函数）在函数结束后才被清空，全局变量则在关闭图形时清空，
传递变量不影响同名变量 这几个原则，理解起来就轻松一些了。
一时间的乱写，不对之处请指正。
我也会继续做测试。

dwg001

关键概念的梳理比一个有用的程式重要百倍，多谢楼主分享。菜鸟期待着您的继续测试的精彩篇章。

雨箭风刀

怎么冒出个传递变量？

snoopychen

谢谢刀兄，这个就是我业余的很的地方了，连名称都是这么的业余，脸红。
查了一下fortran中的，defun fun(a b / c d)中的a b 好像是叫做虚参，主要是做数据传递的
不知道Lisp里面怎么称呼，是叫全局变量还是局部变量好呢。还是直接叫它参数好？
谢谢啊谢谢

ll_j

Lisp中就称“参数”，也有称作“变元”的。

看一个例子：

2. 
   
3. (setq X '((1 2) (3 5)))          ;设置变量x
   
4. (mapcar                           ;遍历，对象为上面设定的X
   
5.    '(lambda(x)                    ;以x为参数1
   
6.       (mapcar                     ;对参数1x遍历，对象为X的表元素
   
7.         '(lambda(x)               ;以x为参数2
   
8.            (+ 1 x)                   ;对参数2运算
   
9.         )                               ;end lambda
   
10.        x                               ;参数1
    
11.      )                                  ;end mapcar
    
12.     )                                   ;end lambda
    
13.   x                                    ;遍历的对象：X
    
14. )                                       ;end mapcar
    

<br /> (setq X '((1 2) (3 5)))          ;设置变量x<br /> (mapcar                           ;遍历，对象为上面设定的X<br />    '(lambda(x)                    ;以x为参数1<br />       (mapcar                     ;对参数1x遍历，对象为X的表元素<br />         '(lambda(x)               ;以x为参数2<br />            (+ 1 x)                   ;对参数2运算<br />         )                               ;end lambda<br />        x                               ;参数1<br />      )                                  ;end mapcar<br />     )                                   ;end lambda<br />   x                                    ;遍历的对象：X<br /> )                                       ;end mapcar<br />

返回：'((2 3) (4 6))
Lisp中大小写是不分的，上面的X只是为了看明白些，以上设置的值、两级使用的参数都是x，运行仍然正常，说明参数x只是一个“临时符号”，使用后会自动立即清除。

最后检查x的值： !x
返回：'((1 2) (3 5))

jx2008

2楼：
关键概念的梳理比一个有用的程式重要百倍，多谢楼主分享。菜鸟期待着您的继续测试的精彩篇章。

但是光是概念的抽象的理论也不行啊，还得具体的形象地，所以需要一些程序例子才能更加理解透彻。

north911

(defun c:test (/ a b)
  (setq a 1
            b 2
  )
  (fun 0 1)
  (+ a b)
)
(defun fun (x y / a b)
  (setq a 3 b 4)
  (+ (+ x a) (+ y b))
)
在fun里a   b就是3   4      在test里a   b就是1   2
意思就是在fun里定义了a   b，则a   b就用fun里面的值，没定义就是test里的变量
有点意思

cr432202

以前学的LISP语言不用都已经忘记了,现在我也在慢慢回忆中