JavaScript基础数据类型

JavaScript基础数据类型共有5种，为：String、Number、Boolean、Null、Undefined。

String

不可变性

重新给字符串赋值时，原本的字符串值不会改变，依然保存在内存中，变量指向新的数值

属性

length

str.length
返回字符串长度

方法

查找

chatAt

str.chatAt(0)//返回第一个字符
返回字符串中指定位置字符，没有找到返回一个空串
与[]返回相比，[]没有找到返回undefined，chatAt没有找到返回一个空串

charCodeAt

返回字符串中指定位置字符的unicode

fromCharCode

string.fromcharcode(74)//J
根据指定unicode字符编码获取字符

indexOf

str.indexOf(substr, pos)
从指定位置pos开始，定位字符串中指定的字符/字符串substr首次出现的位置
如果没找到对应的字符函数返回-1

lastIndexOf

str.lastIndexOf(substr, pos)
从字符串的末尾开始搜索到开头，定位字符串中指定的字符/字符串substr首次出现的位置
如果没找到对应的字符函数返回-1

includes()

str.includes(substr, pos)
根据 str 中是否包含 substr 来返回 true/false。

match

用来查找字符串中特定的字符，并且如果找到的话，则返回这个字符，找不到则返回null。

search()

search(searchvalue)
search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。
如果没有找到任何匹配的子串，则返回 -1。

获取字符串

slice

str.slice(start)
str.slice(start, end)
返回字符串从 start 到（但不包括）end 的部分。
如果没有第二个参数，slice 会一直运行到字符串末尾
start/end 也有可能是负值。它们的意思是起始位置从字符串结尾计算
str.slice(-4,-1)//从右边的第四个位置开始，在右边的第一个位置结束

substring

str.substring(start)
str.substring(start, end)
返回字符串从 start 到（但不包括）end 的部分，这与 slice 几乎相同，但它允许 start 大于 end。
不支持负参数（不像 slice），它们被视为 0。

let str = "stringify";
// 这些对于 substring 是相同的
alert( str.substring(2, 6) ); // "ring"
alert( str.substring(6, 2) ); // "ring"
// 但对 slice 是不同的：
alert( str.slice(2, 6) ); // "ring"（一样）
alert( str.slice(6, 2) ); // ""（空字符串）

substr

str.substr(start)
str.substr(start, length)
返回字符串从 start 开始的给定 length 的部分。
第一个参数可能是负数，从结尾算起：

替换

replace

replace(oldstr，newstr)
在字符串中用某些字符替换另一些字符。
支持正则，在字符串中查找匹配的子串，并替换与正则表达式匹配的子串。

str="Please visit Microsoft!"
var n=str.replace("Microsoft","Runoob");

转换

toUpperCase()

全转变成大写

toLowerCase()

全转变成小写:

split()

字符串转为数组

连接

concat()

concat(string1, string2, ..., stringX)
concat() 方法用于连接两个或多个字符串。
该方法没有改变原有字符串，但是会返回连接两个或多个字符串新字符串。

其他

方法	描述
startsWith()	查看字符串是否以指定的子字符串开头。
endsWith()	判断当前字符串是否是以指定的子字符串结尾的（区分大小写）。
repeat()	复制字符串指定次数，并将它们连接在一起返回。
replaceAll()	在字符串中查找匹配的子串，并替换与正则表达式匹配的所有子串。
trim()	去除字符串两边的空白。
valueOf()	返回某个字符串对象的原始值。
toString()	返回一个字符串。

转义字符

代码	输出
\’	单引号
\"	双引号
\\	斜杆
\n	换行
\r	回车
\t	tab
\b	空格
\f	换页

模板字符串

相较于传统的''或者"",````有着较多的优势

• 可以换行、嵌套使用
• 通过${...}插入变量
• 可以在${...}里插入函数调用

//变量
console.log('我是' + name + ',age:' + age); //传统写法
console.log(`我是${name},age:${age}`); //模板字符串

//表达式
console.log('this is ' + (a + b) + ' and\nnot ' + (2 * a + b) + '.');
// 表达式换行
console.log(`this is ${a + b} and
not ${2 * a + b}.`);
/*打印结果
this is 15 and
not 20.*/

//调用函数
console.log(`www.${getName()}.com`); 

