Localising Variables 局部变量

This tutorial will give a brief overview of the defun function and moreover explain why localising variables is a good habit to get into.

By http://lee-mac.com/localising.html

(defun <symbol> ([arguments] [/ variables]) <expressions>)

Here:

• symbol is the name of the function (if prefixed with 'c:' the function may be called from the command line).
• arguments are symbols representing data that the function requires when called (more about these some other time).
• variables are the symbols used to hold data within the function.
• expressions are all the statements that make up the function itself.

Examples:

(defun test ( arg1 arg2 / var1 var2 ) ;; Function taking two arguments, with two local variables

  ;; Expressions
  (setq var1 (* arg1 2.0) var2 (+ arg2 3))

  (print (- var2 var1))
  (princ)
  
) ;; End of defun

(defun c:MyCommand ( / a b c ) ;; Function with three local variables

  (setq a 1.0 b 2 c 3)

  (print (- b (/ a c)))
  (princ)
)

(defun myfunc ( x y ) ... )         ;; Function takes two arguments
(defun myfunc ( / a b ) ... )       ;; Function has two local variables
(defun myfunc ( x / temp ) ... )    ;; One argument, one local variable
(defun myfunc ( ) ... )             ;; No arguments or local variables

What are the Consequences?

Take this example (Notice no variables are localised):

(defun c:test ( )

  (foreach x '(1 2 3 4 5)
    (setq lst (cons x lst))
  )

  (print lst)
  (princ)
)

Return:

(5 4 3 2 1)

if we run the code again, we receive:

(5 4 3 2 1 5 4 3 2 1)

The list has doubled! This is because the variable lst still holds the list data even after the function has completed.

Hence, when evaluated for the second time, new values are added the existing list.

；；x可认为是foreach的形参，调用的时候IDE自动声明为局部变量了。

This certainly highlights one major issue, but what if we had another function, also without localised variables, using the same symbol for a variable name?

(defun c:test1 ( )

  (foreach x '("1" "2" "3" "4" "5")
    (setq lst (cons x lst))
  )

  (print lst)
  (princ)
)

Upon running the above code, we now have a list containing a mixture of data types：

("5" "4" "3" "2" "1" 5 4 3 2 1 5 4 3 2 1)

To avoid these issues, we localise the variables:

(defun c:test ( / lst )

  (foreach x '(1 2 3 4 5)
    (setq lst (cons x lst))
  )

  (print lst)
  (princ)
)