Develop Reference

How to add values in javascript when converting from string

I have a string that I try to convert to a decimal number with 16 decimals. Then I like to add that number to the number 0 which should be:
30280.9529335
But I get: 030280.9529335
How do you properly do this in javascript?
var totalnumber = 0; var str = "30280.9529335";
totalnumber = totalnumber + ConvertToDouble(str);
console.log(totalnumber); //030280.9529335
function ConvertToDouble(x) {
return Number.parseFloat(x).toFixed(16);
}

Well your problem is placement of toFixed, toFixed return String not number
console.log(typeof (1).toFixed(2))
So here your ConvertToDouble function returns string and 0 + some numeric string will act as concatenation not addition
var totalnumber = 0; var str = "30280.9529335";
totalnumber = totalnumber + ConvertToDouble(str);
console.log(totalnumber.toFixed(16)); //030280.9529335
function ConvertToDouble(x) {
return Number.parseFloat(x)
}

You can use Number.parseFloat and Number.parseInt similar to how you were. You used toFixed incorrectly.
The toFixed() method converts a number into a string, keeping a specified number of decimals. If the desired number of decimals are higher than the actual number, nulls are added to create the desired decimal length.
Example:
let a = "30280.9529335";
console.log(parseFloat(a))
// 30280.9529335
let totalnumber = 0;
let str = "30280.9529335";
function convert(a, b) {
try {
return (Number.parseInt(a) + Number.parseFloat(b)).toFixed(16)
} catch(error) {
return error;
}
}
function convertb(a, b) {
try {
return Number.parseInt(a) + Number.parseFloat(b)
} catch(error) {
return error;
}
}
console.log(convert(totalnumber, str))
console.log(convertb(totalnumber, str))
You can also use bigInts https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt
const theBiggestInt = 9007199254740991n;
const alsoHuge = BigInt(9007199254740991);
// ↪ 9007199254740991n
const hugeString = BigInt("9007199254740991");
// ↪ 9007199254740991n
const hugeHex = BigInt("0x1fffffffffffff");
// ↪ 9007199254740991n
const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111");
// ↪ 9007199254740991n

How to transform numb string to shorter version, and then back to normal form?

I have string of numbers, like '1324436234235464234'. I need to transform this string to something like '5R2f2t4', or other symbol sequence, not very long, all this has to be implemented on client. After this transformation, it's needed to transform it back on server side(node.js).
It looks like encryption/decryption task, but in this case I don't care about security. Is it possible to implement this sequence of transformations?
UPDATE: I can't use DB.

Since your input string is always the same length, you can do a conversion from decimal to some other higher base.
Converting to the short form:
const encode = (alphabetString, input) => {
const alphabet = Array.from(alphabetString);
const digits = input.split('').map(Number);
const result = [];
for (;;) {
let isZero = true;
// Divide the number in `digits` by the alphabet size
let carry = 0;
for (let i = 0; i < digits.length; i++) {
const digit = 10 * carry + digits[i];
if (digit !== 0) {
isZero = false;
}
digits[i] = digit / alphabet.length >>> 0;
carry = digit % alphabet.length;
}
if (isZero) {
break;
}
result.push(alphabet[carry]);
}
return result.reverse().join('') || alphabet[0];
};
const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
console.log(encode(ALPHABET, '1324436234235464234'));
The conversion back with BigInt support (i.e. you’re using Node.js 10):
const decode = (alphabet, input) => {
const map = new Map(
Array.from(alphabet, Array.of)
);
const fromBase = BigInt(alphabet.length);
let value = 0n;
for (const c of input) {
value = fromBase * value + BigInt(map.get(c));
}
return String(value);
};
const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
console.log(decode(ALPHABET, '1Zpvmcf1O26').padStart(19, '0'));
The conversion back without BigInt support:
const decode = (alphabet, input) => {
const map = new Map(
Array.from(alphabet, Array.of)
);
const digits = Array.from(input, c => map.get(c));
const result = [];
for (;;) {
let isZero = true;
let carry = 0;
for (let i = 0; i < digits.length; i++) {
const digit = alphabet.length * carry + digits[i];
if (digit !== 0) {
isZero = false;
}
digits[i] = digit / 10 >>> 0;
carry = digit % 10;
}
if (isZero) {
break;
}
result.push(carry);
}
return result.reverse().join('') || '0';
};
const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
console.log(decode(ALPHABET, '1Zpvmcf1O26').padStart(19, '0'));
Using ASCII digits and letters (62) gives results of up to length 11 for inputs of 19 digits. If you can put more characters in the alphabet with no problems at all, like if you’re trying to fit as many 19-digit strings as possible in a tweet to be read by a machine, do so – each additional character makes some number of inputs shorter (but the returns are diminishing).
If you need to be compatible with older browsers, mind that the const alphabet = Array.from(alphabetString) is only necessary when using characters that require multiple UTF-16 code units. With only ASCII, you can delete that line and rename alphabetString to alphabet.

