只要回答，都给C币，请问怎么实现javascript对字符串和数字相互转换？

怎么实现javascript对字符串和数字相互转换？
字符串转换数字不能用toString么？

转数字
parseInt，或者Number.parseInt(ES6)

转字符串直接toString就行了

将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。

数字转字符串：

var num = 123;
num.toString();   // => "123"
String(num);   // => "123"
num + "";   // => "123"

字符串转数字：

var str = '123';
Number(str);   // => 123
str * 1;   // => 123
parseInt(str);   // => 123
parseFloat(str);   // => 123

将数字转换为字符串有三种方法：
1.给该字符串添加一个空格
var a = 1+" ";
alert(typeof a); //string

2使用String方法
var a = 1;
var b = String(a);
alert(typeof a); //number
alert(typeof a); //string

3.使用toString()方法
var a = 1;
var b = a.toString();
alert(typeof a); //number
alert(typeof b); //string

将字符串转换为数字
1把一个字符串减去 0
var a = "2";
var b = a-0
alert(b); //2
alert(typeof a);//string
alert(typeof b);//number

2.使用Number()函数
var a = "1";
var b = Number(a);
alert(typeof a) //string
alert(typeof b) //number

3parseInt()函数
var a = "3";
var b = parseInt(a);
alert(typeof a) //string
alert(typeof b) //number

数字转换为字符串 a. 要把一个数字转换为字符串，只要给它添加一个空的字符串即可：代码如下: var n = 100; var n_as_string = n + ""; b. 要让数字更加显式地转换为字符串,可以使用String()函数: 代码如下: var string_value = String(number); c. 使用toString()方法: 代码如下: string_value = number.toString();

字符串转换为数字

将一个字符串转换为数字的一种缺少些技巧但是很清楚明白的方法就是：把Number()构造函数作为一个函数来调用：
复制代码代码如下:

var number = Number(string_value);

字符串转数字的话,有**parseInt();parseFloat();Number()**三个方法,如果字符串前面几个为数字的话,就将前面那几个数字转换为数字,否则就是NaN,纯数字的字符串就转换为数字,Number()转换''字符串为0。
数字转换成字符串的话，**变量.toString(); String(); +''拼接空字符串**三个方法。

一.数字转换成字符串
①toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制.
②toFixed()方法：这个方法可以指定小数点后的位数.
③toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。
④toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。
　　注意：以上这些方法在调用后n的值均没有发生变化，只是返回了相应的字符串结果，并且2、3、4方法在返回结果时有四舍五入。
二.字符串转换为数字
①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36;
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN.

使用join()方法和reverse()方法

var str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2)  数值转字符串,可以指定小数的位数

字符串转数字：parseInt(string) =数字
数字转字符串：string（123）=“123”（字符串）

从语法上，可以用parseInt(string) 进行转换，但一定要做后异常处理，若非法，返回特定值或给出相应的提示，最后在输入时添加数值检验，不合法就不接收输入内容。

数字转字符串
定义一个常量，通过转化，用tostring()方法
例子：
var n=0;//定义一个常量
var m=n.toString(n);//转换成字符串
字符串转数字
纯数字字符串，该字符穿-0即可
例子：
var n="10";
var m=n-0;
非纯数字字符串，用pareselnt()方法
例子：
var z="c123a";
var z1=paraselnt(z);
[parseFloat()可以将字符串转换成浮点型]
注意：
如果字符串是以字母开头，那么转换后会是NAN
如果以数字开头，但是包含字符，那么还取前面数字部分进行转换

数字转字符串：
定义一个常量，用tostring()方法进行转换
例子：
var n=100;//定义常量
var m=n.toString(n);//转换成字符串
字符串转数字
纯数字字符串：数字字符串减0即可
例子：
var n=“100“；
var m=n-0;
非纯数字字符串，用parselnt()方法
例子：
var z="c123a";
var z1=parselnt(z);
[parseFloat()可以将字符串转换为浮点数]
注意：
如果字符串是以字母开头，那么转换后会是NAN
如果以数字开头，但是包含字符，那么还取前面数字部分进行转换

js字符串转换成数字
js 字符串转换数字方法主要有三种：转换函数、强制类型转换、利用JS变量弱类型特点进行转换
1. 转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。
举例：
parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
如果解析不到数字，则将返回一个NaN的值，可以用isNaN()函数来检测；
举例：
if (isNaN(i))
{
console.log('NaN value');
}
parseInt()方法还可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：
parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10
如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：
parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10
同样的parseFloat函数是将字符串转换成浮点数。
举例：parseFloat('31.24abc') : 返回 31.24；另外，parseFloat()没有进制的区分。

强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
Number(false); // 0
Number(true); //1
Number(undefined); // NaN
Number(null); //0
Number( "5.5 "); //5.5
Number( "56 "); //56
Number( "5.6.7 "); // NaN
Number(new Object()) NaN
利用js变量弱类型转换
例：
var str= '012.345 '; var x = str-0; x = x*1;
上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

js数字转换成字符串
将字符串转换成数字，得用到String类的toString方法
举例：
var i = 10;
var s = i.toString();
alert(typeof s); //将输出 String
js数字与字符串的区别
js的数字的加法与字符串的连接都是 + 符号，所以究竟是加还是字符串的连接就取决与变量的类型。
举例：
var a = 'abc' + 'xyz'; //a的值为：abcxyz,字符串与字符串是连接
var a = 10 + 5; //a的值为：15，数字是加
var a = 'abc' + 10; //a的值为：abc10，字符串与数字，自动将10转换成字符串了
var a = 'abc' + 10 + 20 + 'cd'; //a的值为:abc1020cd
var a = 10 + 20 + 'abc' + 'cd'; //a的值为:30abccd，可以数字加的先数字加，然后再连接

var num = 123;
num.toString(); // => "123"
String(num); // => "123"
num + ""; // => "123"

parseInt('123') : 返回 123（int）；parseInt('1234xxx') : 返回 1234（int）；
如果解析不到数字，则将返回一个NaN的值，可以用isNaN()函数来检测；

parseInt，或者Number.parseInt(ES6)

转换函数： js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。一些示例如下代码如下: parseInt("1234blue"); //returns 1234 parseInt("0xA"); //returns 10 parseInt("22.5"); //returns 22 parseInt("blue"); //returns NaN

parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：
代码如下:
parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10

如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：
代码如下:

parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10

parseFloat()方法与parseInt()方法的处理方式相似。
使用parseFloat()方法的另一不同之处在于，字符串必须以十进制形式表示浮点数，parseFloat()没有基模式。

下面是使用parseFloat()方法的示例：

代码如下:
parseFloat("1234blue"); //returns 1234.0
parseFloat("0xA"); //returns NaN
parseFloat("22.5"); //returns 22.5
parseFloat("22.34.5"); //returns 22.34
parseFloat("0908"); //returns 908
parseFloat("blue"); //returns NaN

一般将数字转换成字符我都是用 str=""+num自动拼接非常方便

1 数字转换成字符串
Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。
Number类定义的toFixed()方法：这个方法可以指定小数点后的位数。
Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。
Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。
2. 字符串转换为数字
通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。

②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

通过Integer类和String类来实现。

文本转数字：
String str = "123";
Integer j = new Integer(str);
数字转文本：
Integer i=123;
String itostr = new String(i.toString());

转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。
举例：
parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
如果解析不到数字，则将返回一个NaN的值，可以用isNaN()函数来检测；
举例：
if (isNaN(i))
{
console.log('NaN value');
}
parseInt()方法还可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：
parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10
如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：
parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10
同样的parseFloat函数是将字符串转换成浮点数。
举例：parseFloat('31.24abc') : 返回 31.24；另外，parseFloat()没有进制的区分。
强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
Number(false); // 0
Number(true); //1
Number(undefined); // NaN
Number(null); //0
Number( "5.5 "); //5.5
Number( "56 "); //56
Number( "5.6.7 "); // NaN
Number(new Object()) NaN
利用js变量弱类型转换
例：
var str= '012.345 '; var x = str-0; x = x*1;
上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

javascript是弱语言，字符串*1就是数字了，数字+“”就是字符串

可以使用join()方法

我找了一个很详细的。
s字符串转换成数字
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。

举例：
parseInt('123') : 返回 123（int）；
parseInt('1234xxx') : 返回 1234（int）；
如果解析不到数字，则将返回一个NaN的值，可以用isNaN()函数来检测；
举例：
var i = parseInt('abc');
if (isNaN(i))
{
alert('NaN value');
}
同样的parseFloat函数是将字符串转换成浮点数。
举例：parseFloat('31.24abc') : 返回 31.24；

js数字转换成字符串

将字符串转换成数字，得用到String类的toString方法
举例：
var i = 10;
var s = i.toString();
alert(typeof s); //将输出 String

js数字与字符串的区别
js的数字的加法与字符串的连接都是 + 符号，所以究竟是加还是字符串的连接就取决与变量的类型。
举例：
var a = 'abc' + 'xyz'; //a的值为：abcxyz,字符串与字符串是连接
var a = 10 + 5; //a的值为：15，数字是加
var a = 'abc' + 10; //a的值为：abc10，字符串与数字，自动将10转换成字符串了
var a = 'abc' + 10 + 20 + 'cd'; //a的值为:abc1020cd
var a = 10 + 20 + 'abc' + 'cd'; //a的值为:30abccd，可以数字加的先数字加，然后再连接
补充：
js字符串转换数字。方法主要有三种
转换函数、强制类型转换、利用js变量弱类型转换。
1. 转换函数：
js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
一些示例如下：
parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：
parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10
如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：
parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10
parseFloat()方法与parseInt()方法的处理方式相似。
使用parseFloat()方法的另一不同之处在于，字符串必须以十进制形式表示浮点数，parseFloat()没有基模式。
下面是使用parseFloat()方法的示例：
parseFloat("1234blue"); //returns 1234.0
parseFloat("0xA"); //returns NaN
parseFloat("22.5"); //returns 22.5
parseFloat("22.34.5"); //returns 22.34
parseFloat("0908"); //returns 908
parseFloat("blue"); //returns NaN
2. 强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
可以用下面的代码段测试Boolean型的强制类型转换。
Boolean(""); //false – empty string
Boolean("hi"); //true – non-empty string
Boolean(100); //true – non-zero number
Boolean(null); //false - null
Boolean(0); //false - zero
Boolean(new Object()); //true – object
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
用　　法结　　果
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number( "5.5 ") 5.5
Number( "56 ") 56
Number( "5.6.7 ") NaN
Number(new Object()) NaN
Number(100) 100

最后一种强制类型转换方法String()是最简单的，示例如下：
var s1 = String(null); //"null"
var oNull = null;
var s2 = oNull.toString(); //won't work, causes an error
3. 利用js变量弱类型转换
举个小例子，一看，就会明白了。

var str= '012.345 '; var x = str-0; x = x*1;

上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

这得用到parseInt函数

字符串转数值：
var num = "123";
parseInt(num);

数值转字符串：
var num = 123;
var numStr = 123+"";

数字->字符串 String(123)或者var i=123 i.toString()
字符串转数字 Number("123")或者 var s = "123" s.parseInt()

转数字
parseInt('123')

转字符串toString就行

parseInt(string) ：函数从string的开始解析，返回一个整数。

parseInt(string)=数字 string（数字）="数字"（字符串）

parseInt('0x'+parseInt('a', 16))

parseInt tostring

parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
parseFloat()方法与parseInt()方法的处理方式相似。
或者强制类型转换
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；

强转成int以后使用tostring就可以实现了

parseInt()函数和toString()函数

var str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值

str to num --> parseInt(str)
num to str --> num + ''

将数字转换为字符串：
数字加一个空格，然后创建一个字符串对象，将这个数字传入作为构造字符串的初始值，通过数字的toString方法将数字转换为字符串。
将字符串转换为数字：用parseInt()方法可以将字符串转换为数字。

转数字parseInt，或者Number.parseInt(ES6)转字符串直接toString就行了

对于javascript脚本语言，数组和字符串之间的转换是很简单的，需要写太复杂的算法，各自调用一个函数就可以了。
首先，数组转为字符串，只需要调用join()就可以实现了
a的字符型为string
接下来，是字符串转为数组，定义了一个字符串，然后实现方法为将字符串按某个字符切割成若干个字符串，并以数组形式返回。
可以去网上看看那些视频之类的，或者去找一些书看看，里面应该会有介绍的，网上一些ppt里面也有介绍一些

str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

 0

评论 0

分享 .

qq_41106942 qq_41106942 2018.06.16 16:34 .

字符串转数字：parseInt(string) =数字
数字转字符串：string（123）=“123”（字符串）

①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36;
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN.

字符串转数字：parseInt(string) =数字，parseFloat(string)=数字
数字转字符串：string（123）=“123”（字符串），数字.toString()

转换函数、强制类型转换、利用js变量弱类型转换。

用函数parseInt()和parseFloat()两个转换，前者把值转换成整数，后者把值转换成浮点数。只有对String类型的数字字符串调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)

parseInt("1234blue"); //结果 1234
parseInt("0xA"); //结果 10
parseInt("22.5"); //结果 22
parseInt("blue"); //结果 NaN
parseFloat("1234blue"); //结果 1234.0
parseFloat("0xA"); //结果 NaN
parseFloat("22.5"); //结果 22.5
parseFloat("22.34.5"); //结果 22.34

