Comment puis-je générer des nombres aléatoires dans Dart?

Si vous avez besoin d' chiffrement sécurisé nombres aléatoires (par exemple, pour le chiffrement), et vous êtes dans un navigateur, vous pouvez utiliser le DOM cryptography API:

int random() {
  final ary = new Int32Array(1);
  window.crypto.getRandomValues(ary);
  return ary[0];
}

cela fonctionne dans Dartium, Chrome et Firefox, mais probablement pas dans d'autres navigateurs car il s'agit d'une API expérimentale.

une solution alternative pourrait être d'utiliser le code suivant DRandom. Cette classe doit être utilisée avec une graine. Il fournit une interface familière à ce que vous attendriez dans .NET, il a été porté à partir de Mono aléatoire.cs. Ce code peut ne pas être la cryptographie sûre et n'a pas été testé statistiquement.

Une sécurité aléatoire de l'API a été ajouté à dart:math

new Random.secure()

dart:math Random ajout d'un secure constructeur retournant un cryptographique sécurisé générateur aléatoire qui lit à partir de la source d'entropie fournie par le embedder pour chaque valeur aléatoire générée.

qui délègue à window.crypto.getRandomValues() dans le navigateur et vers le système D'exploitation (comme urandom sur le serveur)

voici un extrait pour générer une liste de nombres aléatoires

import 'dart:math';

main() {
  var rng = new Random();
  var l = new List.generate(12, (_) => rng.nextInt(100));
}

cela générera une liste de 12 entiers de 0 à 99 (inclus).

utilisez cette bibliothèque http://dart.googlecode.com/svn/branches/bleeding_edge/dart/lib/math/random.dart fourni un bon générateur aléatoire qui je pense sera inclus dans le sdk bientôt espérons qu'il aide

je viens D'écrire cette petite classe pour générer Normal nombres Aléatoires... c'était un bon point de départ pour la vérification que je dois faire. (Ces ensembles se distribueront sur une "cloche" en forme courbe.) La graine sera définie au hasard, mais si vous voulez être en mesure de re-générer un ensemble, vous pouvez juste passer quelques graines spécifiques et le même ensemble va générer.

amusez-vous bien...

class RandomNormal {
  num     _min, _max,  _sum;
  int     _nEle, _seed, _hLim;
  Random  _random;
  List    _rNAr;

  //getter
  List get randomNumberAr => _rNAr;

  num _randomN() {
    int r0 = _random.nextInt(_hLim);
    int r1 = _random.nextInt(_hLim);
    int r2 = _random.nextInt(_hLim);
    int r3 = _random.nextInt(_hLim);

    num rslt = _min + (r0 + r1 + r2 + r3) / 4000.0;  //Add the OS back in...
    _sum += rslt; //#DEBUG ONLY
    return( rslt );
  }

  RandomNormal(this._nEle, this._min, this._max, [this._seed = null]) {
    if (_seed == null ) {
      Random r = new Random();
      _seed    = r.nextInt(1000);
    }
    _hLim   = (_max - _min).ceil() * 1000;
    _random = new Random(_seed);
    _rNAr   = [];
    _sum    = 0;//#DEBUG ONLY

    h2("RandomNormal with k: ${_nEle}, Seed: ${_seed}, Min: ${_min}, Max: ${_max}");//#DEBUG ONLY
    for(int n = 0; n < _nEle; n++ ){
      num randomN = _randomN();
      //p("randomN  = ${randomN}");
      LIST_add( _rNAr, randomN );
    }

    h3("Mean = ${_sum/_nEle}");//#DEBUG ONLY
  }
}


new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);
new RandomNormal(1000, 80, 120);

Ensuite, vous pouvez simplement l'utiliser comme ceci pour vérifier la moyenne des séries de 1000 nums généré entre une limite basse et haute. Les valeurs sont stockées dans la classe pour qu'elles soient accessibles après instanciation.

_swarmii