花开陌上

JavaScript是一门弱语言，不像C或者Java等那种强类型语言，用一个变量，还要先定义数据类型，定义成了int整型，就不能放字符串进去。

JavaScript定义的变量，就是你先放了数字进去，它就变成了数字类型，后面改放了字符串进去，也就变了字符串类型。

所以，在进行一些运算的时候，虽然灵活，但也会出毛病，这也是它的弱点。

JS中的数据类型：

1. Number
2. String
3. Boolean
4. undefined
5. Symbol
6. Object
7. null
8. function

除了基本类型以外（Number，String，Boolean，undefined ，Symbol ）
其他的都是对象（Object，null，function）

var numa = 18;           // number 数字类型
var stra = 'abc';        // string 字符串
var boola = true;         // boolean  布尔值，两个值  true  false
var a ;              // undefined 未定义
var sya = Symbol ();    //Symbol 类型
var b = document      // object 对象 
var c = null          // object 对象(空对象)
var funa = function(){}  // function 函数

在使用js的时候一定要注意，记清楚每一个变量装什么类型的东西。
比如匈牙利命名法：
数字 | number | n/num | nAge
字符串 | string | s/str | sName strPassword
布尔 | booleans | b/bool | bLogin
对象 | object | o/obj | oUser
函数 | function | fu/func | fuSuccess

获取检测变量的数据类型:

typeof可用来获取检测变量的数据类型,它是一个关键字，不是函数

用typeof运算符查看它们的数据类型：不同类型的返回值：number、string、boolean、function、undefined、symbol、object

typeof 18 -> number
typeof "abc" -> string
typeof true -> boolean
typeof undefined -> undefined
typeof null -> object  //返回的是Object类型

字面量：通俗来说，就是字面量表示如何表达这个值。123、"abc"、true
变量：容器，存储的值可以变的 存东西，可以改
常量：容器，存储的值是不可变的 存东西，不可改

数据类型转换

通俗来说，就是把一种数据类型的变量转换成另一种数据类型

显式类型转换（强制）：

转换为数字型 Number()
Number() 注：首字母大写

• Number(val) 将数据转换成数字
• - 字符串类型，使用 Number() 转换时，规则如下：
1. 1.当整段字符串都符合数字规则时，转换为数字返回
2. 2.空字符串,直接返回 0
3. 3.其余情况，直接返回 NaN
• - 布尔值类型，使用 Number() 转换时，true 返回 1，false 返回 0
• - null，使用 Number() 转换时 返回 0
• - undefined，使用 Number() 转换时 返回 NaN
• - 对象类型，使用 Number() 转换时，调用的对象的toString()方法，然后再次依照前面字符串的转换规则进行转换

console.log(Number('12'));
//  console.log(Number('12')); ==>  12 

// Number它只能转行纯数字的字符串 否则返回NaN
var num = '123.4a';
console.log(typeof num)  // string
       
var num2 = Number(num);
console.log(num2)  //NaN
console.log(typeof num2) //number 

转换为字符串类型 String()
- 数字类型，直接转换数据类型原样返回
- undefined ，直接返回字符串 undefined
- null，直接返回字符串 null
- 布尔值，直接返回字符串 true 或者 false
- 函数，直接把整个函数变成字符串 返回
- 对象，直接调用对象的 toString 方法

        var num = 123;
        var nud = undefined ;
        var nul = null ;
        var bool = true ;
        var fn = function(){} ;
        var obj = {a:12} ;

        console.log(String(num))   // 123
        console.log(String(nud))   // undefined
        console.log(String(nul))   // null 
        console.log(String(bool))  // true 
        console.log(String(fn))    // function (){}
        console.log(String(obj))   // toString([object Object])

转换为布尔型 Boolean()
- 数字类型：非零的合法数字转换为 true, 零代表 false, NaN 代表 false
- 字符串类型：空字符串转换为false，非空字符串转换为true
- null：转换为false
- 对象：转换为true

var str = ' ';
var num = -0.1;
var arr = [];
var nul = null;

console.log(Boolean(num)); // true
console.log(Boolean(str)); // true
console.log('arr',Boolean(arr)); //arr true
console.log('null',Boolean(nul)); arr true

if(12){
  console.log('真');
}else{
  console.log('假');
}

// 什么是真（true），什么是假（ false） -- 有东西就是真，没东西就是假
// 真（true）：非零(正负数)、非空字符串、非空对象
// 假（ false）：零、空字符串、空对象（ 0、''、null、undefined  ）

隐式类型转换（能不用就尽量别用）：

这是存在一定风险的（出现一些小问题什么的），虽然是比较方便的方法，
但如果想要代码严谨一点，不要依赖隐式转换，而是要消除所有存在的隐式转换。
如果是长期使用的，比如一个库什么的，这时就要避免所有存在的隐式操作了，

+    //变字符串
- * / %   //     变数字
==  ===     //  转成布尔值



var a='12';
var b='3';

// + 号有两重含义，数字相加和字符串连接
console.log(a+b);
//  '12' + '3' ==>  ‘123’  变字符串

// - 号就只是存在于数字相减，不存在字符串相减，所以变数字
console.log(a-b);
//  '12' - '3' ==> 9   变数字

 //-----------------------------

var a=12;
var b='12';

// == 带有隐式转换，会先转换成一样的类型再进行比较
console.log(a==b);
// a==b   ==>  true

// === 直接比较
console.log(a===b);
// a===b    ==>   false

NaN 和 isNaN

在使用 NaN 时，要注意 NaN是个特殊的数字，它不等于任何值（包括它自己），也就是 NaN 不等于 NaN。

当我们要检测一条数据是否是 NaN 时，可以使用 isNaN(val) 来进行检测, 在 isNaN 方法中，传入的数据 能被转换成 合法数字时，就会返回 false，当传入的数据不能被转换成 合法数字( 也就是NaN) 时，isNaN 就会返回 true

var str = '123.a';

console.log(str)  // 123.a
console.log(isNaN(Number(str))) // true
// isNaN 是一个NaN 返回 true 、反之 就是false

var a = NaN;
if(a == NaN){
    console.log('等于')  // NaN 不等于NaN 
}  

工具函数

1.三种转换成字符串的方式

toString() 和 String() 一般情况下没什么大的区别,用谁都行。唯一不同的是toString()本质上是一个方法，当用在某些特殊的值上时区别就出来了

String() 转换成字符串

toString()转换成字符串

+''和字符串拼接的结果都是字符串(隐式转换了)

var a=12;
console.log(a,String());  // 12 ""
console.log(a,a.toString());  //12 "12"
console.log(a,a+'');  // 12 "12"  
// a+'' ==> String(a)+''  ==>  "12" 

2.转换成数字

parseInt将string类型转换成整数

parseFloat将string类型转换成浮点数（小数）

注意大小写

// 取整
var num = parseInt(12.345);
console.log(num) //12

// 获取浮点数（保留小数） - 将字符串转成数字
var num = '123.4';
console.log(typeof num)  //string
       
var num2 = parseFloat(num);
console.log(num2)  //123.4
console.log(typeof num2)  //number