Skip to content

Latest commit

 

History

History
240 lines (133 loc) · 4.83 KB

基本数据类型和特殊值.md

File metadata and controls

240 lines (133 loc) · 4.83 KB
Raw

基本数据类型和特殊值

基本数据类型

js 有 7种 内置类型

  • null
  • undefined
  • boolean
  • number
  • string
  • object
  • symbol

除 object 之外 其余的统称为 ‘基本数据类型’

用 typeof 运算符 来 鉴别这些值类型

typeof undefined === 'undefeind'  // true
typeof true === 'boolean'         // true
typeof 42 === 'number'            // true
typeof {a: 1} === 'object'        // true
typeof '42' === 'string'          // true
typeof Symbol() === 'tymbol       // true
typeof NaN === 'number'           // true 因为 NaN 是数字类型

// 但是 null 比较特殊  
typeof null === 'object'   // true
// 所以  我们需要复合条件来判断
let a = null
(!a && typeof a === object)    // true

undefined 和 undeclared

变量在未持有值的时候为 undefined ， 此时 typeof 返回 ‘undefined’

大多数开发者倾向于 将 undefined 等同于 undeclared(未声明) 但在 js 中 他们完全是两码事

已在作用域中声明 但是 还未赋值的变量 是 undefined 相反 在 没有作用域中声明的 命令 是 undeclared 的

var a

a    // undefined
b     //ReferenceError: b is not defined

// 让人 抓狂的是  typeof  处理  undeclared 的方式

typeof a   // undefined
typeof b   // undefined

较小的数值

二进制浮点数最大的问题 （不仅是 js ， 所有遵循 IEEE 754 规范的语言都是如此），时会出现如下情况

0.1 + 0.2 === 0.3    /// false

// 其相加结果 等于  0.30000000000000004   所以结果为 false

整数的安全范围

能够安全呈现的最大整数为 2^53 - 1 在 ES6 中被定义为 Number.MAX_SAFE_INTERGER, 最小整数值 是 -2^53 - 1, 在 ES6 中 被定义为 Number.MIN_SAFE_INTERGER,

整数的检测

可以使用 ES6 中的 Number.isInteger() 方法

 Number.isInteger(42)      // true
 Number.isInteger(42.00)   // true
 Number.isInteger(42.1)    // false

特殊数值

在非严格模式下 我们可以给 全局标识符 undefined 赋值

function foo() {
    undefined = 2
}

function foo() {
    'use strict'
    undefined = 2   // TypeError
}

// 虽然在非严格模式下 可以声明一个名为 undefined 的局部变量  但是 最好永远不要这么做

void 运算符

undefined 是一个内置标识符 ， 他的值 为 undefined ， 通过 void 运算符即可得到该值

表达式 void 没有返回值 ， 因此返回结果是 undefined ， void 并不改变表达式的结果，只是让表达式不返回值

var a = 42 
console.log(void a, a)    // undefined , 42

特殊的数字

如果数学运算的操作符 不是数字类型， 就无法得到一个有效的数字 ， 这种情况下返回值 为 NaN

NaN 意指 ‘不是一个数字’ 将他理解为 无效数值 或者 失败数值 可能会更准确一些

var a = 2 / 'foo'       // NaN

NaN 是一个特殊值 ， 是 唯一一个 非自反的值 （自反 即 x === x 不成立）

NaN != NaN 结果我 true

既然无法对 NaN 进行比较 （永远为false）那么应该怎么判断它呢

可以使用内建的全局工具函数 isNaN 来判断一个值是否是 NaN

var a = 2 / 'foo'

window.isNaN (a)   // true

但是 isNaN 有一个严重的缺陷 ， 他的判断逻辑是 ： 检查参数 既不是 NaN 也不是 数字 所以

var b = 'foo'
window.isNaN(b)   // true     蛋疼  这个bug 自 js 问世以来就存在

ES6 提供了工具函数来解决这个问题

var a = 2 / 'foo'
var b = 'foo'

Number.isNaN(a)   // true
Number.isNaN(b)   // false

实际上还有一个 更简单的办法 ， 利用 NaN 不等于自身的特点

if(!Number.isNaN) {
   Number.isNaN = function(n) {
       return n !== n
   }
 }

零值

js 有一个 常规的 0 （ 也叫做 +0 ） 和 一个 -0

var a = 0 / -3     // -0
var a = 0 * -3     // -0
// 加法和减法 不会得到 -0
// -0 在开发调试控制台中通常显示 -0， 但一些老版本浏览器中显示为  0

// 根绝规范 对 -0  进行字符串化  会返回  0

var a = 0 / -3
a.toString()  // '0'

// 奇怪的是， 如果 将 -0 转换为 数字 结果是正确的
+'-0'              // -0
Number('-0')       // -0
JSON.parse('-0')   // -0

// JSON.parse(-0)     返回 '0'  
// JSON.parse('-0')   返回 -0

Object.is()

由于 NaN 和 -0 在相等比较时表现有些特别 , NaN 自身不相等 ， 而 -0 === 0

ES6 中 加入 Object.is() 工具方法来判断 两个值是否 绝对相等

var b = -3 * 0    // -0
var a = 2 / 'foo'  // NaN

Object.is(a, NaN)  // true
Object.is(b, -0)   // true
Object.is(b, 0)    // false