JS总结篇03--数据类型（上篇）

一. 基本类型方法
为了使基本类型更方便的进行数据操作，使用相关方法，javascript产生了包装类，String，Number，Boolean，Symbol。

如：‘str’.toUpperCase()在调用的时候，有以下过程：
1.'str’为基本类型，当获取其属性toUpperCase时，'str’的包装类String会创建一个包装对象并且获取基本类型的值，这个对象有一些有用的方法如toUpperCase（）
2.toUpperCase()执行并且返回一个新的string类型数据
3.包装对象销毁，原基本类型对象保持原来的值不变。

构造函数String / Number / Boolean 通常不用来创建包装类，而是用来进行类型转换。

alert( typeof 1 ); // "number"
alert( typeof new Number(1) ); // "object"!
let num = Number("123"); // convert a string to number

二. Number类型

所有number类型都是以64位双精度存储的。
数字的表现形式
十进制：10 ， 0.1111
指数： 1e5， 3e-3
十六进制： 0xff //255
八进制：0o377 //255
二进制：0b11111111 //255

其他进制转换：
十进制转其他进制： num.toString(base) //base:进制 2-36
其他进制转十进制：parseInt(string，base) //将string以base进制转换成十进制

取近似值

Math.floor：向下取整
Math.ceil: 向上取整
Math.round: 四舍五入
Math.trunc: 截断取整（ie不支持）
num.toFixed(n): 四舍五入保留小数点后第n位

非精确计算

alert( 0.1 + 0.2 ); // 0.30000000000000004

原因：2进制64位精度有限，无法准确存储某些小数。
解决办法：取有限精度计算

isFinite和isNaN

isFinite(num): 先将num进行number转换，然后判断是否是常规数字，而不是Infinity，-Infinity，NaN

isNaN(num): 判断是否是NaN ， NaN无法用==或===判断

Object.is(): 通常情况下，此方法等同于===
特殊情况：
Object.is(NaN，NaN) 返回true
Object.is(0，-0）返回false

parseInt和parseFloat
此方法会截取字符串前面可转化为数字的部分，并返回数字，如果不满足条件，则会返回NaN。
parseInt(null) //NaN
parseInt(Infinity) //NaN
parseFloat(Infinity) //Infinity

三. String

所有的文字都是存储为string类型，内部以UTF-16存储，与页面编码无关。

引号

let single = 'single-quoted';
let double = "double-quoted";
let backticks = `backticks`

反引号的优点：可使用${}计算表达式， 允许多行输出。

特殊符号表示

\uNNNN : 以NNNN表示的Unicode编码
\u{NNNNNNNN}：一些特殊符号需要4个字节来表示

获取字符

let str = 'hello';
alert(str[0]); // h
alert(str.charAt(0)); // h
alert(str[str.length-1]);  // o
for( let char of 'hello'){
	...
}

区别：没有获取到值得时候，[]返回undefined，charAt返回’’

不可变性

let str = 'Hi';
str[0] = 'h'; // error
alert( str[0] ); // doesn't work

通常都是创建一个新的字符串

方法

大小写转换：
toLowerCase()/toUpperCase()

查找字符串：
str.indexOf(substr，pos);从str中的第pos位查找substr
str.lastIndexOf(substr，pos);反向查找
判断方法：if(~str.indexOf(substr，pos)为false则是未查找到。
现代方法：str.includes(substr，pos)；返回true/false
str.startsWith(substr);是否以substr开头
str.endsWith(substr);是否以substr结尾

分割字符串：
str.slice(start [，end]）：
返回从start到end(不包括)（或结尾）的子串，start和end可以为负数，表示从后往前计算位置

let str = "stringify";
alert( str.slice(0, 5) ); // 'strin', the substring from 0 to 5 (not including 5)
alert( str.slice(2) ); // ringify, from the 2nd position till the end
alert( str.slice(-4, -1) ); // gif

str.substring(start [，end])
返回从start到end的子串，不允许负值，但可start比end大

let str = "stringify";
// these are same for substring
alert( str.substring(2, 6) ); // "ring"
alert( str.substring(6, 2) ); // "ring"
// ...but not for slice:
alert( str.slice(2, 6) ); // "ring" (the same)
alert( str.slice(6, 2) ); // "" (an empty string)

str.substr(start [，length])
返回从start开始，长度为length的子串

let str = "stringify";
alert( str.substr(2, 4) ); // ring, from the 2nd position get 4 characters

比较字符串：
逐个字符比较，以字符unicode码比较大小；
获取unicode码：
str.codePointAt(pos)
String.fromCodePoint(code);
不同语言的比较：str.localeCompare(str2)返回 1/0/-1

四. 数组基础

数组是用来存储有序集合的特殊对象，提供了关于有序集合存储和操作的相关功能。数组中可以存储任何类型的数据，包括函数等…

声明：

let arr = new Array();
let arr = [];

增删方法：

pop/push ，shift/unshift
其中pop/push的速度比shift/unshift快，原因是操作不涉及到移动元素。

内部机制：
数组的核心还是对象，仍采用引用传递，使其特殊的在于内部将数组元素存储在一段连续的内存空间，以及相关的优化，使数组的效率非常高。
不恰当的使用数组将会破坏这种高效率，如：
1.添加非数字的属性。
2.跳跃赋值，如arr[0]赋值后给arr[1000]并且中间没有元素
3.倒序赋值，如arr[1000],arr[999]…

数组方法

增删：
arr.push(…items) 返回增加后数组长度
arr.pop() 返回出栈元素
arr.shift() 返回出栈元素
arr.unshift(…items) 返回增加后数组元素
splice(index [，deleteCount，ele1…] 返回删除元素的数组。原数组被修改
slice(start，end) 返回被删除部分数组，原数组不变。
concat(arg1，arg2) 返回新数组，原数组不变。

查找：
arr.indexOf(item,from)/arr.lastIndexOf(item,from)/arr.includes(item,from）
arr.find((item,index,array)=>{}) /arr.findIndex((item,index,array)=>{})
arr.filter((item,index,array)=>{}

数组转换：
arr.map((item,index,array)=>{})
arr.sort(fn) 返回原数组排序后的数组，原数组被修改，默认按字符排序。
arr.reverse() 返回原数组排序后的数组，原数组被修改。
split/join
reduce/reduceRight((previousValue，item，index，arr)=>{},initial)

遍历：
arr.forEach((item,index,array)=>{})

Array.isArray() 判断是否为数组，可检测出new Array()创建的数组
arr.find/filter/map 除了func参数外，还可以加一个参数，代表func中的this对象。

后续补充：
数字精确计算
特殊字符，图形处理