根据最大后续零删除逗号后的零

Question

我有一个带有网格的页面，用于保存用户号码。它具有以下模式 - 每个数字都以逗号后的 3 位数字结尾。它看起来不太好，例如用户的输入是

123,450
123,670
123,890

最好在逗号后只留 2 个数字，因为最后的 0 毫无意义且多余。

仅当数组中至少有一个元素未以 0

结尾时，它仍应具有 3 位数字的方式

例如：

123,455
123,450
123,560

在这种情况下，数组的第一个元素的最后一位数字不等于 0，因此所有元素都应该有 3 位数字。同样的故事有 2 个或 1 个零

零是多余的：

123,30
123,40
123,50

零是必需的：

123,35
123,40
123,50

问题是如何以编程方式实现它？我是这样开始的：

var zeros2Remove = 0;
numInArray.forEach(function(item, index, numInArray) 
{
    var threeDigitsAfterComma = item.substring(item.indexOf(',') + 1);

    for(var j = 2; j <= 0; j--) 
    {
        if(threeDigitsAfterComma[j] == 0) 
        {
            zeros2Remove =+ 1;
        } 
        else //have no idea what to do..
    }   
})

好吧，在我的实现中，我不知道该怎么做，因为我必须遍历每个元素，但如果至少有 1 个数字的最后一位数字等于零，则中断它。为了做到这一点，我有打破外循环，但不知道如何，我绝对确定我不必...

Answer 1

我认为您可以开始假设您将删除两个额外的零，然后遍历您的数组以查找最后两个位置的数字。对于逗号，我假设您的 numArray 元素是字符串，所有元素都以相同的长度开头。

var numArray = ['123,000', '456,100', '789,110'];

var removeTwo = true, removeOne = true;
for (var i = 0; i < numArray.length; i++) {
    if (numArray[i][6] !== '0') { removeTwo = false; removeOne = false; }
    if (numArray[i][5] !== '0') { removeTwo = false; }
}

// now loop to do the actual removal
for (var i = 0; i < numArray.length; i++) {
    if (removeTwo) {
        numArray[i] = numArray[i].substr(0, 5);
    } else if (removeOne) {
        numArray[i] = numArray[i].substr(0, 6);
    }
}

Answer 2

这个解决方案可能看起来有点麻烦，但它应该适用于所有可能的情况。总是 return 最小小数位数 places/leading 零应该很容易。

希望对您有所帮助。

// Define any array
const firstArray = [
  '123,4350',
  '123,64470',
  '123,8112390',
]

const oneOfOfYourArrays = [
  '123,30',
  '123,40',
  '123,50',
]

// Converts 123,45 to 123.45
function stringNumberToFloat(stringNumber) {
  return parseFloat(stringNumber.replace(',', '.'))
}

// For 123.45 you get 2
function getNumberOfDecimals(number) {
  return number.split('.')[1].length;
}

// This is a hacky way how to remove traling zeros
function removeTralingZeros(stringNumber) {
  return stringNumberToFloat(stringNumber).toString()
}

// Sorts numbers in array by number of their decimals
function byNumberOfValidDecimals(a, b) {
  const decimalsA = getNumberOfDecimals(a)
  const decimalsB = getNumberOfDecimals(b)
  return decimalsB - decimalsA
}

// THIS IS THE FINAL SOLUTION
function normalizeDecimalPlaces(targetArray) {
  const processedArray = targetArray
  .map(removeTralingZeros) // We want to remove trailing zeros
  .sort(byNumberOfValidDecimals) // Sort from highest to lowest by number of valid decimals

  const maxNumberOfDecimals = processedArray[0].split('.')[1].length

  return targetArray.map((stringNumber) => stringNumberToFloat(stringNumber).toFixed(maxNumberOfDecimals))
}

console.log('normalizedFirstArray', normalizeDecimalPlaces(firstArray))

console.log('normalizedOneOfOfYourArrays', normalizeDecimalPlaces(oneOfOfYourArrays))

Answer 3

According to MDN,