There are some libs on npm that would do that for you. This one for example
Here is the RunKit example
You can also pick his brain here: https://github.com/cschen1205/js-string-compression/blob/master/src/jsscompress.js
And there is lzutf8 which would give you something like this:
var l = require("lzutf8")
var result = l.compress('asdasdsadsadsadsadsadsadaseqwrewqasdsadsadsadsadsadsadsadsadsadsadsadsadsadfgweg43g', {outputEncoding: 'Base64' })
console.log(result)
//"YXNkYXNkc2HQA2FzZXF3cmV3cdUe1QNmZ3dlZzQzZw=="
var result2 = l.decompress(result, {inputEncoding: 'Base64'})
console.log(result2)
// "asdasdsadsadsadsadsadsadaseqwrewqas…adsadsadsadsadsadsadsadsadfgweg43g"

You basically want to compress the data you have, but just a head's up, typical compression algorithms wouldn't give you much of a drastic compression result for so small input.
There is this library for zlib related things in JavaScript which you can use to deflate your input.
// For shortening your input
function shorten(input) {
const compressed = pako.deflate(input);
return btoa(String.fromCharCode.apply(null, compressed));
}
// For getting the original value
function revert(compressed) {
const decompressed = pako.inflate(compressed);
return atob(btoa(String.fromCharCode.apply(null, decompressed)));
}
You can send the return value of the shorten function to the server and the server can use the revert function to decompress the string again.
Something to play with:
function cmprs(input) {
const compressed = pako.deflate(input);
return {
base64: btoa(String.fromCharCode.apply(null, compressed)),
binary: compressed
};
}
function revert(compressed) {
const decompressed = pako.inflate(compressed);
return btoa(String.fromCharCode.apply(null, decompressed));
}
document.querySelector("#input").addEventListener("keyup", ev => {
const value = ev.target.value;
document.querySelector("#output").textContent = cmprs(value).base64;
document.querySelector("#decompressed").textContent = atob(
revert(cmprs(value).binary)
);
});
<input id="input" />
<br />
Output: <span id="output"></span>
<br />
Decompressed: <span id="decompressed"></span>
<script src="https://cdnjs.cloudflare.com/ajax/libs/pako/1.0.6/pako.js"></script>
<script src="src/index.js"></script>
CodeSandbox Example

How do get input 2^3 to Math.pow(2, 3)?

I have this simple calculator script, but it doesn't allow power ^.
function getValues() {
var input = document.getElementById('value').value;
document.getElementById('result').innerHTML = eval(input);
}
<label for="value">Enter: </label><input id="value">
<div id="result">Results</div>
<button onclick="getValues()">Get Results</button>
I tried using input = input.replace( '^', 'Math.pow(,)');
But I do not know how to get the values before '^' and after into the brackets.
Example: (1+2)^3^3 should give 7,625,597,484,987

Use a regular expression with capture groups:
input = '3 + 2 ^3';
input = input.replace(/(\d+)\s*\^\s*(\d+)/g, 'Math.pow($1, $2)');
console.log(input);
This will only work when the arguments are just numbers. It won't work with sub-expressions or when you repeat it, like
(1+2)^3^3
This will require writing a recursive-descent parser, and that's far more work than I'm willing to put into an answer here. Get a textbook on compiler design to learn how to do this.

