第 143 题：将 10000000000 形式的字符串，以每 3 位进行分隔展示 10.000.000.000 多种实现方式

Question

千分位（thousands），数学领域术语，一种简化数学表达的方式。小数部分从小数点算起，右边第三位叫做千分位，也可以叫做小数第三位。如：3.754 中的 4 就在千分位。

Answer 1

str.replace(/d(?=(d{3})+$)/g, '$&.');

Answer 2

"1000000000000".split('').reverse().reduce((total, each, i)=>{
        total.push(each)
        if ((i + 1) % 3 == 0) total.push('.')
        return total
}, []).reverse().join('')

有没有考虑到1刚好可以除尽的情况, 就会 .100.000.000.00

Answer 3

如果一行写不出来，我选择不写

// 德国以 . 分割金钱, 转到德国当地格式化方案即可
10000000000..toLocaleString('de-DE') 

// 寻找字符空隙加 .
'10000000000'.replace(/B(?=(d{3})+(?!d))/g, '.')

// 寻找数字并在其后面加 . 
'10000000000'.replace(/(d)(?=(d{3})+b)/g, '$1.')

哪位大神能帮忙解释一下第一种方法为什么有两个点..

Answer 4

如果一行写不出来，我选择不写

// 德国以 . 分割金钱, 转到德国当地格式化方案即可
10000000000..toLocaleString('de-DE') 

// 寻找字符空隙加 .
'10000000000'.replace(/B(?=(d{3})+(?!d))/g, '.')

// 寻找数字并在其后面加 . 
'10000000000'.replace(/(d)(?=(d{3})+b)/g, '$1.')

哪位大神能帮忙解释一下第一种方法为什么有两个点..

因为数字后面接第一个.是会被认为是小数点的，所以就变成了10000000. 之后连接一个toLocaleString('de-DE'),接第二个点才被认为是对这个数字字面量进行操作。

Answer 5

let str = '1000000000000'

let result = [...str].reverse().map( (v, i) => {
  if (i % 3 === 0 && i !== 0) {
    return `${v}.`
  }
  return v
}).reverse().join("")

Answer 6

g, "."); //"10.000.000.000"

应该是酸你想得出来自己想不出来所以就踩了哈哈

Answer 7

'10000000'.replace(/(?!^)(?=(d{3})+$)/g, '.')

Answer 8

Number('1000000000').toLocaleString().replace(/,/g, '.')

Answer 9

不会正则就用粗旷的方式吧

'1000000000000'.split('').reverse().map((v,i)=>{
  return i%3==2?`,${v}`:v
}).reverse().join('')

Answer 10

// 正则不大会...只好一步步来
  function foo(num) {
    const arr = [...num].reverse();
    const rst = arr.reduce((init, ele, i) => {
      i % 3 === 2 ? init.push(ele, '.') : init.push(ele);
      return init;
    }, []);
    return rst.reverse().join('')
  }

'100000000'会输出'.100.000.000'
还需要加个判断 i % 3 === 2&&i!==(arr.length-1) ? init.push(ele, '.') : init.push(ele);

Answer 11

let reg = /(?!^)(?=(d{3})+$)/g
'10000000000'.replace(reg, ',')

Answer 12

Number(100000000000).toLocaleString('de-DE')

Answer 13

87463297 =>"87,463,297"
    "87463297".replace(  /d{1,3}(?=(d{3})+$)/g  ,  (s)=>s+',')
        /d{1,3}(?=(d{3})+$)/g ,//找出后面跟有三个数字的,即["87", "463"],添加逗号在后面即可
            d{1,3} //1-3位数字
            (?=(d{3})+$) //?=表示后面要跟着符合(d{3})+$的, 即1个或多个(3个数字)结尾的

Answer 14

// 从后向前遍历，每次截取三个字符，直到完成
const str = '10000000000';
const arr = [];
for (let len = str.length, i = len - 1; i >= 0; i = i - 3) {
  let start = i - 2;
  if (start < 0) start = 0;
  arr.push(str.slice(start, i + 1));
}
return arr.reverse().join('.');

Answer 15

'10000000000.0000'.replace(/d{1,3}(?=(d{3})+(.d*)?$)/g, '$&,')

笑死我了，运行过吗？

Answer 16