There is no way to stop or break a forEach() loop other than by throwing an exception. If you need such behavior, the forEach() method is the wrong tool. Use a plain loop or for...of instead.

如果您将 forEach 循环转换为 for 循环，您可以使用标签和 break 语句打破它：

// unrelated example
let i;
let j;
outerLoop:
for (i = 2; i < 100; ++i) {
  innerLoop:
  for (j = 2; j < 100; ++j) {
    // brute-force prime factorization
    if (i * j === 2183) { break outerLoop; }
  }
}
console.log(i, j);

我给了你一个不相关的例子，因为你的问题根本不需要嵌套循环。您可以使用正则表达式查找字符串中尾随零的数量：

function getTrailingZeroes (str) {
  return str.match(/0{0,2}$/)[0].length;
}

str.match(/0{0,2}$/) finds between 0 and 2 zeroes at the end of str and returns them as a string in a one-element array. The length of that string is the number of characters you can remove from str. You can make one pass over your array of number-strings, breaking out when necessary, and use Array.map作为一个单独的截断循环：

function getShortenedNumbers (numInArray) {
  let zeroesToRemove = Infinity;
  for (const str of numInArray) {
    let candidate = getTrailingZeroes(str);
    zeroesToRemove = Math.min(zeroesToRemove, candidate);
    if (zeroesToRemove === 0) break;
  }

  return numInArray.map(str => str.substring(0, str.length - zeroesToRemove);
}

总计：

function getTrailingZeroes (str) {
  return str.match(/0{0,2}$/)[0].length;
}

function getShortenedNumbers (numInArray) {
  let zeroesToRemove = Infinity;
  for (const str of numInArray) {
    let candidate = getTrailingZeroes(str);
    zeroesToRemove = Math.min(zeroesToRemove, candidate);
    if (zeroesToRemove === 0) break;
  }

  return numInArray.map(str => str.substring(0, str.length - zeroesToRemove));
}

console.log(getShortenedNumbers(['123,450', '123,670', '123,890']));
console.log(getShortenedNumbers(['123,455', '123,450', '123,560']));

Answer 4

试试这个

function removeZeros(group) {
    var maxLength = 0;
  var newGroup = [];
    for(var x in group) {
    var str = group[x].toString().split('.')[1];
    if(str.length > maxLength) maxLength = str.length;
  }

  for(var y in group) {
    var str = group[y].toString();
    var substr = str.split('.')[1];
    if(substr.length < maxLength) {
        for(var i = 0; i < (maxLength - substr.length); i++) 
        str += '0';
    } 
    newGroup.push(str); 
  }

  return newGroup;
}

在 jsfiddle 上试试：https://jsfiddle.net/32sdvzn1/1/

我的脚本检查每个数字小数部分的长度，请记住 JavaScript 删除了小数中最后的零，所以 3.10 将是 3.1，所以当数字有零时长度会变小最后，在这种情况下，我们只需在数字上加一个零。

更新

我已经更新了脚本，新版本添加了与最大小数长度和分析数字的小数长度之间的差异一样多的零。

例子

我们有：3.11、3.1423、3.1

最大长度为：4 (1423)

maxLenght (4) - .11 (2) 的长度 = 2

我们在 3.11 上加 2 个零，将变成 3.1100

Answer 5

我认为以下代码正是您要查找的内容，请操作数字并查看更改：

var arr = ["111.3030", "2232.0022", "3.001000", "4","558.0200","55.00003000000"];
var map = arr.map(function(a) {
  if (a % 1 === 0) {
    var res = "1";
  } else {
    var lastNumman = a.toString().split('').pop();
    if (lastNumman == 0) {
      var m = parseFloat(a);
      var res = (m + "").split(".")[1].length;
    } else {
      var m = a.split(".")[1].length;
      var res = m;
    }
  }

  return res;

})
var maxNum = map.reduce(function(a, b) {
  return Math.max(a, b);
});

arr.forEach(function(el) {
  console.log(Number.parseFloat(el).toFixed(maxNum));
});

根据最大后续零删除逗号后的零

Removing zeros after comma based on maximum consequent zeros

javascript

string

loops

nested-loops

更新

例子