Cela semble être une comparaison d’équivalence pour certains types, mais pas pour les chaînes.
# 3 != 3;; - : bool = false # 3 != 2;; - : bool = true
C’est comme prévu.
# "odp" = "odp";; - : bool = true # "odp" != "odp";; - : bool = true # "odp" "odp";; - : bool = false
Pourquoi "odp" != "odp"
t-il la valeur true
? Que fait-il réellement? Ne devrait-il pas générer une erreur de type?
vous avez fait la différence entre égalité structurelle et égalité physique.
<>
est à =
(égalité structurelle) comme !=
est à ==
(égalité physique)
"odg" = "odg" (* true *) "odg" == "odg" (* false *)
est faux parce que chacun est instancié dans des emplacements mémoire différents, faisant:
let v = "odg" v == v (* true *) v = v (* true *)
La plupart du temps, vous voudrez utiliser =
et <>
.
éditer sur quand égalité structurelle et physique sont équivalentes :
Vous pouvez utiliser la fonction what_is_it et trouver tous les types égaux sur le plan structurel et physique. Comme mentionné dans les commentaires ci-dessous, et dans l’article lié, les caractères, les entiers, l’unité, la liste vide et certaines instances de types de variantes auront cette propriété.
Le contraire pour l’opérateur !=
est l’opérateur ==
, pas le =
un.
# "a" != "a" ;; - : bool = true # "a" == "a" ;; - : bool = false
L’opérateur == est une “égalité physique”. Lorsque vous tapez "a" == "a"
, vous comparez deux instances différentes de chaînes qui se ressemblent, de sorte que l’opérateur retourne false
. Tout en ayant une instance le rend vrai:
# let str = "a" in str == str ;; - : bool = true # let str = "a" in str != str ;; - : bool = false
Une explication rapide sur ==
et !=
Dans OCaml en plus de toutes les réponses correctes qui ont déjà été fournies:
1 / ==
et !=
Exposent les détails de la mise en œuvre que vous ne voulez vraiment pas connaître. Exemple:
# let x = Some [] ;; val x : 'a list option = Some [] # let t = Array.create 1 x ;; val t : '_a list option array = [|Some []|] # x == t.(0) ;; - : bool = true
Jusqu’à présent, tout va bien: x
et t.(0)
sont physiquement égaux car t.(0)
contient un pointeur sur le même bloc que x
pointe vers. C’est ce que dicte la connaissance de base de la mise en œuvre. MAIS:
# let x = 1.125 ;; val x : float = 1.125 # let t = Array.create 1 x ;; val t : float array = [|1.125|] # x == t.(0) ;; - : bool = false
Ce que vous voyez ici sont les résultats d’une optimisation par ailleurs utile impliquant des flotteurs.
2 / D’autre part, il existe un moyen sûr d’utiliser ==
, et c’est un moyen rapide mais incomplet de vérifier l’égalité structurelle.
Si vous écrivez une fonction d’égalité sur les arbres binarys
let equal t1 t2 = match ...
La vérification de l’égalité physique par t1
et t2
est un moyen rapide de détecter qu’elles sont manifestement égales sur le plan structurel, sans même avoir à les réévaluer et à les lire. C’est:
let equal t1 t2 = if t1 == t2 then true else match ...
Et si vous gardez à l’esprit que dans OCaml, l’opérateur «booléen» est «paresseux»,
let equal t1 t1 = (t1 == t2) || match ...
Ils sont comme deux “Tom” dans votre classe! Car:
Dans ce cas, "odp" = "odp"
car ce sont deux chaînes avec SAME VALUE !!
Ils ne sont donc pas ==
car ils sont DEUX différentes chaînes de caractères stockées dans différents emplacements (mémoire)
Ils sont =
parce qu’ils ont la même valeur de chaîne .
Un pas de plus, “odp” est une variable anonyme. Et deux variables anonymes conduisent à ces deux chaînes.
Pour ta convenance:
# "odp" = "odp";; - : bool = true # "odp" != "odp";; - : bool = true # "odp" <> "odp";; - : bool = false
ints est le seul type où l’égalité physique et l’égalité structurelle sont les mêmes, car ints est le seul type qui n’est pas encapsulé