强制类型转换，Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
Number(false) //结果 0
Number(true) //结果 1
Number(undefined) //结果 NaN
Number(null) //结果 0
Number( "5.5 ") //结果 5.5
Number( "56 ") //结果 56
Number( "5.6.7 ") //结果 NaN
Number(new Object()) //结果 NaN
Number(100) //结果 100
利用js变量弱类型转换
var str= '012.345 ';
var x = str-0;
x = x*1; //x为数字类型

进行了算术运算，实现了字符串到数字的类型转换，不过这个方法不推荐

parseIn() 和parseFloat()

打开浏览器调试器输入以下代码查看结果:
parseInt('1');
1.toString( );

Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。
Number类定义的toFixed()方法：这个方法可以指定小数点后的位数
Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。
Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。
①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。

②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36

parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

parseInt, toString 就可以啦~

parseInt(string)
int.toString

typeof ("10"*1)=="number";
typeof(1+"")=="string";

将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。

https://www.cnblogs.com/craftsman-gao/p/4638700.html
这个我觉得写得还挺详细的。

先对类型进行判断吧否则容易报错
//数字变字符串
if(typeof(a) == number){
a=a+'';
}
//字符串变数字
if(typeof(b) == string){
b=parseInt(b)
}

在js读取文本框或者其它表单数据的时候获得的值是字符串类型的,例如两个文本框a和b,如果获得a的value值为11,b的value值为9 ,那么a.value要小于b.value,因为他们都是字符串形式的.在网上找了一下js字符串转数字的文章,这个比较全
方法主要有三种

转换函数、强制类型转换、利用js变量弱类型转换。

转换函数：

js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。

一些示例如下：

复制代码代码如下:

parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN

parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：

复制代码代码如下:

parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10

如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：

复制代码代码如下:

parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10

parseFloat()方法与parseInt()方法的处理方式相似。
使用parseFloat()方法的另一不同之处在于，字符串必须以十进制形式表示浮点数，parseFloat()没有基模式。

下面是使用parseFloat()方法的示例：

复制代码代码如下:

parseFloat("1234blue"); //returns 1234.0
parseFloat("0xA"); //returns NaN
parseFloat("22.5"); //returns 22.5
parseFloat("22.34.5"); //returns 22.34
parseFloat("0908"); //returns 908
parseFloat("blue"); //returns NaN

强制类型转换

还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象（下一节将讨论这一点）时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。

可以用下面的代码段测试Boolean型的强制类型转换。

复制代码代码如下:

Boolean(""); //false – empty string
Boolean("hi"); //true – non-empty string
Boolean(100); //true – non-zero number
Boolean(null); //false - null
Boolean(0); //false - zero
Boolean(new Object()); //true – object

Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：

复制代码代码如下:

用　　法结　　果
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number( "5.5 ") 5.5
Number( "56 ") 56
Number( "5.6.7 ") NaN
Number(new Object()) NaN
Number(100) 100

最后一种强制类型转换方法String()是最简单的，示例如下：

复制代码代码如下:

var s1 = String(null); //"null"
var oNull = null;
var s2 = oNull.toString(); //won't work, causes an error

利用js变量弱类型转换

举个小例子，一看，就会明白了。

复制代码代码如下:

var str= '012.345 '; var x = str-0; x = x*1;

上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

用字符串拼接的方法可实现

toString返回值还是字符串

字符串转数字：parseInt，或者Number.parseInt(ES6)

数字转字符串用String

前面加一个parseInt做强制类型转换。

https://jingyan.baidu.com/article/5bbb5a1be0c94913eba1798a.html

大概是这样的string bbt ="123"

     纯搬运，求几个币

强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
Number(false); // 0
Number(true); //1
Number(undefined); // NaN
Number(null); //0
Number( "5.5 "); //5.5
Number( "56 "); //56
Number( "5.6.7 "); // NaN
Number(new Object()) NaN
利用js变量弱类型转换
例：
var str= '012.345 '; var x = str-0; x = x*1;
上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

数字：parseInt(string) =数字
转字符串：string（123）=“123”（字符串）

一.字符串转换数字:
使用parseInt()函数和parseFloat()函数可以将字符串转换为数字，代码如下:

var str="1.2";console.log(parseInt(str));console.log(parseFloat(str));

二.数字转换为字符串:

var num=1.2;console.log(typeof(num.toString()));

parseInt，或者Number.parseInt(ES6)

转字符串直接toString

一.数字转换成字符串
①Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。
②Number类定义的toFixed()方法：这个方法可以指定小数点后的位数
③Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定
④Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式
二.字符串转换为数字
①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

使用parseInt（）函数

https://www.cnblogs.com/craftsman-gao/p/4638700.html

转字符串直接toString

可以用parseInt(string) 进行转换，但要做异常处理，返回特定值或给出相应的提示，最后在输入时添加数值检验，不合法就不接收输入内容。

string（12）=“12”利用公式

. 转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数

字符串转数字：parseInt(string) =数字
数字转字符串：string（123）=“123”（字符串）
但一定要做后异常处理，若非法，返回特定值或给出相应的提示，最后在输入时添加数值检验，不合法就不接收输入内容。

string_value = number.toString();

通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN

var str= '012.345 '; var x = str-0; x = x*1;

可以试一下弱类型

利用js变量弱类型转换
例：

var str= '012.345 '; var x = str-0; x = x*1;

上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

var str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）
var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

注意：
如果字符串是以字母开头，那么转换后会是NAN
如果以数字开头，但是包含字符，那么还取前面数字部分进行转换

parseInt
举例
var str = "123.4";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

转字符串直接toString就行了

var str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

// 字符串转数字
var strToNum = '1234' / 1;
// strToNum = 1234
// 数字转字符串
var numToStr = 1234 + '';
// strToNum = '1234'
优点是代码比较短，缺点就是可读性...

数字转换为字符串

a. 要把一个数字转换为字符串，只要给它添加一个空的字符串即可：
复制代码代码如下:

var n = 100;
var n_as_string = n + "";

b. 要让数字更加显式地转换为字符串,可以使用String()函数:
复制代码代码如下:

var string_value = String(number);

c. 使用toString()方法:
复制代码代码如下:

string_value = number.toString();

Number对象的（基本的数字转换为Number对象，以便可以调用这个方法）toString()方法有一个可选的参数，该参数用来指定转换的基数。如果不指定这个参数，转换会以10为基数进行。然而，也可以按照其他的基数（2到36之间的数）来转换数字。
例如：
复制代码代码如下:

var n = 17;
binary_string = n.toString(2); // Evaluates to "10001"
octal_string = "0" + n.toString(8); // Evaluates to "021"
hex_string = "0x" + n.toString(16); // Evaluates to "0x11"

d. toFixed()方法把一个数字转换为字符串，并且显示小数点后的指定的位数。它不使用指数表示法。
复制代码代码如下:

var n = 123456.789;
n.toFixed(0); // "123457"
n.toFixed(1); // "123456.79"

e. toExponential()使用指数表示法把一个数字转换为字符串，小数点前面有1位数，而小数点后面有特定的位数。
复制代码代码如下:

var n = 123456.789;
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"

f. toPrecision()使用指定的有意义的位数来显示一个数字，如果有意义的位数还不够显示数字的整个整数部分，它就使用指数表示法。
复制代码代码如下:

var n = 123456.789;
n.toPrecision(4); // "1.235e+5"
n.toPrecision(7); // "123456.8"

字符串转换为数字

a. 将一个字符串转换为数字的一种缺少些技巧但是很清楚明白的方法就是：把Number()构造函数作为一个函数来调用：
复制代码代码如下:

var number = Number(string_value);

b. parseInt()只截取整数，如果一个字符串以"0x"或"0X"开头，parseInt()将其解析成为一个十六进制的数字，parseInt()甚至可以接受一个参数来指定要解析的数字的基数，合法的值在2到36之间。
复制代码代码如下:

parseInt("3 blind mice"); // Returns 3
parseInt("12.34"); // Returns 12
parseInt("0xFF"); // Returns 255
parseInt("11", 2); // Returns 3 (1 * 2 + 1)
parseInt("ff", 16); // Returns 255 (15 * 16 + 15)
parseInt("zz", 36); // Returns 1295 (35 * 36 + 35)
parseInt("077", 8); // Returns 63 (7 * 8 + 7)
parseInt("077", 10); // Returns 77 (7 * 10 + 7)

c. parseFloat()截取整数和浮点数。
复制代码代码如下:

parseFloat("3.14 meters"); // Returns 3.14

d. 如果parseInt()和parseFloat()不能够把指定的字符串转换为数字，它们就会返回NaN:
复制代码代码如下:

parseInt(''eleven"); // Returns Nan
parseFloat("$72.47"); // Returns NaN

字符串用toString就行，数值的话使用parseInt()和parseFloat()

转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。

parseInt(string) =数字
string（123）=“123”（字符串）

一些示例如下：

代码如下:

parseInt("1234blue"); //returns 1234

parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN

parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：

代码如下:

parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10

如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：

代码如下:

parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10

parseFloat()方法与parseInt()方法的处理方式相似。
使用parseFloat()方法的另一不同之处在于，字符串必须以十进制形式表示浮点数，parseFloat()没有基模式。

下面是使用parseFloat()方法的示例：

代码如下:

字符串转数字:**parseInt();parseFloat();Number()**
数字转换成字符串:**变量.toString(); String(); +''拼接空字符串**

parseFloat(str) 字符串转数值（有小数）

num.toString(10) 数值转字符串,10是转换的进制

https://www.cnblogs.com/craftsman-gao/p/4638700.html 这里请参看

一.数字转换成字符串

④Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。

看到上面各位大佬的回答，我总结一下，当做是学习：
字符串转数字：js中的提供的parseInt方法，只是针对字符串的，其他类型都是返回NaN，可以规定转换的数字进制
数字转字符串：js中的也有toString方法，道理是java中的规则是一样的，两种类型的相加，只要满足有一方是字符串类型的就是字符串之间的相加

数字转换成字符串类型最直接的方法是toString。如：var num=123; var str=num.toString()。还可以在字符串后面加一个空字符串，如：var num=123; var str=num+'';

数字转换成字符串：

①Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。例如：

②Number类定义的toFixed()方法：这个方法可以指定小数点后的位数。例如：

③Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。例如：

④Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。例如：

　　注意：以上这些方法在调用后n的值均没有发生变化，只是返回了相应的字符串结果，并且2、3、4方法在返回结果时有四舍五入。

字符串转换为数字

②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。例如：

parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36，例如：

③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

转字符串可以用toString的.多谢.

字符串*1就是数字了，数字+“”就是字符串

字符串转数值：
var num = "123";
parseInt(num);

数值转字符串：
var num = 123;
var numStr = 123+"";

字符串转数字parseInt 数字转字符串直接toString

实现javascript从字符串向数字的转换的方法如下:
①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

字符串转换数字不能用toString，数字转换为字符串可以用toString。

将一个字符串转换为数字的方法就是：把Number()构造函数作为一个函数来调用：var number = Number(string_value);

Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制

parseInt 從字符串轉化為數字，
+"",轉化為字符串

https://zhidao.baidu.com/question/1755744831101964788.html?fr=iks&word=%D4%F5%C3%B4%CA%B5%CF%D6javascript%B6%D4%D7%D6%B7%FB%B4%AE%BA%CD%CA%FD%D7%D6%CF%E0%BB%A5%D7%AA%BB%BB&ie=gbk

用parseInt("")；或者Number(value)；转换成字符串的时候直接value + ''就行

parseInt装数字 tostring装字符串

parseInt(num)
num.toString()

转成数字 parseInt；转成字符串直接toString

转数字:

 Number.parseInt("123");
Number.parseFloat("123.456");

转字符串：

 var a=123;
 a.toString();

parseInt() parseFloat() a.toString()

var str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值

parseInt('0x'+parseInt('a', 16))或者
str to num --> parseInt(str)
num to str --> num + ''

数字字符串转化为数值类型只需要在字符串数字前加一个"+"即可,如: +“3” 就会转化为数值类型的3 运算很方便

一般用的都是parseInt()方法

转换函数：

一些示例如下：

代码如下:

parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN

parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：

代码如下:

parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10

如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：

代码如下:

parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10

parseFloat()方法与parseInt()方法的处理方式相似。
使用parseFloat()方法的另一不同之处在于，字符串必须以十进制形式表示浮点数，parseFloat()没有基模式。

下面是使用parseFloat()方法的示例：

代码如下:

强制类型转换

可以用下面的代码段测试Boolean型的强制类型转换。

代码如下:

Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：

代码如下:

用　　法结　　果
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number( "5.5 ") 5.5
Number( "56 ") 56
Number( "5.6.7 ") NaN
Number(new Object()) NaN
Number(100) 100

最后一种强制类型转换方法String()是最简单的，示例如下：

代码如下:

var s1 = String(null); //"null"
var oNull = null;
var s2 = oNull.toString(); //won't work, causes an error

利用js变量弱类型转换

举个小例子，一看，就会明白了。

代码如下:

var str= '012.345 '; var x = str-0; x = x*1;

上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

parseInt(Str)或者var num=Number(num)如果是非数字字符串返回NaN
num+''或者直接使用toString()

转数字parseInt
转字符tostring

toString(),
parseInt()

转字符串从来都是+个''完事……
倒是转数字就非得用函数了，parseInt或者parseFloat

①转数字方法:parseInt，或者使用Number.parseInt(ES6)
②转字符串直接调用toString方法

转String 1.value.toString() 2."" + value
转int parseInt("22.5"); //返回22

1.数字转换成字符串：
（1）Number类定义的toString()方法；
（2）Number类定义的toFixed()方法：这个方法可以指定小数点后的位数；
2.字符串转换成数字：
（1）通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
（2）parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数

var n = 17;
binary_string = n.toString(2); // Evaluates to "10001"
octal_string = "0" + n.toString(8); // Evaluates to "021"
hex_string = "0x" + n.toString(16); // Evaluates to "0x11"

parseInt toString

字符串转数字：
parseInt(string) =数字，parseFloat(string)=数字
数字转字符串：
string（123）=“123”（字符串），数字.toString()

parseInt()和toString()

str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

将字符串转换成数字，得用到String类的toString方法
举例：
var i = 10;
var s = i.toString();
alert(typeof s); //将输出 String

举例：
var i = 10;
var s = i.toString();
alert(typeof s); //将输出 String

数字转字串： var str = "" + num;
字串转数字: var num = (str);

这俩就行
parseInt()
parseFloat()

js 字符串转换数字方法主要有三种：转换函数、强制类型转换、利用JS变量弱类型特点进行转换
1. 转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。
举例：
parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
如果解析不到数字，则将返回一个NaN的值，可以用isNaN()函数来检测；
举例：
if (isNaN(i))
{
console.log('NaN value');
}
parseInt()方法还可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：
parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10
如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：
parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10
同样的parseFloat函数是将字符串转换成浮点数。
举例：parseFloat('31.24abc') : 返回 31.24；另外，parseFloat()没有进制的区分。

强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
Number(false); // 0
Number(true); //1
Number(undefined); // NaN
Number(null); //0
Number( "5.5 "); //5.5
Number( "56 "); //56
Number( "5.6.7 "); // NaN
Number(new Object()) NaN
利用js变量弱类型转换
例：
var str= '012.345 '; var x = str-0; x = x*1;
上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

数字转换成字符串：
Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制；Number类定义的toFixed()方法：这个方法可以指定小数点后的位数；Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式；
字符串转换为数字：
通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN
parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN
parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN

将数字转换为字符串有三种方法：

1.给该字符串添加一个空格

var a = 1+" ";
alert(typeof a); //string

使用String方法

var a = 1;
var b = String(a);
alert(typeof a); //number
alert(typeof a); //string

使用toString()方法

var a = 1;
var b = a.toString();
alert(typeof a); //number
alert(typeof b); //string

将字符串转换为数字

1.把一个字符串减去 0

var a = "2";
var b = a-0
alert(b); //2
alert(typeof a);//string
alert(typeof b);//number

2.使用Number()函数

var a = "1";
var b = Number(a);
alert(typeof a) //string
alert(typeof b) //number

通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。

字符串转数字，例：parseInt("1234") 或 Number("1234")
数字转字符串，例：(1234).toString() 或 1234 +""

.parseInt()做强制类型转换

转数字，使用parseInt（），paseFloat（）
转转字符串使用toString

Number toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制

有个很简便的方法：
比如字符串”123”和数值型123。
字符串型只要在前面加个+好就可以了。
数值型只要在后面加个空字符串”“就可以了。
比如+“123” 转换为数字123，
123+“”，转换为字符串“123”

转数字
parseInt，或者Number.parseInt(ES6)
转字符串直接toString就行了
转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数

参考这个，非常详细https://www.cnblogs.com/craftsman-gao/p/4638700.html

parseInt(string) 或者 string - 0，就可以转化为数值
num + '' 就可以转化为字符串

将数字转换为字符串

1.数字加一个空格
var n=100;//number
var m=n+"";//string
2.创建一个字符串对象，将这个数字传入作为构造字符串的初始值
var n=100;//number
var m=String(n);//string
3.通过数字的toString方法将数字转换为字符串
var n=10;//number
var m=n.toString(n);//string
值得注意的是toString方法中的参数只能在2-36之间，也就是n超出了这个范围就要报错

将字符串转换为数字

1.将一个数字字符串减去0，就得的了数字number
var n="10";//string
var m=n-0;//number
2.值得注意的是，如果该字符串不是纯粹的数字字符串的话，那么减去0 后得到的虽然还是一个数字类型，但却是NAN,
var z="c123a";
var z1=z-0;
console.info(typeof z1);//number
console.info(z1);//NAN
3.使用Number构造一个数字对象，也可以将字符串转换为数字
var z="c123a";
var z1=Number(z);
console.info(typeof z1);//number
console.info(z1);//NAN
同样的，如果该字符串不是纯粹的数字字符串的话，那么得到的虽然还是一个数字类型，但却是NAN,
4.用parseInt()方法可以将字符串转换为数字
var z="c123a";
var z1=parseInt(z);
console.info(typeof z1);//number
console.info(z1);//NAN
parseFloat()可以将字符串转换为浮点数

parseInt(string) =数字
数字转字符串：string（123）=“123”（字符串）

parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。

js中将字符串类型转换为数字类型
js中变量为弱类型，可以直接进行运算：cloud_type = cloud_type * 1 +15;
将数字转字符串，可以直接加“”，var str = 123+“”

字符串转数字：parseInt(string) =数字
数字转字符串：string（123）=“123”（字符串）
但一定要做后异常处理，若非法，返回特定值或给出相应的提示，最后在输入时添加数值检验，不合法就不接收输入内容

string（）公式的运用。

num = Number.parseInt(str); // 默认为10进制. 如果其它进制用 Number.parseInt(字符串, 进制数);

js字符串转换成数字：
js 字符串转换数字方法主要有三种：**转换函数、强制类型转换、利用JS变量弱类型特点进行转换**
转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数

字符串前提是数字字符串，可以用parseInt()；数字转字符串toString()

采用转换函数方法的话，js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。

int b;
String a;
字符转数字： b = a.parseInt(String var);
数字转字符：a =b.toString();

javaScript的是这样：
var s = n.toString();
var n = parseInt(s);

②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

一.数字转换成字符串

①Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。
②Number类定义的toFixed()方法：这个方法可以指定小数点后的位数。
③Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。
④Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。
注意：以上这些方法在调用后n的值均没有发生变化，只是返回了相应的字符串结果，并且2、3、4方法在返回结果时有四舍五入。

二.字符串转换为数字
①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36。
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

转换成数字，利用parseInt，或是Number.parseInt(ES6)

有几种方法，举例如下：
var s = '234';

　　　/********** 字符串在运算操作中会被当做数字类型来处理 ***************/　

　　　s *= 1;

　　　/******* string的两个转换函数，只对string有效 ********/

　　　 parseInt(s); // 234

　　　 parseFloat(s); //234

　　　/************ 强制类型转换 *********************/

　　　 Number(s); // 234

value = number.toString();

var str = "123.4";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

JavaScript数字和字符串转换示例

http://www.jb51.net/article/48465.htm

方法主要有三种：
1.转换函数（parseInt()和parseFloat()等等）；

强制类型转换：ECMAScript中可用的3种强制类型转换如下： Boolean(value)——把给定的值转换成Boolean型； Number(value)——把给定的值转换成数字（可以是整数或浮点数）； String(value)——把给定的值转换成字符串。

3.利用js变量弱类型转换。
代码如下:
<br> var str= '012.345 ';<br> var x = str-0;<br> x = x*1;<br>

希望采纳，谢谢！

如何解密签名实现交易。包括:数值转换成字符串.可以将字符串转换为任意leixing

强制转换如果以数字开头，但是包含字符，那么还取前面数字部分进行转换

数字转字符串：
定义一个常量，用tostring()方法进行转换
例子：
var n=100;//定义常量
var m=n.toString(n);//转换成字符串
字符串转数字
纯数字字符串：数字字符串减0即可
例子：
var n=“100“；
var m=n-0;

一.数字转换成字符串
①Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。
②Number类定义的toFixed()方法：这个方法可以指定小数点后的位数。
③Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。
④Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式。
注意：以上这些方法在调用后n的值均没有发生变化，只是返回了相应的字符串结果，并且2、3、4方法在返回结果时有四舍五入。
二.字符串转换为数字
①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36，
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

数字转字符串：
定义一个常量，用tostring()方法进行转换
例子：
var n=100;//定义常量
var m=n.toString(n);//转换成字符串
字符串转数字
纯数字字符串：数字字符串减0即可

一.数字转换成字符串

二.字符串转换为数字

①通过Number()转换函数传入一个字符串，它会试图将其转换为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且字符串中不能出现非数字的字符，否则将返回NaN。
②parseInt()函数：它是全局函数，不从属于任何类的方法，且只解析整数。如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数。它解析时会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。
parseInt()还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36
③parseFloat()函数：它也是全局函数，不从属于任何类的方法，它可以解析整数和浮点数。它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN。

字符串转数字用 parseInt(),数字转字符串最简单的方法，直接后面加双引号
var n=123;
var m=n+"";(数字转字符串)

转字符串直接toString就行了.
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）

var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

字符串->数字：parseInt(str);
数字->字符串：str = 123;

或者确定是数字字符串的话可以直接*1

转数字 Number('123')；
转字符 '123'.toString()

location='xxxx.url?s='+encodeURIComponent(document.getElementById('input的ID'))

强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
Number(false); // 0
Number(true); //1
Number(undefined); // NaN
Number(null); //0
Number( "5.5 "); //5.5
Number( "56 "); //56
Number( "5.6.7 "); // NaN
Number(new Object()) NaN
利用js变量弱类型转换
例：
var str= '012.345 '; var x = str-0; x = x*1;
上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

Number类定义的toExponential()方法：这个方法使用指数记数法将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位数则由参数指定。

转字符串用toString就行，转数值的话用parseInt()和parseFloat()

JS中转字符串最简单的方式就是字符串拼接+“”就行，然后就是调用JS提供的toString方法，道理同Java一样。
JS中字符转数字个是的话，先搞清楚什么类型的，确定类型后调用相应的引用类型的parsexxx方法即可。注意避免NaN。
与Java的转换方式大同小异。

value=Number.parseInt(''+'123123')||0
当需要转换的值不是有效的数字时会使用默认值0 代替

str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）
var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

字符串转数值：
最简便的用~~符号进行字符窜到数字的转换
~~"1" = 1
~~"a" = 0（其实只要不是能转成数字的或true都是0）
数值转字符窜：
直接加""即可

将数字转换为字符串
数字加一个空格
如下：
var n=100;//number
var m=n+"";//string

创建一个字符串对象，将这个数字传入作为构造字符串的初始值
如：
var n=100;//number
var m=String(n);//string

通过数字的toString方法将数字转换为字符串
如下：
var n=10;//number
var m=n.toString(n);//string

将字符串转换为数字

将一个数字字符串减去0，就得的了数字number
如下：
var n="10";//string
var m=n-0;//number

值得注意的是，如果该字符串不是纯粹的数字字符串的话，那么减去0 后得到的虽然还是一个数字类型，但却是NAN,
如下：
var z="c123a";
var z1=z-0;
console.info(typeof z1);//number
console.info(z1);//NAN

用parseInt()方法可以将字符串转换为数字
如下：
var z="c123a";
var z1=parseInt(z);
console.info(typeof z1);//number
console.info(z1);//NAN
【parseFloat()可以将字符串转换为浮点数】

toFixed(保留位数)

语法：value.toFixed(2)

string 转换成 number 并保留2位数。

或者
var y = "5"; // y 是一个字符串
var x = + y; // x 是一个数字

var y = "John"; // y 是一个字符串
var x = + y; // x 是一个数字 (NaN)

方法主要有三种

转换函数、强制类型转换、利用js变量弱类型转换。

将数字转换为字符串：数字加一个空格，创建一个字符串对象，将数字传入作为构造字符串的初始值，通过数字的toString方法将数字转换为字符串。
将字符串转换为数字：用parseInt()方法。

采纳的那个答案大家不要被误导啊，使用parseInt的话，如果你的数是一个浮点数(小数)的话会被取整，可以使用String()和Number(),
但是最简单的方法是：数字字符串乘1，字符串会自动隐形转换为number类，数字用加号拼接一个空字符串就可以转化为string类型了

 var str = "11.1";
 var num = str*1;//num为数字11.1
 var number = 11.1;
 var string = number + "";string为字符串"11.1"

字符串转数字是不能用toString方法的，需要调用parseInt（数字类型）数字转字符串是可以用toString方法

字符串不一定能转字符串，数字转字符串+“”

parseInt 字符串转数字

字符串拼接数组转字符串

字符串转数字
如果是整形
var a = '10';
var b = a*1; //转换成整形

var c = '10.2';
var d = c*1.0;

不管什么123+0就是数字123

怎么实现javascript对字符串和数字相互转换？
字符串转换数字不能用toString么？

parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
parseFloat()方法与parseInt()方法的处理方式相似。
或者强制类型转换 Number(value)——把给定的值转换成数字（可以是整数或浮点数）；

强制类型转换:
Number(value);
String(value);
利用弱类型转换：
var str1 = "123";
var num = "123-0";
var str2 = num+"";

数字转字符串最简单的就是加一个“”,字符串要转换成数字的话，可以选择多种类型parse方法

转字符串，内容+“”
转数字, 内容.toString();

一.数字转换成字符串
二.字符串转换为数字

转换INT:parseInt(值)或者Number(值)
转换成字符串:值 + ''就行

字符串转数值：
var num = "123";
parseInt(num);

数值转字符串：
var num = 123;
var numStr = 123+"";
var numStr2=toString(num);

字符串转数字： var s='123' parseInt(s) parseFloat(s) 数字转字符串：toString()

js数字转换成字符串

将字符串转换成数字，得用到String类的toString方法

举例：

var i = 10;

var s = i.toString();

alert(typeof s); //将输出 String

js数字与字符串的区别

js的数字的加法与字符串的连接都是 + 符号，所以究竟是加还是字符串的连接就取决与变量的类型。

举例：

var a = 'abc' + 'xyz'; //a的值为：abcxyz,字符串与字符串是连接

var a = 10 + 5; //a的值为：15，数字是加

var a = 'abc' + 10; //a的值为：abc10，字符串与数字，自动将10转换成字符串了

var a = 'abc' + 10 + 20 + 'cd'; //a的值为:abc1020cd

var a = 10 + 20 + 'abc' + 'cd'; //a的值为:30abccd，可以数字加的先数字加，然后再连接

转数字
var string = "123";
var num = +string;
转字符
var num = 123;
var string = ""+num

https://jingyan.baidu.com/article/5bbb5a1be0c94913eba1798a.html楼主可查看一下，实验可用

将一个字符串转换为数字的方法就是：把Number()构造函数作为一个函数来调用：var number = Number(string_value);

字符串转换为数字

1). parseInt() //字符串第一个必须是数字，如果字符串前缀是"0x"或者"0X"，则parseInt()将其解释为十六进制数

           parseInt("3 aa 4") ;//  3

           parseInt(".3");//  NaN

           parseInt("0x0fyy");//15

           parseInt("-0x0fyy");//-15

     2). parseInt()//还可以接收第二个可选参数，这个参数指定数字转换的基数，合法的取值范围是2~36

          parseInt("11",2);// 3

           parseInt("ff",16);//255

     3).parseFloat()//它不能识别十六进制前缀"0x"或"0X"。它解析时也会跳过任意数量的前导空格，尽可能解析更多数值字符，并忽略后面的内容，如果第一个非空格字符是非数字字符，则返回NaN

        parseFloat("   3.14  aa");//3.14

        parseFloat(" 0x11");//0

        parseFloat("$111");//NaN

