js中的数据类型和数据转换

变量基本概念

变量
- var,let
- 变量名可以包括字母,_,开头。
- 不可以用系统关键字和保留字命名。
- 原始值存储在栈内存
  - number
  - string
  - boolean
  - undefinded
  - null
  - symbol(es6才有的)
- 引用类型, 存储在堆内存，通过引用
  - object
  - array
  - function

类型转换

typeof 检测类型

typeof(a)-----undefined;
//未经声明使用 a，唯一不报错的方式；
typeof(undefined)-----undefined;
typeof(NaN)-----number;
typeof(null)-----object;

a instance of b
- 官方介绍：a对象是不是由b构造函数构造出来的。
- 判断一个对象与构造函数是否在一个原型链上

const Person = function() {}
const p1 = new Person()
p1 instanceof Person // true

var str = 'hello world'
str instanceof String // false

var str1 = new String('hello world')
str1 instanceof String // true

类型转换

number(mix);
parseInt(String,radix);
parseFloat(String
String(mix);
toString(radix
Boolean;

转boolean
除了以下，都会转为真，包括空数组，空对象

 //false
 //undefined
 //null
 //''
 //NaN
 //0
 // -0

隐式转换

isNaN();
//++/--/+/- 
//---->Number()
//加减乘除；
//!！转为布尔值

其中一方为字符串，那么就会把另一方也转换为字符串
如果一方不是字符串或者数字，那么会将它转换为数字或者字符串

还需要注意这个表达式'a' + + 'b'

'a' + + 'b' // -> "aNaN"

因为 + 'b' 等于 NaN，所以结果为 "aNaN"，你可能也会在一些代码中看到过 + '1' 的形式来快速获取 number 类型。

隐式转换题目

console.log(true +1);//2

var demo = false == 1;
console.log(demo);//false

if(typeof(a)&& -true + (+undefined) + "") {
    console.log（会打印，因为前后都是字符串）;
}

//!!" "   --------空格是true
//!!""    --------空串是false

`100 +` 问题

'100' + 100   // "100100"

100 + '100'   // "100100"

100 + true    // 101

100 + false   // 100

100 + undefined //NaN

100 + null    // 100

类型判断函数

/**
 * 类型判断
 1.判断null
 2.判断基础类型
 3.判断引用类型-原理是利用call指向引用类型，调用重写后的toString 方法
 */
function getType(target) {
  //先处理最特殊的Null
  if(target === null) {
    return 'null';
  }
  //判断是不是基础类型
  const typeOfT = typeof target
  if(typeOfT !== 'object') {
    return typeOfT;
  }
  //肯定是引用类型了
  //template函数用来转换系统提示
  const template = {
    "[object Object]": "object",
    "[object Array]" : "array",
    "[object Function]": "function",
    // 一些包装类型
    "[object String]": "object - string",
    "[object Number]": "object - number",
    "[object Boolean]": "object - boolean"
  };
  const typeStr = Object.prototype.toString.call(target);
  return template[typeStr];
}

基本数据类型的toString 方法

基本类型是没有属性和方法的，但仍然可以使用对象才有的属性方法。这时因为在对基本类型使用属性方法的时候，后台会隐式的创建这个基本类型的对象，之后再销毁这个对象

== 操作符

对于 == 来说，如果对比双方的类型不一样的话，就会进行类型转换

判断流程：

首先会判断两者类型是否相同。相同的话就是比大小了
类型不相同的话，那么就会进行类型转换
会先判断是否在对比 null 和 undefined，是的话就会返回 true
判断两者类型是否为 string 和 number，是的话就会将字符串转换为 number

1 == '1'
      ↓
1 ==  1

判断其中一方是否为 boolean，是的话就会把 boolean 转为 number 再进行判断

'1' == true
        ↓
'1' ==  1
        ↓
 1  ==  1

判断其中一方是否为 object 且另一方为 string、number 或者 symbol，是的话就会把 object 转为原始类型再进行判断

'1' == { a: 'b' }
        ↓
'1' == '[object Object]'

两边都是对象的话，那么只要不是同一对象的不同引用，都为false

注意，只要出现NaN，就一定是false，因为就连NaN自己都不等于NaN
对于NaN，判断的方法是使用全局函数 isNaN()

=== 操作符

不转类型，直接判断类型和值是否相同。
但是 NaN === NaN 还是false

{} 等于true还是false

var a = {};

a == true // -> ?
a == false // -> ?

答案是两个都为false
因为 a.toString() -> '[object Object]' -> NaN

1 与 Number(1)有什么区别

一个是变量，一个是函数

typeof 123 // "number"
typeof new Number(123) // "object"
123 instanceof Number // false
(new Number(123)) instanceof Number // true
123 === new Number(123) // false

区分对象的三种方式

1.instanceof

[] instanceof Array  //---> true

2.constructor

[].__proto__.constructor     //--->f Array(){}

3.指向重写后的toString方法

Obje.prototype.toString.call(123);//object Number
Object.prototype.toString.call({});//object Object
Objectct.prototype.toString.call([]);//object Array

对象

方式1-字面量表示，推荐使用

var a = {};

方式2-调用构造函数,不推荐使用

var obj = new Object();

方式3 ，自定义方法,形式和函数一样，为了区分，构造函数命名严格按照大驼峰形式（所有单词首字母大写）

function Person(){}
var person = new Person();