Это называется функцией стрелки, частью спецификации ECMAScript 2015 spec ...
var foo = ['a', 'ab', 'abc'];
var bar = foo.map(f => f.length);
console.log(bar); // 1,2,3
Более короткий синтаксис, чем предыдущий:
// < ES6:
var foo = ['a', 'ab', 'abc'];
var bar = foo.map(function (f) {
return f.length;
});
console.log(bar); // 1,2,3
Другая удивительная вещь - лексическая this
... Обычно вы делаете что-то вроде:
function Foo() {
this.name = name;
this.count = 0;
this.startCounting();
}
Foo.prototype.startCounting = function() {
var self = this;
setInterval(function () {
// this is the Window, not Foo {}, as you might expect
console.log(this); // [object Window]
// that's why we reassign this to self before setInterval()
console.log(self.count);
self.count++;
},1000)
}
new Foo();
Но это можно было бы переписать стрелкой следующим образом:
function Foo() {
this.name = name;
this.count = 0;
this.startCounting();
}
Foo.prototype.startCounting = function() {
setInterval(() => {
console.log(this); // [object Object]
console.log(this.count); // 1, 2, 3
this.count++;
},1000)
}
new Foo();
Для получения более здесь довольно хороший ответ для , когда использовать функции стрелок.
Самый простой способ - использовать функцию native Number
:
var x = Number("1000")
Если это не работает для вас, то есть parseInt, унарный плюс, parseFloat с полом и Методы Math.round.
parseInt:
var x = parseInt("1000", 10); // you want to use radix 10
// so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])
унарный плюс, если ваша строка уже имеет форму целого:
var x = +"1000";
, если ваш string является или может быть float, и вы хотите целое число:
var x = Math.floor("1000.01"); //floor automatically converts string to number
или, если вы собираетесь использовать Math.floor несколько раз:
var floor = Math.floor;
var x = floor("1000.01");
Если вы - тот тип, который забывает вставлять radix, когда вы вызываете parseInt, вы можете использовать parseFloat и обходить его, как вам нравится.
var floor = Math.floor;
var x = floor(parseFloat("1000.01"));
Интересно, что Math.round (например, Math.floor) будет преобразовывать строку в числовое преобразование, поэтому, если вы хотите округлить число (или если у вас есть целое число в строка), это отличный способ, может быть, мой любимый:
var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
В JavaScript есть много способов конвертировать строку в числовое значение ... Все просто и удобно, выберите способ, которым вы работаете:
var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5
Также любая математическая операция преобразует их к числу, например ...
var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999
Мой предпочитаемый способ использует знак +
, который является изящным способом преобразования строки в число в JavaScript.
Другим вариантом является двойное значение XOR с самим собой:
var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));
Это будет выводить:
i = 12.34
i ⊕ i ⊕ i = 12
Я написал неправильный ответ здесь, извините. Исправлено.
Это старый вопрос, но мне нравится этот трюк:
~~"2.123"; //2
~~"5"; //5
Двойной побитовый отрицательный результат отбрасывает что-либо после десятичной точки И преобразует его в числовой формат. Мне сказали, что это немного быстрее, чем вызов функций и еще много чего, но я не совсем уверен.
EDIT: Еще один метод, который я видел здесь здесь (вопрос о javascript >>>, который является правым сдвигом нулевой заливки), который показывает, что смещение числа на 0 с помощью этого оператора преобразует число в uint32, что приятно, если вы также хотите, чтобы он был беззнаковым. Опять же, это преобразуется в целое число без знака, что может привести к странному поведению, если вы используете подписанный номер.
"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
ParseInt () и + разные
parseInt("10.3456") // returns 10
+"10.3456" // returns 10.3456
Хотя старый вопрос, но может быть, это может быть полезно кому-то.
Я использую этот способ преобразования строки в int number
var str = "25"; // string
var number = str*1; // number
Итак, при умножении на 1 , значение не изменяется, но js автоматически возвращает число.
Но, как показано ниже, это следует использовать, если вы уверены, что str
является числом (или может быть представлено как число), в противном случае оно вернет NaN - не число.
вы можете создать простую функцию для использования, например
function toNumber(str) {
return str*1;
}
[/g0]
function doSth(){
var a = document.getElementById('input').value;
document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
return +str;
}
<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>
Чтобы преобразовать String в Integer, я рекомендую использовать parseFloat и NOT parseInt. Вот почему:
Использование parseFloat:
parseFloat('2.34cms') //Output: 2.34
parseFloat('12.5') //Output: 12.5
parseFloat('012.3') //Output: 12.3
Использование parseInt:
parseInt('2.34cms') //Output: 2
parseInt('12.5') //Output: 12
parseInt('012.3') //Output: 12
Итак, если вы заметили, что parseInt отбрасывает значения после десятичных знаков, тогда как parseFloat позволяет работать с числами с плавающей запятой и, следовательно, более подходит, если вы хотите сохранить значения после десятичных знаков. Используйте parseInt тогда и только тогда, когда вы уверены, что хотите получить целочисленное значение.
Также как побочная заметка: Mootools имеет функцию toInt (), которая используется для любой родной строки (или float (или integer)).
"2".toInt() // 2
"2px".toInt() // 2
2.toInt() // 2
SyntaxError
, вы должны использовать двойную точку, например: 2..toInt();
, первая точка закончит представление литерала Number
, а вторая точка - это свойство accessor.
– CMS
25 January 2010 в 07:41
Попробуйте parseInt.
var number = parseInt("10", 10); //number will have value of 10.
Ниже приведено небольшое сравнение скорости (только для Mac Os) ...:)
Для chrome 'plus' и 'mul' являются самыми быстрыми, Math.floor - самый медленный (> 700 000,00 оп / сек). Для Firefox 'plus' самый медленный (!) 'Mul' самый быстрый (> 900 000 000 оп / сек). В Safari «parseInt» - это посты, «число» является самым медленным (но resulats очень похожи,> 13 000 000 и 31 000 000). Таким образом, Safari для строки cast для int более чем в 10 раз медленнее, чем другие браузеры. Итак, победителем является «mul»:)
Вы можете запустить его в своем браузере по этой ссылке https://jsperf.com/casttonumber
Существует два основных способа преобразования строки в число в javascript. Один из способов - проанализировать его, а другой способ - изменить его тип на число. Все трюки в других ответах (например, унарный плюс) подразумевают неявное принуждение типа строки к числу. Вы также можете сделать то же самое с помощью функции Number.
Парсинг
var parsed = parseInt("97", 10);
parseInt и parseFloat - это две функции, используемые для разбора строк на числа. Синтаксический анализ остановится молча, если он попадет в символ, который он не распознает, что может быть полезно для синтаксического анализа строк, например «92px», но это также несколько опасно, поскольку оно не даст вам никакой ошибки при плохом вводе, вместо этого вы 'вернем NaN, если строка не начинается с числа. Пробел в начале строки игнорируется. Вот пример того, как он делает что-то другое в соответствии с тем, что вы хотите, и не указывая на то, что что-то пошло не так:
var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97
Хорошая практика всегда указывать в качестве второго аргумента radix. В старых браузерах, если строка начиналась с 0, она была бы интерпретирована как восьмеричная, если бы не было указано значение radix, которое привлекло много людей врасплох. Поведение для шестнадцатеричного запуска запускается, если строка начинается с 0x, если не указано значение radix. 0xff
. Стандарт фактически изменился с помощью ecmascript 5, поэтому современные браузеры больше не запускают восьмеричные, когда есть ведущее 0, если не указано никаких оснований. parseInt понимает радики до основания 36, и в этом случае буквы верхнего и нижнего регистра рассматриваются как эквивалентные.
Изменение типа строки на число
Все остальные трюки упомянутые выше, которые не используют parseInt, включают неявное принуждение строки к числу. Я предпочитаю делать это явно,
var cast = Number("97");
Это имеет другое поведение для методов анализа (хотя оно по-прежнему игнорирует пробелы). Это более строго: если он не понимает всю строку, чем возвращает NaN
, вы не можете использовать ее для строк, таких как 97px
. Поскольку вы хотите примитивное число, а не объект обертки Number, убедитесь, что вы не помещаете new
перед функцией Number.
Очевидно, что преобразование в число дает вам значение, которое может быть float, а не целое число, поэтому, если вам нужно целое число, вам нужно его изменить. Есть несколько способов сделать это:
var rounded = Math.floor(Number("97.654")); // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0; // do not use for large numbers
Любой побитовый оператор (здесь я сделал поразрядный или, но вы также можете сделать двойное отрицание, как в более раннем ответе или бит-сдвиге) преобразует значение для 32-битного целого числа, и большинство из них преобразуется в целое число со знаком. Обратите внимание, что это не будет делать желаемого для больших целых чисел. Если целое число не может быть представлено в 32 битах, оно будет завершено.
~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers
Чтобы правильно работать с большими числами, вы должны использовать методы округления
Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))
. Помните, что все эти методы понимают экспоненциальную нотацию, поэтому 2e2
200
, а не NaN. Кроме того, Number понимает «Бесконечность», в то время как методы анализа не делают.
Пользовательский
Маловероятно, чтобы любой из этих методов выполнял именно то, что вы хотите. Например, обычно мне нужна ошибка, возникающая при сбое синтаксического анализа, и мне не нужна поддержка Infinity, экспоненты или ведущие пробелы. В зависимости от вашего использования, иногда имеет смысл написать пользовательскую функцию преобразования.
Всегда проверяйте, что вывод Number или один из методов анализа - это число, которое вы ожидаете. Вы почти наверняка захотите использовать isNaN
, чтобы убедиться, что число не NaN (обычно это единственный способ узнать, что синтаксический анализ не удалось).
97,8,00
и аналогичный или нет. Простой трюк состоит в том, чтобы сделать .replace(/[^0-9]/g, "")
, который удалит все ненулевые цифры из вашей строки, а затем выполнит преобразование впоследствии. Это, конечно, будет игнорировать все виды сумасшедших строк, которые вы, вероятно, должны ошибаться, а не просто анализировать ...
– kybernetikos
5 February 2015 в 01:09
.replace(/[^0-9.]/g, "")
, иначе «1,05» станет «105».
– J.Steve
8 June 2015 в 17:18
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
мы получаем string
(из-за метода .toFixed
) вместо number
(целое число). Если мы хотим округленное целое число, то, вероятно, лучше просто использовать Math.round("97.654");
– Edu Zamora
17 February 2018 в 10:58
Google дал мне этот ответ как результат, поэтому ...
Мне на самом деле нужно было «сохранить» строку как целое, для привязки между C и JavaScript, поэтому я конвертирую строку в целочисленное значение:
/*
Examples:
int2str( str2int("test") ) == "test" // true
int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
Limitations:
max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
var ret = 0;
var len = the_str.length;
if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) << 0;
if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) << 8;
if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
return ret;
}
function int2str(the_int) {
var tmp = [
(the_int & 0x000000ff) >> 0,
(the_int & 0x0000ff00) >> 8,
(the_int & 0x00ff0000) >> 16,
(the_int & 0xff000000) >> 24
];
var ret = "";
for (var i=0; i<4; i++) {
if (tmp[i] == 0)
break;
ret += String.fromCharCode(tmp[i]);
}
return ret;
}
int2str
останавливается, если байт равен 0, который может быть законным элементом внутри значения, поэтому if
... break
следует удалить, чтобы вы получили полное 4-байтовое значение.
– Suncat2000
16 March 2017 в 13:47
Опасайтесь, если вы используете parseInt для преобразования float в научную нотацию! Например:
parseInt("5.6e-14")
приведет к
5
вместо
0
parseInt
не будет работать правильно для float. parseFloat
работает в этом случае.
– benekastah
14 October 2011 в 16:57
На мой взгляд, ни один ответ не охватывает все случаи краев, поскольку синтаксический анализ поплавка должен приводить к ошибке.
function parseInteger(value) {
if(value === '') return NaN;
const number = Number(value);
return Number.isInteger(number) ? number : NaN;
}
parseInteger("4") // 4
parseInteger("5aaa") // NaN
parseInteger("4.33333") // NaN
parseInteger("aaa"); // NaN
parseInteger
, а не parseNumber
. Я думаю, что все решения являются обходным решением, так как JS не поддерживает целые числа и плавает как отдельные типы. Мы могли бы вернуть null
вместо NaN
, если Not A Number вводит в заблуждение.
– Michał Knapik
27 March 2017 в 15:25
Я использую этот
String.prototype.toInt = function (returnval) {
var i = parseInt(this);
return isNaN(i) ? returnval !== undefined ? returnval : - 1 : i;
}
таким образом, я всегда получаю int back.
мы можем использовать +(stringOfNumber)
вместо использования parseInt(stringOfNumber)
Ex: +("21")
возвращает int 21, как parseInt("21")
.
мы можем использовать этот унарный " + "для синтаксического анализа float тоже ...
+
?
– NiCk Newman
30 October 2015 в 03:27
все вышесказанное верно. Пожалуйста, будьте уверены, прежде чем это число в строке, сделав «typeot x === 'number», «другой мудрый он вернет NaN
var num = "fsdfsdf242342";
typeof num => 'string';
var num1 = "12423";
typeof num1 => 'number';
+num1 = > 12423`
var num1 = "12423"; typeof num1;
возвращает string
.
– Edu Zamora
17 February 2018 в 10:55
См. приведенный ниже пример. Это поможет устранить ваше сомнение
Example Result
parseInt("4") 4
parseInt("5aaa") 5
parseInt("4.33333") 4
parseInt("aaa"); NaN (means "Not a Number")
с помощью функции parseint. Оно будет давать только op целого числа, а не строку
parseInt(aaa5)
возвращает NaN
.
– sntran
6 December 2017 в 17:15
Попробуйте str - 0
преобразовать string
в number
.
> str = '0'
> str - 0
0
> str = '123'
> str - 0
123
> str = '-12'
> str - 0
-12
> str = 'asdf'
> str - 0
NaN
> str = '12.34'
> str - 0
12.34
Вот две ссылки для сравнения производительности нескольких способов преобразования строки в int
'1'
будет преобразован в 1
на ToNumber
, тогда 1 - 0
будет 1
– zangw
1 May 2017 в 13:59
Попробуйте функцию parseInt:
var number = parseInt("10");
Но есть проблема. Если вы попытаетесь преобразовать «010» с помощью функции parseInt, он обнаруживает восьмеричное число и вернет номер 8. Итак, вам нужно указать радиус (от 2 до 36). В этом случае база 10.
parseInt(string, radix)
Пример:
var result = parseInt("010", 10) == 10; // Returns true
var result = parseInt("010") == 10; // Returns false
parseInt('0asdf', 10)
создает 0
.
– Sam
19 April 2018 в 01:08
valueOf
? Для строк он возвращает строку. – pimvdb 17 August 2012 в 12:34Number("1000")
для преобразования этого типа – eliocs 31 October 2012 в 17:19~~
.~~"1" === 1
,~~1.6 === 1
~~-1.6 === -1
,~~undefined === 0
(так это NaN и Infinity и все остальное, которые невозможно преобразовать в целое число) – Tomalak 13 February 2013 в 16:17Number("1000")
?? – TMS 28 April 2013 в 11:53