LISP lokale/Globale variable Zuordnung

Wenn wir eine Funktion definieren, die so etwas wie

(defun foo(x)
  (setf x somevalue))

Ist x definiert als eine lokale variable oder global??? mit setf/q ist der Wert global sein.
wenn es global ist, kann mir jemand sagen, wie definieren Sie eine lokale variable in lisp andere als let?

Dank!

Betrachten Sie das folgende Beispiel

(let ((x 0)) 
  (defun foo (y) 
    (when (equal x 0) (setq x y)) 
    (when (< x y) (setq x y))
    x))

wenn ich gebe ein wenig input zu foo wie (foo 2) es ist wieder 2 und wenn wir führen Sie die Funktion erneut mit (foo 1) es noch gibt 2 zurück, und (foo 3) 3 gibt.Dies ist, was ich wirklich wollen, es zu tun.Aber die Frage ist, wie ist dies möglich, weil, wenn ich versuche, auf die variable x außerhalb der Funktion aus der clisp-terminal, ich bin nicht in der Lage.Wenn ich Zugriff auf die Funktion erneut, es scheint, behalten den bisherigen Wert von x.

danke!

InformationsquelleAutor Sid | 2012-09-08

common-lisp lisp

8

Parallelen zu ziehen zu anderen Sprachen wie C, C++, Java oder Python, was Ihr code änderungen ist eine "lokale variable", auch wenn dies nicht eine Formulierung, die ein Lisper verwenden würde (die Formulierung im Lisp-Jargon wäre eine lokale "Bindung").

Können Sie zum erstellen von lokalen Variablen durch die Verwendung von Funktionsparametern wie dein Beispiel ist, oder mit einige standard-Formen wie:
- (let ((x 12)) ...)
- (do ((x 0 (1+ i))) ...)
- (dotimes (x 10) ...)
- (loop for x from 0 to 10 do ...)
Auf der anderen Seite ist es möglich, dass bei Ihrer Umsetzung alle lokalen Variablen erzeugt werden, indem Parameter und andere Formen sind einfach Makros zu erweitern, dass. Zum Beispiel:
```
(let ((x 10)) ...)
```
entspricht
```
(funcall (lambda (x) ...) 10)
```
Beachten Sie auch, dass in der Tat Lesen Sie Ihre code-fragment ist es möglich, dass x ist in gewissem Sinne eine "Globale variable", weil es hätte deklariert special:
```
(defvar x 12)
;; ==> x

(defun bar ()
  (format t "The value of x is ~a" x))
;; ==> bar

(defun foo (x)
  (bar))
;; ==> foo

(foo 42)
The value of x is 42
;; ==> NIL

x
;; ==> 12
```
Wenn Sie eine variable deklarieren, die "special" mit (defvar ...) wird es anders gehandhabt werden: es ist wie jedes mal, wenn Sie es als parameter, oder verwenden Sie es in einem (let ..) form, was der code tun ist, speichern Sie den aktuellen Wert mit dem neuen Wert zur Verfügung gestellt und dann wiederherstellen der Wert nach verlassen der Funktion oder let.

Also diese Variablen sind sowohl "global" (weil die äußeren Funktionen, die Sie sehen kann), aber auch lokale (weil nach Ihrer Funktion oder lassen Sie beendet, wird der Vorherige Wert wiederhergestellt wird).

Der Konvention ist der name der speziellen Variablen, die mit "Ohrenschützer", d.h. mit einem Stern sowohl am Anfang und am Ende der Namen wie:
```
(defvar *x* 12)
```
Dies hilft, wer liest deinen code zu verstehen, dass die variable special. Beachten Sie, dass dies jedoch nicht zwingend durch die Sprache und jeder name kann verwendet werden, für eine Besondere variable.

Es gibt nichts vergleichbares, um spezielle Variablen in C, C++, Java oder Python.

Einer letzten Anmerkung über setq und setf. Dinge sind ein bisschen schwierig hier, weil Sie müssen verstehen, den unteren Ebenen von Lisp um zu sehen, warum setq benötigt wird. Wenn Sie mit Common Lisp, dann sollten Sie einfach vergessen setq und verwenden Sie immer setf.

setf ist ein makro, das expandiert wird setq bei Bedarf (jedoch auch setq ändern können, in setf bei Bedarf (symbol Makros), und dies ist, wo die Dinge bekommen kann verwirrend für einen Neuling).

