Detailed explanation of JS randomly generated numbers and sequence methods

This time I will bring you a detailed explanation of JS randomly generated numbers and sequence methods. What are the precautions for JS randomly generated numbers and sequences? Here are practical cases, let’s take a look.

•1.Math.random(); The result is a random number between 0-1 (including 0, excluding 1)

•2.Math.floor(num); Parameters num is a numerical value, and the function result is the integer part of num. The same as the parseInt(num) method for taking integers.

•3.Math.round(num); The parameter num is a numerical value, and the function result is the integer after num is rounded.

•4.Math.ceil(num); Returns the smallest integer greater than or equal to n.

Reasonably use the above method to generate a random number in the specified range:

Including the minimum value but not the maximum value:

ParseInt(num) rounds the incoming Convert num to a small integer. Multiply Math.random() by the difference between the maximum and minimum, process it with parseInt (note that the range at this time is [0-difference)), and add the minimum value, you can get the minimum value but not the maximum integer value.

To obtain a random number that contains the minimum value but not the maximum value, use the following function:

function getRandom1(start, end) {
      var length = end - start;
      var num = parseInt(Math.random() * (length) + start);
      return num;
    }

Including the maximum value but not the minimum value:

　Math.ceil(num)Get the smallest integer greater than or equal to num, that is, convert the passed num into a large integer. Multiply Math.random() by the difference between the maximum and minimum, process it with Math.ceil() (note that the range at this time is (0-difference]), and add the minimum value, you can get the minimum value excluding the minimum value. value but including the maximum value. That is, change the parseInt in the above case to Math.ceil()

To obtain the random number that contains the maximum value but not the minimum value, use the following function:

 function getRandom1(start, end) {
    var length = end - start;
    var num = Math.ceil(Math.random() * (length) + start);
    return num;
  }

The situation where both the maximum value and the minimum value are included:

The maximum value and the minimum value are both included. At this time, the range of possible values ​​has been expanded by 1 compared with the above two cases. In the random number generation stage. , it is necessary to expand the range of possible random numbers by 1. It is possible to use parseInt to round to small values, and to use Math.ceil(num) to convert to large values ​​(regardless of which method is used). , the key is to add 1 to the range during the random number generation stage.

Use the parseInt method

function getRandom1(start, end) {
    var length = end - start + 1;
    var num = parseInt(Math.random() * (length) + end);
    return num;
  }

--------------------- -------------------------------------------------- ---------

Sometimes, just generating random numbers is not enough. You also need to arrange the values ​​in the specified range in random order. We convert this problem into generating random numbers and then add them. Arrays and avoid duplication problems. The numbers generated in each loop are randomly added to the array in order to achieve random arrangement of numerical sizes.

Generate random numbers in the specified range. Sequence:

The random sequence can be implemented directly through the sort method. A group containing a set of numerical elements arranged in order, calls the sort method, and passes in a randomly generated value (which may be positive or negative) through the function. , you can disrupt the order and get the random sequence of the array.

is as follows: getNum() returns an array of numbers 1-10 arranged in order, then the obtained numArr is a random sequence of 1-10. :

  var numArr = getNum().sort(function () {
        return Math.random() - 0.5;
      });

It is also feasible to write your own logic to generate a random sequence:

Define an array to store random numbers, and then loop to generate random numbers. After generation, search in the existing array. If it exists, If the mark becomes false, it means that the generated random number is repeated. If the addition to the array is successful, the array subscript index (indicating the number of array elements) will be incremented and the condition will be exited . . The following example implements a random sequence between 5-10 (the following cases include left and right):

function getOrder(start, end) {
      var length = end - start;
      var myorder = new Array();
      var index = 0;
      while (index < length+1) {
        var flag = true;
        var num = parseInt(Math.random() * (length + 1));
        for (var i in myorder) {
          if (myorder[i] == num) {
            flag = false;
          }
        }
        if (flag == true) {
          myorder[index] = num;
          index++;
        }
      }
      alert(myorder.length);
      alert(myorder);
    }
getOrder(5, 10);

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the PHP Chinese website !

Recommended reading:

This points to the use of call and apply

##Less installation and usage details

The above is the detailed content of Detailed explanation of JS randomly generated numbers and sequence methods. For more information, please follow other related articles on the PHP Chinese website!