¿Cómo obtener un resultado negativo usando el operador de módulo en JavaScript?

El operador % (módulo) en JavaScript da el resto obtenido al dividir dos números. Hay una diferencia entre el operador %(módulo) y el resto . Cuando el resto o %(módulo) se calcula sobre números positivos, ambos se comportan de manera similar, pero cuando se usan números negativos, ambos se comportan de manera diferente. El %(módulo)
de JavaScript se comporta como una operación de resto y da el resto y como el número es negativo, el resto también resulta ser negativo. Entendamos y comparemos la claridad de los resultados de la operación %(modulo) y resto.

Ejemplos de Operador Módulo:

For Positive Numbers:
Input: a = 21, b = 4
Output: 1
Explanation: 
modulo = 21 % 4
modulo = 21 - 4 * 5
modulo = 21 - 20 = 1 
Other Explanation:
The number 21 can be written in terms of 4 as
21 = 5 * 4 + 1
So, here '1' is the result.

For Negative Numbers:
Input: a = -23, b = 4
Output: 1
Explanation: 
modulo = -23 % 4
modulo = -23 + 4 * 6
modulo = -23 + 24 = 1
Other Explanation:
The number -23 can be written in terms of 4 as
-23 = (-6) * 4 + 1
So, here '1' is the result.

Ejemplos de operador Resto:

Remainder operator uses the formula:
Remainder = a - (a / b) * b

Note: Result of (a / b) is first converted into Integer Value.

For Positive Numbers:
Input: a = 21, b = 4
Output: 1
Explanation: 
Remainder = 21 - (21 / 4) * 4 
Remainder = 21 - 5 * 4   
Remainder = 21 - 20 = 1

For Negative Numbers:
Input: a = -23, b = 4
Output: -3
Explanation: 
Remainder = -23 -( -23 / 4) * 4
Remainder = -23 -(-5) * 4
Remainder = -23 + 20 = -3

Entonces, de la comparación anterior, está claro que tanto las operaciones de resto como las de módulo son diferentes. El operador %(módulo) de JavaScript no es más que el operador resto, por eso da resultados negativos en números negativos.

  • Number.prototype: el constructor de prototipos permite agregar nuevas propiedades y métodos a los números de JavaScript, de modo que todos los números obtengan esta propiedad y puedan acceder al método de forma predeterminada.
    Por lo tanto, usaremos Number.prototype para crear una función mod que devolverá un módulo de dos números.

    Sintaxis:

    Number.prototype.mod = function(a) {
        // Calculate
        return this % a;
    }
    

    A continuación, los programas ilustran el operador %(módulo) en JavaScript:

    Ejemplo 1: este ejemplo utiliza el operador de módulo (%) para realizar la operación.

    <script>
      
    // JavaScript code to perform modulo (%)
    // operation on positive numbers
          
    // mod() function
    Number.prototype.mod = function(a) {
          
        // Calculate
        return this % a;
    }
          
    // Driver code
    var x = 21;
    var b = 4;
      
    // Call mod() function
    var result = x.mod(b);
          
    // Print result
    document.write("The outcome is: " + result);
    </script>                                            

    Producción:

    The outcome is: 1
    

    Ejemplo 2:

    <script>
      
    // JavaScript code to perform modulo (%)
    // operation on negative numbers
          
    // Use mod() function
    Number.prototype.mod = function(a) {
          
        // Calculate
        return this % a;
    }
          
    // Driver code
    var x = -21;
    var b = 4;
      
    // Call mod()
    var result = x.mod(b);
          
    // Print result
    document.write("The outcome is: " + result);
    </script>                                

    Producción:

    The outcome is: -1
    

    Por lo tanto, está claro por qué JavaScript %(modulo) da un resultado negativo.

  • Realización de cambios en JavaScript %(módulo) para que funcione como un operador de modulación: para realizar el operador de módulo (%) como módulo real en lugar de calcular el resto. Usaremos la siguiente fórmula.
    Supongamos que los números son a y b, luego calcule mod = a % b

    Sintaxis:

    Number.prototype.mod = function(b) {
        // Calculate
        return ((this % b) + b) % b;
    }
    

    En la fórmula anterior, estamos calculando el módulo a partir del resto usando la propiedad modular (a + b) mod c = (a mod c + b mod c) mod c .

    El siguiente programa ilustra el enfoque anterior:

    Ejemplo:

    <script>
      
    // JavaScript implementation of above approach
          
    // Use mod() function
    Number.prototype.mod = function(b) {
          
        // Calculate
        return ((this % b) + b) % b;
    }
          
    // Driver code
    var x = -21;
    var b = 4;
      
    // Call mod() function
    var result = x.mod(b);
          
    // Print result
    document.write("The outcome is: " + result + "</br>");
          
    x = -33;
    b = 5;
      
    // Call mod() function
    result = x.mod(b);
          
    // Print result
    document.write("The outcome is: " + result);
    </script>                        

    Producción:

    The outcome is: 3
    The outcome is: 2
    

Publicación traducida automáticamente

Artículo escrito por Rajnis09 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *