Почему неподписанные переменные не используются чаще? [дубликат]
Вы можете сделать это с помощью map и sort .
let obj = [{0: {name: 'Joel', age:25, id: 2}}, {1: {name: 'Sam', age: 23, id: 4}}, {2: {name: 'Tim', age:27, id: 3}}]
let op = obj.map((e,index)=>{
return{
[e[index].id] : e[index]
}
}).sort((a,b)=> Object.keys(a) - Object.keys(b))
console.log(op)12 ответов
Используя стандартные, вероятно, избегает кастинга к неподписанным версиям. В Вашем коде можно, вероятно, поддержать различие хорошо, но много других исходных данных и сторонней привычки библиотек и таким образом кастинга просто сведет людей с ума!
Идея, которая неподписанный предотвратит Вас от проблем с методами/участниками, которым не придется иметь дело с отрицательными величинами, несколько испорчена:
- теперь необходимо проверить на большие значения ('переполнение') в случае ошибки
- тогда как Вы, возможно, проверили на <=0 с со знаком
- используйте только один интервал со знаком в своих методах, и Вы вернулись к "подписанному" квадрату :)
Используйте неподписанный при контакте с битами. Но не используйте биты сегодня так или иначе, кроме Вас имеют так многое из них, что они заполняют некоторые мегабайты или по крайней мере Вашу маленькую встроенную память.
Одна причина состоит в том, что открытые методы или свойства, относящиеся к неподписанным типам, не CLS-совместимы.
Вы будете почти всегда видеть, что этот атрибут относился к блокам .NET, поскольку различные мастера включают его по умолчанию:
[блок: CLSCompliant (верный)]
Так в основном, если Ваш блок будет включать атрибут выше, и Вы пытаетесь использовать неподписанные типы в своем открытом интерфейсе с внешним миром, то Вы получите ошибку компиляции.
Я не могу помнить точно, как C# делает свои неявные преобразования, но в C++, расширяющиеся преобразования сделаны неявно. Неподписанный считается более широким, чем со знаком, и таким образом, это приводит к неожиданным проблемам:
int s = 5;
unsigned int u = 25;
// s > u is false
int s = -1;
unsigned int u = 25;
// s > u is **TRUE**! Error error!
В примере выше, s переполненный, таким образом, это - значение, будет что-то как 4294967295. Это вызвало меня проблемы прежде, у меня часто есть возврат методов-1 для высказывания "соответствия" или чего-то как этот, и с неявным преобразованием ему просто не удается сделать то, что я думаю, что он должен.
Через некоторое время программисты, изученные, чтобы почти всегда использовать подписанные переменные, кроме исключительных случаев. Компиляторы в эти дни также производят предупреждения для этого, которое очень полезно.
нет никакой реальной потребности. Объявление чего-то как неподписанное для высказывания чисел должно быть положительным, бедные, укомплектовывает попытку проверки.
На самом деле было бы лучше просто иметь единственный класс числа, который представил все числа.
Для Проверки чисел, необходимо использовать некоторую другую технику, потому что обычно ограничение не является просто положительными числами, это - диапазон набора. Обычно лучше использовать самый неограниченный метод для представления чисел и затем если Вы хотите изменить правила для допустимых значений, Вы изменяете ПРОСТО правила проверки НЕ тип.
Для простоты. Современное программное обеспечение вовлекает достаточно бросков и преобразований. Существует преимущество для придерживаний как можно меньше, обычно доступные типы данных для сокращения сложности и неоднозначности о надлежащих интерфейсах.
Неподписанные типы данных перенесены с былых времен, когда memomry был премией. Таким образом, теперь нам действительно не нужны они с этой целью. Объединение, что с кастингом и они являются немного громоздкими.
Не желательно использовать целое число без знака, потому что при присвоении отрицательных величин ему все повреждение ада проигрывает. Однако, если Вы настаиваете на том, чтобы делать его правильный путь, попытайтесь использовать Spec#, объявите это как целое число (где Вы использовали бы uint), и присоедините инвариант к нему, говоря, что это никогда не может быть отрицательно.
Вы правы в этом, вероятно, было бы лучше использовать uint для моментов, которые никогда не должны быть отрицательными. На практике, тем не менее, существует несколько причин против него:
- интервал является 'стандартом' или 'значением по умолчанию', это имеет много инерции позади него.
- Необходимо использовать раздражающие/ужасные явные броски везде для возвращения к интервалу, в котором Вы, вероятно, испытываете необходимость, чтобы сделать много из-за первой точки, в конце концов.
- Когда Вы действительно вспоминаете интервал, что происходит, если Ваше значение uint собирается переполнить его?
- Много времени, люди используют ints для моментов, которые никогда не отрицательны, и затем используют-1 или-99 или что-то как этот для кодов ошибок или неинициализированных значений. Это немного лениво, возможно, но снова это - что-то, с чем uint менее гибок.
Самая большая причина состоит в том, что люди обычно слишком ленивы, или не думающий достаточно тесно, для знания, где они являются соответствующими. Что-то как size_t никогда не может быть отрицательным, таким образом неподписанный корректно.
Кастинг от со знаком до неподписанного может быть чреват опасностью, хотя, из-за особенностей в том, как знаковые биты обрабатываются базовой архитектурой.
Вы не должны должны быть вручную бросать его, я не думаю.
Так или иначе это - потому что для большинства приложений, это не имеет значения - диапазон для любого является достаточно большим для большей части использования.
Это - потому что они не CLS-совместимы, что означает, что Ваш код не мог бы работать, как Вы ожидаете на других реализациях платформы.NET или даже на других языках.NET (если не поддерживается).
Также это не совместимо с другими системами, при попытке передать их. Как веб-сервис, который будет использован Java, или называют к Win32 API
Посмотрите, что ТАК отправляют на причине почему также