str.split("").reverse().reduce((prev, cur, index) => (index + 1) % 3 == 0 ? '.' + cur + prev : cur + prev)

有点问题
'100000000'.split("").reverse().reduce((prev, cur, index) => (index + 1) % 3 == 0 ? '.' + cur + prev : cur + prev)
=> //".100.000.000"

Answer 17

const thousandSeparator = (num) => {
  let tstr = num.toString()
  let res = ''
  let count = 0
  for (let i = tstr.length - 1; i >= 0; i--) {
    res += tstr[i]
    ++count
    if (count % 3 === 0 && i !== 0) {
      res += '.'
    }
  }
  res = res.split('').reverse().join('')
  return res
}

Answer 18

考虑符号和小数位，用的笨办法

const thousands = (num) => {
  let suff;
  let pre;
  let symbol='';
  if(num){
    num = num +'';
    [pre,suff] = num.split('.')
    if(pre.length <= 3) return num;
    if(isNaN(pre.slice(0,1))){
      symbol = pre.slice(0,1);
      pre = pre.slice(1);
    }
    pre = pre.split('').reverse();
    for(let i in pre){
      if(i>1 && i%3 === 0){
        pre[i] = pre[i]+',';
      }
    }
    return symbol+pre.reverse().join('')+(suff ? ('.'+suff):'');
  }
  return num;
}

Answer 19

const regex = /(?<!^)(?=(d{3})+$)/g;
const s = '123456789';
s.replace(regex, ',');

Answer 20

/**
 * @param {String} str
 * @return {String}
 */
function separate(str) {
  const arr = str.split('')
  for (let i = arr.length - 3; i > 0; i -= 3) {
    arr[i] = `.${arr[i]}`
  }
  return arr.join('')
}

const res = separate('100000000')
console.log('res: ', res)

Answer 21

'10000000000'
.split('')
.reverse()
.join('')
.replace(/(d{3})/g,'$1.')
.split('')
.reverse()
.join('')

Answer 22

Number('100000000').toLocaleString()

Answer 23

"1000000000000".split('').reverse().reduce((total, each, i)=>{
        total.push(each)
        if ((i + 1) % 3 == 0) total.push('.')
        return total
}, []).reverse().join('')

有没有考虑到1刚好可以除尽的情况, 就会 .100.000.000.00

可以这么写
"1000000000000".split("").reverse().reduce((prev, next, index) => {
if(index > 0 && index % 3 == 0) {
return next = next + '.' + prev
} else {
return next + prev
}
}, '')

Answer 24

"1000000000000".split("").reverse().reduce((prev, next, index) => {
if(index > 0 && index % 3 == 0) {
return next = next + '.' + prev
} else {
return next + prev
}
}, '')

Answer 25

const fond07 = (str) => {
let defaultStr = ''
if (str !== null && str !== '' && str !== undefined) {
defaultStr = str.replace(/(d)(?=(d{3})+b)/g, '$1.')
}
return defaultStr
}

Answer 26

考虑数字是三的倍数情况

function splitNum(str) {
    return str.replace(/(d)(?=(d{3})+$)/g, '$1.');
  }

Answer 27

const transStr = str => str.split('')
                       .reduceRight((result, word, index, arr) => 
                                         ((index + 1) % 3 === 0  && index !== arr.length - 1  ?  '.'  :  '' ) 
                                         + word + result)

Answer 28

function format(str) {
  const reverse = str.toString().split('').reverse().join('');
  return reverse.replace(/(d{3})/g, '$1,').replace(/,$/g, '').split('').reverse().join('');
}

Answer 29

'-1019234801211.2142345678'.replace(/(?<!...)(d)(?=(d{3})+($|.))/g, '$1,')

Answer 30

//  保留两位小数后添加千分位符
 getEffective = str => {
        let [int, decimal] = String(Number(str).toFixed(2)).split('.')
        let res =
          [...int]
            .reverse()
            .reduce(
              (prev, item, index) => (
                prev.push(index % 3 === 2 ? ',' + item : item), prev
              ),
              []
            )
            .reverse()
            .join('') + `.${decimal}`
        if (res[0] === ',') {
          return res.slice(1)
        }
        return res
      }

Answer 31

