Что вы можете сделать по этому поводу?
Здесь есть много хороших ответов, объясняющих, что такое пустая ссылка и как ее отладить. Но очень мало о том, как предотвратить проблему или, по крайней мере, сделать ее легче поймать.
Проверить аргументы
Например, методы могут проверять разные аргументы, чтобы увидеть, null и выбросить ArgumentNullException
, исключение, явно созданное для этой конкретной цели.
Конструктор для ArgumentNullException
даже принимает имя параметра и сообщение как аргументы, чтобы вы могли точно сказать разработчику, что проблема.
public void DoSomething(MyObject obj) {
if(obj == null)
{
throw new ArgumentNullException("obj", "Need a reference to obj.");
}
}
Использовать инструменты
Есть также несколько библиотек, которые могут помочь. Например, «Resharper» может предоставить вам предупреждения во время написания кода, особенно если вы используете их атрибут: NotNullAttribute
В разделе «Контракты кода Microsoft» вы используете синтаксис, например Contract.Requires(obj != null)
, который дает вам проверку выполнения и компиляцию: Представление кодовых контрактов .
Существует также «PostSharp», который позволит вам просто использовать такие атрибуты:
public void DoSometing([NotNull] obj)
Сделав это и сделав PostSharp частью вашего процесса сборки, obj
будет проверяться на нуль во время выполнения. См. Ошибка проверки PostSharp
Решение для простого кода
Или вы всегда можете использовать свой собственный подход, используя простой старый код. Например, вот структура, которую вы можете использовать, чтобы поймать нулевые ссылки. Он моделируется после той же концепции, что и Nullable
:
[System.Diagnostics.DebuggerNonUserCode]
public struct NotNull where T: class
{
private T _value;
public T Value
{
get
{
if (_value == null)
{
throw new Exception("null value not allowed");
}
return _value;
}
set
{
if (value == null)
{
throw new Exception("null value not allowed.");
}
_value = value;
}
}
public static implicit operator T(NotNull notNullValue)
{
return notNullValue.Value;
}
public static implicit operator NotNull(T value)
{
return new NotNull { Value = value };
}
}
. Вы использовали бы очень похоже на то, как вы бы использовали Nullable
, за исключением того, что цель заключалась в том, чтобы сделать абсолютно противоположное - не разрешать null
. Вот несколько примеров:
NotNull person = null; // throws exception
NotNull person = new Person(); // OK
NotNull person = GetPerson(); // throws exception if GetPerson() returns null
NotNull
неявно отбрасывается в и из T
, поэтому вы можете использовать его в любом месте, где это необходимо. Например, вы можете передать объект Person
методу, который принимает значение NotNull
:
Person person = new Person { Name = "John" };
WriteName(person);
public static void WriteName(NotNull person)
{
Console.WriteLine(person.Value.Name);
}
Как вы можете видеть выше, как с помощью nullable, вы получите доступ к базовому значению через Value
имущество. Кроме того, вы можете использовать явный или неявный листинг, вы можете увидеть пример с возвращаемым значением ниже:
Person person = GetPerson();
public static NotNull GetPerson()
{
return new Person { Name = "John" };
}
Или вы даже можете использовать его, когда метод просто возвращает T
(в этом случае Person
), выполнив бросок. Например, следующий код будет похож на код выше:
Person person = (NotNull)GetPerson();
public static Person GetPerson()
{
return new Person { Name = "John" };
}
Объединить с Extension
Объединить NotNull
с методом расширения, и вы можете охватить еще больше ситуаций. Вот пример того, как может выглядеть метод расширения:
[System.Diagnostics.DebuggerNonUserCode]
public static class NotNullExtension
{
public static T NotNull(this T @this) where T: class
{
if (@this == null)
{
throw new Exception("null value not allowed");
}
return @this;
}
}
И вот пример того, как он может быть использован:
var person = GetPerson().NotNull();
GitHub
Для вашей справки я сделал код выше, доступный на GitHub, вы можете найти его по адресу:
https://github.com/luisperezphd/NotNull
Функция родственного языка
В C # 6.0 был введен «оператор с нулевым условием», который немного помогает в этом. С помощью этой функции вы можете ссылаться на вложенные объекты, и если какой-либо из них null
, все выражение возвращает null
.
Это уменьшает количество нулевых проверок, которые вы должны выполнять в некоторых случаях. Синтаксис заключается в том, чтобы поставить вопросительный знак перед каждой точкой. Возьмите следующий код, например:
var address = country?.State?.County?.City;
Представьте, что country
является объектом типа Country
, который имеет свойство, называемое State
и т. Д. Если country
, State
, County
или City
- null
, то address will be
null . Therefore you only have to check whether
адрес is
null`.
Это отличная функция, но она дает вам меньше информации. Это не делает очевидным, какой из 4 является нулевым.
Встроенный как Nullable?
C # имеет красивую стенографию для Nullable
, вы можете сделать что-то нулевое помещая знак вопроса после такого типа int?
.
Было бы неплохо, если бы у C # было что-то вроде структуры NotNull
выше и имела аналогичную стенографию, может быть, восклицательный знак (!), чтобы вы могли написать что-то вроде: public void WriteName(Person! person)
.
Это отлично работает в FF4:
parseFloat(Math.round(num3 * 100) / 100).toFixed(2);
Live Demo
var num1 = "1";
document.getElementById('num1').innerHTML = parseFloat(Math.round(num1 * 100) / 100).toFixed(2);
var num2 = "1.341";
document.getElementById('num2').innerHTML = parseFloat(Math.round(num2 * 100) / 100).toFixed(2);
var num3 = "1.345";
document.getElementById('num3').innerHTML = parseFloat(Math.round(num3 * 100) / 100).toFixed(2);
span {
border: 1px solid #000;
margin: 5px;
padding: 5px;
}
<span id="num1"></span>
<span id="num2"></span>
<span id="num3"></span>
Обратите внимание, что он будет округлен до 2 знаков после запятой, поэтому вход 1.346
вернет 1.35
.
var quantity = 12;
var import1 = 12.55;
var total = quantity * import1;
var answer = parseFloat(total).toFixed(2);
document.write(answer);
function currencyFormat (num) {
return "$" + num.toFixed(2).replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}
console.info(currencyFormat(2665)); // $2,665.00
console.info(currencyFormat(102665)); // $102,665.00
Преобразуйте число в строку, сохраняя только два десятичных знака:
var num = 5.56789;
var n = num.toFixed(2);
Результат n будет:
5.57
Расширить объект Math с помощью метода точности
Object.defineProperty(Math, 'precision',{
value: function (value,precision,type){
var v = parseFloat(value),
p = Math.max(precision,0)||0,
t = type||'round';
return (Math[t](v*Math.pow(10,p))/Math.pow(10,p)).toFixed(p);
}
});
console.log(
Math.precision(3.1,3), // round 3 digits
Math.precision(0.12345,2,'ceil'), // ceil 2 digits
Math.precision(1.1) // integer part
)
Для наиболее точного округления создайте эту функцию:
function round(value, decimals) {
return Number(Math.round(value +'e'+ decimals) +'e-'+ decimals).toFixed(decimals);
}
и используйте ее для округления до двух знаков после запятой:
console.log("seeked to " + round(1.005, 2));
> 1.01
Благодаря Razu , эта статья и ссылка на Math.round MDN .
(num + "").replace(/^([0-9]*)(\.[0-9]{1,2})?.*$/,"$1$2")
Это вы имеете в виду?
function showAsFloat(num, n){
return !isNaN(+num) ? (+num).toFixed(n || 2) : num;
}
document.querySelector('#result').textContent =
[
'command | result',
'-----------------------------------------------',
'showAsFloat(1); | ' + showAsFloat(1),
'showAsFloat(1.314); | ' + showAsFloat(1.314),
'showAsFloat(\'notanumber\') | ' + showAsFloat('notanumber'),
'showAsFloat(\'23.44567\', 3) | ' + showAsFloat('23.44567', 3),
'showAsFloat(2456198, 5) | ' + showAsFloat('2456198', 5),
'showAsFloat(0); | ' + showAsFloat(0)
].join('\n');
<pre id="result"></pre>
function number_format(string,decimals=2,decimal=',',thousands='.',pre='R$ ',pos=' Reais'){
var numbers = string.toString().match(/\d+/g).join([]);
numbers = numbers.padStart(decimals+1, "0");
var splitNumbers = numbers.split("").reverse();
var mask = '';
splitNumbers.forEach(function(d,i){
if (i == decimals) { mask = decimal + mask; }
if (i>(decimals+1) && ((i-2)%(decimals+1))==0) { mask = thousands + mask; }
mask = d + mask;
});
return pre + mask + pos;
}
var element = document.getElementById("format");
var money= number_format("10987654321",2,',','.');
element.innerHTML = money;
#format{
display:inline-block;
padding:10px;
border:1px solid #ddd;
background:#f5f5f5;
}
<div id='format'>Test 123456789</div>
Вот как я решаю свою проблему:
parseFloat(parseFloat(floatString).toFixed(2));
Самый простой ответ:
var num = 1.2353453;
num.toFixed(2); // 1.24
Пример: http://jsfiddle.net/E2XU7/
Вот также общая функция, которая может форматировать любое количество знаков после запятой:
function numberFormat(val, decimalPlaces) {
var multiplier = Math.pow(10, decimalPlaces);
return (Math.round(val * multiplier) / multiplier).toFixed(decimalPlaces);
}
Вы не даете нам всей картины.
javascript:alert(parseFloat(1).toFixed(2))
показывает 1,00 в моих браузерах, когда я вставляю его в строку местоположения. Однако, если после этого вы что-то сделаете, он вернется.
var num = 2
document.getElementById('spanId').innerHTML=(parseFloat(num).toFixed(2)-1)
shows 1 and not 1.00
Гораздо более общее решение для округления до N мест
function roundN(num,n){
return parseFloat(Math.round(num * Math.pow(10, n)) /Math.pow(10,n)).toFixed(n);
}
console.log(roundN(1,2))
console.log(roundN(1.34,2))
console.log(roundN(1.35,2))
console.log(roundN(1.344,2))
console.log(roundN(1.345,2))
console.log(roundN(1.344,3))
console.log(roundN(1.345,3))
console.log(roundN(1.3444,3))
console.log(roundN(1.3455,3))
Output
1.00
1.34
1.35
1.34
1.35
1.344
1.345
1.344
1.346
Если требуется конкретное форматирование, вы должны написать свою собственную процедуру или использовать библиотечную функцию, которая делает то, что вам нужно. Основная функциональность ECMAScript обычно недостаточна для отображения отформатированных чисел.
Подробное объяснение округления и форматирования находится здесь: http://www.merlyn.demon.co.uk/js-round. htm # RiJ
Как правило, округление и форматирование должны быть определены только как последний шаг перед выходом. Выполнение этого ранее может привести к неожиданно большим ошибкам и уничтожению форматирования.
Если вы уже используете jQuery, вы можете посмотреть, как использовать плагин jQuery Number Format .
Плагин может возвращать отформатированные числа в виде строки, вы можете установить десятичную , и разделители тысяч, и вы можете выбрать количество десятичных знаков для отображения.
$.number( 123, 2 ); // Returns '123.00'
Вы также можете получить формат номера jQuery из GitHub .
Вы ищете пол?
var num = 1.42482;
var num2 = 1;
var fnum = Math.floor(num).toFixed(2);
var fnum2 = Math.floor(num2).toFixed(2);
alert(fnum + " and " + fnum2); //both values will be 1.00
var num = new Number(14.12);
console.log(num.toPrecision(2));//outputs 14
console.log(num.toPrecision(3));//outputs 14.1
console.log(num.toPrecision(4));//outputs 14.12
console.log(num.toPrecision(5));//outputs 14.120
Number(1).toFixed(2); // 1.00
Number(1.341).toFixed(2); // 1.34
Number(1.345).toFixed(2); // 1.34 NOTE: See andy's comment below.
Number(1.3450001).toFixed(2); // 1.35
Этот ответ потерпит неудачу, если value = 1.005
.
В качестве лучшего решения проблему округления можно избежать, используя числа, представленные в экспоненциальном обозначении:
Number(Math.round(1.005+'e2')+'e-2').toFixed(2); // 1.01
Мне нравится:
var num = 12.749;
parseFloat((Math.round(num * 100) / 100).toFixed(2)); // 123.75
Закруглить число с двумя десятичными точками, затем обязательно проанализируйте его с помощью parseFloat()
, чтобы вернуть Number, а не String, если вам все равно, Строка или число.
var number = 123456.789;
console.log(new Intl.NumberFormat('en-IN', { maximumFractionDigits: 2 }).format(number));
https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat