JQuery nombre aléatoire de la gamme. Aléatoire géré dans JavaScript. Fixer le nombre dans la gamme

Après le générateur NG, un nombre aléatoire utilisant un programme informatique, il est toujours considéré comme un nombre aléatoire si le numéro sélectionné est en partie ou plein de source. Mais si cela a été changé, alors les mathématiques ne l'acceptez pas comme un nombre aléatoire, et ils peuvent l'appeler un nombre biaisé. Mais si vous développez un programme pour une tâche simple, il ne sera pas pris en compte. Mais si vous développez un programme de génération d'un nombre aléatoire pour un matériau précieux, tel qu'un programme de loterie ou un jeu de jeu, votre programme sera rejeté par le manuel si vous ne considérez pas ce cas.

Donc, pour ceux qui ont de telles personnes, voici mon offre :.

Génération de nombres aléatoires avec math.random () (disons-le n)

Maintenant, le sol N * 10 est votre réponse et, si nécessaire, l'étage N * 100 est votre réponse et ainsi de suite.

Maintenant, entrez votre rôle:

Vous avez demandé des chiffres parmi une plage spécifique. (Dans ce cas, vous êtes déplacé dans cette gamme. - Ayant accepté le nombre de, tournant le cube, vous allez ajouter à, mais il s'agit toujours d'un cas aléatoire, si et seulement si le décès de l'impartial.)

Alors considérez votre gamme \u003d\u003d\u003e le nombre d'éléments dans la plage \u003d 247 - 78 + 1 \u003d 170; (Comme les deux frontières incluent

/ * Mthod 1: * / var i \u003d 78, j \u003d 247, k \u003d 170, a \u003d, b \u003d, c, d, e, f, l \u003d 0; pour (; je<= j; i++){ a.push(i); } while(l < 170){ c = Math.random()*100; c = Math.floor(c); d = Math.random()*100; d = Math.floor(d); b.push(a[c]); e = c + d; if((b.length != k) && (e < k)){ b.push(a[e]); } l = b.length; } console.log("Method 1:"); console.log(b); /*Method 2:*/ var a, b, c, d = , l = 0; while(l < 170){ a = Math.random()*100; a = Math.floor(a); b = Math.random()*100; b = Math.floor(b); c = a + b; if(c <= 247 || c >\u003d 78) (d.push (c);) d'autre (d.push (a);) l \u003d d.length; ) Console.log ("Méthode 2:"); Console.log (d);

REMARQUE: , puis mettez-le dans un tableau. Ici, j'ai généré deux nombres aléatoires et utilisé leur montant total pour optimiser la vitesse du programme, en minimisant la fréquence des défaillances, recevant un nombre utile. Je recommanderai également ma première méthode de génération de nombres aléatoires dans une plage spécifique.

Dans les deux méthodes, votre console E montrera le résultat. (Appuyez sur F12 en Chrome pour ouvrir la console)

Leur Math.random () La fonction renvoie un point flottant, un nombre pseudo-aléatoire dans la plage 0-1 (inclus de 0, mais pas 1) avec une distribution approximativement uniforme sur cette plage - que vous pouvez ensuite faire échelle à votre plage souhaitée. La mise en œuvre sélectionne la graine initiale à l'algorithme de génération de nombres aléatoires; Il ne peut pas être choisi ou réinitialisé par l'utilisateur.

Math.random () ne fait pas. Fournir des nombres aléatoires sécurisés cryptographiquement. Ne les utilisez pas pour rien de liaison avec la sécurité. Utilisez l'API Crypto ASStead et davantage de la méthode.

Syntaxe

Math.random ()

Valeur de retour.

Un point de flotte, nombre pseudo-aléatoire entre 0 (inclus) et 1 (exclusif).

Exemples.

Notez que, comme les chiffres de JavaScript sont IEEE 754 Numéros de points flottants avec un comportement rond-le plus proche, les plages revendiquées pour les fonctions ci-dessous (à l'exclusion de celle de Math.Random () elle-même) Aren "t exact. Si des limites extrêmement importantes sont choisies. (2 53 ou supérieur), il est posé dans extrêmement. De rares cas pour calculer la limite supérieure généralement exclue.

Obtenir un nombre aléatoire entre 0 (inclus) et 1 (exclusif)

Fonction GeRandom () (retour Math.Random ();)

Obtenir un nombre aléatoire entre deux valeurs

Cet exemple renvoie un nombre aléatoire entre les valeurs spécifiées. La valeur renvoyée n'est pas inférieure à (et peut éventuellement égale) min, et est inférieure à (et non égale) max.

Fonction GetRandomarbitraire (min, max) (retour Math.Random () * (max - min) + min;)

Obtenir un entier aléatoire entre deux valeurs

Cet exemple retourne un hasard entier Entre les valeurs spécifiées. La valeur n'est pas inférieure à Thanner (ou le prochain entier supérieur à Min si min n'est pas un entier), et est inférieur à (mais pas égal à) max.

Fonction GetRandomint (min, max) (min \u003d math.ceil (min); max \u003d math.floor (max); retour math.floor (math.random () * (max - min)) + min; // Le maximum Est exclusif et le minimum est inclusif)

Il pourrait être tentant d'utiliser Math.Round () pour accomplir cela, mais cela ferait de même que vos chiffres aléatoires suivent une distribution non uniforme, ce qui peut ne pas être acceptable pour vos besoins.

Obtenir un entier aléatoire entre deux valeurs, inclus

Bien que la fonction GetRandomint () ci-dessus soit inclusive au minimum, il est exclusif du maximum. Et si vous avez besoin que les résultats soient inclusifs au minimum et au maximum? La fonction GetRandominTinclusive () ci-dessous accomplit cela.

Fonction GetRandomintinclive (min, max) (min \u003d math.ceil (min); max \u003d math.floor (max); retour math.floor (math.random () * (max - min + 1)) + min; // Le maximum est inclus et le minimum est inclusif)

Caractéristiques.

spécification	Statut.	Commenter
ECMAScript 1ère édition (ECMA-262)	Standard	Définition initiale. JavaScript 1.0 (Unix uniquement) / JavaScript 1.1 (Toutes les plates-formes).
ECMAScript 5.1 (ECMA-262)	Standard
ECMAScript 2015 (6ème édition, ECMA-262) La définition de "math.random" dans cette spécification.	Standard
Dernier brouillon ECMAScript (ECMA-262) La définition de "math.random" dans cette spécification.	BROUILLON.

Compatibilité du navigateur

La table de compatibilité de cette page est générée à partir de données structurées. Si vous souhaitez contribuer aux données, veuillez consulter https://github.com/mdn/browser-compat-data et envoyez-nous une demande de traction.

Mettre à jour les données de compatibilité sur GitHub

	Bureau.						Mobile						Serveur
	Chrome.	Bord.	Firefox.	Internet Explorer.	Opéra.	Safari.	Android webview.	Chrome pour Android	Firefox pour Android	Opéra pour Android	Safari sur iOS.	Samsung internet	Nœud.js.
Aléatoire	Support complet chrome Oui	Edge Support complet 12	Firefox Support complet 1	Ie support complet oui	Opéra Support complet Oui	Safari Support complet oui	WebView Android Support complet Oui	Chrome Android Support complet Oui	Firefox Android Support complet 4	Opera Android Support complet Oui	Safari iOS Support complet oui	Samsung Internet Android Support complet Oui	nODEJS Support complet Oui

Très souvent, les calculs de JavaScript ne donnent pas tout à fait les résultats que nous voulons. Bien sûr, nous pouvons faire avec des chiffres tout simplement arrondi de manière large ou plus petite, définir les gammes, couper des nombres inutiles à un certain nombre de décimales, tout dépend de ce que vous voulez faire à l'avenir avec ce nombre.

Pourquoi avez-vous besoin d'arrondir?

L'un des aspects curieux de JavaScript est que cela ne stocke pas les entiers, nous travaillons immédiatement avec des numéros de points flottants. Ceci, en association avec le fait que de nombreuses valeurs fractionnaires ne peuvent pas être exprimées par le nombre final de signes décimaux, nous pouvons obtenir de tels résultats dans JavaScript:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Aux fins pratiques, cette inexactitude n'a pas d'importance, dans notre cas, nous parlons de l'erreur dans Quintillion Dollars, cependant, quelqu'un peut décevoir. Nous pouvons obtenir un résultat légèrement étrange et lorsque vous travaillez avec des nombres qui sont des valeurs de la vanne, des pourcentages ou des tailles de fichiers. Afin de corriger ces inexactitudes, nous devons juste pouvoir arrondir les résultats, alors qu'il suffit d'établir une précision décimale.

L'arrondi des numéros a une application pratique, nous pouvons manipuler le nombre dans une certaine gamme, par exemple, nous souhaitons arrondir la valeur à l'entier le plus proche et ne fonctionne pas uniquement avec la partie décimale.

Arrondir les nombres décimaux

Afin de couper le nombre décimal, utilisez la méthode TOFIXED ou TOPRÉCISION. Les deux sont prises par un seul argument qui détermine, respectivement, combien de numéros significatifs (c'est-à-dire le nombre total de nombres utilisés entre le nombre) ou après un point-virgule (quantité après le point décimal) devrait inclure le résultat:

1. Si l'argument n'est pas défini pour TOFIXED (), il sera donc de zéro, ce qui signifie que 0 marque après la virgule, l'argument a une valeur maximale égale à 20.
2. Si l'argument n'est pas spécifié pour TOPRÉCISION, le nombre reste intact

Laissez Randnum \u003d 6.25; randnum.tofixed (); \u003e "6" math.pi.topision (1); \u003e "3" randnum \u003d 87.335; Randnum.tofixed (2); \u003e "87.33" Randnum \u003d 87.337; Randnum.toprecision (3); \u003e "87.3"
Les méthodes Tofixed () et TOPRecision () renvoient une représentation de chaîne du résultat, pas un nombre. Cela signifie que lors de la somme de la valeur arrondie avec Randnum, des rangées concaténates seront effectuées et non la quantité de chiffres:

Laissez Randnum \u003d 6.25; Laisser arrondir \u003d randnum.tofixed (); // console "6 ".log (randnum + arrondi); \u003e "6.256"
Si vous souhaitez que le résultat ait un type de données numérique, vous devrez appliquer Paysfloat:

Laissez Randnum \u003d 6,25; Laisser arrondir \u003d parsefloat (randnum.tofixed (1)); Console.log (arrondi); \u003e 6.3.
Veuillez noter que 5 valeurs sont arrondies, à l'exception de rares cas.

Les méthodes TOFIXED () et TOPRecision () sont utiles, car elles peuvent non seulement couper la partie fractionnée, mais également compléter les signes après la virgule, qui est pratique lorsque vous travaillez avec la devise:

Laisser wholenum \u003d 1 let dollarscents \u003d wholenum.tofixed (2); Console.log (dollars); \u003e "1,00"
Notez que la toprocision donnera le résultat dans un enregistrement exponentiel si le nombre d'entiers est supérieur à la précision elle-même:

Soit num \u003d 123.435 Num.Topision (2); \u003e "1.2e + 2"

Comment éviter d'arrondir des erreurs avec des nombres décimaux

Dans certains cas, TOFIXED et TOPRECISION entourent la valeur 5 à un côté plus petit et dans un grand:

Laisser numtest \u003d 1,005; numtest.tofixed (2); \u003e "1,00"
Le résultat du calcul ci-dessus devait être 1.01, et non 1. Si vous souhaitez éviter une erreur similaire, nous pouvons utiliser la solution proposée par Jack L Moore, qui utilise des numéros exponentiels pour calculer:

Tour de fonctionnement (numéro de retour (Math.Round (Value + E »+ Décimales) +« E - »+ Décimales);)
À présent:

Rond (1.005.2); \u003e 1.01
Si vous souhaitez une solution plus fiable que la solution indiquée ci-dessus, vous pouvez aller à MDN.

Arrondissement Machine Epsilon

La méthode alternative d'arrondissement des nombres décimaux a été introduite dans l'ES6. L'arrondi Machine EpSilon fournit une limite d'erreur raisonnable lors de la comparaison de deux nombres de points flottants. Sans arrondi, les comparaisons peuvent donner des résultats comme suit:

0,1 + 0,2 \u003d\u003d\u003d 0.3\u003e Faux
Nous utilisons Math.epsilon dans notre fonction pour obtenir une comparaison correcte:

Fonction du texte suivant (x, y) (retour math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
La fonction prend deux arguments: le calcul du premier courant, le second est le résultat attendu. Il retourne une comparaison de deux:

Sujeux (0,1 + 0,2, 0,3)\u003e vrai
Tous les navigateurs modernes prennent déjà en charge les fonctions mathématiques ES6, mais si vous souhaitez obtenir une prise en charge des navigateurs tels que IE 11, utilisez des polyfills.

Réduire la partie fractionnée

Toutes les méthodes présentées ci-dessus sont en mesure d'arrondir des nombres décimaux. Afin de simplement couper le nombre à deux signes après la virgule, vous devez d'abord la multiplier par 100, puis le résultat obtenu est déjà divisé par 100:

Fonction tronquée (num) (retour math.trunch (num * 100) / 100;) tronqué (3.1416)\u003e 3.14
Si vous souhaitez adapter la méthode pour n'importe quel nombre de points-virgules, vous pouvez utiliser un déni à double bitty:

Fonction tronquée (let numpowerconverter \u003d math.pow (10, décimalplaces); retour ~~ (NumpowerConverter) / NumpowerConverter;)
À présent:

Laissez Randint \u003d 35.874993; Tronqué (Randint, 3); \u003e 35.874.

Arrondir au nombre le plus proche

Afin de contourner le nombre décimal au nombre le plus proche de plus ou de plus petit, en fonction de ce que nous sommes les plus proches, utilisez Math.Round ():

Math.Round (4.3)\u003e 4 Math.Round (4.5)\u003e 5
Veuillez noter que "la moitié de la valeur", 0,5 est arrondi dans une direction importante selon les règles de mathématiques.

Arrondir à un entier plus petit au plus proche

Si vous voulez toujours arrondir à un côté plus petit, utilisez Math.Floor:

Math.floor (42.23); \u003e 42 math.floor (36.93); \u003e 36.
Veuillez noter que l'arrondi de manière plus petite fonctionne pour tous les chiffres, y compris pour négatif. Imaginez un gratte-ciel avec un nombre infini d'étages, y compris les sols de basse niveau (représentant des nombres négatifs). Si vous êtes dans l'ascenseur au niveau inférieur compris entre 2 et 3 (qui est une valeur -2.5), Math.Floor vous livrera à -3:

Math.floor (-2.5); \u003e -3.
Mais si vous voulez éviter une situation similaire, utilisez Math.Trunc, pris en charge dans tous les navigateurs modernes (sauf c.-à-delà d'IE / Edge):

Math.trunc (-41.43); \u003e -41
Vous trouverez une polyfill sur MDN pour fournir un support math.trunc dans les navigateurs et IE / Edge.

Arrondi à plus d'entier le plus proche

D'autre part, si vous avez toujours besoin d'arrondir jusqu'au plus grand, utilisez Math.Ceuil. Encore une fois, souvenez-vous de l'ascenseur sans fin: Math.Ceuil va toujours monter, que le nombre soit négatif ou non:

Math.ceil (42.23); \u003e 43 mathsil (36.93); \u003e 37 mathsil (-36,93); \u003e -36

Arrondi à un nombre plus grand / plus petit

Si nous voulons nous rendre au nombre le plus proche, plusieurs 5, le moyen le plus simple de créer une fonction qui divise le numéro sur 5 tours, puis la multiplie au même montant:

Fonction RoundTo5 (Num) (retour Math.Round (Num / 5) * 5;)
À présent:

Rond-point5 (11); \u003e 10.
Si vous souhaitez arrondir de multiples votre valeur, nous utilisons une fonction plus générale en passant la valeur initiale et multiple à celle-ci:

Fonction RoundTomultiple (Num, multiple) (retour Math.Round (Num / Multiple) * Plusieurs;)
À présent:

Laisser initialNumber \u003d 11; Laisser plusieurs \u003d 10; Ttomultiple (initialeNumber, multiple); \u003e 10;

Fixer le nombre dans la gamme

Il y a beaucoup de cas lorsque nous voulons obtenir la valeur de x couchée dans la plage. Par exemple, nous devrons peut-être avoir besoin d'une valeur de 1 à 100, mais nous avons en même temps une valeur de 123. Pour le réparer, nous pouvons utiliser le minimum (retourne le plus petit du nombre de chiffres) et le maximum ( renvoie le plus grand de tous les numéros multiples). Dans notre exemple, la gamme de 1 à 100:

Laisser lowbound \u003d 1; Laissez Highbound \u003d 100; Laisser numinput \u003d 123; Laissez clampier \u003d math.max (Lowbound, math.min (Numinput, Highbound)); Console.log (serré); \u003e 100;
Encore une fois, nous pouvons réutiliser l'opération et envelopper tout cela dans la fonction, nous utilisons la solution proposée par Daniel X. Moore:

Numéro.Prototype.Clammp \u003d fonction (min, max) (retour Math.min (Math.MAX (Ceci, Min), max);););
À présent:

Numinput.lamp (Lowbound, Highbound); \u003e 100;

Arrondissement gaussien

L'arrondi gaussien, également connu sous le nom d'arrondissement de la banque, est que l'arrondi pour ce cas se produit au noir le plus proche. Cette méthode d'arrondi fonctionne sans erreur statistique. La meilleure solution a été proposée par Tim Down:

Fonction Gaussron (laissez D \u003d décimalplaces || 0, m \u003d math.pow (10, d), n \u003d + (d? Num * m: num) .tofixed (8), i \u003d math.floor (n), f \u003d n - i, e \u003d 1e-8, r \u003d (f\u003e 0.5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
À présent:

Gaussron (2.5)\u003e 2 Gaussron (3.5)\u003e 4 Gaussron (2.57,1)\u003e 2.6
Connexion décimale en CSS:

Étant donné que JavaScript est souvent utilisé pour créer une conversion de position d'éléments HTML, vous pouvez vous demander ce qui se produit si nous génèverons des valeurs décimales pour nos articles:

#Box (largeur: 63.667731993PX;)
La bonne nouvelle est que les navigateurs modernes prendront en compte les valeurs décimales dans un modèle de bloc, y compris dans des unités de mesure de pourcentage ou de pixels.

Tri

Très souvent, nous devons trier tous les éléments, par exemple, nous disposons d'une gamme d'enregistrements de jeu, alors qu'ils devraient être organisés comme ordre décroissant des joueurs. Malheureusement, la méthode de tri standard () a des restrictions incroyables: cela fonctionne bien avec des mots anglais fréquemment utilisés, mais se brise immédiatement lors d'une réunion avec des chiffres, des caractères uniques ou des mots en majuscules.

Trier par ordre alphabétique

Il semblerait que la tâche de tri alphabétiquement soit la tâche la plus simple:

Laissez Fruit \u003d ["Squash de butternut", "Abricot", "Cantaloup"]; fruit.sort (); \u003e "Apricot", "Squash de butternut", "Cantaloup"]
Néanmoins, nous sommes confrontés au problème dès que l'un des éléments est dans les majuscules:

Laissez Fruit \u003d ["Squash de butternut", "aprot", "Cantalope"]; fruit.sort (); \u003e "Cantaloup", "aprot", "Squash de butternut"]
Cela est dû au fait que, par défaut, la trieuse compare le premier symbole présenté dans Unicode. Unicode est un code unique pour tout symbole, quelle que soit la plate-forme, quel que soit le programme, quelle que soit la langue. Par exemple, si vous regardez via la table de code, le caractère "A" est U + 0061 (Système hexadécimal 0x61), tandis que le symbole "C" a du code U + 0043 (0x43), qui va avant dans la table Unicode que le symbole "a".

Pour trier un tableau capable de contenir des registres mélangés des premières lettres, nous devons soit convertir tous les éléments vers temporairement dans le registre inférieur, soit déterminer votre ordre de tri à l'aide de la méthode localecompare () avec quelques arguments. En règle générale, pour un tel cas, il est préférable de créer immédiatement une fonction pour une utilisation répétée:

Fonction Alphasort (Arr) (retour A.Localecompare (B, EN ", (" Sensibilité ":" Base "));));));); Alphasort (fruit)\u003e
Si vous souhaitez obtenir un tableau dans l'ordre alphabétique inverse, modifiez simplement les positions A et B sur la fonction:

Fonction Alphasort (Arr) (retour B.Localecompare (A, EN ", (" Sensibilité ":" Base ")));));));); laisser fruit \u003d [" Squash butternut "," Abricot "," Cantaloup "]; Alphasort (fruit)\u003e ["Cantaloup", "Squash de butternut", "Apricot"]
Il convient de faire attention à ce que localecompare est utilisé avec des arguments, il est encore nécessaire de se rappeler qu'il est soutenu par IE11 +, pour les versions plus anciennes, nous pouvons l'utiliser sans arguments et dans le registre inférieur:

Case de fonction (ARR) (retour A.Tolowcase (). Localecompare (B.Tolowercase ());)););) Laissez Fruit \u003d ["Squash butternut", "Abricot", "Cantaloup"]; Recueil\u003e [Apricot, "Squash de butternut", "Cantaloup"]

Tri numérique

Tout cela ne s'applique pas à l'exemple dont nous avons parlé de la gamme ci-dessus d'enregistrements de jeu. Avec des matrices numériques, le tri fonctionne parfaitement, mais à un moment donné, le résultat peut être imprévisible:

Laisser les hautescores \u003d; highscores.sort (); \u003e
Le fait est que la méthode de tri () produit une comparaison lexicographique: et cela signifie que les numéros seront convertis en une chaîne et des comparaisons seront effectués à nouveau en mappant le premier caractère de cette chaîne dans les symboles de la table Unicode. Par conséquent, nous devons déterminer votre ordre de tri:

Laisser les hautescores \u003d; Highscores.sort (retour A - B;)); \u003e
Encore une fois, pour trier les nombres dans l'ordre inverse, modifiez les positions A et B sur la fonction.

Trier la structure de type JSON

Et enfin, si nous avons une structure de données semblable à un JSON, représentées comme une gamme d'enregistrements de jeu:

Laissez Scores \u003d [((nom »:" Daniel "," Score ": 21768), (" Nom ":" Michael "," Note ": 33579), (" Nom ":" Alison "," Score ": 38395 )];
Dans ES6 +, vous pouvez utiliser les fonctions de flèche:

Scores.sort ((a, b) \u003d\u003e b.score - a.score));
Pour les vieux navigateurs qui n'ont pas de tel soutien:

Scores.sort (retour A.Score - B.Score));
Comme vous pouvez le constater, le tri de JavaScript est une chose assez évidente, j'espère que ces exemples faciliteront la vie.

Travailler avec des fonctions de puissance

L'exercice est une opération, définie à l'origine à la suite d'une multiplication multiple d'un nombre naturel sur lui-même, une racine carrée du numéro A est un nombre donné à un carré. Avec ces fonctions, nous pourrions constamment profiter de la vie quotidienne des cours de mathématiques, y compris lors du calcul des zones, des volumes ou même de la modélisation physique.

En JavaScript, une fonction d'alimentation est représentée comme maths.Pow (), dans la nouvelle norme ES7, un nouvel opérateur d'exercice a été présenté au diplôme - "* *".

Erend en degré de diplôme

Afin de créer un numéro dans le degré N-UY, utilisez la fonction Math.Pow (), où le premier argument est le numéro érigé dans un diplôme, le deuxième argument est un indicateur du degré:

Math.pow (3.2)\u003e 9
Une telle forme de moyen d'enregistrement 3 dans un carré, ou 3 × 3, qui entraîne un résultat 9. Un autre exemple peut être donné, bien sûr:

Maths.pow (5.3); \u003e 125.
C'est-à-dire 5 à Cuba, ou 5 × 5 × 5, égal à 125.

ECMAScript 7 est la version suivante de JavaScript, en principe, nous pouvons utiliser le nouvel opérateur d'exercices proposé à un degré - * *, une telle forme d'enregistrement peut être plus visuelle:

3 ** 2 > 9
Pour le moment, le soutien de cet opérateur est assez limité, il n'est donc pas recommandé de l'utiliser.

La fonction puissante peut être utile dans diverses situations. Un exemple simple, calculant le nombre de secondes en une heure: math.pow (60.2).

Racine carrée et cubique

MATH.SQRT () et MATH.CBRT () sont opposés aux fonctions MATH.POW (). Comme nous nous souvenons, la racine carrée du numéro A est un nombre qui donne un moment où le carré est érigé.

MATH.SQRT (9)\u003e 3
Dans le même temps, la racine cubique du numéro A est un nombre qui donne une lorsque le cube est érigé.

MATH.CBRT (125)\u003e 5
MATH.CBRT () a été introduit dans la spécification JavaScript récemment et n'est donc prise en charge que dans les navigateurs modernes: Chrome 38+, Firefox et Opera 25+ et Safari 7.1+. Vous remarquerez que Internet Explorer manque dans cette liste, cependant, vous trouverez Polyfill sur MDN.

Exemples

Bien sûr, nous pouvons utiliser et non entier dans l'une de ces fonctions:

Math.pow (1.25, 2); \u003e 1.5625 MATH.CBRT (56.57)\u003e 3.8387991760286138
Veuillez noter que cela fonctionne assez bien lorsque vous utilisez des valeurs négatives d'arguments:

Math.pow (-5.2)\u003e 25 maths.pow (10, -2)\u003e 0.01
Cependant, pour une racine carrée, cela ne fonctionnera pas:

MATH.SQRT (-9)\u003e NAN
De l'analyse mathématique, nous savons que sous un nombre imaginaire, ils comprennent des racines carrées des nombres négatifs. Et cela peut nous conduire à une autre technique de travailler avec des nombres complexes, mais c'est une autre histoire.

Vous pouvez utiliser des valeurs fractionnaires en maths.Pow () pour trouver des numéros de racines carrées et cubes. Racine carrée utilise un indicateur 0,5:

Math.pow (5, 0.5); // \u003d math.sqrt (5) \u003d 5 ** (1/2)\u003e 2.23606797749979
Cependant, en raison de caprices de points flottants, vous ne pouvez pas supposer avec précision le résultat correct:

Math.pow (2.23606797749979,2)\u003e 5.0000000000001
Dans de telles situations, vous devrez recourir à des signes de coupure en chiffres ou en arrondissement à n'importe quelle valeur.

Certains, pour des raisons incompréhensibles dans JavaScript confondent la fonction Math.Pow () avec MATH.EXP (), qui est une fonction exponentielle pour les nombres dans son ensemble. Remarque: En anglais, l'indicateur "Exposant" est traduit par "Exponent", de sorte qu'il fait plutôt référence à la langue anglaise, bien qu'il existe des noms d'indicateurs alternatifs tels que l'index, l'énergie.

Constantes mathématiques

Travailler avec des mathématiques à JavaScript est facilité par un certain nombre de constantes intégrées. Ces constantes sont les propriétés de l'objet mathématique. Il convient de noter que les constantes sont écrites dans les majuscules et non de la notation Camelcase.

Seuls les utilisateurs enregistrés peuvent participer à l'enquête. , vous êtes les bienvenus.

Tags: Ajouter des tags

Techniquement, le terme "générateur de nombres aléatoires" est absurde, car les chiffres eux-mêmes ne sont pas aléatoires. Par exemple, 100 est un nombre aléatoire? Et 25? En fait, ce terme signifie que c'est ce que la séquence de nombres apparaît aléatoirement est créée. Cela génère une question plus difficile: qu'est-ce qu'une séquence de nombres aléatoires? La seule réponse correcte est la suivante: une séquence de nombres aléatoires est une séquence dans laquelle tous les éléments ne sont pas liés. Cette définition conduit à un tel paradoxe que toute séquence peut être à la fois aléatoire et non aléatoire en fonction de la manière dont cette séquence est obtenue. Par exemple, la prochaine ligne de chiffres
1 2 3 4 5 6 7 8 9 0
Il a été obtenu en imprimant la rangée supérieure du clavier dans l'ordre, la séquence ne peut donc pas être considérée comme générée de manière aléatoire. Mais comment être si vous obtenez la même séquence, supprimez les balles de tennis numérotées du baril. Dans ce cas, il est déjà au hasard la séquence générée. Cet exemple montre que les risques d'une séquence dépend de la manière dont il a été obtenu, et non de celui-ci lui-même.

N'oubliez pas que la séquence de nombres générés par l'ordinateur est déterministe: chaque numéro sauf le premier dépend des numéros précédents. Techniquement, cela signifie que seule la séquence quasonique des nombres peut être générée par l'ordinateur, c'est-à-dire En fait, ils ne sont pas vraiment aléatoires. Cependant, cela suffit pour la plupart des tâches et de telles séquences de simplicité seront appelées aléatoires. Une méthode très intéressante a été développée par John Background Neuman; Il est souvent appelé RMS. Dans cette méthode, le nombre aléatoire précédent est érigé dans un carré, puis des nombres moyens sont libérés du résultat. Par exemple, si vous créez des nombres de trois chiffres et que le nombre précédent était de 121, la construction du carré donne le résultat 14641. La sélection de trois chiffres moyens donne le nombre aléatoire 464 aléatoire suivant. L'inconvénient de cette méthode est qu'elle a une très courte période de répétition, appelée cycle. Pour cette raison, cette méthode n'est pas utilisée aujourd'hui. Les méthodes modernes pour générer des nombres aléatoires sont beaucoup plus compliquées.

Nombres aléatoires en PHP

Il existe deux groupes de fonctions avec des nombres aléatoires dans PHP. Purement externe, ils peuvent être distingués par le préfixe MT_ dans toutes les fonctions de l'un des groupes.

Fonctions obsolètes
Fonction rand. Renvoie un entier de zéro à la valeur RAND_MAX (qui est égal à 32767). Il peut avoir deux paramètres entier optionnels - s'ils sont spécifiés, un nombre aléatoire est généré à partir du premier paramètre à la seconde.

ECHO RAND (); Echo Rand (1 100); // donne un nombre aléatoire de 1 à 100

SRAND FONCTION. Définit la séquence de nombres aléatoires émises par la fonction RAND. Il a un paramètre entier - avec différentes valeurs de ce paramètre Rand produira différentes séquences de nombres. La fonction Srand suffit à appeler une seule fois avant tous les défis de la fonction RAND. Exemple d'utilisation:

Srand (1288); // initialisation du générateur de nombres aléatoires pour ($ i \u003d 0; $ i<5;$i++){ echo rand(); echo "
"; }

Attention! À partir de la version PHP 4.2.0, vous n'avez pas besoin de causer SRAND () - PHP le fait automatiquement.
GetRandMax () fonction (). Renvoie la valeur du nombre aléatoire maximum (32767).

Fonctions du deuxième groupe (avec le préfixe MT_)
Leurs noms et actions sont similaires aux caractéristiques du premier groupe - MT_RAND, MT_SRAND et MT_GETRANDMAX. La principale différence est que des nombres aléatoires sont extraits d'une plage plus large: de 0 à 2 19937 - 1. De plus, ces fonctions fonctionnent de manière significative plus rapide que les anciens analogues, car le générateur de nombres aléatoires est utilisé par la Mersenne Twister, développée en 1997 par japonais. scientifiques. D'où le préfixe MT_ (Mersenne Twister).
Exemple d'utilisation:

// nous émettons un nombre aléatoire de 1000 à 2000 echo mt_rand (1000, 2000);

Numéros aléatoires en JavaScript

Nombre aléatoire en JavaScript Vous pouvez générer avec math.random (). Cependant, ce sera un nombre fractionnaire compris entre 0 et 1 (non compris entre 0 et 1). Pour générer un entier aléatoire dans la plage souhaitée, il est nécessaire d'écrire votre fonction.

La description

Math.Random () La méthode renvoie un nombre pseudo-aléatoire entre 0 et 1.

Le nombre pseudo-aléatoire est créé dans la plage de 0 (inclus) à 1 (exclusivement), c'est-à-dire que le numéro de retour peut être égal à zéro, mais il y en aura toujours moins d'un.

Pour arrondi le numéro de point flottant dans l'ensemble, vous pouvez utiliser par exemple la méthode Math.Floor ().

Syntaxe

Math.random ()

Valeur de retour

• Numéro de point flottant dans la gamme de 0 (inclus) à 1 (exclusivement).

Math.Random () La méthode est principalement utilisée pour générer un nombre pseudo-aléatoire dans une plage spécifique. Par exemple, nous devons obtenir un numéro dans la plage de 50 à 100 (inclus). Pour ce faire, nous devrons écrire le code suivant:

Document.write (maths.floor (math.random () * 51 + 50));

Considérez en détail comment notre exemple fonctionne et pourquoi une telle forme d'enregistrement est utilisée. Tout d'abord, nous devons spécifier la valeur minimale de la plage souhaitée, dans notre exemple, c'est le numéro 50. Nous devons maintenant avoir un nombre aléatoire, lequel, lors de l'addition avec le numéro 50, ne dépassera pas le nombre 100. Comme nous le savons des mathématiques, la recherche d'une composante inconnue est faite en soustrayant de la somme de l'allégation bien connue. 100 - 50: Nous obtenons la différence 50. Maintenant, pour vérifier, ce numéro nous approche ou non, multipliez-le pour un nombre minimum et maximum éventuellement renvoyé par Math.Random (). Multipliez Minimal 0.004704564176082244 * 50 \u003d 0,2 ... et le maximum 0.99999999999746223 * 50 \u003d 49.9 ... et nous voyons donc que lorsque vous multipliez la différence pour le nombre aléatoire maximal possible, cela nous donne une partie intégrante du nombre par unité moins que nécessaire. Pour corriger la situation, nous devons juste ajouter une unité à 50, c'est-à-dire. 50 + 1 \u003d 51, maintenant si le numéro obtenu multiplié au maximum possible, le nombre de 50,9 sera renvoyé par la méthode de 50,9 ... - C'est ce dont nous avons besoin, après l'ajout de numéros 50.9 + 50, nous obtenons 100.9. Pour arrondi le numéro dans l'ensemble, utilisez la méthode Math.Floor (). Ainsi, la formule d'obtention du nombre souhaitée est la suivante: max - min + 1. Je vais réécrire l'exemple ci-dessus:

Var max \u003d 100, min \u003d 50; Document.write (math.floor (math.random () * (max - min + 1) + min));

Cette formule est particulièrement utile lorsqu'elle n'est pas connue à l'avance dans quelle plage il est nécessaire d'obtenir un nombre aléatoire.

Exemple

Nombre pseudo-aléatoire dans la gamme de 1 à 10.