aboutsummaryrefslogtreecommitdiff
path: root/files/fr/web/javascript/reference/operators/inequality/index.md
blob: d9465f8ba5c5029a0bdb3aa15278d218090bbaef (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
---
title: Inégalité (!=)
slug: Web/JavaScript/Reference/Operators/Inequality
tags:
  - JavaScript
  - Language feature
  - Operator
  - Reference
browser-compat: javascript.operators.inequality
translation-of: Web/JavaScript/Reference/Operators/Inequality
---
<div>{{jsSidebar("Operators")}}</div>

<p>L'opérateur d'inégalité (<code>!=</code>) vérifie si ses deux opérandes ne sont pas égaux et renvoie un booléen correspondant au résultat. À la différence de l'opérateur <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">d'inégalité stricte</a>, l'opérateur d'inégalité tente une conversion de ses opérandes avant la comparaison si ceux-ci sont de types différents.</p>

<div>{{EmbedInteractiveExample("pages/js/expressions-inequality.html")}}</div>

<h2 id="syntax">Syntaxe</h2>

<pre class="brush: js">
x != y
</pre>

<h2 id="description">Description</h2>

<p>L'opérateur d'inégalité vérifie si ses deux opérandes ne sont pas égaux. Il s'agit de la négation de <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">l'opérateur d'égalité</a> et les deux lignes suivantes fourniront donc toujours le même résultat :</p>

<pre class="brush: js">
x != y
!(x == y)
</pre>

<p>Pour plus de détails sur l'algorithme de comparaison utilisé, voir <a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">la page relative à l'opérateur d'égalité</a>.
</p>

<p>À l'instar de l'opérateur d'égalité, l'opérateur d'inégalité tentera une conversion des opérandes si ceux-ci ne sont pas de même type :</p>

<pre class="brush: js">
3 != "3"; // false
</pre>

<p>Si cette conversion implicite n'est pas souhaitable et qu'on souhaite considérer des valeurs de types différents comme étant différentes, on privilégiera <a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">l'opérateur d'inégalité stricte</a> à la place :</p>

<pre class="brush: js">
3 !== "3"; // true
</pre>

<h2 id="examples">Exemples</h2>

<h3 id="comparison_with_no_type_conversion">Comparaison sans conversion de types</h3>

<pre class="brush: js">
1 != 2;              // true
"hello" != "hola";   // true

1 != 1;              // false
"hello" != "hello";  // false
</pre>

<h3 id="comparison_with_type_conversion">Comparaison avec conversion de types</h3>

<pre class="brush: js">
"1" !=  1;            // false
1 != "1";             // false
0 != false;           // false
0 != null;            // true
0 != undefined;       // true
0 != !!null;          // false, voir la documentation pour !!
0 != !!undefined;     // false, voir la documentation pour !!
null != undefined;    // false

const number1 = new Number(3);
const number2 = new Number(3);
number1 != 3;         // false
number1 != number2;   // true
</pre>

<h3 id="comparison_of_objects">Comparaison d'objets</h3>

<pre class="brush: js">
const objet1 = {"clé": "valeur"}
const objet2 = {"clé": "valeur"};

objet1 != objet2 // true
objet2 != objet2 // false
</pre>

<h2 id="specifications">Spécifications</h2>

<p>{{Specifications}}</p>

<h2 id="browser_compatibility">Compatibilité des navigateurs</h2>

<p>{{Compat}}</p>

<h2 id="see_also">Voir aussi</h2>

<ul>
  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Equality">L'opérateur d'égalité</a></li>
  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_equality">L'opérateur d'égalité stricte</a></li>
  <li><a href="/fr/docs/Web/JavaScript/Reference/Operators/Strict_inequality">L'opérateur d'inégalité stricte</a></li>
</ul>