JavaScript 数据类型

1.基本类型

字符串，数字，布尔类型都是基本类型，他们的值存放在栈区，即使是相互赋值，他们的值也是相互独立的。

// 字符串类型
var a = 'hello'
var b = a
console.log(a,b) // hello hello

a = 'xxx' // 修改a的值不会影响b
console.log(a,b) // xxx hello

// 数字类型
var a = 10
var b = a
console.log(a,b) // 10 10

a = 20 // 修改a的值不会影响b
console.log(a,b) // 20 10

// 函数传参
var a = 10
function revise(n){
    n = n*2  //修改函数内参数的值不会影响到外面的参数
    console.log(n)
}
revise(a)  // 20
console.log(a) // 10

2.引用类型

数组和对象都属于引用类型
他们的值实际上是一个指针，指向（引用）一个数组或者对象。
如果两个变量同时指向（引用）同一个数组或者对象，此时修改任意一个变量，另一个变量就会受到影响，可以看成他们共享一个数据

var a = [1,2,3]
var b = a
console.log(a,b) // [1, 2, 3]    [1, 2, 3]
a[0] = 9  // 通过a修改数组的第一个元素，b也会受到影响
console.log(a[0], b[0]) // 9  9

var p = {name: '亚索',age: 20}
var p2 = p
p.name = '托儿索'
console.log(p.name, p2.name) // 托儿索 托儿索

函数传参：函数参数传递的是数组或者元素的指针，在函数内部操作形参实际上操作的就是实参本身

var a = [1,2,3]
function revise(arr){
    arr[0] = arr[0] * 5
    console.log(arr[0])
}
revise(a) // 5
console.log(a[0])  // 5

var p = {name: '亚索',age: 20}
function revise(obj){
    obj.name = '托儿索'
    console.log(obj.name)
}
revise(p)  // 托儿索
console.log(p.name) // 托儿索

3.数据类型的判断

• typeof将数据类型当作字符串返回，这种方法简单直接，但是 null/数组/对象 输出的结果都是object，无非区分

<script>
    console.log(typeof "hello world")  // string
    console.log(typeof 123) // number
    console.log(typeof true) // boolean
    console.log(typeof null) // object
    console.log(typeof undefined) // undefined
    console.log(typeof []) // object
    console.log(typeof {}) // object
    console.log(typeof fn) // function
    function fn(){} 
</script>

• instanceof 判断一个变量是否是某个对象的实例

console.log([] instanceof Array) // true
console.log([] instanceof Object) // true

console.log({} instanceof Array) // false
console.log({} instanceof Object) // true

• constructor属性返回他的构造函数

console.log({}.constructor.toString()) //function Object() { [native code] }
console.log([].constructor.toString()) // function Array() { [native code] }

• 封装一个判断数据类型的函数

<script>
    function dataType(val){
        var type = (typeof val).toLowerCase()

        // 判断typeof是否输出'object'
        if(type !== 'object'){
            // 是的话直接返回结果
            return type
        }

        // 判断数据是否为null
        if(val === null){
            return null
        }

        // 区分数组与对象
        if(val.constructor.toString().indexOf('function Object()') !== -1){
            return 'object'
        }else if(val.constructor.toString().indexOf('function Array()') !== -1){
            return 'array'
        }
    }
    console.log(dataType('hello world')) // string
    console.log(dataType(123)) // number
    console.log(dataType(true)) // boolean
    console.log(dataType(null)) // null
    console.log(dataType(undefined)) // undefined
    console.log(dataType([])) // array
    console.log(dataType({})) // object
    console.log(dataType(fn)) // function
    function fn(){}
</script>

4.数据类型转换

• 对象，数组转字符串 JSON.stringify(val)

var person = {name: 'kyo'}
console.log(JSON.stringify(person)) //'{"name":"kyo"}'

console.log(person.toString()) //'[object Object]'

var arr = [1, 2, 3, {name: 'kyo'}]
console.log(JSON.stringify(arr)) //[1,2,3,{"name":"kyo"}]

console.log(arr.toString()) //1,2,3,[object Object]

• JSON字符串转对象或数组 JSON.parse(val)
  这个方法作用与JSON.stringify(val) 相反

<script>
    var arrStr = "[1, 2, 3, 4]"
    var personStr = '{"name": "kyo"}'
    var arr = JSON.parse(arrStr)
    var person = JSON.parse(personStr)
    console.log(arr) //  [1, 2, 3, 4]
    console.log(person) // {name: "kyo"}
</script>

• 字符串强制转换成数字
  Number(val)：只能转换纯数字的字符串(包含小数),空字符串和null都转换成0，undefined和其他非数字字符转换成NaN
  parseInt(val)：如果字符串以数字开头，则将开头的数子转换成整数类型，后面的其他字符忽略。以其他类型的开头的（布尔,null,undefined）一律转换成NaN
  parseFloat(val)：与parseInt()类型，不过它不会忽略小数点

console.log(Number('12')) //12
console.log(Number('02')) //2
console.log(Number('12a')) //NaN

console.log(Number(true)) //1
console.log(Number(false)) //0

console.log(Number(null)) //0
 console.log(Number('')) //0
console.log(Number(undefined)) //NaN

console.log('12.2') //12.2

console.log(parseInt('12'))  //12
console.log(parseInt('12a')) //12
console.log(parseInt('1a2')) //1
console.log(parseInt('a12')) //NaN

console.log(parseInt(true)) //NaN
console.log(parseInt(false)) //NaN

console.log(parseInt('')) //NaN
console.log(parseInt(null)) //NaN
console.log(parseInt(undefined)) //NaN

console.log(parseInt("12.2")) //12

console.log(parseFloat("12.2")) //12.2

• 运算时的自动转换
  2个数据进行运算时会临时自动转换数据类型以便于计算（保证数据类型一致）
  而计算无非就是 加减乘除取余
  除了 + 这个符号比较特殊（数字类型为加法，字符串为拼接），减乘除都只适用于数字类型
  对于减乘除：要计算的数据一律转换为数字类型（使用Number()规则转换）,不能转为数字类型的就为NaN,一旦有一个数据是NaN，则结果必然是 NaN

console.log('4' * '2')  //8
console.log('4' * '2a') //NaN '2a'转换为/NaN
console.log('4' * '2.2') //8.8
console.log('4' * '2.2a') //NaN '2.2a'转换为/NaN
console.log('4' * null) //0
console.log('4' * '') //0
console.log('4' * true) //4
console.log('4' * false) //0
console.log('4' * undefined) //NaN

"+"运算符:一种含义是拼接 另一种含义是 加法
如果有一个是字符串类型，则其余数据转化为字符串类型进行拼接

console.log('4' + '2') //'42'
console.log('4' + 2)  //'42'
console.log('4' + null) //4null
console.log('4' + true) //4true
console.log('4' + false) //4false
console.log('4' + undefined) //4undefined

如果参与运算的没有字符串，则全部转为数字类型在做加法运算

console.log(4 + null) //4
console.log(4 + true) //5
console.log(4 + false) //4
console.log(4 + undefined) //NaN

console.log(true + false) //1
console.log(true + true) //2
console.log(false + false) //0

console.log(null + null) //0

console.log(undefined + undefined) //NaN

原文地址：https://www.cnblogs.com/OrochiZ-/p/11567574.html