I don't think you'll be able to do this with simple replace.
If you want to parse infix operators, you build two stacks, one for symbols, other for numbers. Then sequentially walk the formula ignoring everything else than symbols, numbers and closing parenthesis. Put symbols and numbers into their stacks, but when you encounter closing paren, take last symbol and apply it to two last numbers. (was invented by Dijkstra, I think)
const formula = '(1+2)^3^3'
const symbols = []
const numbers = []
function apply(n2, n1, s) {
if (s === '^') {
return Math.pow(parseInt(n1, 10), parseInt(n2, 10))
}
return eval(`${n1} ${s} ${n2}`)
}
const applyLast = () => apply(numbers.pop(), numbers.pop(), symbols.pop())
const tokenize = formula => formula.split(/(\d+)|([\^\/\)\(+\-\*])/).filter(t => t !== undefined && t !== '')
const solver = (formula) => {
const tf = tokenize(formula)
for (let l of formula) {
const parsedL = parseInt(l, 10)
if (isNaN(parsedL)) {
if (l === ')') {
numbers.push(applyLast())
continue
} else {
if (~['+', '-', '*', '/', '^'].indexOf(l))
symbols.push(l)
continue
}
}
numbers.push(l)
}
while (symbols.length > 0)
numbers.push(applyLast())
return numbers.pop()
}
console.log(solver(formula))

Get your input into a string and do...
var input = document.getElementById('value').value;
var values = input.split('^'); //will save an array with [value1, value 2]
var result = Math.pow(values[0], values[1]);
console.log(result);
This only if your only operation is a '^'
EDIT: Saw example after edit, this no longer works.

function getValues() {
var input = document.getElementById('value').value;
// code to make ^ work like Math.pow
input = input.replace( '^', '**');
document.getElementById('result').innerHTML = eval(input);
}
The ** operator can replace the Math.pow function in most modern browsers. The next version of Safari (v10.1) coming out any day supports it.

As said in other answers here, you need a real parser to solve this correctly. A regex will solve simple cases, but for nested statements you need a recursive parser. For Javascript one library that offers this is peg.js.
In your case, the example given in the online version can be quickly extended to handle powers:
Expression
= head:Term tail:(_ ("+" / "-") _ Term)* {
var result = head, i;
for (i = 0; i < tail.length; i++) {
if (tail[i][1] === "+") { result += tail[i][3]; }
if (tail[i][1] === "-") { result -= tail[i][3]; }
}
return result;
}
Term
= head:Pow tail:(_ ("*" / "/") _ Pow)* { // Here I replaced Factor with Pow
var result = head, i;
for (i = 0; i < tail.length; i++) {
if (tail[i][1] === "*") { result *= tail[i][3]; }
if (tail[i][1] === "/") { result /= tail[i][3]; }
}
return result;
}
// This is the new part I added
Pow
= head:Factor tail:(_ "^" _ Factor)* {
var result = 1;
for (var i = tail.length - 1; 0 <= i; i--) {
result = Math.pow(tail[i][3], result);
}
return Math.pow(head, result);
}
Factor
= "(" _ expr:Expression _ ")" { return expr; }
/ Integer
Integer "integer"
= [0-9]+ { return parseInt(text(), 10); }
_ "whitespace"
= [ \t\n\r]*
It returns the expected output 7625597484987 for the input string (1+2)^3^3.

Here is a Python-based version of this question, with solution using pyparsing: changing ** operator to power function using parsing?

How to generate a Random token of 32 bit in Javascript?

I need to generate an accurate 32 bits random alphanumeric string in JavaScript.Is there any direct function to do it ?

Using crypto and a typed array;
function random32bit() {
let u = new Uint32Array(1);
window.crypto.getRandomValues(u);
let str = u[0].toString(16).toUpperCase();
return '00000000'.slice(str.length) + str;
}
This gives us a 32-bit crypto-random number represented as a zero-padded string of 8 chars (base 16)
If you want to extend this to arbitrary numbers of chars;
function randomHash(nChar) {
let nBytes = Math.ceil(nChar = (+nChar || 8) / 2);
let u = new Uint8Array(nBytes);
window.crypto.getRandomValues(u);
let zpad = str => '00'.slice(str.length) + str;
let a = Array.prototype.map.call(u, x => zpad(x.toString(16)));
let str = a.join('').toUpperCase();
if (nChar % 2) str = str.slice(1);
return str;
}
In ES5, with comments
function randomHash(nChar) {
// convert number of characters to number of bytes
var nBytes = Math.ceil(nChar = (+nChar || 8) / 2);
// create a typed array of that many bytes
var u = new Uint8Array(nBytes);
// populate it wit crypto-random values
window.crypto.getRandomValues(u);
// convert it to an Array of Strings (e.g. "01", "AF", ..)
var zpad = function (str) {
return '00'.slice(str.length) + str
};
var a = Array.prototype.map.call(u, function (x) {
return zpad(x.toString(16))
});
// Array of String to String
var str = a.join('').toUpperCase();
// and snip off the excess digit if we want an odd number
if (nChar % 2) str = str.slice(1);
// return what we made
return str;
}

I need to generate an accurate 32 bits random alphanumeric string in
JavaScript.
If you mean 32 characters, you can use URL.createObjectURL, String.prototype.slice(), String.prototype.replace()
var rand = URL.createObjectURL(new Blob([])).slice(-36).replace(/-/g, "")

Inspired by Paul S.'s answer but a little simpler:
const Token = () => {
const array = new Uint32Array(1)
window.crypto.getRandomValues(array)
return array[0].toString(36)
}

You can use this function:
function returnHash(){
abc = "abcdefghijklmnopqrstuvwxyz1234567890".split("");
var token="";
for(i=0;i<32;i++){
token += abc[Math.floor(Math.random()*abc.length)];
}
return token; //Will return a 32 bit "hash"
}
Use by calling returnHash()

This will generate the 32 bit random alphanumeric string as requested:
crypto.getRandomValues(new Uint8Array(4)).reduce((p,c)=>p+String.fromCharCode(c))

How to convert a currency string to a double with Javascript?

I have a text box that will have a currency string in it that I then need to convert that string to a double to perform some operations on it.
"$1,100.00" → 1100.00
This needs to occur all client side. I have no choice but to leave the currency string as a currency string as input but need to cast/convert it to a double to allow some mathematical operations.

Remove all non dot / digits:
var currency = "-$4,400.50";
var number = Number(currency.replace(/[^0-9.-]+/g,""));

accounting.js is the way to go. I used it at a project and had very good experience using it.
accounting.formatMoney(4999.99, "€", 2, ".", ","); // €4.999,99
accounting.unformat("€ 1.000.000,00", ","); // 1000000
You can find it at GitHub