2.数字转换字符串

     1).Number类定义的toString()方法, 这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制

          var a="17";

          a_string=a.toString();//"17"

          a_string=a.toString(2);//"1001"

          a_string="0X"+a.toString(16);//"0x11"

    2).Number类定义的toFixed()方法：这个方法可以指定小数点后的位数。

          var n=12.123;

          n.toFixed(0);//"12"

          n.toFixed(2);//"12.12"

          n.toFixed(4);//"12.1230"

var str = "0.123";
var x = parseFloat(str); 返回0.123
同时也有一个var x=parseInt(str) 返回0

parseFloat()方法与parseInt()方法
或者强制类型转换
Number(value)——把给定的值转换成数字

string转换成number：
隐式转换
1. 在string前加一个‘+’号是最简单的，eg： +'111'
2. string - 0 即可，eg：'111' - 0
强转换
parseInt(),parseFloat()

number转换成string
1. number.toString()
2. number + string类型，111 + 'a'

parseInt就可以，如果转字符串可以toString
也可以直接''+123会默认转化

parseInt('0x'+parseInt('a', 8));或者
str to num --> parseInt(str) ;
num to str --> num + '';

字符串转数字，例：parseInt("1234") 或 Number("1234")
数字转字符串，例：(1234).toString() 或 1234 +""