//嵌套使用
function myTemplate() {
	return `<ul>
		${nameList.map((item) => `<li>${item}</li>`).join('')}
	</ul>`;
}

变音符号和规范化

alert( 'S\u0307' ); // Ṡ
alert( 'S\u0307\u0323' ); // Ṩ

Number

特点

JavaScript 不是类型语言，不定义不同类型的数字，比如整数、短、长、浮点等等。
在JavaScript中，数字不分为整数类型和浮点型类型，所有的数字都是浮点型类型
JavaScript 采用 IEEE754 标准定义的 64 位浮点格式表示数字，它能表示最大值为 ±1.7976931348623157e+308，最小值为 ±5e-324。
整数（不使用小数点或指数计数法）最多为 15 位。
小数的最大位数是 17，但是浮点运算并不总是 100% 准确

js精度问题处理方式

• 可以使用 +toFix() 方法进行小数的截取
• 使用乘2的整数倍以至于成为整数进行运算后再除相同倍数
• 使用现成的库，比如decimal.js、 Math.js。

进制

• 二进制，前缀0b
• 八进制，前缀0o
• 十六进制，前缀0x

可以使用 toString() 方法输出不同进制。

var myNumber=128;
myNumber.toString(16);   // 返回 80
myNumber.toString(8);    // 返回 200
myNumber.toString(2);    // 返回 10000000
myNumber.toString(36);    // 范围可以从2到36

128..toString();//只有一个.就会出错，可能..包含隐式类型转换
(128).toString();//这个也可以

或者使用parseInt(str,num)

parseInt('0xff', 16) // 255
parseInt('ff', 16) // 255，没有 0x 仍然有效
parseInt('2n9c', 36) // 123456

隐式转换

-、*、/、%这几个符号会自动进行隐式转换。（除了加都会）
var a = "4" + 3 - 6; //37

特殊值

无穷大（Infinity）

如果使用 Number 表示的变量超过了最大值，则会返回Infinity。

• 无穷大（正无穷）：Infinity
• 无穷小（负无穷）：-Infinity

注意：typeof Infinity的返回结果是number。
基于它们的加、减、乘和除运算结果还是本身。

NaN - 非数字值

NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。可以把 Number 对象设置为该值，来指示其不是数字值。
可以使用isNaN()全局函数来判断一个值是否是 NaN 值。
注意：

• typeof NaN的返回结果是 number。
• infinity不是NAN
• Undefined和任何数值计算的结果为 NaN。
• NaN 与任何值都不相等，包括 NaN 本身。

关于 Infinity， -Infinity 和 NaN

• Infinity ， -Infinity 和 NaN 都是 JavaScript 保留字，不能用作标识符，对大小写敏感。
• -Infinity 不需要用括号包围； 1 - (-Infinity) 和 1 - -Infinity 是等价的。
• 和其他数字一样，这三者与字符串相加会得到字符串。
• 这三者不等于任何一个有限数字。
• 使用对象的.stringgify()方法转换为 JSON 文本时，这三者会被转换为 null

Infinity 运算法则

• 正数除以 0 得 Infinity。
• Infinity 加或减任何有限数字都得 Infinity 。Infinity + Infinity 或 Infinity - -Infinity 也得 Infinity 。
• Infinity 乘或除以任何有限正数得 Infinity 。Infinity 乘或除以任何有限负数得 -Infinity 。 Infinity * Infinity 或 Infinity / 0 也得 Infinity 。Infinity * -Infinity 得 -Infinity。
• Infinity - Infinity 得 NaN 。 Infinity / Infinity 得 NaN 。 Infinity * 0 得 NaN 。
• Infinity == Infinity 为真。 Infinity.isNaN() 为假。 Infinity.isFinite() 为假。 Boolean(Infinity) 为真。

-Infinity 运算法则

• 负数除以 0 得 -Infinity。
• -Infinity 加或减任何有限数字都得 -Infinity 。-Infinity + -Infinity 或 -Infinity - Infinity 也得 -Infinity 。
• -Infinity 乘或除以任何有限正数得 -Infinity 。-Infinity 乘或除以任何有限负数得 Infinity 。 -Infinity * Infinity 或 -Infinity / 0 也得 -Infinity 。-Infinity * -Infinity 得 Infinity。
• -Infinity - -Infinity 得 NaN 。 -Infinity / -Infinity 得 NaN 。 -Infinity * 0 得 NaN 。
• -Infinity == -Infinity 为真。 -Infinity.isNaN() 为假。 -Infinity.isFinite() 为假。 Boolean(-Infinity) 为真。