Use a regex to remove the formating (dollar and comma), and use parseFloat to convert the string to a floating point number.`
var currency = "$1,100.00";
currency.replace(/[$,]+/g,"");
var result = parseFloat(currency) + .05;

I know this is an old question but wanted to give an additional option.
The jQuery Globalize gives the ability to parse a culture specific format to a float.
https://github.com/jquery/globalize
Given a string "$13,042.00", and Globalize set to en-US:
Globalize.culture("en-US");
You can parse the float value out like so:
var result = Globalize.parseFloat(Globalize.format("$13,042.00", "c"));
This will give you:
13042.00
And allows you to work with other cultures.

I know this is an old question, but CMS's answer seems to have one tiny little flaw: it only works if currency format uses "." as decimal separator.
For example, if you need to work with russian rubles, the string will look like this:
"1 000,00 rub."
My solution is far less elegant than CMS's, but it should do the trick.
var currency = "1 000,00 rub."; //it works for US-style currency strings as well
var cur_re = /\D*(\d+|\d.*?\d)(?:\D+(\d{2}))?\D*$/;
var parts = cur_re.exec(currency);
var number = parseFloat(parts[1].replace(/\D/,'')+'.'+(parts[2]?parts[2]:'00'));
console.log(number.toFixed(2));
Assumptions:
currency value uses decimal notation
there are no digits in the string that are not a part of the currency value
currency value contains either 0 or 2 digits in its fractional part *
The regexp can even handle something like "1,999 dollars and 99 cents", though it isn't an intended feature and it should not be relied upon.
Hope this will help someone.

This example run ok
var currency = "$1,123,456.00";
var number = Number(currency.replace(/[^0-9\.]+/g,""));
console.log(number);

For anyone looking for a solution in 2021 you can use Currency.js.
After much research this was the most reliable method I found for production, I didn't have any issues so far. In addition it's very active on Github.
currency(123); // 123.00
currency(1.23); // 1.23
currency("1.23") // 1.23
currency("$12.30") // 12.30
var value = currency("123.45");
currency(value); // 123.45
typescript
import currency from "currency.js";
currency("$12.30").value; // 12.30

This is my function. Works with all currencies..
function toFloat(num) {
dotPos = num.indexOf('.');
commaPos = num.indexOf(',');
if (dotPos < 0)
dotPos = 0;
if (commaPos < 0)
commaPos = 0;
if ((dotPos > commaPos) && dotPos)
sep = dotPos;
else {
if ((commaPos > dotPos) && commaPos)
sep = commaPos;
else
sep = false;
}
if (sep == false)
return parseFloat(num.replace(/[^\d]/g, ""));
return parseFloat(
num.substr(0, sep).replace(/[^\d]/g, "") + '.' +
num.substr(sep+1, num.length).replace(/[^0-9]/, "")
);
}
Usage : toFloat("$1,100.00") or toFloat("1,100.00$")

// "10.000.500,61 TL" price_to_number => 10000500.61
// "10000500.62" number_to_price => 10.000.500,62
JS FIDDLE: https://jsfiddle.net/Limitlessisa/oxhgd32c/
var price="10.000.500,61 TL";
document.getElementById("demo1").innerHTML = price_to_number(price);
var numberPrice="10000500.62";
document.getElementById("demo2").innerHTML = number_to_price(numberPrice);
function price_to_number(v){
if(!v){return 0;}
v=v.split('.').join('');
v=v.split(',').join('.');
return Number(v.replace(/[^0-9.]/g, ""));
}
function number_to_price(v){
if(v==0){return '0,00';}
v=parseFloat(v);
v=v.toFixed(2).replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
v=v.split('.').join('*').split(',').join('.').split('*').join(',');
return v;
}

You can try this
var str = "$1,112.12";
str = str.replace(",", "");
str = str.replace("$", "");
console.log(parseFloat(str));

let thousands_seps = '.';
let decimal_sep = ',';
let sanitizeValue = "R$ 2.530,55".replace(thousands_seps,'')
.replace(decimal_sep,'.')
.replace(/[^0-9.-]+/, '');
// Converting to float
// Result 2530.55
let stringToFloat = parseFloat(sanitizeValue);
// Formatting for currency: "R$ 2.530,55"
// BRL in this case
let floatTocurrency = Number(stringToFloat).toLocaleString('pt-BR', {style: 'currency', currency: 'BRL'});
// Output
console.log(stringToFloat, floatTocurrency);

I know you've found a solution to your question, I just wanted to recommend that maybe you look at the following more extensive jQuery plugin for International Number Formats:
International Number Formatter

How about simply
Number(currency.replace(/[^0-9-]+/g,""))/100;
Works with all currencies and locales. replaces all non-numeric chars (you can have €50.000,00 or $50,000.00) input must have 2 decimal places

jQuery.preferCulture("en-IN");
var price = jQuery.format(39.00, "c");
output is: Rs. 39.00
use jquery.glob.js,
jQuery.glob.all.js

Here's a simple function -
function getNumberFromCurrency(currency) {
return Number(currency.replace(/[$,]/g,''))
}
console.log(getNumberFromCurrency('$1,000,000.99')) // 1000000.99

For currencies that use the ',' separator mentioned by Quethzel Diaz
Currency is in Brazilian.
var currency_br = "R$ 1.343,45";
currency_br = currency_br.replace('.', "").replace(',', '.');
var number_formated = Number(currency_br.replace(/[^0-9.-]+/g,""));

var parseCurrency = function (e) {
if (typeof (e) === 'number') return e;
if (typeof (e) === 'string') {
var str = e.trim();
var value = Number(e.replace(/[^0-9.-]+/g, ""));
return str.startsWith('(') && str.endsWith(')') ? -value: value;
}
return e;
}

This worked for me and covers most edge cases :)
function toFloat(num) {
const cleanStr = String(num).replace(/[^0-9.,]/g, '');
let dotPos = cleanStr.indexOf('.');
let commaPos = cleanStr.indexOf(',');
if (dotPos < 0) dotPos = 0;
if (commaPos < 0) commaPos = 0;
const dotSplit = cleanStr.split('.');
const commaSplit = cleanStr.split(',');
const isDecimalDot = dotPos
&& (
(commaPos && dotPos > commaPos)
|| (!commaPos && dotSplit[dotSplit.length - 1].length === 2)
);
const isDecimalComma = commaPos
&& (
(dotPos && dotPos < commaPos)
|| (!dotPos && commaSplit[commaSplit.length - 1].length === 2)
);
let integerPart = cleanStr;
let decimalPart = '0';
if (isDecimalComma) {
integerPart = commaSplit[0];
decimalPart = commaSplit[1];
}
if (isDecimalDot) {
integerPart = dotSplit[0];
decimalPart = dotSplit[1];
}
return parseFloat(
`${integerPart.replace(/[^0-9]/g, '')}.${decimalPart.replace(/[^0-9]/g, '')}`,
);
}
toFloat('USD 1,500.00'); // 1500
toFloat('USD 1,500'); // 1500
toFloat('USD 500.00'); // 500
toFloat('USD 500'); // 500
toFloat('EUR 1.500,00'); // 1500
toFloat('EUR 1.500'); // 1500
toFloat('EUR 500,00'); // 500
toFloat('EUR 500'); // 500

Such a headache and so less consideration to other cultures for nothing...
here it is folks:
let floatPrice = parseFloat(price.replace(/(,|\.)([0-9]{3})/g,'$2').replace(/(,|\.)/,'.'));
as simple as that.

$ 150.00
Fr. 150.00
€ 689.00
I have tested for above three currency symbols .You can do it for others also.
var price = Fr. 150.00;
var priceFloat = price.replace(/[^\d\.]/g, '');
Above regular expression will remove everything that is not a digit or a period.So You can get the string without currency symbol but in case of " Fr. 150.00 " if you console for output then you will get price as
console.log('priceFloat : '+priceFloat);
output will be like priceFloat : .150.00
which is wrong so you check the index of "." then split that and get the proper result.
if (priceFloat.indexOf('.') == 0) {
priceFloat = parseFloat(priceFloat.split('.')[1]);
}else{
priceFloat = parseFloat(priceFloat);
}

function NumberConvertToDecimal (number) {
if (number == 0) {
return '0.00';
}
number = parseFloat(number);
number = number.toFixed(2).replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1");
number = number.split('.').join('*').split('*').join('.');
return number;
}

This function should work whichever the locale and currency settings :
function getNumPrice(price, decimalpoint) {
var p = price.split(decimalpoint);
for (var i=0;i<p.length;i++) p[i] = p[i].replace(/\D/g,'');
return p.join('.');
}
This assumes you know the decimal point character (in my case the locale is set from PHP, so I get it with <?php echo cms_function_to_get_decimal_point(); ?>).

You should be able to handle this using vanilla JS. The Internationalization API is part of JS core: ECMAScript Internationalization API
https://www.w3.org/International/wiki/JavaScriptInternationalization
This answer worked for me: How to format numbers as currency strings