var str= '10000000000';
new Intl.NumberFormat().format(str);
// "10,000,000,000"

Answer 32

"1000000000000".split('').reverse().reduce((total, each, i)=>{
        total.push(each)
        if ((i + 1) % 3 == 0) total.push('.')
        return total
}, []).reverse().join('')

Answer 33

new Intl.NumberFormat().format(100000000000).replace(/,/g, '.');

Answer 34

console.log('100000000000'.replace(/(?!^)(?=(d{3})+$)/g,','))

Answer 35

const getStr=(str,splitNum=3,split=',')=>{
    return str.split('').reverse().map((v,i)=>{
            if(i&&i%splitNum==0){
                return `${v}${split}`
            }
            return v
    }).reverse().join('');
}

getStr('10000000000',3,',');

Answer 36

var reg = /(B)(?=(d{3})+$)/g;
console.log("1000000000".replace(reg, '.'));  // 1.000.000.000

Answer 37

'10000000000'.replace(/(?!^)(?=(d{3})+$)/g,'.')

Answer 38

str.split("").reverse().reduce((prev, cur, index) => (index + 1) % 3 == 0 ? '.' + cur + prev : cur + prev) 上面没有考虑索引+1正好等于长度的时候. 此题str多加一个字符串就会有问题

Answer 39

// 正则不大会...只好一步步来
  function foo(num) {
    const arr = [...num].reverse();
    const rst = arr.reduce((init, ele, i) => {
      i % 3 === 2 ? init.push(ele, '.') : init.push(ele);
      return init;
    }, []);
    return rst.reverse().join('')
  }

Answer 40

str.split("").reverse().reduce((prev, cur, index) => (index + 1) % 3 == 0 ? '.' + cur + prev : cur + prev)

Answer 41

如果主要想考数字的千位分隔符表示法，可以使用正则
var str= '10000000000';
var reg=/(?!^)(?=(d{3})+$)/g;
str.replace(reg, '.') // "10.000.000.000"

Answer 42

类似金额的转化，这里相对还要简单一些
'10000000000'.replace(/(?!^)(?=(d{3})+$)/g, '.');
(?!^)的目的是不匹配开头，虽然这里刚好不会匹配到开头；
但是可以不增加(?!^)试试字符串'100000000000'

Answer 43

笨方法

function addCommaIntoStringNumber(sNumber, splitNumber = 3){
  if (sNumber.length <= splitNumber) {
      return sNumber
  }
  let result = []
  let sNumberQuene = sNumber.split('')
  let index = 1
  let sNumberLength = sNumber.length
  while(sNumberLength--) {
    result.unshift(sNumberQuene.pop())
    if (index++ === splitNumber) {
        result.unshift(',')
        index = 1
    }
  }
  return result.join('')

}

Answer 44

应该是考金额的转换吧，考虑到小数点的情况，如下：
'10000000000.0000'.replace(/d{1,3}(?=(d{3})+(.d*)?$)/g, '$&,')

Answer 45

var myNum = Number('10000000000'); //字符串转数字后就可以使用toLocaleString()啦~

var num2Str = myNum .toLocaleString(); //"10,000,000,000"

num2Str.replace(/,/g, "."); //"10.000.000.000"

哭了，这么好的方法竟然这么多人踩

Answer 46

如果一行写不出来，我选择不写

// 德国以 . 分割金钱, 转到德国当地格式化方案即可
10000000000..toLocaleString('de-DE') 

// 寻找字符空隙加 .
'10000000000'.replace(/B(?=(d{3})+(?!d))/g, '.')

// 寻找数字并在其后面加 . 
'10000000000'.replace(/(d)(?=(d{3})+b)/g, '$1.')

Answer 47

const splitStr = (str, point = 3, split = '.') => {
    let newStr = '';
    const reverseStr = str.split('').reverse().join('');
    for (const s in reverseStr) {
        newStr = (s !== '0' && s % point === 0) ? newStr + split + reverseStr[s] : newStr + reverseStr[s];
    }
    return newStr.split('').reverse().join('');
}

Answer 48

var str = '10000000000';
var arr = [];
for(var i=0; i<Math.round(a.length/3); i++){
arr.push(str.substring(str.length-3*(i+1), str.length-i*3));
}
arr.reverse();
arr.join('.')