NaN 运算法则

• 0 / 0 得 NaN ，数字+undefined 或者 undefined+数字得NaN
• Infinity - Infinity 得 NaN 。 Infinity / Infinity 得 NaN 。 Infinity * 0 得 NaN 。
• -Infinity - -Infinity 得 NaN 。 -Infinity / -Infinity 得 NaN 。 -Infinity * 0 得 NaN 。
• NaN 加、减、乘或除以任何数（包括 Infinity 、 -Infinity 和 NaN 本身）得 NaN 。
• 无论变量 x 取何值（包括 undefined 、 null 、 true 、 false 、 Infinity 、 -Infinity 和 NaN 本身），NaN == x 恒为假。NaN.isNaN() 为真。 NaN.isFinite() 为假。 Boolean(NaN) 为假。

属性

属性	描述
Number.MAX_VALUE	最大值
Number.MIN_VALUE	最小值
Number.NaN	非数字
Number.NEGATIVE_INFINITY	负无穷，在溢出时返回
Number.POSITIVE_INFINITY	正无穷，在溢出时返回
Number.EPSILON	表示 1 和比最接近 1 且大于 1 的最小 Number 之间的差别
Number.MIN_SAFE_INTEGER	最小安全整数
Number.MAX_SAFE_INTEGER	最大安全整数

方法

toFixed

num.toFixed(num)
将数字舍入到小数点后 num 位，并以字符串形式返回结果。
这会向上或向下舍入到最接近的值，类似于Math.round
如果小数部分比所需要的短，则在结尾添加零

var a = 123; 
b = a.toFixed(2); //"123.00"
c = 

isNaN

num.isNaN()
将参数转化为number类型，并且判断是不是NaN
NaN是独一无二的，NaN === NaN 为false，故用isNaN检测是否是NaN

isFinite

num.isFinite()
将其参数转换为数字，如果是常规数字而不是 NaN/Infinity/-Infinity，则返回 true

parseInt

num.parseInt 或者parseInt(num)
返回到第一个非数字以前的数字

parseFloat

num.parseFloat 或者parseFloat(num)
返回到第一个非数字非.以前的数字或者第二个.以前的数字

其他

方法	描述
Number.isInteger()	判断传递的参数是否为整数。
Number.isSafeInteger()	判断传递的参数是否为安全整数。
toExponential()	返回一个数字的指数形式的字符串，如：1.23e+2
toPrecision()	返回一个指定精度的数字。如下例子中，a=123 中，3会由于精度限制消失:
var a=123; b=a.toPrecision(2); // b=“1.2e+2”

其余写法

let billion = 1_000_000_000;//js引擎会忽略_，以便于阅读
let billion = 1e9;  // 10 亿，字面意思：数字 1 后面跟 9 个 0
let mcs = 1e-6; // 1 的左边有 6 个 0

Boolean

Boolean 对象代表两个值:“true” 或者 “false”
var myBoolean = new Boolean();
如果布尔对象无初始值或者其值为: 0、-0、null、“”、false、undefined、NaN，那么对象的值为 false。
否则，其值为 true（即使当变量值为字符串 “false” 时）

Null、Undefined

null

• 用来定义一个**空对象 **let a = null
• 定义一个没有确定内容的变量用来保存引用类型，可以在初始化时将其设置为 null。let myObj = null;
• Null 类型的值只有一个，就是 null。

typeof null // object

null > 0 //false
null == 0 //false
null >= 0 //true
/** < > <= >=比较时会转换为数字 null被返回了 0 所以null >= 0
== 时不会进行类型转换 只有null==null 或者 null==undefined 为true**/

undefined

• Undefined 类型的值只有一个，就是 undefind。

typeof undefined // undefined

undefined > 0 // false 
undefined < 0 // false 
undefined == 0 // false 
/** < > <= >=比较时会转换为数字 undefined被返回了 0 所以null >= 0
== 时不会进行类型转换 只有undefined==null 或者 undefined==undefined 为true**/

//定义后未赋值变量为 undefined
let name;
console.log(name); // undefined
console.log(typeof name); // undefined

