js中的变量和类型
js中的变量和类型
1. javascript规定了几种语言类型
7种基本数据类型，分别是：
1. String
2. Number
3. Boolean
4. Null
5. Undefine
6. NAN
7. Symbol
2中引用类型，分别是：
1. Object
2. Function
2. Symbol类型在实际开发中的应用、可手动实现一个简单的Symbol
首先来说说symbol是用来做什么的：
`symbol`可以创建全局独一无二的值。
它不是对象，而是一种类似字符串的数据类型，所以也不能`new Symbol()`。
const a = Symbol('amy'); //amy只是对该symbol的描述，类似与注释
const b = Symbol('amy');
const c = Symbol();
const d = Symbol();
c !== d // true
a !== b // true
3. JavaScript中的变量在内存中的具体存储形式
| 堆内存 | 栈内存 | 队列 |
|---|---|---|
| 引用类型值 | 基本数据类型值 | 事件序列 |
| 类似json的key,value匹配 | 叠衣服，拿衣服，放在最上面的最先取 | 排队，先排先到 |
| 无序存储，根据引用获取 | 先进后出，后进先出 | 先进先出， 后进后出 |
| 存放对象 | 执行程序 | - |
| 代码分配 | 系统自动分配 | - |
| 存储值大小不固定，可动态调整 | 存储值大小固定 | - |
| 空间大，运行效率相对较低 | 空间小，运行效率较高 | - |
严格意义上来说，变量对象也是存放于堆内存中，但是由于变量对象的特殊职能，我们在理解时仍然需要将其于堆内存区分开来。
4. 基本类型对应的内置对象，以及他们之间的装箱拆箱操作
基本类型中的内置对象有：
String(),
Number(),
Boolean(),
symbol()
引用类型的内置对象有：
RegExp(),
Date(),
Array(),
Object(),
Function(),
Error()
装箱操作：隐式转换 值类型 =》 对象类型
拆箱操作：显式转换 对象类型 =》 值类型
5. 理解值类型和引用类型
原型链
堆、栈存储方式
6. null和undefined的区别
null == undefined // true
null === undefined // false
!!null // false
!!undefined // false
Number(null) //0
Number(undefined) //NaN
null更多表示引用语义, 它表示一个值被定义了，定义为“空值”。
undefined更多表示值语义，它表示根本不存在定义。
所以设置一个值为null是合理的，但是设置一个值为undefined就不合理。
typeof null // object
typeof undefined // undefined
7. 至少可以说出三种判断JavaScript数据类型的方式，以及他们的优缺点，如何准确的判断数组类型
1. typeof XXX // string boolean undefined number function object
缺点： null, Date, arrary返回的都是object.
2. XXX instanceof XXX
3. constructor // XXX.constructor === XXX(Arrary/Date/Function)
缺点：constructor在继承时会出错。
4. prototype Object.prototype.toString.call(XXX) === '[object Sting/Number/Arrary/Date/Function]'
8. 可能发生隐式类型转换的场景以及转换原则，应如何避免或巧妙应用
强制转换： Number()强制转为数值型、String()强制转为字符串、Boolean()、parseInt()、parseFloat()。
隐式转换：
console.log(0 && 123); // 0
console.log(123 && 0) //0
console.log(123 && 234) //234
9. 出现小数精度丢失的原因，JavaScript可以存储的最大数字、最大安全数字，JavaScript处理大数字的方法、避免精度丢失的方法
示例代码：
var x = 0.3 - 0.2; //30美分减去20美分
var y = 0.2 - 0.1; //20美分减去10美分
x == y; // =>false,两值不相等
x == 0.1; // =>false,真实值为：0.09999999999999998
y == 0.1; // =>true
这个问题并不只是在Javascript中才会出现，任何使用二进制浮点数的编程语言都会有这个问题，只不过在 C++/C#/Java 这些语言中已经封装好了方法来避免精度的问题，而 JavaScript 是一门弱类型的语言，从设计思想上就没有对浮点数有个严格的数据类型，所以精度误差的问题就显得格外突出。
2.产生原因
Javascript采用了IEEE-745浮点数表示法（几乎所有的编程语言都采用），这是一种二进制表示法，可以精确地表示分数，比如1/2，1/8，1/1024。遗憾的是，我们常用的分数（特别是在金融的计算方面）都是十进制分数1/10，1/100等。二进制浮点数表示法并不能精确的表示类似0.1这样 的简单的数字，上诉代码的中的x和y的值非常接近最终的正确值，这种计算结果可以胜任大多数的计算任务：这个问题也只有在比较两个值是否相等时才会出现。
javascript的未来版本或许会支持十进制数字类型以避免这些舍入问题，在这之前，你更愿意使用大整数进行重要的金融计算，例如，要使用整数‘分’而不是使用小数‘元’进行货比单位的运算---------以上整理自《Javascript权威指南P37》
- 0.1+0.2的计算
首先，我们要站在计算机的角度思考 0.1 + 0.2 这个看似小儿科的问题。我们知道，能被计算机读懂的是二进制，而不是十进制，所以我们先把 0.1 和 0.2 转换成二进制看看：
0.1 => 0.0001 1001 1001 1001…（无限循环）
0.2 => 0.0011 0011 0011 0011…（无限循环）
双精度浮点数的小数部分最多支持 52 位，所以两者相加之后得到这么一串 0.0100110011001100110011001100110011001100110011001100 因浮点数小数位的限制而截断的二进制数字，这时候，我们再把它转换为十进制，就成了 0.30000000000000004。
4.解决方案 （引自：解决方案）
为了解决浮点数运算不准确的问题，在运算前我们把参加运算的数先升级(10的X的次方)到整数，等运算完后再降级(0.1的X的次方)。
//加法
Number.prototype.add = function(arg){
var r1,r2,m;
try{r1=this.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2))
return (this*m+arg*m)/m
}
//减法
Number.prototype.sub = function (arg){
return this.add(-arg);
}
//乘法
Number.prototype.mul = function (arg)
{
var m=0,s1=this.toString(),s2=arg.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m)
}
//除法
Number.prototype.div = function (arg){
var t1=0,t2=0,r1,r2;
try{t1=this.toString().split(".")[1].length}catch(e){}
try{t2=arg.toString().split(".")[1].length}catch(e){}
with(Math){
r1=Number(this.toString().replace(".",""))
r2=Number(arg.toString().replace(".",""))
return (r1/r2)*pow(10,t2-t1);
}
}
问题9摘自segmentfault