精华内容
下载资源
问答
  • Javascript 中内置的 Math 对象提供了一个 random 函数, random 函数的返回值是随机生成的 0~1 之间的任意数。 Math.random() // 0.1953200186720061 Math.floor 函数 Math 对象提供了一个 floor 函数, ...

    Math.random 函数

    Javascript 中内置的 Math 对象提供了一个 random 函数, random 函数的返回值是随机生成的 0~1
    之间的任意数。

    Math.random()
    // 0.1953200186720061

    Math.floor 函数

    Math 对象提供了一个 floor 函数, floor 函数的作用是对一个数进行下摄入,它接收一个数作为参数,
    返回最接近这个数并且小于或者等于这个数的整数.

    Math.floor(2.5)
    // 2

    生成 0 到任意整数之间的随机数

    接下来我们要使用 Math.random 和 Math.floor 生成 0 到 任意整数的随机数. 假设我们要生成 0 ~10
    之间的任意随机整数:

    Math.random()*10

    这样可以生成 0~10 之间的任意浮点数数,接下来:

    Math.floor(Math.random()*10);

    这样我们可以得到 0~9 之间的任意整数,所以我们需要给 10 再加 1:

    Math.floor(Math.random()*(10 + 1));

    这样我们就可以真正得到 0~10 之间任意整数了。由此可以得到生成 0~n 之间任意整数的方法为:

    Math.floor(Math.random()*(n + 1));

    生成指定区间内的任意整数

    上面我们实现了随机生成从 0 到 任意整数之间的随机整数,下面看如何生成 min~max 之间的任意整数

    Math.floor(Math.random()*(max + 1 - min))

    这样就生成了 0 到 (max-min) 之间的任意整数。所以我们需要在 Math.floor 前,给生成的随机数加上 min。
    最终结果就是:

    Math.floor(Math.random()*(max + 1 - min) + min)
    展开全文
  • JavaScript有提供一个生成值区间在(0, 1)的随机小数的函数。 Math.random(); // 0.10529863457509858 如果你和喜欢的人一起执行这个函数,之后生成随机小数一样的话,那就说明你们很喜欢吃榴莲呢。 接下来...

    JavaScript有提供一个生成值区间在(0, 1)的随机小数的函数。

    Math.random(); // 0.10529863457509858

    如果你和喜欢的人一起执行这个函数,之后生成的随机小数一样的话,那就说明你们很喜欢吃榴莲呢。

    接下来我们就利用这个函数去生成指定范围的随机整数。

    function randomRange(min, max) { // min最小值,max最大值
        return Math.floor(Math.random() * (max - min)) + min;
    }

    原理就是,先将最大值减最小值得出差(保证不超过最大值),和一个随机小数相乘,然后加上最小值(保证不小于最小值),最后向下取整。

    使用则传入要指定的最小值和最大值到函数即可。

    console.log(randomRange(0, 1000); // 362

    是不是很简单呢。

     

    "就算彼此交换了几百万条文字,心也没有因此接近一毫米。"

    转载于:https://www.cnblogs.com/yanggb/p/10732787.html

    展开全文
  • 如何可以生成两个指定的变量之间的随机整数JavaScript中,例如x = 4和y = 8将输出任何的4, 5, 6, 7, 8 ?

    如何可以生成两个指定的变量之间的随机整数在JavaScript中,例如x = 4y = 8将输出任何的4, 5, 6, 7, 8


    #1楼

    对于具有范围的随机整数,请尝试:

    function random(minimum, maximum) {
      var bool = true;
    
      while (bool) {
        var number = (Math.floor(Math.random() * maximum + 1) + minimum);
        if (number > 20) {
          bool = true;
        } else {
          bool = false;
        }
      }
    
      return number;
    }
    

    #2楼

    function randomRange(min, max) {
      return ~~(Math.random() * (max - min + 1)) + min
    }
    

    如果您使用的是Underscore.js ,则可以选择使用

    _.random(min, max)
    

    #3楼

    使用计算机程序生成随机数后,如果所选择的数字是初始数字的一部分或全部,则仍将其视为随机数字。 但是,如果更改了它,则数学家不会将其视为随机数,他们可以称其为有偏数。 但是,如果您正在为一个简单的任务开发程序,则不会考虑这种情况。 但是,如果您正在开发一个程序来为诸如彩票程序或赌博游戏之类的有价值的东西生成一个随机数,那么如果您不考虑上述情况,那么您的程序将被管理层拒绝。

    因此,对于那些人,这是我的建议:

    使用Math.random()生成一个随机数(说n )。

    Now for [0,10) ==>  n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e. two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive.
    Then remove the rest after the decimal point. (i.e. get floor) - using Math.floor(), this can be done.
    

    如果您知道如何读取随机数表以选择一个随机数,则可以知道上面的过程(乘以1,10,100等等)并没有违反我在开始时提到的过程。(因为它只会改变小数点的位置。)

    研究以下示例,并根据需要进行开发。

    如果需要样本[0,9],则答案为n * 10,如果需要[0,99],则答案为n * 100,依此类推。

    现在让我们进入您的角色:

    您已问过特定范围内的数字。 (在这种情况下,您在该范围内有偏差。-通过掷骰子从[1,6]中取一个数字,然后将您偏差到[1,6],但当且仅当骰子无偏差时,它仍然是随机的)

    因此,请考虑您的范围==> [78,247]范围内的元素数= 247-78 + 1 = 170; (因为两个边界都是包容性的。

    /*Mthod 1:*/
        var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
        for(; i <= 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 >= 78){ d.push(c); }else{ d.push(a); }
            l = d.length;
        }
        console.log('Method 2:');
        console.log(d);
    

    注意:在方法一中,首先我创建了一个包含所需数字的数组,然后将它们随机放入另一个数组中。 在方法二中,随机生成数字并检查它们是否在所需范围内。 然后将其放入数组。 在这里,我生成了两个随机数,并使用它们的总数来通过最大程度地降低获得有用数的失败率来最大化程序的速度。 但是,将生成的数字相加也会带来一些偏差。 因此,我建议我使用第一种方法来生成特定范围内的随机数。

    在这两种方法中,您的控制台都将显示结果。(在Chrome中按f12键打开控制台)


    #4楼

    Mozilla开发人员网络页面上有一些示例:

    /**
     * Returns a random number between min (inclusive) and max (exclusive)
     */
    function getRandomArbitrary(min, max) {
        return Math.random() * (max - min) + min;
    }
    
    /**
     * Returns a random integer between min (inclusive) and max (inclusive).
     * The value is no lower than min (or the next integer greater than min
     * if min isn't an integer) and no greater than max (or the next integer
     * lower than max if max isn't an integer).
     * Using Math.round() will give you a non-uniform distribution!
     */
    function getRandomInt(min, max) {
        min = Math.ceil(min);
        max = Math.floor(max);
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
    

    这是背后的逻辑。 这是三个简单的规则:

    Math.random()返回一个介于0(含)和1( Math.random()之间的Number 。 所以我们有一个这样的间隔:

    [0 .................................... 1)
    

    现在,我们想要一个介于min (含)和max (不含)之间的数字:

    [0 .................................... 1)
    [min .................................. max)
    

    我们可以使用Math.random在[min,max)间隔中获取对应的对象。 但是,首先我们应该通过从第二个间隔中减去min来解决这个问题:

    [0 .................................... 1)
    [min - min ............................ max - min)
    

    这给出:

    [0 .................................... 1)
    [0 .................................... max - min)
    

    现在我们可以应用Math.random ,然后计算对应的对象。 让我们选择一个随机数:

                    Math.random()
                        |
    [0 .................................... 1)
    [0 .................................... max - min)
                        |
                        x (what we need)
    

    因此,为了找到x ,我们要做:

    x = Math.random() * (max - min);
    

    别忘了加min ,这样我们就可以在[min,max)间隔中得到一个数字:

    x = Math.random() * (max - min) + min;
    

    这是MDN的第一个功能。 第二个,返回介于minmax之间(包括两个端点)的整数。

    现在要获取整数,可以使用roundceilfloor

    您可以使用Math.round(Math.random() * (max - min)) + min ,但这会产生不均匀的分布。 minmax滚动率只有大约一半:

    min...min+0.5...min+1...min+1.5   ...    max-0.5....max
    └───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘   ← Math.round()
       min          min+1                          max
    

    如果从间隔中排除了max ,则滚动的机会比min还要少。

    使用Math.floor(Math.random() * (max - min +1)) + min您可以获得完美的均匀分布。

    min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
    |        |        |         |        |        |
    └───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
       min     min+1               max-1    max
    

    您不能在该方程式中使用ceil()-1 ,因为max现在滚动的机会略少,但是您也可以滚动(不需要的) min-1结果。


    #5楼

    function getRandomizer(bottom, top) {
        return function() {
            return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
        }
    }
    

    用法:

    var rollDie = getRandomizer( 1, 6 );
    
    var results = ""
    for ( var i = 0; i<1000; i++ ) {
        results += rollDie() + " ";    //make a string filled with 1000 random numbers in the range 1-6.
    }
    

    分解:

    我们正在返回一个函数(从函数编程中借用),该函数在被调用时将返回一个在值bottomtop之间的随机整数(包括首尾)。 我们说“包含”是因为我们希望在可以返回的数字范围内同时包含底部和顶部。 这样, getRandomizer( 1, 6 )将返回1、2、3、4、5或6。

    (底部是较低的数字,顶部是较大的数字)

    Math.random() * ( 1 + top - bottom )
    

    Math.random()返回一个介于0和1之间的随机双Math.random() ,如果将它乘以1加上topbottom之间的差,我们将在01+ba之间得到一个双1+ba

    Math.floor( Math.random() * ( 1 + top - bottom ) )
    

    Math.floor将数字四舍五入到最接近的整数。 现在我们有了0top-bottom之间的所有整数。 1看起来令人困惑,但是它必须存在,因为我们一直在四舍五入,因此没有它,就不会真正达到最高数字。 我们生成的随机小数必须在0(1+top-bottom)的范围内,因此我们可以四舍五入并获得在0top-bottom范围内的int

    Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
    

    前面示例中的代码为我们提供了一个0top-bottom范围内的整数,因此,我们现在要做的就是在结果中添加bottom以获得一个范围在bottomtop包括bottom范围内的整数。 :D


    注意:如果您首先传入一个非整数值或更大的数字,您将得到不希望有的行为,但是除非有人要求,否则我不会深入研究参数检查代码,因为它与原始问题的意图相去甚远。


    #6楼

    function getRandomInt(lower, upper)
    {
        //to create an even sample distribution
        return Math.floor(lower + (Math.random() * (upper - lower + 1)));
    
        //to produce an uneven sample distribution
        //return Math.round(lower + (Math.random() * (upper - lower)));
    
        //to exclude the max value from the possible values
        //return Math.floor(lower + (Math.random() * (upper - lower)));
    }
    

    要测试此功能及其功能的变体,请将以下HTML / JavaScript保存到文件中,然后使用浏览器打开。 该代码将产生一个图表,显示一百万个函数调用的分布。 该代码还将记录边缘情况,因此,如果该函数产生的值大于最大值或小于最小值,则you.will.know.about.it。

    <html>
        <head>
            <script type="text/javascript">
            function getRandomInt(lower, upper)
            {
                //to create an even sample distribution
                return Math.floor(lower + (Math.random() * (upper - lower + 1)));
    
                //to produce an uneven sample distribution
                //return Math.round(lower + (Math.random() * (upper - lower)));
    
                //to exclude the max value from the possible values
                //return Math.floor(lower + (Math.random() * (upper - lower)));
            }
    
            var min = -5;
            var max = 5;
    
            var array = new Array();
    
            for(var i = 0; i <= (max - min) + 2; i++) {
              array.push(0);
            }
    
            for(var i = 0; i < 1000000; i++) {
                var random = getRandomInt(min, max);
                array[random - min + 1]++;
            }
    
            var maxSample = 0;
            for(var i = 0; i < max - min; i++) {
                maxSample = Math.max(maxSample, array[i]);
            }
    
            //create a bar graph to show the sample distribution
            var maxHeight = 500;
            for(var i = 0; i <= (max - min) + 2; i++) {
                var sampleHeight = (array[i]/maxSample) * maxHeight;
    
                document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
            }
            document.write('<hr/>');
            </script>
        </head>
        <body>
    
        </body>
    </html>
    

    #7楼

    var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
    

    #8楼

    要获得介于1到6之间的随机数,请首先执行以下操作:

        0.5 + (Math.random() * ((6 - 1) + 1))
    

    这会将随机数乘以6,然后再加上0.5。 接下来通过执行以下操作将数字四舍五入为正整数:

        Math.round(0.5 + (Math.random() * ((6 - 1) + 1))
    

    将数字四舍五入到最接近的整数。

    为了使它更容易理解,请执行以下操作:

        var value = 0.5 + (Math.random() * ((6 - 1) + 1))
        var roll = Math.round(value);
        return roll;
    

    通常,使用变量执行此操作的代码为:

        var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
        var roll = Math.round(value);
        return roll;
    

    之所以要从最小值中减去0.5,是因为仅使用最小值将使您获得的整数比最大值大1。 通过从最小值中减去0.5,实际上可以防止最大值被四舍五入。

    希望能有所帮助。


    #9楼

    最低和最高之间的随机整数:

    function randomRange(l,h){
      var range = (h-l);
      var random = Math.floor(Math.random()*range);
      if (random === 0){random+=1;}
      return l+random;
    }
    

    不是最优雅的解决方案..但是很快。


    #10楼

    返回1到10之间的随机数:

    Math.floor((Math.random()*10) + 1); 
    

    返回1到100之间的随机数:

    Math.floor((Math.random()*100) + 1)
    

    #11楼

    其他答案并没有说明01的完全合理的参数。 相反,您应该使用ceil round 而不是 ceilfloor

    function randomNumber(minimum, maximum){
        return Math.round( Math.random() * (maximum - minimum) + minimum);
    }
    
    console.log(randomNumber(0,1));  # 0 1 1 0 1 0
    console.log(randomNumber(5,6));  # 5 6 6 5 5 6
    console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1
    

    #12楼

    这是我用来生成随机数的方法。

    function random(high,low) {
        high++;
        return Math.floor((Math.random())*(high-low))+low;
    }
    

    我们执行high++是因为Math.random()生成一个介于0(含)和1(不含)之间的随机数。被排除的那个意味着我们必须在执行任何数学运算之前将高值加1。 然后,我们从高点减去低点,从而给我们生成的最大数-从低到高,再到+低,使高点恢复正常,并使最小数至少为低。 然后我们返回结果数

    random(7,3)可以返回3,4,5,6, or 7


    #13楼

    Math.random()

    Mozilla开发人员网络文档中:

    // Returns a random integer between min (include) and max (include)
    
    Math.floor(Math.random() * (max - min + 1)) + min;
    

    有用的例子:

    // 0 - 10
    Math.floor(Math.random() * 11);
    
    // 1 - 10
    Math.floor(Math.random() * 10) + 1;
    
    // 5 - 20
    Math.floor(Math.random() * 16) + 5;
    
    // -10 - (-2)
    Math.floor(Math.random() * 9) - 10;
    

    #14楼

    使用以下代码,您可以在给定范围内生成随机数数组,而无需重复。

    function genRandomNumber(how_many_number,min,max) {
    
                // parameters
                // how_many_number : how many numbers you want to generate. For example it is 5.
                // min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. i.e 4
                // max(inclusive) : maximun value of a range. it must be any positive integer. i.e 50
                // return type: array
    
                var random_number = [];
                for (var i = 0; i < how_many_number; i++) {
                    var gen_num = parseInt((Math.random() * (max-min+1)) + min);
                    do {
                        var is_exist = random_number.indexOf(gen_num);
                        if (is_exist >= 0) {
                            gen_num = parseInt((Math.random() * (max-min+1)) + min);
                        }
                        else {
                            random_number.push(gen_num);
                            is_exist = -2;
                        }
                    }
                    while (is_exist > -1);
                }
                document.getElementById('box').innerHTML = random_number;
            }
    

    #15楼

    这是我对某个范围内的随机数的看法,因为我想获得一个从基数到指数范围内的随机数。 例如,base = 10,指数= 2,给出一个从0到100的随机数,理想情况下,依此类推。

    如果它有助于使用它,则为:

    // get random number within provided base + exponent
    // by Goran Biljetina --> 2012
    
    function isEmpty(value){
        return (typeof value === "undefined" || value === null);
    }
    var numSeq = new Array();
    function add(num,seq){
        var toAdd = new Object();
         toAdd.num = num;
         toAdd.seq = seq;
         numSeq[numSeq.length] = toAdd;
    }
    function fillNumSeq (num,seq){
        var n;
        for(i=0;i<=seq;i++){
            n = Math.pow(num,i);
            add(n,i);
        }
    }
    function getRandNum(base,exp){
        if (isEmpty(base)){
            console.log("Specify value for base parameter");
        }
        if (isEmpty(exp)){
            console.log("Specify value for exponent parameter");
        }
        fillNumSeq(base,exp);
        var emax;
        var eseq;
        var nseed;
        var nspan;
        emax = (numSeq.length);
        eseq = Math.floor(Math.random()*emax)+1;
        nseed = numSeq[eseq].num;
        nspan = Math.floor((Math.random())*(Math.random()*nseed))+1;
        return Math.floor(Math.random()*nspan)+1;
    }
    
    console.log(getRandNum(10,20),numSeq);
    //testing:
    //getRandNum(-10,20);
    //console.log(getRandNum(-10,20),numSeq);
    //console.log(numSeq);
    

    #16楼

        <!DOCTYPE html>
    <html>
        <head>
                <meta charset="utf-8" />
        </head>
        <body>
            <script>
                /*
    
                    assuming that window.crypto.getRandomValues is available
                    the real range would be fron 0 to 1,998 instead of 0 to 2,000
                    See javascript documentation for explanation
                    https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
                */
                var array = new Uint8Array(2);
                window.crypto.getRandomValues(array);
                console.log(array[0] + array[1]);
    
            </script>
        </body>
    </html>
    

    Uint8Array创建一个由最多3位数字组成的数组,该数字最多为999。此代码非常短。


    #17楼

    我知道这个问题已经回答,但我的回答可以帮助某人。

    我在W3Schools上找到了这个简单的方法:

    Math.floor((Math.random() * max) + min);
    

    希望这会帮助某人。


    #18楼

    最多可以处理20位UNIQUE随机数

    JS

    var generatedNumbers = [];
    
    function generateRandomNumber(precision) { // precision --> number precision in integer 
        if (precision <= 20) {
            var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
            if (generatedNumbers.indexOf(randomNum) > -1) {
                if (generatedNumbers.length == Math.pow(10, precision))
                    return "Generated all values with this precision";
                    return generateRandomNumber(precision);
            } else {
                generatedNumbers.push(randomNum);
                return randomNum;
            }
        } else
           return "Number Precision shoould not exceed 20";
    }
    generateRandomNumber(1);
    

    在此处输入图片说明

    JsFiddle


    #19楼

    这是javascript-中的Random类的MS DotNet实现

    var Random = (function () {
    function Random(Seed) {
        if (!Seed) {
            Seed = this.milliseconds();
        }
        this.SeedArray = [];
        for (var i = 0; i < 56; i++)
            this.SeedArray.push(0);
        var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
        var num2 = 161803398 - num;
        this.SeedArray[55] = num2;
        var num3 = 1;
        for (var i_1 = 1; i_1 < 55; i_1++) {
            var num4 = 21 * i_1 % 55;
            this.SeedArray[num4] = num3;
            num3 = num2 - num3;
            if (num3 < 0) {
                num3 += 2147483647;
            }
            num2 = this.SeedArray[num4];
        }
        for (var j = 1; j < 5; j++) {
            for (var k = 1; k < 56; k++) {
                this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
                if (this.SeedArray[k] < 0) {
                    this.SeedArray[k] += 2147483647;
                }
            }
        }
        this.inext = 0;
        this.inextp = 21;
        Seed = 1;
    }
    Random.prototype.milliseconds = function () {
        var str = new Date().valueOf().toString();
        return parseInt(str.substr(str.length - 6));
    };
    Random.prototype.InternalSample = function () {
        var num = this.inext;
        var num2 = this.inextp;
        if (++num >= 56) {
            num = 1;
        }
        if (++num2 >= 56) {
            num2 = 1;
        }
        var num3 = this.SeedArray[num] - this.SeedArray[num2];
        if (num3 == 2147483647) {
            num3--;
        }
        if (num3 < 0) {
            num3 += 2147483647;
        }
        this.SeedArray[num] = num3;
        this.inext = num;
        this.inextp = num2;
        return num3;
    };
    Random.prototype.Sample = function () {
        return this.InternalSample() * 4.6566128752457969E-10;
    };
    Random.prototype.GetSampleForLargeRange = function () {
        var num = this.InternalSample();
        var flag = this.InternalSample() % 2 == 0;
        if (flag) {
            num = -num;
        }
        var num2 = num;
        num2 += 2147483646.0;
        return num2 / 4294967293.0;
    };
    Random.prototype.Next = function (minValue, maxValue) {
        if (!minValue && !maxValue)
            return this.InternalSample();
        var num = maxValue - minValue;
        if (num <= 2147483647) {
            return parseInt((this.Sample() * num + minValue).toFixed(0));
        }
        return this.GetSampleForLargeRange() * num + minValue;
    };
    Random.prototype.NextDouble = function () {
        return this.Sample();
    };
    Random.prototype.NextBytes = function (buffer) {
        for (var i = 0; i < buffer.length; i++) {
            buffer[i] = this.InternalSample() % 256;
        }
    };
    return Random;
    }());
    

    采用:

            var r = new Random();
            var nextInt = r.Next(1, 100); //returns an integer between range
            var nextDbl = r.NextDouble(); //returns a random decimal
    

    #20楼

    这是一个javascript函数的示例,它可以在不使用Math.random()的情况下生成任意指定长度的随机数

        function genRandom(length)
        {
         const t1 = new Date().getMilliseconds();
         var min = "1",max = "9";
         var result;
         var numLength = length;
         if (numLength != 0)
         {
            for (var i = 1; i < numLength; i++)
            {
               min = min.toString() + "0";
               max = max.toString() + "9";
            }
         } 
         else
         {
            min = 0;
            max = 0;
            return; 
         }
    
          for (var i = min; i <= max; i++)
          {
               //Empty Loop
          }
    
          const t2 = new Date().getMilliseconds();
          console.log(t2);
          result = ((max - min)*t1)/t2;
          console.log(result);
          return result;
        }
    

    #21楼

    如果您需要0到max之间的变量,则可以使用:

    Math.floor(Math.random() *  max);
    

    #22楼

    / *编写一个名为randUpTo的函数,该函数接受一个数字并返回一个介于0和该数字之间的随机整数? * /

    var randUpTo = function(num) {
        return Math.floor(Math.random() * (num - 1) + 0);
    };
    

    / *编写一个名为randBetween的函数,该函数接受表示范围的两个数字并返回这两个数字之间的随机整数。 * /

    var randBetween = function (min, max) {
        return Math.floor(Math.random() * (max - min - 1)) + min;
    };
    

    / *编写一个名为randFromTill的函数,该函数接受代表范围的两个数字并返回介于min(含)和max( randFromTill )之间的随机数。 * /

    var randFromTill = function (min, max) {
        return Math.random() * (max - min) + min;
    };
    

    / *编写一个名为randFromTo的函数,该函数接受代表范围的两个数字并返回介于min(含)和max(含)之间的随机整数* /

    var randFromTo = function (min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    };
    

    #23楼

    替代解决方案:-

    let makeGuess = function(guess){
        let min = 1;
        let max = 5;   
        let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min
    
        return guess === randomNumber;
    
    }
    console.log(makeGuess(1));
    

    #24楼

    我想知道足够的运行次数后,这种随机化函数的分布情况如何。

    并且还要检查该分布在不同的浏览器中是否大致相同。

    因此,这是一个要运行的代码段。 可以在按下按钮之前更改数字。

     function getRandomNumberInRange(Min, Max) { return Math.floor(Math.random() * (Max - Min + 1)) + Min; } function printDictAsTable(dict){ let htmlstr = "<table border=1><tr><th>Number</th><th>Count</th></tr>"; let sortedKeys = Object.keys(dict).sort(function(a,b){return ab}); for (let i=0; i<sortedKeys.length; i++) { let key = sortedKeys[i]; htmlstr += "<tr><td>"+ key +" </td><td>" + dict[key] + " </td></tr>"; } htmlstr += "</table>"; document.getElementById("tableContainer").innerHTML = htmlstr; } function loopRandomAndPrint(){ let min = Number(document.getElementById("randomMinLimit").value); let max = Number(document.getElementById("randomMaxLimit").value); if (max < min){let temp = max; max = min; min = temp;} let loopTotal = Number(document.getElementById("loopLimit").value); let dict = {}; for(i = min; i <= max; ++i){ dict[i] = 0; } for(i = 0; i < loopTotal; i++){ let num = getRandomNumberInRange(min, max); dict[num] = dict[num] + 1; } printDictAsTable(dict); } loopRandomAndPrint(); 
     <div id="topContainer"> <div id="inputAndButton" style="float: left;"> <p>Min : <input type="number" id="randomMinLimit" value=4></p> <p>Max : <input type="number" id="randomMaxLimit" value=8></p> <p>Loops: <input type="number" id="loopLimit" value=1000></p> <button type="button" onclick="loopRandomAndPrint()"> Loop random function and show </button> </div> <div id="tableContainer" style="float: right;"> </div> </div> 


    #25楼

    使用此函数获取给定范围之间的随机数

    function rnd(min,max){
        return Math.floor(Math.random()*(max-min+1)+min );
    }
    

    #26楼

    生成五位数的随机数

     function rn(min, max){
        return Math.floor(Math.random() * min + max);
     }
    

     rn(2342, 9999)
    

    希望能帮助到你


    #27楼

    Math.random()快速且适用于多种用途,但是如果您需要密码安全的值(这是不安全的),或者如果您需要来自完全一致的无偏分布的整数(在其他答案中使用的乘法方法会产生结果),则此方法不合适某些值比其他值更频繁)。

    在这种情况下,我们可以使用crypto.getRandomValues()生成安全整数,并拒绝任何我们不能均匀地映射到目标范围的生成值。 这会比较慢,但是除非生成大量的值,否则它并不重要。

    为了澄清偏向分布问题,请考虑以下情况:我们要生成一个介于1到5之间的值,但是我们有一个随机数生成器,它生成介于1到16之间的值(一个4位值)。 我们希望有相同数量的生成值映射到每个输出值,但是16不能平均除以5:它剩下1的余数。因此,我们需要拒绝1个可能的生成值,并且仅当获得可以统一映射到我们目标范围内的15个较小值之一。 我们的行为可能类似于以下伪代码:

    Generate a 4-bit integer in the range 1-16.
    If we generated  1,  6, or 11 then output 1.
    If we generated  2,  7, or 12 then output 2.
    If we generated  3,  8, or 13 then output 3.
    If we generated  4,  9, or 14 then output 4.
    If we generated  5, 10, or 15 then output 5.
    If we generated 16 then reject it and try again.
    

    以下代码使用类似的逻辑,但是会生成一个32位整数,因为这是可以由JavaScript的标准number类型表示的最大公共整数大小。 (如果需要更大的范围,可以将其修改为使用BigInt 。)无论选择哪个范围,被拒绝的生成值的分数始终小于0.5,因此预期的拒绝数始终小于1.0。通常接近0.0; 您无需担心它会永远循环。

     const randomInteger = (min, max) => { const range = max - min; const maxGeneratedValue = 0xFFFFFFFF; const possibleResultValues = range + 1; const possibleGeneratedValues = maxGeneratedValue + 1; const remainder = possibleGeneratedValues % possibleResultValues; const maxUnbiased = maxGeneratedValue - remainder; if (!Number.isInteger(min) || !Number.isInteger(max) || max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) { throw new Error('Arguments must be safe integers.'); } else if (range > maxGeneratedValue) { throw new Error(`Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.`); } else if (max < min) { throw new Error(`max (${max}) must be >= min (${min}).`); } else if (min === max) { return min; } let generated; do { generated = crypto.getRandomValues(new Uint32Array(1))[0]; } while (generated > maxUnbiased); return min + (generated % possibleResultValues); }; console.log(randomInteger(-8, 8)); // -2 console.log(randomInteger(0, 0)); // 0 console.log(randomInteger(0, 0xFFFFFFFF)); // 944450079 console.log(randomInteger(-1, 0xFFFFFFFF)); // Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295. console.log(new Array(12).fill().map(n => randomInteger(8, 12))); // [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9] 


    #28楼

    我制作此函数时考虑了最小值,最大值,排除(要排除的整数列表)和种子(如果需要种子随机生成器)的选项。

    get_random_int = function(args={})
    {
        let def_args =
        {
            min: 0,
            max: 1,
            exclude: false,
            seed: Math.random
        }
    
        args = Object.assign(def_args, args)
    
        let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)
    
        if(args.exclude)
        {
            let diff = args.max - args.min
            let n = num
    
            for(let i=0; i<diff*2; i++)
            {
                if(args.exclude.includes(n))
                {
                    if(n + 1 <= args.max)
                    {
                        n += 1
                    }
    
                    else
                    {
                        n = args.min
                    }
                }
    
                else
                {
                    num = n
                    break
                }
            }
        }
    
        return num
    }
    

    可以像这样使用:

    let n = get_random_int
    (
        {
            min: 0,
            max: some_list.length - 1,
            exclude: [3, 6, 5],
            seed: my_seed_function
        }
    )
    

    或更简单地说:

    let n = get_random_int
    (
        {
            min: 0,
            max: some_list.length - 1
        }
    )
    

    然后,您可以执行以下操作:

    let item = some_list[n]
    

    要点: https : //gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e


    #29楼

    您可以使用此代码段,

    let randomNumber = function(first,second){
    let number = Math.floor(Math.random()*Math.floor(second));
    while(number<first){
    
        number = Math.floor(Math.random()*Math.floor(second));
    }
    return number;
    }
    

    #30楼

    • random(min,max)生成一个介于min(含)和max(不含)之间的随机数
    • Math.floor将数字四舍五入到最接近的整数

       function generateRandomInteger (min, max) { return Math.floor(random(min,max)) }` 

    因此,要生成一个介于4到8之间的随机整数,请使用以下参数调用上述函数:

    generateRandomInteger (4,9)
    

    #31楼

    要获得ragne [x,y]中的强加密随机整数,请尝试

     let rand= (x,y)=> x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0 console.log(rand(4,8)) 


    #32楼

    Ionuț G. Stan给出了一个很好的答案,但这对我来说太复杂了。 因此,我在Jason Anello的https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation中找到了一个更简单的解释。

    注意:在阅读Jason的解释之前,您应该知道的唯一重要的事情是“截断”的定义。 他在描述Math.floor()时使用了该术语。 牛津词典将“截断”定义为:

    剪掉顶部或末端以缩短(东西)。


    #33楼

    我生成0到n之间的随机数的方法(排除n):

    Math.floor((Math.random() * 10) % n)
    
    展开全文
  • Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。 我们的目的是要取某范围内的整数,...

          Math.Random()函数能够返回带正号的double值,该值大于等于0.0且小于1.0,即取值范围是[0.0,1.0)的左闭右开区间,返回值是一个伪随机选择的数,在该范围内(近似)均匀分布。

     

    我们的目的是要取某范围内的整数,所以我们新定义一个Random函数。

    给这个函数两个参数“from”,“to”表示取值范围。

    使用公式:from+Math.random()*(to-from)即可得到double形的范围是from~to的数

    然后强制转换为int形整数即可

    具体代码如下:

    1 function Random(from,to){
    2     var rdmnum = from+Math.random()*(to-from);
    3     rdmnum = parseInt(rdmnum, 10);
    4     return rdmnum;
    5 }

     

    转载于:https://www.cnblogs.com/iStu/p/8480027.html

    展开全文
  • JavaScript 随机JS 数学JS 逻辑Math.random()Math.random() 返回 0(包括) 至 1(不包括) 之间的随机数:实例Math....JavaScript 随机整数Math.random() 与 Math.floor() 一起使用用于返回随机整数。实例Math.floor(...
  • * 指定长度的无重复随机整数生成器 * * @param {number=} length 要生成的数字长度 2~10 * @param {Array} arr 初始数组 * @return {Array} 返回值为数组 */ function raNumsGenerator(length = 4, arr = []) ...
  • //生成一个整数随机数,并且范围为[min,max) test function randomInt(min,max){ if(min < 0 || max <0){ throw "不支持负数"; } var number = parseInt(Math.random().toString().substring(2))....
  • 摘要:  本文讲解如何使用js生成n到m间的随机数字,主要目的是为后期的...生成n-m,包含n但不包含m的整数: 第一步算出 m-n的值,假设等于w 第二步Math.random()*w 第三步Math.random()*w+n 第四步parseInt(Ma...
  • 这个应该是程序设计中...如果我们要想得到随机整数则要在此基础之上多做一步工作。但总结下来根本规则是这样的parseInt(Math.random()*(上限-下限+1)+下限);注意:这种方法产生的随机数范围是同时包含上限和下限的哦
  • JS生成随机整数

    2021-05-07 09:08:29
    JS生成随机整数 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术: Dw、JS 作者: 撰写时间:2021/5/1 首先先了解一下JS JS的全称是 JavaScript ...
  •  1、中的xxx是0-255之间的随机整数,用Math.random()*255取得0-255之间的随机数,  再Math.floor()保留小数点前面的  2、中的x是0123456789abxdef中的随机6个的组合,  这里可以用数组或者字符串处理,这里采用...
  • 生成 [n,m] 的随机整数,包括n和mfunction random(min, max){  var random = max - min + 1;  return Math.floor(Math.random() * random + min); }生成(n, m)的随机小数
  • ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具和关键技术:Visual Studio 2015,JavaScript 作者:金建勇 ...最近在做项目的过程中,遇到了一个需要随机生成编号或者卡号的功能...
  • * 指定长度的无重复随机整数生成器 * * @param {number=} length 要生成的数字长度 2~10 * @param {Array} arr 初始数组 * @return {Array} 返回值为数组 */ function raNumsGenerator(length = 4, arr = []) ...
  • js函数: function randomInt(x1,x2) {  var min_int = parseInt(x1);  var max_int = parseInt(x2);  if ( isNaN(min_int) || isNaN(max_int) ) ... alert('parameter error');...1-100之间的随机整数,包括1 和 100
  • Math.random()生成介于0和≈0.9之间的随机数。 Before multiplying it, it resolves the part between parenthesis (myMax - myMin + 1) because of the grouping operator ( ). 在将其相乘之前,由于分组运算符( )...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 138
精华内容 55
关键字:

javascript随机生成整数

java 订阅