//未声明变量为 undefined
console.log(typeof nothing); // undefined
console.log(nothing); // 打印结果：Uncaught ReferenceError: a is not defined

//无返回值函数的返回值为undefined
function foo() {}
console.log(foo()); // 打印结果：undefined

//调用函数未传参为undefined
function foo(name) {
    console.log(name);
}
foo(); // 调用函数时，未传参。执行函数后的打印结果：undefined

null和undefined区别

• null 和 undefined 有很大的相似性。看看 null == undefined 的结果为 true 也更加能说明这点。
• 但是 null === undefined 的结果是 false。它们虽然相似，但还是有区别的，其中一个区别是，和数字运算时：
  • 任何数据类型和 undefined 运算都是 NaN;
  • 任何值和 null 运算，null 可看做 0 运算。
• null 是一个只有一个值的特殊类型，表示一个空对象引用
  • 用null清空对象，值为null，但是typeof（即为类型）为对象
  • 用undefined清空对象，值为undefined，类型为undefined

任何变量都可以通过undefined清空

判断数据类型

typeof

返回右操作数对象类型，返回值都是字符串
可以判断类型：undefined/数值/字符串/布尔值/function
不能判断:null/object/array（返回的都是object）

typeof "John"                // 返回 string
typeof 3.14                  // 返回 number
typeof false                 // 返回 boolean
typeof [1,2,3,4]             // 返回 object
typeof {name:'John', age:34} // 返回 object
typeof function(){}          // 返回 function

instanceof

判断左操作数是不是右操作数的实例，通过原型链判断，返回一个布尔值
可以判断类型：object/array/function
不能判断：原始数据类型（undefined/null/数值/字符串/布尔值）

function(){} instanceof Function    //true
{name:'John', age:34} instanceof Object //true
[] instanceof Array//true

constructor

[].constructor === Array

数据类型转换

显式类型转换

• toString()
• String()

---

• Number()
• parseInt(string)
• parseFloat(string)

---

• Boolean()

隐式类型转换

isNaN ()

解释：判断指定的参数是否为 NaN（非数字类型），返回结果为 Boolean 类型。也就是说：任何不能被转换为数值的参数，都会让这个函数返回 true。

1. 调用Number(参数)函数；
2. 将Number(参数)的返回结果和NaN进行比较。

console.log(isNaN('123')); // 返回结果：false。
console.log(isNaN('abc')); // 返回结果：true。因为 Number('abc') 的返回结果是 NaN
console.log(isNaN(null)); // 返回结果：false
console.log(isNaN(undefined)); // 返回结果：true
console.log(isNaN(NaN)); // 返回结果：true

自增/自减运算符：++、—-

1. 调用Number(参数)函数；
2. 将Number(参数)的返回结果进行 加 1 操作。

正号/负号：+a、-a

任何值做+a、-a、/a运算时，运算结果都会自动转换为 Number 类型。 内部调用的是 Number() 函数。

加号：+

• 字符串 + 数字
  • 当加号的两边，只要有一个是字符串的时候，就会调用String()函数将数字转为字符串，然后再计算。导致最终的运算结果是字符串。
• Boolean + 数字
  • Boolean 型和数字型相加时， true 按 1 来算 ，false 按 0 来算。这里其实是先调 Number() 函数，将 Boolean 类型转换为 Number类型，然后再和 数字相加。
• null + 数字
  • 等价于：0 + 数字
• undefined + 数字
  • 计算结果：NaN

运算符：-、*、/

任何非 Number 类型的值做-、*、/运算时，会调用Number()函数再运算，运算结果是 Number 类型。

逻辑运算符：&&、||、！

非布尔值进行与或运算时，会先调用Boolean()再运算，但运算结果是原值。
&&：前者true则返回后者的值，前者false则返回前者的值，不执行后者
||：前者true则返回前者的值，不执行后者，前者false则返回后者的值
&&优先级高于||

关系运算符：<、>、<=、>=、==