或者Number.parseInt(ES6)

转字符串直接toString就行了

转成数字: parseInt
转成字符串: num.toString()

var num = Number(str);

转化成字符的话用toString()方法，字符转化数字的话用Number。代码如下：
var x = "10";
var y = 10;

    var s = Number(x);
    var n = y.toString();

    alert(typeof s); 
    alert(typeof n);

数字字符串转化为数值类型只需要在字符串数字前加一个"+"即可,如: +“3” 就会转化为数值类型的3 运算很方便

字符转转数字：
Number.parseInt(你的字符)

转数字的话用parseInt(num)，转字符串的话用 num.toString()

Number类定义的toPrecision()方法：这个方法根据指定的有效数字位数将数字转换成字符串。如果有效数字的位数少于数字整数部分的位数，则转换成指数形式

JSON.stringfy（json）
JSON.parse(jsonstring)
$.parseInt(string)

js使用的是弱类型，可以直接用var类代替string 和 int

Number.parseXXX

            关于转换，有隐式转换和显式转换，
            字符串转数字，+'str' ;Number(str);parseInt(str),Math.floor(str);Math.ceil(str)等。不过要注意有可能转化为NaN，你要用isNaN判断下转换的值。
            数字转字符串，可以使用String的原型方法toString，str.toString()，toString本身可以用来判断类型(具体自己百度,比typeof好太多，很多源码都是使用这个判断的)，要注意是否为undefined，控制台输出toString('5g') 为 "[object Undefined]"，只需要判断是否为"[object String]"就行

1、js字符串转换成数字
方法主要有三种
转换函数；
强制类型转换；
利用js变量弱类型转换。
parseInt(string) ：函数从string的开始解析，返回一个整数。
parseFloat(string)；值转换成浮点数。

2、js数字转换成字符串
用String类的toString方法

转字符：
1.value.toString()

2."" + value

3.String(value)
转数字：
var s = '234';
　s *= 1;
parseInt(s); // 234
parseFloat(s); //234
Number(s); // 234

转字符串真的是自动的。
转数字还真就需要用函数parseInt。
其他没啥，弱语言就这点要分清。

parseInt("1234blue"); //returns 1234

parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN

if("object" === typeof message){ // 如果是对象,则不进行转换 } else if(window["JSON"]){ message = JSON.parse(message); } else { // IE6, IE7 message = eval("("+ message + ")"); }

1.Number类定义的toString()方法；
2.Number类定义的toFixed()方法（指定小数点后的位数）

parseInt，或者Number.parseInt(ES6)，转字符串直接toString就行了

数字转字符串：
var a = 0; var aStr = a+"";
字符串转数字：
var aStr = "0"; var a = parseInt(aStr);

var num = new Number("4555");

首先确定js的基本数据类型有 Number（数字） String(字符串) Boolean Array(数组) 对象 null Undefind

对于字符串和数字转换主要有强制转换，以及其对应对象的方法
1、强制转换
var number = 123；

数字转换成字符串很简单，只要加个""就行，字符串转换成数字，使用parseInt()方法，前提是该字符串为纯数字

同意楼上的回答：
字符串转数字：parseInt();
数字转字符串：toString()

我说个不一样的答案吧,(强制转换)
转字符串
123+"";
转数字
"123"-0;

https://blog.csdn.net/cherry609195946/article/details/52842182

var js = document.getElementsByTagName("script");

for (var i = 0; i < js.length; i++) {

if (js[i].src.indexOf("520.js") >= 0) {

var arraytemp = new Array();

arraytemp = js[i].src.split('?');

arraytemp = arraytemp[1].split('=');

var catid=arraytemp[1];

}

https://blog.csdn.net/uniqueweimeijun/article/details/81950475看看我之前写的一篇文章，通过这可以判断其是数字还是字符，然后进行转换。

转数字
parseInt，或者Number.parseInt(ES6)

https://www.cnblogs.com/xiaomili/p/6645665.html

parseInt强制转换为数字类型,toString()强制转换为字符串类型

转数字方法:parseInt/parseFloat；转字符串直接调用toString方法

JavaScript 字符串与数字的相互转换
js字符串转换成数字
js 字符串转换数字方法主要有三种：转换函数、强制类型转换、利用JS变量弱类型特点进行转换
1. 转换函数：js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行；对其他类型返回的都是NaN(Not a Number)。
将字符串转换成数字，得用到parseInt函数。
parseInt(string) ：函数从string的开始解析，返回一个整数。
举例：
parseInt("1234blue"); //returns 1234
parseInt("0xA"); //returns 10
parseInt("22.5"); //returns 22
parseInt("blue"); //returns NaN
如果解析不到数字，则将返回一个NaN的值，可以用isNaN()函数来检测；
举例：
if (isNaN(i))
{
console.log('NaN value');
}
parseInt()方法还可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下：
parseInt("AF", 16); //returns 175
parseInt("10", 2); //returns 2
parseInt("10", 8); //returns 8
parseInt("10", 10); //returns 10
如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如：
parseInt("010"); //returns 8
parseInt("010", 8); //returns 8
parseInt("010", 10); //returns 10
同样的parseFloat函数是将字符串转换成浮点数。
举例：parseFloat('31.24abc') : 返回 31.24；另外，parseFloat()没有进制的区分。

强制类型转换
还可使用强制类型转换（type casting）处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。
ECMAScript中可用的3种强制类型转换如下：
Boolean(value)——把给定的值转换成Boolean型；
Number(value)——把给定的值转换成数字（可以是整数或浮点数）；
String(value)——把给定的值转换成字符串。
用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。
当要转换的值是至少有一个字符的字符串、非0数字或对象时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。
Number()的强制类型转换与parseInt()和parseFloat()方法的处理方式相似，只是它转换的是整个值，而不是部分值。示例如下：
Number(false); // 0
Number(true); //1
Number(undefined); // NaN
Number(null); //0
Number( "5.5 "); //5.5
Number( "56 "); //56
Number( "5.6.7 "); // NaN
Number(new Object()) NaN
利用js变量弱类型转换
例：
var str= '012.345 '; var x = str-0; x = x*1;
上例利用了js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换，不过这个方法还是不推荐的

都可以用“+”号来解决

字符串转数字

var num = +str;

数字转字符串

var str = num + '';

这俩就行
parseInt()
parseFloat()

数字转字串： var str = "" + num;
字串转数字: var num = (str)

https://www.cnblogs.com/craftsman-gao/p/4638700.html
可以参考这往篇博客，里面有详细介绍

图片说明"
parseInt

ar str = "123.456";
parseInt(str, 10) 字符串转数值（只有整数）,10是转换的进制
parseFloat(str) 字符串转数值（有小数）
var num = 123.456;
num.toString(10) 数值转字符串,10是转换的进制
num.toFixed(2) 数值转字符串,可以指定小数的位数

string str= number.toString();

parselnt函数可以，望采纳

数字加一个空格
如下：
var n=100;//number
var m=n+"";//string

Number类定义的toString()方法：这个方法可以接收表示转换基数（radix，范围在2~36之间）的可选参数，如果不指定此参数，转换规则将是基于十进制。

数字可以直接转字符串，字符串用isNaN()判断

 Number( "56 ")

用parseInt函数。 parseInt(string) ：函数从string的开始解析，然后返回一个整数。

字符串转数值可以使用parseInt()和parseFloat()函数转换
数值转字符串toString或者隐式转换 + '';

开发ios程序需要mac本，没的话就只能在虚拟机上安装一个MacOS。

C语言提供了几个标准库函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串。以下是用itoa()函数将整数转换为字符串的一个例子：

include

int main ()

{

int num = 435443435;

char str[30];

itoa( num, str, 10 );

printf("The number 'num' is %d and the string 'str' is %s. /n" , num, str );

getchar();

return 0;

}

可以使用Number()函数将字符转化成数字

使用parseInt（）函数，也可以看看reverse可不可以

Javascript字符串转数字的三种方法:转换函数、强制类型转换、利用js变量弱类型转换。

转换函数:

js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数，后者把值转换成浮点数。只有对String类型调用这些方法，这两个函数才能正确运行;对其他类型返回的都是NaN(Not a Number)。

一些示例如下:

代码如下:

parseInt(\"1234blue\"); //returns 1234 parseInt(\"0xA\"); //returns 10 parseInt(\"22.5\"); //returns 22 parseInt(\"blue\"); //returns NaN

parseInt()方法还有基模式，可以把二进制、八进制、十六进制或其他任何进制的字符串转换成整数。基是由parseInt()方法的第二个参数指定的，示例如下:

代码如下:

parseInt(\"AF\", 16); //returns 175 parseInt(\"10\", 2); //returns 2 parseInt(\"10\", 8); //returns 8 parseInt(\"10\", 10); //returns 10

如果十进制数包含前导0，那么最好采用基数10，这样才不会意外地得到八进制的值。例如:

代码如下:

parseInt(\"010\"); //returns 8 parseInt(\"010\", 8); //returns 8 parseInt(\"010\", 10); //returns 10

parseFloat()方法与parseInt()方法的处理方式相似。使用parseFloat()方法的另一不同之处在于，字符串必须以十进制形式表示浮点数，parseFloat()没有基模式。

下面是使用parseFloat()方法的示例:

代码如下:

parseFloat(\"1234blue\"); //returns 1234.0 parseFloat(\"0xA\"); //returns NaN parseFloat(\"22.5\"); //returns 22.5 parseFloat(\"22.34.5\"); //returns 22.34 parseFloat(\"0908\"); //returns 908 parseFloat(\"blue\"); //returns NaN

强制类型转换

还可使用强制类型转换(type casting)处理转换值的类型。使用强制类型转换可以访问特定的值，即使它是另一种类型的。ECMAScript中可用的3种强制类型转换如下:Boolean(value)――把给定的值转换成Boolean型;Number(value)――把给定的值转换成数字(可以是整数或浮点数);String(value)――把给定的值转换成字符串。用这三个函数之一转换值，将创建一个新值，存放由原始值直接转换成的值。这会造成意想不到的后果。当要转换的值是至少有一个字符的字符串、非0数字或对象(下一节将讨论这一点)时，Boolean()函数将返回true。如果该值是空字符串、数字0、undefined或null，它将返回false。

可以用下面的代码段测试Boolean型的强制类型转换。

代码如下:

Boolean(\"\"); //false

利用js变量弱类型转换

举个小例子，一看，就会明白了。

转数字
Integer.parseInt(Str)

转字符串直接toString

parseInt就行！

转数字
parseInt，或者Number.parseInt(ES6)

转字符串直接toString

可以用parseInt来转