1. JavaScript规定了几种语言类型
2. JavaScript对象的底层数据结构是什么
3. Symbol类型在实际开发中的应用、可手动实现一个简单的 Symbo
4. JavaScript中的变量在内存中的具体存储形式
5.基本类型对应的内置对象,以及他们之间的装箱拆箱操作
6.理解值类型和引用类型
7. null和 undefined的区别
8.至少可以说出三种判断 JavaScript数据类型的方式,以及他们的优缺点,如何准确的判断数组类型
9.可能发生隐式类型转换的场景以及转换原则,应如何避免或巧妙应用
10.出现小数精度丢失的原因, JavaScript可以存储的最大数字、最大安全数字, JavaScript处理大数字的方法、避免精度丢失的方法
1. JavaScript
规定了几种语言类型(推荐阅读 https://www.cnblogs.com/onepixel/p/5140944.html)
答:JavaScript有7大基本类型。(6种原始类型,1种引用类型) https://www.cnblogs.com/memphis-f/p/11913756.html
1)、Undefined
undefined表示未定义,它的值只有一个:undefined。当声明的变量未初始化时,变量的默认值是undefined
任何变量赋值前都是undefined类型,值为undefined而不是null,undefined是一个变量而不是一个关键字。
我们一般不会把变量赋值为undefined,这样可以保证所有值为undefined的变量,都是从未赋值的自然变量。
2)、Null
只有一个值就是null,表示空值,是关键字。
null用来表示尚未存在的对象,常用来表示函数企图返回一个不存在的对象
3)、Boolean
Boolean(true) // true Boolean(false) // false Boolean('Hello Wolrd') // true Boolean() // false Boolean('') // false Boolean(' ') // true (里面有空格) Boolean(1) // true Boolean(0) // false Boolean(NaN) // false Boolean({}) // true Boolean([]) // true Boolean(null) // false Boolean(undefined) // false
把其他类型转换为Boolean类型有三种方式:
1)Boolean()
2)! 或者 !!,取反,先转为Boolean然后再取反
3)条件判断
4)、String
字符串是存储字符的变量。
在JS中的字符串需要用引号引起来(英文单引号或者双引号)
String对象方法:
1)indexOf()
该方法可返回某个指定字符串值在字符串中首次出现的位置。并返回第一次出现的位置。如果要检索的字符串值没有出现,则返回-1
2)lastIndexOf()
该方法可返回某个指定字符串值在字符串中最后出现的位置,在一个字符串中的指定位置从后向前检索。如果要检索的字符串值没有出现,则返回-1
3)concat()
该方法用于连接两个或多个字符串。使用 + 号运算符来进行字符串的连接运算通常会更简便些。
4)slice()
该方法可提取字符串的某个部分,并以返回被提取的部分
5)toLowerCase()
该方法用于将字符串转换为小写
6)toUpperCase()
该方法用于将字符串转换为大写
5)、Number
Number是与数字值对应的引用类型
常用方法:
1)toFixed()
方法会按照指定的小数位返回数值的字符串表示
2)toExponential()
该方法返回以指数表示法(也称 e 表示法)表示的数值的字符串形式
3)toPrecision()
方法可能会返回固定大小(fixed)格式,也可能返回指数(exponential)格式;具体规则是看哪种格式最合适。
这个方法接收一个参数,即表示数值的所有数字的位数(不包括指数部分)。
var num = 10; alert(num.toFixed(2)); //"10.00" var num = 10; alert(num.toExponential(1)); //"1.0e+1" var num = 99; alert(num.toPrecision(1)); //"1e+2" alert(num.toPrecision(2)); //"99" alert(num.toPrecision(3)); //"99.0"
6)、Symbol
表示独一无二的值,它是一切非字符串的对象key的集合。 Symbol 值通过Symbol函数生成。
这就是说,对象的属性名现在可以有两种类型,一种是原来就有的字符串,另一种就是新增的 Symbol 类型。
凡是属性名属于 Symbol 类型,就都是独一无二的,可以保证不会与其他属性名产生冲突。
Symbol函数可以接受一个字符串作为参数,表示对 Symbol 实例的描述,但是即使描述相同,Symbol值也不相等。
let s1 = Symbol('foo'); let s2 = Symbol('foo'); s1 === s2 // false 一些标准中提到的 Symbol,可以在全局的 Symbol 函数的属性中找到。例如,我们可以使用 Symbol.iterator 来自定义 for…of 在对象上的行为: var o = new Object o[Symbol.iterator] = function() { var v = 0 return { next: function() { return { value: v++, done: v > 10 } } } }; for(var v of o) console.log(v); // 0 1 2 3 ... 9
7)、Object
对象是某个特定引用类型的实例。在ECMAScript中,object类型是所有它的实例的基础。换句话说,Object类型所具有的任何属性和方法也同样存在于更具体的对象中。
Object的每个实例都具有下列的属性和方法:
- [x] constructor: 构造函数
-
[x] hasOwnProperty(propertyName)
用于检查给定的属性在当前对象实例(而不是实例的原型)中是否存在。 -
[x] isPrototypeOf(Object):
用于检查其原型链的对象是否存在于指定对象的实例中,是则返回true,否则返回false。
例如:var a = {} function Person() {} var p1 = new Person() // 继承自原来的原型,但现在已经无法访问 var Person.prototype = a var p2 = new Person() // 继承a console.log(a.isPrototypeOf(p1)) // false a是不是p1的原型 console.log(a.isPrototypeOf(p2)) // true a是不是p2的原型 console.log(Object.prototype.isPrototypeOf(p1)) // true console.log(Object.prototype.isPrototypeOf(p2)) // true
- [x] propertyIsEnumerable(propertyName)
用于检查给定的属性是否可以用 for-in 语句进行枚举。 - [x] toLocaleString()
返回对象的字符串表示,该字符串与执行环境的地区对应。 - [x] toString()
返回对象的字符串表示。 - [x] valueOf()
返回对象的字符串、数值、布尔值表示。通常与toString()方法的返回值相同。
创建Object实例的方法:
1、第一种是使用new操作符后跟Object构造函数。
var person=new Object(); person.name="Nicholas"; person.age=29;
2、使用对象字面量。对象字面量是对象定义的一种简写形式,目的在于简化创建包含大量属性的对象的过程。
var person={ name:"Nicholas", age:29 };
2. JavaScript
对象的底层数据结构是什么
参考文章:再谈JS 对象数据结构底层实现原理
3. Symbol
类型在实际开发中的应用、可手动实现一个简单的 Symbol(参考文档)
答:Symbol
是由ES6规范引入的一项新特性,它的功能类似于一种标识唯一性的ID。每个Symbol实例都是唯一的。
因此,当你比较两个Symbol实例的时候,将总会返回false
:
let s1 = Symbol() let s2 = Symbol('another symbol') let s3 = Symbol('another symbol') s1 === s2 // false s2 === s3 // false
应用场景1:使用symbol来作为对象属性名(key)
// ① 通常我们定义或访问对象的属性时都是使用字符串 let obj = { abc: 123, "hello": "world" } obj["abc"] // 123 obj["hello"] // 'world' // ② 现在symbol同样可以用于对象属性的定义和访问 const PROP_NAME = Symbol() const PROP_AGE = Symbol() let obj = { [PROP_NAME]: "一斤代码" } obj[PROP_AGE] = 18 obj[PROP_NAME] // '一斤代码' obj[PROP_AGE] // 18 // ③ Symbol类型的key是不能通过Object.keys()或者for...in来枚举的,它未被包含在对象自身的属性名集合(property names)之中。所以,利用该特性,我们可以把一些不需要对外操作和访问的属性使用Symbol来定义。如下: let obj = { [Symbol('name')]: '一斤代码', age: 18, title: 'Engineer' } Object.keys(obj) // ['age', 'title'] for (let p in obj) { console.log(p) // 分别会输出:'age' 和 'title' } Object.getOwnPropertyNames(obj) // ['age', 'title']
// ④ 也正因为这样一个特性,当使用JSON.stringify()将对象转换成JSON字符串的时候,Symbol属性也会被排除在输出内容之外: JSON.stringify(obj) // {"age":18,"title":"Engineer"}
// ⑤ 我们可以利用这一特点来更好的设计我们的数据对象,让“对内操作”和“对外选择性输出”变得更加优雅。 // ⑥ 获取以symbol方式定义对象属性的API // 使用Object的API Object.getOwnPropertySymbols(obj) // [Symbol(name)] // 使用新增的反射API Reflect.ownKeys(obj) // [Symbol(name), 'age', 'title']
应用场景2:使用symbol来代替常量
// 我们经常定义一组常量来代表一种业务逻辑下的几个不同类型,我们通常希望这几个常量之间是唯一的关系,为了保证这一点,我们需要为常量赋一个唯一的值(比如这里的'AUDIO'、'VIDEO'、 'IMAGE'),
常量少的时候还算好,但是常量一多,你可能还得花点脑子好好为他们取个好点的名字。如下: const TYPE_AUDIO = 'AUDIO' const TYPE_VIDEO = 'VIDEO' const TYPE_IMAGE = 'IMAGE' function handleFileResource(resource) { switch(resource.type) { case TYPE_AUDIO: playAudio(resource) break case TYPE_VIDEO: playVideo(resource) break case TYPE_IMAGE: previewImage(resource) break default: throw new Error('Unknown type of resource') } } // 现在有了Symbol,我们大可不必这么麻烦了,这样定义,直接就保证了三个常量的值是唯一的了: const TYPE_AUDIO = Symbol() const TYPE_VIDEO = Symbol() const TYPE_IMAGE = Symbol()
应用场景3:使用Symbol定义类的私有属性/方法
// 在JavaScript中,是没有如Java等面向对象语言的访问控制关键字private的,类上所有定义的属性或方法都是可公开访问的。因此这对我们进行API的设计时造成了一些困扰。 而有了Symbol以及模块化机制,类的私有属性和方法才变成可能。例如: 在文件 a.js中: const PASSWORD = Symbol( class Login { constructor(username, password) { this.username = username this[PASSWORD] = password } checkPassword(pwd) { return this[PASSWORD] === pwd } } export default Login 在文件 b.js 中: import Login from './a' const login = new Login('admin', '123456') login.checkPassword('123456') // true login.PASSWORD // oh!no! login[PASSWORD] // oh!no! login["PASSWORD"] // oh!no! // 由于Symbol常量PASSWORD被定义在a.js所在的模块中,外面的模块获取不到这个Symbol,也不可能再创建一个一模一样的Symbol出来(因为Symbol是唯一的),
// 因此这个PASSWORD的Symbol只能被限制在a.js内部使用,所以使用它来定义的类属性是没有办法被模块外访问到的,达到了一个私有化的效果。
4. JavaScript
中的变量在内存中的具体存储形式(参考文档)
答:JavaScript中的变量分为基本类型和引用类型
基本类型是保存在栈内存中的简单数据段,它们的值都有固定的大小,保存在栈空间,通过按值访问
引用类型是保存在堆内存中的对象,值大小不固定,栈内存中存放的该对象的访问地址指向堆内存中的对象,JavaScript不允许直接访问堆内存中的位置,因此操作对象时,实际操作对象的引用
![](https://img2018.cnblogs.com/blog/1210492/201912/1210492-20191205111538201-947687082.png)
- 引用类型的复制,同样为新的变量b分配一个新的值,保存在栈内存中,不同的是,这个值仅仅是引用类型的一个地址指针
- 他们两个指向同一个值,也就是地址指针相同,在堆内存中访问到的具体对象实际上是同一个
- 因此改变b.x时,a.x也发生了变化,这就是引用类型的特性
![](https://img2018.cnblogs.com/blog/1210492/201912/1210492-20191205111600414-692451043.png)
![](https://img2018.cnblogs.com/blog/1210492/201912/1210492-20191205111732667-2134336941.png)
5. 基本类型对应的内置对象,以及他们之间的装箱拆箱操作
答:基本类型对应的内置对象:String()、Number()、Boolean()、RegExp()、Date()、Error()、Array()、
Function()、Object()、symbol();类似于对象的构造函数
1、这些内置函数构造的变量都是封装了基本类型值的对象如:
Var a=new String(‘abb’); //typeof(a)=object
除了利用Function()构造的变量通过typeof输出为function外其他均为object
2、为了知道构造的变量的真实类型可以利用:
Object.prototype.toString.call([1,2,3]);//”[object,array]”,后面的一个值即为传入参数的类型
3、如果有常量形式(即利用基本数据类型)赋值给变量就不要用该方式来定义变量
一、装箱
所谓装箱,就是把基本类型转变为对应的对象。装箱分为隐式和显式:
隐式
// 每当读取一个基本类型的值时,后台会创建一个该基本类型所对应的对象。在这个基本类型上调用方法,其实是在这个基本类型对象上调用方法。这个基本类型的对象是临时的,它只存在于方法调用那一行代码执行的瞬间,执行方法后立刻被销毁。具体到代码如下: num.toFixed(2); // '123.00' // 上方代码在后台的真正步骤为 var c = new Number(123); c.toFixed(2); c = null; // 当我们访问 num 时,要从内存中读取这个数字的值,此时访问过程处于读取模式。在读取模式中,后台进行了三步处理: /** 1、创建一个 Number 类型的实例。 2、在实例上调用方法。 3、销毁实例。 **/
显式
// 通过内置对象 Boolean Object String等可以对基本类型进行显式装箱 var obj = new String('123');
二、拆箱
拆箱与装箱相反,把对象转变为基本类型的值。
// 拆箱过程内部调用了抽象操作ToPrimitive: // 该操作接受两个参数,第一个参数是要转变的对象,第二个参数 PreferredType 是对象被期待转成的类型。 ToPrimitive('要转变的对象', PreferredType) { // 操作方法 ........ } // 第二个参数不是必须的,默认该参数为 number,即对象被期待转为数字类型。有些操作如 String(obj) 会传入 PreferredType 参数。有些操作如 obj + " " 不会传入 PreferredType。 // 具体转换过程是这样的: // ① 默认情况下,ToPrimitive 先检查对象是否有 valueOf 方法,如果有则再检查 valueOf 方法是否有基本类型的返回值; // ② 如果没有 valueOf 方法或 valueOf 方法没有返回值,则调用 toString 方法; // ③ 如果 toString 方法也没有返回值,产生 TypeError 错误。 // PreferredType 影响 valueOf 与 toString 的调用顺序。如果 PreferrenType 的值为 string。则先调用 toString ,再调用 valueOf。 // 具体测试代码如下: var obj = { valueOf : () => {console.log("valueOf"); return []}, toString : () => {console.log("toString"); return []} } String(obj) // toString // valueOf // Uncaught TypeError: Cannot convert object to primitive value obj+' ' //valueOf //toString // Uncaught TypeError: Cannot convert object to primitive value Number(obj) //valueOf //toString // Uncaught TypeError: Cannot convert object to primitive value
6. 理解值类型和引用类型
答:JavaScript中的变量类型:
(1) 值类型(基本类型):字符串(string)、数值(number)、布尔值(boolean)、undefined、null (这5种基本数据类型是按值访问的,因为可以操作保存在变量中的实际的值)
(ECMAScript 2016新增了一种基本数据类型:symbol http://es6.ruanyifeng.com/#docs/symbol )
(2) 引用类型:对象(Object)、数组(Array)、函数(Function)
值类型和引用类型的区别
(1) 值类型:
1、占用空间固定,保存在栈中
(当一个方法执行时,每个方法都会建立自己的内存栈,在这个方法内定义的变量将会逐个放入这块栈内存里,随着方法的执行结束,这个方法的内存栈也将自然销毁了。
因此,所有在方法中定义的变量都是放在栈内存中的;
栈中存储的是基础变量以及一些对象的引用变;
基础变量的值是存储在栈中;
而引用变量存储在栈中的是指向堆中的数组或者对象的地址。
这就是为何修改引用类型总会影响到其他指向这个地址的引用变量。)
2、保存与复制的是值本身
3、使用typeof检测数据的类型
4、基本类型数据是值类型
(2) 引用类型:
1、占用空间不固定,保存在堆中
(当我们在程序中创建一个对象时,这个对象将被保存到运行时数据区中,以便反复利用(因为对象的创建成本通常较大),这个运行时数据区就是堆内存。
堆内存中的对象不会随方法的结束而销毁,即使方法结束后,这个对象还可能被另一个引用变量所引用(方法的参数传递时很常见),
则这个对象依然不会被销毁
,只有当一个对象没有任何引用变量引用它时,系统的垃圾回收机制才会在核实的时候回收它。)
2、保存与复制的是指向对象的一个指针
3、使用instanceof检测数据类型
4、使用new()方法构造出的对象是引用型
7. null
和 undefined
的区别
答:null:Null类型,代表 “空值”,代表一个空对象指针,使用typeof运算得到 “object” ,所以可以认为它是一个特殊的对象值。表示"没有对象",即该处不应该有值。用法:
Object.getPrototypeOf(Object.prototype)
// null
(1) 作为函数的参数,表示该函数的参数不是对象。 (2) 作为对象原型链的终点。
undefined:Undefined类型只有一个值,即undefined。表示"缺少值",就是此处应该有一个值,但是还没有定义。用法:
(1)变量被声明了,但没有赋值时,就等于undefined。(2) 调用函数时,应该提供的参数没有提供,该参数等于undefined。(3)对象没有赋值的属性,该属性的值为undefined。(4)函数没有返回值时,默认返回undefined。
知识了解:
undefined与null的区别,这与JavaScript的历史有关。1995年JavaScript诞生时,最初像Java一样,只设置了null作为表示"无"的值。
根据C语言的传统,null被设计成可以自动转为0。
Number(null)
// 0
5 + null
// 5
但是,JavaScript的设计者Brendan Eich,觉得这样做还不够,有两个原因。
首先,null像在Java里一样,被当成一个对象。但是,JavaScript的数据类型分成原始类型(primitive)和合成类型(complex)两大类,Brendan Eich觉得表示"无"的值最好不是对象。
其次,JavaScript的最初版本没有包括错误处理机制,发生数据类型不匹配时,往往是自动转换类型或者默默地失败。Brendan Eich觉得,如果null自动转为0,很不容易发现错误。
因此,Brendan Eich又设计了一个undefined。
8. 至少可以说出三种判断 JavaScript
数据类型的方式,以及他们的优缺点,如何准确的判断数组类型
答:判断数据类型的方法一般可以通过:typeof、instanceof、constructor、toString四种常用方法:
1、typeof (可以对基本类型做出准确的判断,但对于引用类型,用它就有点力不从心了)
typeof返回一个表示数据类型的字符串,返回结果包括:number、boolean、string、object、undefined、function等6种数据类型。
typeof 可以对JS基本数据类型做出准确的判断(除了null),而对于引用类型返回的基本上都是object,。
其实返回object也没有错,因为所有对象的原型链最终都指向了Object,Object是所有对象的`祖宗`。 但当我们需要知道某个对象的具体类型时,typeof 就显得有些力不从心了。
注意:typeof null会返回object,因为特殊值null被认为是一个空的对象引用
2、instanceof
判断对象和构造函数在原型链上是否有关系。有关系返回真,否则返回假。
function Aaa(){} var a1 = new Aaa(); //alert( a1 instanceof Aaa); //true 判断a1和Aaa是否在同一个原型链上,是的话返回真,否则返回假 var arr = []; alert( arr instanceof Aaa);//false
看一下下面的判断: var str = 'hello'; alert(str instanceof String);//false var bool = true; alert(bool instanceof Boolean);//false var num = 123; alert(num instanceof Number);//false var nul = null; alert(nul instanceof Object);//false var und = undefined; alert(und instanceof Object);//false var oDate = new Date(); alert(oDate instanceof Date);//true var json = {}; alert(json instanceof Object);//true var arr = []; alert(arr instanceof Array);//true var reg = /a/; alert(reg instanceof RegExp);//true var fun = function(){}; alert(fun instanceof Function);//true var error = new Error(); alert(error instanceof Error);//true 从上面的运行结果我们可以看到,基本数据类型是没有检测出他们的类型,但是我们使用下面的方式创建num、str、boolean,是可以检测出类型的: var num = new Number(123); alert(num instanceof Number);//true var str = new String('abcdef'); alert(str instanceof String);//true var boolean = new Boolean(true); alert(boolean instanceof Boolean;//true
3、constructor:查看对象对应的构造函数
constructor在其对应的原型下面,是自动生成的。在我们写一个构造函数的时候,程序会自动添加:构造函数名.prototype.constructor = 构造函数名
function Aaa(){} //Aaa.prototype.constructor = Aaa; //每一个函数都会有的,都是自动生成的
判断数据类型的方法
var str = 'hello'; alert(str.constructor == String);//true var bool = true; alert(bool.constructor == Boolean);//true var num = 123; alert(num.constructor ==Number);//true // var nul = null; // alert(nul.constructor == Object);//报错 //var und = undefined; //alert(und.constructor == Object);//报错 var oDate = new Date(); alert(oDate.constructor == Date);//true var json = {}; alert(json.constructor == Object);//true var arr = []; alert(arr.constructor == Array);//true var reg = /a/; alert(reg.constructor == RegExp);//true var fun = function(){}; alert(fun.constructor ==Function);//true var error = new Error(); alert(error.constructor == Error);//true // 从上面的测试中我们可以看到,undefined和null是不能够判断出类型的,并且会报错。因为null和undefined是无效的对象,因此是不会有constructor存在的 // 同时我们也需要注意到的是:使用constructor是不保险的,因为constructor属性是可以被修改的,会导致检测出的结果不正确 function Aaa(){} Aaa.prototype.constructor = Aaa;//程序可以自动添加,当我们写个构造函数的时候,程序会自动添加这句代码 function BBB(){} Aaa.prototype.constructor = BBB;//此时我们就修改了Aaa构造函数的指向问题 alert(Aaa.construtor==Aaa);//false // 可以看出,constructor并没有正确检测出正确的构造函数
4、Object.prototype.toString()
toString() 是 Object 的原型方法,调用该方法,默认返回当前对象的 [[Class]] 。这是一个内部属性,其格式为 [object Xxx] ,其中 Xxx 就是对象的类型。
对于 Object 对象,直接调用 toString() 就能返回 [object Object] 。而对于其他对象,则需要通过 call / apply 来调用才能返回正确的类型信息。
判断类型example:
Object.prototype.toString.call('') ; // [object String] Object.prototype.toString.call(1) ; // [object Number] Object.prototype.toString.call(true) ; // [object Boolean] Object.prototype.toString.call(Symbol()); //[object Symbol] Object.prototype.toString.call(undefined) ; // [object Undefined] Object.prototype.toString.call(null) ; // [object Null] Object.prototype.toString.call(new Function()) ; // [object Function] Object.prototype.toString.call(new Date()) ; // [object Date] Object.prototype.toString.call([]) ; // [object Array] Object.prototype.toString.call(new RegExp()) ; // [object RegExp] Object.prototype.toString.call(new Error()) ; // [object Error] Object.prototype.toString.call(document) ; // [object HTMLDocument] Object.prototype.toString.call(window) ; //[object global] window 是全局对象 global 的引用
9. 可能发生隐式类型转换的场景以及转换原则,应如何避免或巧妙应用
答:1、运算符转换
-,*,/,%会将操作数转换为数字去计算,但+不一样,两边纯数字会按数字相加,纯字符串会拼接,但数字和字符串也会将字符串和数字拼接起来。
console.log("1 - '2'"); console.log(1 - '2'); //-1 console.log("1 * '2'"); console.log(1 * '2'); //2 console.log("6 / '4'"); console.log(6 / '4'); //1.5 console.log("6 % '4'"); console.log(6 % '4'); //2
console.log("6 + 4"); console.log(6 + 4); //10 console.log("6 + '4'"); console.log(6 + '4'); //64 console.log("'6' + '4'"); console.log('6' + '4'); //64 console.log("typeof'6' + '4'"); console.log(typeof('6' + '4')); //string
2、双等号转换
两边会转换为同一类型再进行比较。双等号两边只要有以便是NaN,便返回false,且他自身不相等
console.log("NaN == 1"); console.log(NaN == 1); //false console.log("NaN == NaN"); console.log(NaN == NaN);//false console.log("undefined == NaN"); console.log(undefined == NaN);//false
布尔值会转换为数字,false转换为0,true转换为1
console.log('0 == false'); console.log(0 == false); console.log('1 == true'); console.log(1 == true);
对象的转换
var a = []; var b = []; var c = {}; var d = {}; console.log("[] == []"); console.log(a == b); // false console.log("[] == {}"); console.log(a == c); // false console.log("{} == {}"); console.log(d == c); // false console.log("[] == ![]"); console.log(a == !b); // true // 对于前三个的原理是一样的,当两个值都是对象 (引用值) 时, 比较的是两个引用值在内存中是否是同一个对象. 因为此 [] 非彼 [], 虽然同为空数组, 确是两个互不相关的空数组, 所以为false。 // 而最后一个是因为右边空数组会转化为true,取反变为false,false变为0;左边空数组变为空字符串再变为0,0==0就为true。
3、· 点号操作符
数字、字符串等直接做·操作调用方法时,隐式地将类型转换成对象。
4、if()语句
括号里的表达式部分会被隐式转换为布尔类型进行判别
10.出现小数精度丢失的原因, JavaScript
可以存储的最大数字、最大安全数字, JavaScript
处理大数字的方法、避免精度丢失的方法
答:精度丢失:
因为有些小数在计算机使用二进制方式表示时无法准确的表示出来,类似于十进制中的1/3一样,无理数,无限循环.
可是计算机存储小数的类型不管是float还是double都是有位数限制的,所以他们存储的只是一个近似值,这就导致了精度丢失.
解决办法:
对于整数,前端出现问题的几率可能比较低,毕竟很少有业务需要需要用到超大整数,只要运算结果不超过 Math.pow(2, 53) 就不会丢失精度。
对于小数,前端出现问题的几率还是很多的,尤其在一些电商网站涉及到金额等数据。解决方式:把小数放到位整数(乘倍数),再缩小回原来倍数(除倍数)
// 0.1 + 0.2 (0.1*10 + 0.2*10) / 10 == 0.3 // true
一位网友写的方法,对小数的加减乘除丢失精度做了屏蔽,换算后的整数不能超过 9007199254740992:
(大整数的精度丢失和浮点数本质上是一样的,尾数位最大是 52 位,因此 JS 中能精准表示的最大整数是 Math.pow(2, 53),十进制即 9007199254740992。)
/** * floatObj 包含加减乘除四个方法,能确保浮点数运算不丢失精度 * * 我们知道计算机编程语言里浮点数计算会存在精度丢失问题(或称舍入误差),其根本原因是二进制和实现位数限制有些数无法有限表示 * 以下是十进制小数对应的二进制表示 * 0.1 >> 0.0001 1001 1001 1001…(1001无限循环) * 0.2 >> 0.0011 0011 0011 0011…(0011无限循环) * 计算机里每种数据类型的存储是一个有限宽度,比如 JavaScript 使用 64 位存储数字类型,因此超出的会舍去。舍去的部分就是精度丢失的部分。 * * ** method ** * add / subtract / multiply /divide * * ** explame ** * 0.1 + 0.2 == 0.30000000000000004 (多了 0.00000000000004) * 0.2 + 0.4 == 0.6000000000000001 (多了 0.0000000000001) * 19.9 * 100 == 1989.9999999999998 (少了 0.0000000000002) * * floatObj.add(0.1, 0.2) >> 0.3 * floatObj.multiply(19.9, 100) >> 1990 * */ var floatObj = function() { /* * 判断obj是否为一个整数 */ function isInteger(obj) { return Math.floor(obj) === obj } /* * 将一个浮点数转成整数,返回整数和倍数。如 3.14 >> 314,倍数是 100 * @param floatNum {number} 小数 * @return {object} * {times:100, num: 314} */ function toInteger(floatNum) { var ret = {times: 1, num: 0} var isNegative = floatNum < 0 if (isInteger(floatNum)) { ret.num = floatNum return ret } var strfi = floatNum + '' var dotPos = strfi.indexOf('.') var len = strfi.substr(dotPos+1).length var times = Math.pow(10, len) var intNum = parseInt(Math.abs(floatNum) * times + 0.5, 10) ret.times = times if (isNegative) { intNum = -intNum } ret.num = intNum return ret } /* * 核心方法,实现加减乘除运算,确保不丢失精度 * 思路:把小数放大为整数(乘),进行算术运算,再缩小为小数(除) * * @param a {number} 运算数1 * @param b {number} 运算数2 * @param digits {number} 精度,保留的小数点数,比如 2, 即保留为两位小数 * @param op {string} 运算类型,有加减乘除(add/subtract/multiply/divide) * */ function operation(a, b, digits, op) { var o1 = toInteger(a) var o2 = toInteger(b) var n1 = o1.num var n2 = o2.num var t1 = o1.times var t2 = o2.times var max = t1 > t2 ? t1 : t2 var result = null switch (op) { case 'add': if (t1 === t2) { // 两个小数位数相同 result = n1 + n2 } else if (t1 > t2) { // o1 小数位 大于 o2 result = n1 + n2 * (t1 / t2) } else { // o1 小数位 小于 o2 result = n1 * (t2 / t1) + n2 } return result / max case 'subtract': if (t1 === t2) { result = n1 - n2 } else if (t1 > t2) { result = n1 - n2 * (t1 / t2) } else { result = n1 * (t2 / t1) - n2 } return result / max case 'multiply': result = (n1 * n2) / (t1 * t2) return result case 'divide': result = (n1 / n2) * (t2 / t1) return result } } // 加减乘除的四个接口 function add(a, b, digits) { return operation(a, b, digits, 'add') } function subtract(a, b, digits) { return operation(a, b, digits, 'subtract') } function multiply(a, b, digits) { return operation(a, b, digits, 'multiply') } function divide(a, b, digits) { return operation(a, b, digits, 'divide') } // exports return { add: add, subtract: subtract, multiply: multiply, divide: divide } }();