• 关系运算符，得到的运算结果都是布尔值：要么是true，要么是false。
• 对于非数值进行比较时，会将其转换为数字然后再比较。
• 如果符号两侧的值都是字符串时，不会将其转换为数字进行比较。比较两个字符串时，比较的是字符串的Unicode编码。因此：当我们在比较两个字符串型的数字时，一定一定要先转型再比较大小，比如 parseInt()。
• 任何值和NaN做任何比较都是false，即NaN == NaN为false
• undefined 衍生自 null，所以这两个值做相等判断时，会返回true。即undefined == null为true
• 当非 Boolean 类型的数值和 Boolean类型的数值做==时，会先把前者进行隐式转换为 Boolean类型，然后再做比较；且不会改变前者的数据类型。

const a = 1;
console.log(a == true); // 打印结果：true
console.log(typeof a); // 打印结果：number。可见，上面一行代码里，a 做了隐式类型转换，但是 a 的数据类型并没有发生变化，仍然是 Number 类型
console.log(0 == true); // 打印结果：false

转换成字符串

利用“+”的隐式类型转换：字符串拼接

变量+"" 或者 变量+"abc"
c = c + "" 等价于 c = String(c)。

调用toString()

变量.toString()

• 不影响原变量
• null 和 undefined 这两个值没有 toString()方法
• Number 类型的变量，在调用 toString()时，可以在方法中传递一个整数作为参数。此时它将会把数字转换为指定的进制，如果不指定则默认转换为 10 进制。

String()

String(变量)

• 对于 Number 和 Boolean 而言，本质上就是调用toString()方法。
• 但是对于 null 和 undefined，则不会调用 toString()方法。它会将 null 直接转换为 “null”。将 undefined 直接转换为 “undefined”。

prompt()

prompt（）就是专门用来弹出能够让用户输入的对话框。重要的是：用户不管输入什么，都当字符串处理。
即返回时是用户输入的字符串

转换成数字

Number()

• 字符串 --> 数字
  • 如果字符串中是纯数字，则直接将其转换为数字。
  • 如果字符串是一个空串或者是一个全是空格的字符串，则转换为 0。
  • 只要字符串中包含了其他非数字的内容（小数点按数字来算），则转换为 NaN。
• 布尔 --> 数字
  • true 转成 1
  • false 转成 0
• null --> 数字
  • 结果为：0
• undefined --> 数字
  • 结果为：NaN

parseInt()

parseInt(argument)
parseInt(argument,num)
第二个参数辅助表示第一个参数的进制
parseInt()的作用是将字符串中的有效的整数内容转为数字，如果对非 String使用 parseInt()或 parseFloat()，它会先将其转换为 String 然后再操作。

• 字符串 --> 数字
  • 只保留字符串最开头的数字，后面的中文自动消失。
  • 如果字符串不是以数字开头，则转换为 NaN。
  • 如果字符串是一个空串或者是一个全是空格的字符串，转换时会报错。
• Boolean --> 数字
  • 结果为：NaN
• Null --> 数字
  • 结果为：NaN
• Undefined --> 数字
  • 结果为：NaN
• 数字 --> 数字
  • 取整，不四舍五入

var a = 168.23;
console.log(parseInt(a)); 
//打印结果：168  （因为是先将 a 转为字符串"168.23"，然后然后再操作）
var b = true;
console.log(parseInt(b)); 
//打印结果：NaN （因为是先将 b 转为字符串"true"，然后然后再操作）
var c = null;
console.log(parseInt(c)); 
//打印结果：NaN  （因为是先将 c 转为字符串"null"，然后然后再操作）
var d = undefined;
console.log(parseInt(d)); 
//打印结果：NaN  （因为是先将 d 转为字符串"undefined"，然后然后再操作）

var a = '110';
var num = parseInt(a, 16); // 将a当成十六进制来看待，转换成十进制的num
console.log(num);//272

var a = '5';
var num = parseInt(a, 2); //将a当成二进制来看待，转换成十进制的num
console.log(num); // NaN。二进制中没有5这个数，转换失败。

parseFloat()

转换结果为浮点数，其余类似parseInt()

转换成布尔

Boolean()

• 数字 --> 布尔
  • 除了 0 和 NaN，其余的都是 true。
• 字符串 —> 布尔
  • 除了空串、全是空格的字符串、字符串’0’，其余的都是 true。
• null 和 undefined 都会转换为 false。
• 引用数据类型会转换为 true。空数组[]和空对象{}，转换结果也是 true

!!

使用 !!可以显式转换为 Boolean 类型。比如 !!3的结果是true。