Quelle est la différence entre eq, eql, égal et égal dans Common Lisp? Je comprends que certains d’entre eux vérifient les types, certains d’entre eux vérifient tous les types, mais lequel est lequel? Quand est-il préférable d'utiliser les uns que les autres?
Réponses
Trop de publicités?
De Common Lisp: Des Prédicats D'Égalité
(eq x y) est vrai si et seulement si x et y sont le même objet.
Le eql prédicat est vrai si ses arguments sont de l'égaliseur, ou si ce sont des nombres du même type avec la même valeur, ou si elles sont de caractère des objets qui représentent le même personnage.
L'égalité de prédicat est vrai si ses arguments sont structurellement similaires (isomorphe) des objets. Un principe de base est que les deux objets sont égaux si et seulement si leurs imprimés représentations sont les mêmes.
Les deux objets sont equalp si ils sont égaux; s'ils sont des personnages et de satisfaire char-égalité, qui ignore alphabétique de cas et de certains autres attributs de caractères; si ce sont des nombres et ont la même valeur numérique, même si elles sont de différents types; ou s'ils ont des composants qui sont tous equalp.
Voici quelques exemples à partir de la même page, j'ai lié ci-dessus:
(eq 'a 'b) is false.
(eq 'a 'a) is true.
(eq 3 3) might be true or false, depending on the implementation.
(eq 3 3.0) is false.
(eq 3.0 3.0) might be true or false, depending on the implementation.
(eq #c(3 -4) #c(3 -4))
might be true or false, depending on the implementation.
(eq #c(3 -4.0) #c(3 -4)) is false.
(eq (cons 'a 'b) (cons 'a 'c)) is false.
(eq (cons 'a 'b) (cons 'a 'b)) is false.
(eq '(a . b) '(a . b)) might be true or false.
(progn (setq x (cons 'a 'b)) (eq x x)) is true.
(progn (setq x '(a . b)) (eq x x)) is true.
(eq #\A #\A) might be true or false, depending on the implementation.
(eq "Foo" "Foo") might be true or false.
(eq "Foo" (copy-seq "Foo")) is false.
(eq "FOO" "foo") is false.
(eql 'a 'b) is false.
(eql 'a 'a) is true.
(eql 3 3) is true.
(eql 3 3.0) is false.
(eql 3.0 3.0) is true.
(eql #c(3 -4) #c(3 -4)) is true.
(eql #c(3 -4.0) #c(3 -4)) is false.
(eql (cons 'a 'b) (cons 'a 'c)) is false.
(eql (cons 'a 'b) (cons 'a 'b)) is false.
(eql '(a . b) '(a . b)) might be true or false.
(progn (setq x (cons 'a 'b)) (eql x x)) is true.
(progn (setq x '(a . b)) (eql x x)) is true.
(eql #\A #\A) is true.
(eql "Foo" "Foo") might be true or false.
(eql "Foo" (copy-seq "Foo")) is false.
(eql "FOO" "foo") is false.
(equal 'a 'b) is false.
(equal 'a 'a) is true.
(equal 3 3) is true.
(equal 3 3.0) is false.
(equal 3.0 3.0) is true.
(equal #c(3 -4) #c(3 -4)) is true.
(equal #c(3 -4.0) #c(3 -4)) is false.
(equal (cons 'a 'b) (cons 'a 'c)) is false.
(equal (cons 'a 'b) (cons 'a 'b)) is true.
(equal '(a . b) '(a . b)) is true.
(progn (setq x (cons 'a 'b)) (equal x x)) is true.
(progn (setq x '(a . b)) (equal x x)) is true.
(equal #\A #\A) is true.
(equal "Foo" "Foo") is true.
(equal "Foo" (copy-seq "Foo")) is true.
(equal "FOO" "foo") is false.
(equalp 'a 'b) is false.
(equalp 'a 'a) is true.
(equalp 3 3) is true.
(equalp 3 3.0) is true.
(equalp 3.0 3.0) is true.
(equalp #c(3 -4) #c(3 -4)) is true.
(equalp #c(3 -4.0) #c(3 -4)) is true.
(equalp (cons 'a 'b) (cons 'a 'c)) is false.
(equalp (cons 'a 'b) (cons 'a 'b)) is true.
(equalp '(a . b) '(a . b)) is true.
(progn (setq x (cons 'a 'b)) (equalp x x)) is true.
(progn (setq x '(a . b)) (equalp x x)) is true.
(equalp #\A #\A) is true.
(equalp "Foo" "Foo") is true.
(equalp "Foo" (copy-seq "Foo")) is true.
(equalp "FOO" "foo") is true.
skypher
Points
2158
Quelques remarques:
La plupart des CL fonctions utilisent implicitement EQL lorsque aucun test n'est spécifié
Voir aussi la CHAÎNE de l'ÉGALITÉ, = et ARBRE ÉGAL
Au cœur de l'ÉGALISEUR est généralement un pointeur de comparaison
Et un rough guide:
À comparer à... l'Utilisation... Les objets/les Structures de l'ÉGALISEUR NUL EQ (mais la fonction NULLE est plus concis et sans doute moins cher) T EQ (ou seulement la valeur, mais alors vous n'avez pas de soins pour le type) Les chiffres précis EQL Flotteurs = Caractères EQL ou CHAR-ÉGALITÉ Listes, Conses, des Séquences EQ (si vous le souhaitez exactement le même objet) L'ÉGALITÉ (si vous venez de soins sur les éléments) Les chaînes de l'ÉGALITÉ (sensible à la casse), EQUALP (insensible à la casse) La CHAÎNE de l'ÉGALITÉ (si vous jetez des symboles dans le mélange) Les arbres (listes de listes) de l'ARBRE-l'ÉGALITÉ (avec les :TEST argument)
Notez que pour plus d'efficacité généralement EQ >> EQL >> l'ÉGALITÉ >> EQUALP.
A.s. Bhullar
Points
466
À partir d' ici et de mon professeur de diapositives
eq tests pour voir si ses arguments(représenté par le même bloc de mémoire de l'ordinateur) sont même symbole ou pas.
Par Exemple:
(eq ‘A ‘B) NÉANT
(eq ‘RAM ‘RAM) T
(eq (cons 'a 'b) (cons' b')) ; C'est parce que les différents appels sont effectués pour les deux inconvénients, de sorte qu'ils seront évidemment alloué différents segments de mémoire
eql premiers tests pour voir si ses arguments satisfaire EQ, si non, essaie de voir si ils sont des nombres de même type et de même valeur.
Par Exemple:
(eql 4 4.0) NÉANT
(eql 4 4) T
Maintenant remarque une différence:
(eq 4.0 4.0) NÉANT ;Dépendre de la plate-forme comme décrit dans la première (accepté)répondre
(eql 4.0 4.0) T ;le type et la valeur des arguments en est de même de
Dans certaines implémentations (eq 4.0 4.0) peut renvoyer vrai, car il n'est pas spécifié dans la norme si une mise en œuvre doit conserver une copie de chiffres et de caractères dans la mémoire, comme il le fait avec des symboles).En règle générale, ne pas utiliser l'égaliseur sur les chiffres et les caractères, sauf si vous savez vraiment ce que vous faites.
l'égalité est un "plus saine" fonction de comparaison. En règle générale, vous pouvez penser que vous dire si deux objets ont la même apparence (structurellement similaire, ou isomorphe). C'est probablement l'opérateur que vous souhaitez utiliser pour l'égalité. Il se comporte comme eql pour les nombres, les caractères et les symboles, mais pour les listes (conses) et les chaînes qu'il raconte si leurs éléments
Par Exemple:
(équivalant à 4 de 4) T
(equal (+ 2 2) 4) T
Maintenant remarque une différence
(eql (cons 'a 'b) (cons 'a 'b)) NÉANT
(equal (cons 'a 'b) (cons 'a 'b)) T ; l'égalité est généralement vrai pour les choses que l'impression de la même
equalp est comme l'égalité, juste un peu plus avancé. Comparaison de nombres est de type insensible. La comparaison des caractères et chaînes de caractères est insensible à la casse.
Par Exemple:
(equalp (cons 'a 'b) (cons 'a 'b)) T ;de même que l'égalité des
Maintenant remarque une différence
l'égalité(4 4.0) NÉANT
equalp(4 4.0) T ; Comme equalp traite des numéros de type insensiblement
