Convertir un nombre négatif en positif en JavaScript

Existe-t-il une fonction mathématique en JavaScript qui convertit les nombres en valeur positive?

Vous pouvez utiliser ceci ...

Math.abs(x)

Math​.abs()| MDN

Et alors x *= -1? J'aime sa simplicité.

Math.abs(x)ou si vous êtes certain de la valeur est négative avant la conversion juste préfixer un signe moins régulier: x = -x.

Le signe moins (-) peut convertir des nombres positifs en nombres négatifs et des nombres négatifs en nombres positifs. x=-yest du sucre visuel pour 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 ... 

Je trouve cette solution facile à comprendre.

Si vous souhaitez écrire du code intéressant que personne d'autre ne pourra jamais mettre à jour, essayez ceci:

~ --x

Je sais que c'est un peu tard, mais pour les personnes aux prises avec cela, vous pouvez utiliser les fonctions suivantes:

• Rendez n'importe quel nombre positif

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

• Transformez n'importe quel nombre en négatif

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

• Inverser n'importe quel nombre

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

Négatif à positif

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

Positif à négatif

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

La multiplication par (-1) est le moyen le plus rapide de convertir un nombre négatif en positif. Mais vous devez faire attention à ne pas convertir mon erreur en nombre positif en négatif! Un contrôle supplémentaire est donc nécessaire ...

Ensuite, Math.abs, Math.floor et parseInt sont les plus lents.

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

J'ai fait quelque chose comme ça moi-même.

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

Il vérifie si le nombre est négatif et si c'est le cas, multipliez par -1. Cela renvoie une valeur, à vous de voir si vous la capturez. Si vous souhaitez l'attribuer à quelque chose, vous devriez probablement faire quelque chose comme:

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

Mais cela dépend vraiment de votre objectif. Pour moi, c'était simple, le rendre positif s'il est négatif, sinon ne rien faire. D'où le '' dans le code. Dans ce cas j'ai utilisé un opérateur tertiaire car je le voulais, ça pourrait très bien être:

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

J'ai vu la solution au niveau du bit ici et je voulais également commenter celle-ci.

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

Cette soultion est très fantaisiste à mon avis, on pourrait la réécrire comme ceci:

~(num = num-1);

En termes simples, nous prenons le nombre négatif, en retirons un, puis l'inversons au niveau du bit. Si nous l'avions inversé au niveau du bit, nous obtiendrions une valeur 1 trop petite. Vous pouvez également le faire:

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

Cela fera de même mais inversera d'abord, puis ajoutera 1 au nombre positif. Bien que vous puissiez faire ceci:

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

Cela ne fonctionnera pas en raison de la priorité , les opérateurs de suffixe tels que ceux num++qui seraient évalués avant ~ et la raison pour laquelle le préfixe ++numne fonctionnerait pas même s'il est sur la même priorité que NOT au niveau du bit (~), est parce qu'il est évalué de droite à gauche. J'ai essayé de les échanger, mais il semble que le préfixe soit un peu capricieux par rapport au NON bit à bit. Le +1 fonctionnera car «+» a une priorité plus élevée et sera évalué plus tard.

J'ai trouvé cette solution plutôt amusante et j'ai décidé de l'étendre car elle était juste jetée là-bas et les gens qui la regardaient l'ignoraient probablement. Bien que oui, cela ne fonctionnera pas avec des flotteurs.

J'espère que ce message ne s'est pas éloigné de la question d'origine. : /

Mon approche minimale

Pour convertir un nombre négatif en positif et vice-versa

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

Vous pouvez utiliser l' opérateur ~ qui convertit logiquement le nombre en négatif et ajoute 1 au négatif:

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

Je connais une autre façon de le faire. Cette technique fonctionne de négatif à positif et vice versa

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

Vice versa:

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

CODE EN DIRECT:

// 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);

Pour une programmation fonctionnelle, Ramda a une belle méthode pour cela. La même méthode fonctionne du positif au négatif et vice versa.

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

Si vous voulez que le nombre soit toujours positif, peu importe ce que vous pouvez faire.

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

Vous pouvez également essayer ceci, mais je ne le recommande pas:

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

Le problème avec cela est que vous pouvez changer le nombre en négatif, puis convertir en chaîne et supprimer le - de la chaîne, puis reconvertir en int. Ce qui, je suppose, nécessiterait plus de traitement que l'utilisation de l'autre fonction.

J'ai testé cela en php et la première fonction est plus rapide, mais parfois JS fait des choses folles, donc je ne peux pas le dire avec certitude.