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

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 个数字的最后一位数字等于 0，则将其中断。为了做到这一点，我必须打破外循环，但不知道如何，我绝对确定我不必...

Answer 1

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

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

Answer 2

According to MDN,

除了抛出异常之外，没有其他方法可以停止或中断 forEach() 循环。如果您需要这种行为，那么 forEach() 方法是错误的工具。请改用普通循环或for...of。

如果您将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}$/) 在 str 的末尾找到 0 到 2 个零，并将它们作为单元素数组中的字符串返回。该字符串的长度是您可以从str 中删除的字符数。您可以遍历您的数字字符串数组，在必要时中断，并使用 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 3

这个解决方案可能看起来有点麻烦，但它应该适用于所有可能的情况。始终返回最少的小数位数/前导零应该很容易。

希望对你有帮助。

// 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 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) - 长度为 0.11 (2) = 2

我们将 2 个零添加到 3.11，这将成为 3.1100

Answer 5

我认为您可以开始假设您将删除两个额外的零，然后循环遍历数组以查找最后两个位置的数字。使用逗号，我假设您的 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);
    }
}