You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
La méthode **`RandomSource.getRandomValues()`** permet d’obtenir des valeurs pseudo-aléatoires cryptographiquement satisfaisantes. Le tableau donné en paramètre est rempli avec des nombres pseudo-aléatoires.
10
+
La méthode **`Crypto.getRandomValues()`** permet d'obtenir des valeurs aléatoires suffisamment fortes pour un usage cryptographique. Le tableau fourni en paramètre est rempli de nombres aléatoires (au sens cryptographique).
17
11
18
-
Pour garantir une performance suffisante, les implémentations n’utilisent pas un vrai générateur de nombres aléatoires, mais un générateur de nombres pseudo-aléatoires _semé_ avec une valeur ayant suffisamment d'{{Glossary("entropie")}}. Les générateurs utilisés d’une implémentation à une autre seront différents mais toujours satisfaisants pour une utilisation en cryptographie. Les implémentations doivent également utiliser une graine ayant suffisamment d’entropie, comme une source d’entropie au niveau du système.
12
+
Pour garantir des performances suffisantes, les implémentations n'utilisent pas un générateur de nombres aléatoires, mais un générateur de nombres pseudo-aléatoires _amorcé_ (<ilang="en">seeded</i>) avec une graine ayant suffisamment d'entropie. L'algorithme du générateur de nombres pseudo-aléatoires (PRNG) peut varier selon les [agents utilisateur](/fr/docs/Glossary/User_agent), mais est considéré comme satisfaisant pour un usage cryptographique. Les implémentations doivent utiliser une graine ayant suffisamment d'entropie, telle qu'une source d'entropie au niveau du système.
13
+
14
+
`getRandomValues()` est la seule propriété de l'interface `Crypto` qui peut être utilisée depuis un contexte non-sécurisé.
19
15
20
16
## Syntaxe
21
17
22
-
cryptoObj.getRandomValues(typedArray);
18
+
```js
19
+
getRandomValues(typedArray)
20
+
```
23
21
24
22
### Paramètres
25
23
26
-
-_typedArray_
27
-
- : Un {{jsxref("TypedArray")}} de nombres entiers, qui est un {{jsxref("Int8Array")}}, un {{jsxref("Uint8Array")}}, un {{jsxref("Uint16Array")}}, un {{jsxref("Int32Array")}}, ou encore un {{jsxref("Uint32Array")}}. Tous les éléments du tableau seront subsitués avec des nombres aléatoires.
24
+
-`typedArray`
25
+
- : Un tableau typé ([`TypedArray`](/fr/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)) utilisant des valeurs entières, c'est-à-dire une valeur dont le type est l'un des types suivants : [`Int8Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Int8Array), [`Uint8Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), [`Uint8ClampedArray`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray), [`Int16Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Int16Array), [`Uint16Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array), [`Int32Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Int32Array), [`Uint32Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array), [`BigInt64Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/BigInt64Array), [`BigUint64Array`](/fr/docs/Web/JavaScript/Reference/Global_Objects/BigUint64Array) (mais **pas** `Float32Array` ni `Float64Array`). Tous les éléments du tableau seront écrasés avec des nombres aléatoires.
26
+
27
+
### Valeur de retour
28
+
29
+
La valeur de retour correspond au même tableau que celui passé en argument mais dont le contenu a été remplacé par des nombres aléatoires générés pour l'occasion. On notera que `typedArray` est modifié directement, il n'y a pas de copie effectuée.
28
30
29
31
### Exceptions
30
32
31
-
- Une {{exception("QuotaExceededError")}} {{domxref("DOMException")}} est levée si la taille de la requête est plus grand que 65 536 octets.
33
+
Cette méthode peut lever une exception dans certaines conditions.
34
+
35
+
-[`DOMException`](/fr/docs/Web/API/DOMException) (avec le nom [`QuotaExceededError`](/fr/docs/Web/API/DOMException#quotaexceedederror))
36
+
- : La longueur demandée dépasse 65536 octets.
37
+
38
+
## Notes d'utilisation
39
+
40
+
`getRandomValues()` ne doit pas être utilisée afin de générer des clés de chiffrement. Il faut utiliser la méthode [`generateKey()`](/fr/docs/Web/API/SubtleCrypto/generateKey) à la place. En effet, plusieurs raisons invitent à ce choix et notamment le fait que `getRandomValues()` puisse être exécutée depuis un contexte non sécurisé.
41
+
42
+
Il n'y a pas de seuil minimal d'entropie imposé par la spécification pour la cryptographie web. Les agents utilisateurs doivent fournir la meilleure entropie possible lors de la génération de nombres aléatoires en utilisant un générateur de nombres pseudo-aléatoires bien défini et efficace, construit au sein de l'agent utilisateur mais amorcé avec des graines provenant d'une source de nombres pseudo-aléatoires externe, comme une fonction spécifique à la plateforme sous-jacente (par exemple, l'appareil `/dev/urandom` sur Unix) ou une autre source de données aléatoires ou pseudo-aléatoires.
32
43
33
-
## Exemple
44
+
## Exemples
34
45
35
46
```js
36
-
/* on part du principe ici que window.crypto.getRandomValues est disponible */
47
+
/* En partant du principe que window.crypto.getRandomValues */
- {{ domxref("Window.crypto") }} pour obtenir un objet {{domxref("Crypto")}}.
60
-
- {{jsxref("Math.random")}}, une source non cryptographique de nombres aléatoires.
69
+
-[L'API Web Crypto](/fr/docs/Web/API/Web_Crypto_API)
70
+
-[`crypto`](/fr/docs/Web/API/crypto_property) qui permet d'obtenir un objet [`Crypto`](/fr/docs/Web/API/Crypto)
71
+
-[`Math.random()`](/fr/docs/Web/JavaScript/Reference/Global_Objects/Math/random), une fonction qui permet de générer des nombres aléatoires à des fins non-cryptographiques.
La méthode **`Element.closest()`**renvoie l'ancêtre le plus proche de l'élément courant (ou l'élément courant) qui correspond aux sélecteurs passés comme paramètres. S'il n'existe pas de tel ancêtre, la méthode renvoie `null`.
9
+
La méthode **`closest()`**traverse [l'élément](/fr/docs/Web/API/Element) courant et ses parents (en direction de la racine) jusqu'à trouver un nœud qui correspond aux sélecteurs exprimés par la chaîne de caractères passée en argument. Elle renverra l'élément ou l'ancêtre le plus proche qui correspond. Si aucun élément ne correspond, la méthode renvoie `null`.
14
10
15
11
## Syntaxe
16
12
17
-
var elt = element.closest(selecteurs);
13
+
```js
14
+
closest(selecteurs)
15
+
```
18
16
19
17
### Paramètres
20
18
21
19
-`selecteurs`
22
-
- : Une chaîne {{domxref("DOMString")}} qui contient une liste de sélecteurs tels que `"p:hover, .toto + q"`
20
+
- : Une chaîne de caractères contenant une liste de sélecteurs. Par exemple `p:hover, .toto + q`.
23
21
24
22
### Valeur de retour
25
23
26
-
L'élément ({{domxref("Element")}}) qui est le plus proche ancêtre de l'élément courant et qui correspond aux sélecteurs décrits dans le paramètres ou {{jsxref("null")}} s'il n'y en a aucun.
24
+
L'élément ([`Element`](/fr/docs/Web/API/Element)) qui est l'ancêtre le plus proche de l'élément courant et qui correspond aux sélecteurs. S'il n'y en a aucun, ce sera `null`.
27
25
28
26
### Exceptions
29
27
30
-
- {{exception("SyntaxError")}} sera levée si `selecteurs` n'est pas une liste de sélecteurs valide.
28
+
Une exception[`SyntaxError`](/fr/docs/Web/API/DOMException#syntaxerror) est levée si la chaîne de caractères`selecteurs` n'est pas une liste de sélecteurs valide.
31
29
32
30
## Exemples
33
31
34
32
### HTML
35
33
36
34
```html
37
35
<article>
38
-
<divid="div-01">Here is div-01
39
-
<divid="div-02">Here is div-02
40
-
<divid="div-03">Here is div-03</div>
36
+
<divid="div-01">Voici div-01
37
+
<divid="div-02">Voici div-02
38
+
<divid="div-03">Voici div-03</div>
41
39
</div>
42
40
</div>
43
41
</article>
@@ -46,52 +44,53 @@ L'élément ({{domxref("Element")}}) qui est le plus proche ancêtre de l'élém
46
44
### JavaScript
47
45
48
46
```js
49
-
var el =document.getElementById('div-03');
47
+
constel=document.getElementById('div-03');
50
48
51
-
var r1 =el.closest("#div-02");
52
-
// Renvoie l'élément avec l'identifiant id=div-02
49
+
constr1=el.closest('#div-02');
50
+
// Renvoie l'élément avec l'identifiant div-02
53
51
54
-
var r2 =el.closest("div div");
55
-
// Renvoie le plus proche ancêtre qui est un div
56
-
//dans un div. Ici, c'est div-03 lui-même.
52
+
constr2=el.closest('div div');
53
+
// Renvoie le plus proche ancêtre qui est un div dans un div
54
+
// Ici, c'est div-03 lui-même
57
55
58
-
var r3 =el.closest("article > div");
59
-
// Renvoie le plus proche ancêtre qui est un div
60
-
// et dont l'élément parent est article. Ici c'est
61
-
// div-01.
56
+
constr3=el.closest('article > div');
57
+
// Renvoie le plus proche ancêtre qui est un div et qui a un
58
+
// article parent, il s'agit ici de div-01
62
59
63
-
var r4 =el.closest(":not(div)");
64
-
// Renvoie le plus proche ancêtre qui n'est pas un
65
-
//div. Dans ce cas, c'est l'élément article.
60
+
constr4=el.closest(':not(div)');
61
+
// Renvoie le plus proche ancêtre qui n'est pas un div,
Pour les navigateurs qui ne prennent pas en charge `Element.closest()` mais qui permettent d'utiliser `element.matches()` (ou un équivalent préfixé, à partir d'IE9+), on peut utiliser le polyfill suivant :
67
+
Pour les navigateurs qui ne prennent pas en charge `Element.closest()`, mais qui implémentent `element.matches()` (ou un équivalent préfixé comme IE9+), il est possible d'implémenter une prothèse :
if (!document.documentElement.contains(el)) returnnull;
81
-
do {
82
-
if (el.matches(s)) return el;
83
-
el =el.parentElement||el.parentNode;
84
-
} while (el !==null&&el.nodeType==1);
85
-
returnnull;
86
-
};
70
+
if (!Element.prototype.matches) {
71
+
Element.prototype.matches=
72
+
Element.prototype.msMatchesSelector||
73
+
Element.prototype.webkitMatchesSelector;
74
+
}
75
+
76
+
if (!Element.prototype.closest) {
77
+
Element.prototype.closest=function(s) {
78
+
var el =this;
79
+
80
+
do {
81
+
if (Element.prototype.matches.call(el, s)) return el;
82
+
el =el.parentElement||el.parentNode;
83
+
} while (el !==null&&el.nodeType===1);
84
+
returnnull;
85
+
};
86
+
}
87
87
```
88
88
89
-
Cependant, si vous avez besoin de supporter IE 8, vous pouvez utiliser la prothèse suivante qui marchera, mais beaucoup plus lentement. Elle ne supporte que les sélecteurs CSS 2.1 dans IE 8, et peut causer de gros pics de latence dans les sites web :
89
+
Si la prise en charge d'IE8 est nécessaire, le fragment de code qui suit fera l'affaire (lentement mais sûrement). Toutefois, il ne prend en charge que les sélecteurs CSS 2.1 pour IE8 et entraînera une importante baisse de performance pour les sites web en production.
90
90
91
91
```js
92
92
if (window.Element&&!Element.prototype.closest) {
93
-
Element.prototype.closest=
94
-
function(s) {
93
+
Element.prototype.closest=function(s) {
95
94
var matches = (this.document||this.ownerDocument).querySelectorAll(s),
96
95
i,
97
96
el =this;
@@ -106,20 +105,20 @@ if (window.Element && !Element.prototype.closest) {
-Dans Edge `document.createElement(tagName).closest(tagName)`retournera`null` si l'élément n'est pas attaché au DOM au préalable.
116
+
-Pour Edge 15-18, `document.createElement(tagName).closest(tagName)`renverra`null` si l'élément n'est pas d'abord connecté (directement ou indirectement) à l'objet de contexte, par exemple l'objet [`Document`](/fr/docs/Web/API/Document) dans le cas du DOM classique.
120
117
121
118
## Voir aussi
122
119
123
-
- L'interface {{domxref("Element")}}
124
-
-[La syntaxe pour les sélecteurs](/fr/Apprendre/CSS/Les_bases/Les_sélecteurs)
125
-
- Autres méthodes utilisant des sélecteurs: {{domxref("element.querySelector()")}} et {{domxref("element.matches()")}}.
0 commit comments