Converti un numero negativo in uno positivo in JavaScript

Esiste una funzione matematica in JavaScript che converte i numeri in valore positivo?

Potresti usare questo ...

Math.abs(x)

Math​.abs()| MDN

Che dire x *= -1? Mi piace la sua semplicità.

Math.abs(x)o se si è certi il valore è negativo prima della conversione basta anteporre un segno meno regolare: x = -x.

Il segno meno (-) può convertire numeri positivi in ​​numeri negativi e numeri negativi in ​​numeri positivi. x=-yè lo zucchero visivo per x=(y*-1).

var y = -100;
var x =- y;

unsigned_value = Math.abs(signed_value);

var posNum = (num < 0) ? num * -1 : num; // if num is negative multiple by negative one ... 

Trovo questa soluzione facile da capire.

Se desideri scrivere un codice interessante che nessun altro potrà mai aggiornare, prova questo:

~ --x

So che è un po 'tardi, ma per le persone che lottano con questo, puoi usare le seguenti funzioni:

• Trasforma qualsiasi numero in positivo

  let x =  54;
  let y = -54;
  let resultx =  Math.abs(x); //  54
  let resulty =  Math.abs(y); //  54

• Trasforma qualsiasi numero in negativo

  let x =  54;
  let y = -54;
  let resultx = -Math.abs(x); // -54
  let resulty = -Math.abs(y); // -54

• Invertire qualsiasi numero

  let x =  54;
  let y = -54;
  let resultx = -(x);         // -54
  let resulty = -(y);         //  54

Da negativo a positivo

var X = -10 ;
var number = Math.abs(X);     //result 10

Da positivo a negativo

var X = 10 ;
var number = (X)*(-1);       //result -10

Moltiplicare per (-1) è il modo più veloce per convertire un numero negativo in positivo. Ma devi stare attento a non convertire il mio errore in un numero positivo in negativo! Quindi è necessario un controllo aggiuntivo ...

Quindi Math.abs, Math.floor e parseInt sono i più lenti.

https://jsperf.com/test-parseint-and-math-floor-and-mathabs/1

Ho fatto qualcosa del genere da solo.

num<0?num*=-1:'';

Verifica se il numero è negativo e, se lo è, moltiplicalo per -1 Questo restituisce un valore, dipende da te se lo acquisisci. Nel caso in cui tu voglia assegnarlo a qualcosa, probabilmente dovresti fare qualcosa del tipo:

var out = num<0?num*=-1:num; //I think someone already mentioned this variant.

Ma dipende davvero qual è il tuo obiettivo. Per me è stato semplice, rendilo positivo se negativo, altrimenti non fare nulla. Da qui il '' nel codice. In questo caso ho usato l'operatore terziario perché volevo, potrebbe benissimo essere:

if(num<0)num*=-1;

Ho visto la soluzione bit per bit qui e volevo commentare anche quella.

~--num; //Drawback for this is that num original value will be reduced by 1

Quest'anima è molto elegante secondo me, potremmo riscriverla in questo modo:

~(num = num-1);

In termini semplici, prendiamo il numero negativo, ne togliiamo uno e poi lo invertiamo bit per bit. Se lo avessimo invertito bit per bit normalmente avremmo un valore 1 troppo piccolo. Puoi anche fare questo:

~num+1; //Wont change the actual num value, merely returns the new value

Ciò farà lo stesso ma invertirà prima e poi aggiungerà 1 al numero positivo. Sebbene CANT lo faccia:

~num++; //Wont display the right value.

Ciò non funzionerà a causa della precedenza , gli operatori postfix come num++verrebbero valutati prima di ~ e il prefisso del motivo++num non funzionerebbe anche se si trova sulla stessa precedenza di NOT bit a bit (~), perché è valutato da destra a sinistra. Ho provato a scambiarli, ma sembra che il prefisso sia un po 'schizzinoso rispetto al NOT bit a bit. Il +1 funzionerà perché '+' ha una precedenza più alta e verrà valutato in seguito.

Ho trovato quella soluzione piuttosto divertente e ho deciso di ampliarla perché è stata appena lanciata lì e postare persone che la guardano probabilmente la stanno ignorando. Anche se sì, non funzionerà con i float.

Le mie speranze sono che questo post non si sia allontanato dalla domanda originale. : /

Il mio approccio minimale

Per convertire un numero negativo in positivo e viceversa

var num = -24;
num -= num*2;
console.log(num)
// result = 24

È possibile utilizzare l' operatore ~ che converte logicamente il numero in negativo e ne aggiunge 1 in negativo:

var x = 3;
x = (~x + 1);
console.log(x)
// result = -3

Conosco un altro modo di farlo. Questa tecnica funziona da negativa a positiva e viceversa

var x = -24;
var result = x * -1;

Vice versa:

var x = 58;
var result = x * -1;

CODICE LIVE:

// NEGATIVE TO POSITIVE: ******************************************
var x = -24;
var result = x * -1;
console.log(result);

// VICE VERSA: ****************************************************
var x = 58;
var result = x * -1;
console.log(result);

// FLOATING POINTS: ***********************************************
var x = 42.8;
var result = x * -1;
console.log(result);

// FLOATING POINTS VICE VERSA: ************************************
var x = -76.8;
var result = x * -1;
console.log(result);

Per una programmazione funzionale Ramda ha un buon metodo per questo. Lo stesso metodo funziona andando da positivo a negativo e viceversa.

https://ramdajs.com/docs/#negate

Se vuoi che il numero sia sempre positivo, qualunque cosa tu possa fare.

function toPositive(n){
    if(n < 0){
        n = n * -1;
    }
    return n;
}
var a = toPositive(2);  // 2
var b = toPositive(-2); // 2

Potresti anche provare questo, ma non lo consiglio:

function makePositive(n){
    return Number((n*-n).toString().replace('-','')); 
}
var a = makePositive(2);  // 2
var b = makePositive(-2); // 2

Il problema è che potresti cambiare il numero in negativo, quindi convertirlo in stringa e rimuovere il - dalla stringa, quindi riconvertirlo in int. Il che immagino richiederebbe una maggiore elaborazione rispetto all'uso dell'altra funzione.

Ho provato questo in php e la prima funzione è più veloce, ma a volte JS fa cose pazze, quindi non posso dirlo con certezza.