Ihre Letzte Beispiel ist ein Fall einer "Schließung". Wenn Sie eine Funktion definieren (entweder benannt oder Unbenannt mit einem (lambda ...) form) kann die Funktion "capture", die Variablen, die sichtbar sind, und verwenden Sie Sie später. Ein einfacher Fall oft gezeigt wird, ist die "adder":
```
(defun adder (x)
  (lambda (y) (incf x y)))
```
diese Funktion liefert eine Funktion, halten das hinzufügen der übergebene Wert an einen internen Zähler:
```
(let ((f (adder 10)))
  (print (funcall f 3))
  (print (funcall f 9))
  (print (funcall f 11)))
```
ist die Ausgabe 13 (10 + 3), 22 (13 + 9) und 33 (22 + 11).

Die anonyme Funktion "eingefangen" wird die lokale variable x und können es auch nach dem beenden des adder Funktion. In Sprachen wie C, C++ oder Java eine lokale variable kann nicht überleben, wenn Sie verlassen Sie den Bereich, der definiert die variable.

C++11 hat Unbenannte Funktionen, aber immer noch Variablen nicht erfasst werden können und überleben den Rahmen (Sie kopiert werden kann auf lokale Variablen der Unbenannte Funktion, aber das ist nicht das gleiche).
- vielen Dank!!! können Sie mir helfen mit diesem code was mich band an meinem Kopf zu einer Wand: ((mal (x nil) (defun (y)
- das gilt nicht, lisp code (Klammern sind auch nicht symmetrisch): sprechen Sie darüber, dass eine (defun ...) Formular innerhalb eines (let ...) form? Wenn Sie Fragen zu common lisp im IRC-channel #lisp hilfreich sein kann, die (webchat.freenode.net)
- ich habe bearbeitet die Frage ein bisschen mit einem weiteren Beispiel.Kannst du bitte einen Blick drauf werfen?Danke!!!sorry für die Mühe
- Danke.Ich werde tun einige googeln auf lisp closure.Vielen Dank für die Hilfe wieder 🙂
- also in anderen Worten,für lisp, alle "lokale Variablen" sind immer in der Sprache der ((x) => {/*yay, I has a local binding */})(x)?
InformationsquelleAutor 6502
4

Eigentlich x ist lokal zur Funktion, so setf oder setqing, es ändert sich nur die lokale variable x.

Beantworten, den zweiten Teil Ihrer Frage, es ist ein weiterer Weg, um eine lokale variable definieren andere als gelassen:
```
(funcall (lambda (var1 var2...)
           ... use var1 var2 ...)-
   val1 val2 ...)
```
In der Tat defun umgesetzt werden könnten
```
`(setf (symbol-function ,name) (lambda ,args ,@body))
```
obwohl alle Implementierungen, die ich geprüft habe mehr als das tun.

Auch, die symbol-function Ort ermöglicht es Ihnen, dies zu tun:
```
(setf (symbol-function '+) (function -))
```
aber das ist allgemein eine schlechte Idee.

Ihre zweite Frage

Was dort passiert, ist, dass x ist lokal auf den Bereich, der enthält die defun. Es ist nicht eine Globale variable. Was du tust mit, dass defun ist die Schaffung einer Schließung, die "fängt" alle die lexikalisch-Bereich (nicht mit erstellt defvar/defparameter) Variablen in die umliegenden Bereiche und hält Sie für die Zukunft. Wenn Sie wollen, um zu überprüfen, den Wert der x, fügen Sie eine weitere Funktion
```
(defun get-x () x)
```
innerhalb der let. Um es anders auszudrücken, x lokalen let ist, dass die Funktion in. Die situation Sie haben die ähnlich ist:
```
(let ((x 3))
    (print x)
    (let ((y 7))
        (print (list x y))
        (setf x y))
    (print x))
```
außer der inneren let wird ersetzt durch eine defun (das ist ein lambda).

InformationsquelleAutor krzysz00
0

In Ihrem code x ist ein parameter für die f Funktion und somit lokal zu der Funktion. Der Aufruf setf erstellt keine neue variable, sondern stellt einfach den Wert der bestehenden lokalen Variablen x. Mit setq statt setf würde dasselbe Verhalten.

InformationsquelleAutor sepp2k

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Ihre zweite Frage