Так называемая численная форма состоит в том, чтобы добавить запятую между каждым тремя цифрами, начиная с однозначных цифр. Например, "10000". Чтобы удовлетворить это требование, я изначально написал функцию подобной:
Кода -копия выглядит следующим образом:
// Метод 1
функция тысячи (num) {
var result = [], счетчик = 0;
num = (num || 0) .toString (). Split ('');
for (var i = num.length-1; i> = 0; i--) {
счетчик ++;
result.unshift (num [i]);
if (! (Counter % 3) && i! = 0) {result.unshift (','); }
}
return result.join ('');
}
Процесс выполнения метода один - преобразовать числа в строки, разбить их на массив, а затем начать с конца, вставить элементы в массиве в начало нового массива (результат). Каждый раз, когда вставлен элемент, счетчик считает число (добавить 1). Когда счетчик кратно 3, вставлена запятая, но будьте осторожны с тем, что в начале не требуется запятая (когда мне 0). Наконец, результат получен путем вызова метода соединения нового массива.
Метод был более ясным и проще для понимания, и он также некоторое время использовался в проекте. Но интуиция говорит мне, что она не работает хорошо.
Метод 2 - Строковая версия метода 1
Кода -копия выглядит следующим образом:
// Метод 2
функция тысячи (num) {
var result = '', счетчик = 0;
num = (num || 0) .toString ();
for (var i = num.length-1; i> = 0; i--) {
счетчик ++;
result = num.charat (i) + result;
if (! (счетчик % 3) && i! = 0) {result = ',' + result; }
}
результат возврата;
}
Метод 2 - это улучшенная версия метода 1. Он не разбивает строки на массивы и всегда работает на строках.
Метод 3 - Цикл соответствует трем числам в конце
Кода -копия выглядит следующим образом:
// Метод 3
функция тысячи (num) {
var num = (num || 0) .toString (), re = // d {3} $/, result = '';
while (re.test (num)) {
result = regexp.lastmatch + результат;
if (num! == regexp.lastmatch) {
result = ',' + result;
num = regexp.leftContext;
} еще {
num = '';
перерыв;
}
}
if (num) {result = num + result; }
результат возврата;
}
Метод 3 - совершенно другой алгоритм. Три числа в конце сопоставляются через регулярную петлю выражения. Каждый раз, когда совпадение сопоставлено, запятая и соответствующий контент вставляются в начале строки результата, а затем соответствующая цель (NUM) присваивается контенту, который еще не соответствует (regexp.leftContext). Кроме того, обратите внимание:
1. Если количество цифр составляет кратное 3, последнее матч должно быть тремя числами, но нет необходимости добавлять запятую перед первыми тремя числами;
2. Если количество битов числа не равномерно 3, то у числовой переменной определенно останется от 1 до 2 чисел в конце. После цикла оставшиеся числа должны быть вставлены в начале строки результатов.
Хотя метод третий уменьшает количество петель (три символа обрабатываются за раз), потребление в определенной степени увеличивается из -за использования регулярных выражений.
Метод 4 - Строковая версия метода 3
Кода -копия выглядит следующим образом:
// Метод 4
функция тысячи (num) {
var num = (num || 0) .toString (), result = '';
while (num.length> 3) {
result = ',' + num.slice (-3) + result;
num = num.slice (0, num.length - 3);
}
if (num) {result = num + result; }
результат возврата;
}
Фактически, функция перехвата последних трех символов может быть достигнута с помощью метода Slice, substr или подстроения типа строки. Это избегает регулярных выражений.
Метод 5 - Метод комбинации и конвергенции
Кода -копия выглядит следующим образом:
// Метод 5
функция тысячи (num) {
var num = (num || 0) .toString (), temp = num.length % 3;
Switch (temp) {
Случай 1:
num = '00' + num;
перерыв;
Случай 2:
num = '0' + num;
перерыв;
}
вернуть num.match (// d {3}/g) .join (','). Заменить (/^0+/, '');
}
Во -первых, составьте количество цифр в кратные 3, нарезайте их в группы каждых трех чисел посредством регулярных выражений, затем добавьте запятые с помощью метода соединения и, наконец, удалите комплемент 0.
Метод 6 - Ленивый метод
Кода -копия выглядит следующим образом:
// Метод 6
функция тысячи (num) {
return (num || 0) .toString (). Заменить (/(/d) (? = (?:/d {3})+$)/g, '$ 1,');
}
Я всегда чувствую, что это форматирование может быть сделано с помощью регулярной замены выражения, но мне нужно использовать утверждения и другие методы письма, но я не знаком с этой частью. После Google It я нашел такое регулярное выражение, которое, вероятно, является самой короткой реализацией кода.
Результаты теста
| число | Время, проведенное 5000 раз (мс) | |||||
|---|---|---|---|---|---|---|
| Метод 1 | Метод 2 | Метод 3 | Метод 4 | Метод 5 | Метод 6 | |
| 1 | 4 | 1 | 3 | 1 | 14 | 2 |
| 10 | 14 | 1 | 3 | 0 | 7 | 2 |
| 100 | 12 | 1 | 2 | 4 | 5 | 3 |
| 1000 | 13 | 2 | 3 | 2 | 9 | 5 |
| 10000 | двадцать один | 4 | 3 | 1 | 6 | 3 |
| 100000 | двадцать один | 3 | 2 | 1 | 5 | 6 |
Сильное сравнение между методом 1 и методом 2 показывает, что эффективность строковых операций намного выше, чем в операциях массива; Результаты испытаний метода 6 говорят нам, что длина кода не имеет ничего общего с производительностью. Метод 4 имеет наилучшую комплексную производительность (но почему NUM уменьшается, когда 100 Num действительно неразрешимо), основная причина - это:
1. Сравните методы 1 и 2, управляйте 3 символами вместо 1 символа каждый раз, чтобы уменьшить количество петель;
2. Методы сравнения 3, 5 и 6, без использования регулярных выражений, снижая потребление.
Наконец, я выбрал четвертый метод в качестве окончательного решения для оптимизации. Читатели могут комментировать, если у них есть лучшие методы реализации или предложения.