JS 学习笔记--3--数据类型

1、typeof 操作符 用来获取变量或者字面量的类型，也可以typeof(x);但是typeof并非内置函 数，而是一个操作符变量
2、JS 一共6种类型 Undefined/Null/Boolean/Number/String/Object此六种类型
3、用typeof x;获取x变量或者字面量的类型返回的是上面6种类型的所有小写，并且Null类型的 变量返回的也是object

4、Unfined 类型：
 就是在变量声明了但是没有赋初始值的元素var box;alert(typeof box);//unfined
 alert(typeof age);age没有定义，但是同样会返回unfined，但是age逻辑上是不存在的
5、Null 类型：
 Null类型的变量时要显示的赋值为null的（var box = null;）他表示一个空的对象引用，typeof box;返回的是object，可以用次类型来判断一个变量是否已经存在，如果变量被重新赋值则 box!=null 返回的是真；box 是一个空对象；而 var box={};是空的对象；
  Undefined 是派生自 null 的，如果用 == 做相等性检查会返回为真  因为他们检查的其实是 值，但是逻辑上并不想等 用 typeof 来比较或者用恒等符 === 来比较，因为类型不一样
5、Boolean 类型：
 Boolean 类型只有两个值 true 和 false；True 和 False 都不是Boolean类型的值，任 何类型的变量都能够隐试转换为 Boolean类型，
 
6、Number 类型： 包括两种类型数据 整形 和 浮点型
  基本上数值字面量是十进制，也有八进制和十六进制，八进制必须以0开头，后面的数值必 须 是0到7之间的数，否则系统会自动去掉前导数值0，转换为十进制数据；十六进制数据必须 以0x开头，后面是0~9和A~F;
  浮点型数据中数值必须包含一个小数点，并且小数点后面至少要一位数字，而且由于浮点数内存 比整数要大两倍，故系统会自动的将能够转换成整形的浮点数转换成整形（1、小数点后面 没有数值，2、小数点后面全部为0）。
  过大或者过小的数据可以采用科学计数法表示数据1.2e3;1.2e-3分别表示1200和0.0012;
  浮点数最高可以表示17位，但是算术运算中可能不会精确，故做判断的时候一定要考虑此问题，  比如0.1+0.2；返回的是 0.300000000000000004
  可以用 Number.MAX_VALUE 和 Number.MIN_VALUE 获得浮点数表示的最大和最小值
  如果超出了浮点数的范围会返回 Infinity （正无穷）和 -Infinity (负无穷)，也可以用 Number.POSITIVE_INFINITY 和 Number.NEGATIVE_INFINITY 来获得正负无穷大 Infinity 和 -Infinity
  要想判断某一个数是否超过了一个数是否超过了最大最小值范围 可以用 isFinite(x)函数
7、NaN : Not a Number是指那些本该返回一个number类型的值但是并不能够返回一个值

8、三种转换函数，可以讲其他类型的数据转换成 Number 类型的数据：  Number(),parseInt(),parseFloat()

Number() 可以将任意类型的数据转换成 Number 数据类型，   boolean中的true转换为1，false 转换为 0；null 对象转换成 0；数值型直接返回  unfined返回的是 NaN

如果是字符串，转换的规则包含以下：  

　　1）、只是包含数值的字符串，会直接转换成十进制数值如果包含前导 0 即自动去掉

　　2）、如果只是包含浮点数的字符串,会直接转换成浮点数,如果包含前导和后导0会自动去掉  

　　3）、如果是空字符串，直接转换成 0: Number('');//0  

　　4）、如果不是以上三种类型 那么返回的是 NaN  

如果是对象，首先会调用 valueOf()方法，然后确定返回值是否能够转换成数值，如果转换结果 是NaN,则基于这个返回值再调用 toString() 方法，再测试返回值

var box={
    toString:function(){
        return '123'    //可以改为 字符串 'abc' 测试结果
    }
};
alert(Number(box));//123    

parseInt():  转换的时候先看第一位是否是数值，如果是就一直返回直到连续的数值结束为止。

parseInt('12bca');//12 　　parseInt('hh23k');//NaN 　　 parseInt('12.45');//12 　　parseInt('');//NaN 

parseInt() 也可以识别八进制和十六进制：

　　需要传递第二个参数 8,10,2,16中的一个，第二个参数代表的是前面带转换的数值的以什么进制来读取;

　　如果待转换的数据前面包含0x 则可以不传递第二位参数也OK   

parseFloat() 用于转换成浮点数，和parseInt()一样从第一位开始解析，但是不认识十六进制同时只是认识一个小数点  

8、String 类型：  String类型就是由0到多个由16位Unincode编码组成的类型  即字符串，可以有单双引号成对出现来表示 任何类型的数据都可以转换成String类型，用 x.toString(),但是如果是 null 和 undefined 则需要用 String(x)方法来进行转换。如果待转换的字符串全是由数值组成则 toString() 可以传递一个参数，2,8,16,10 但是转换后的值是带有引号的值，  

9、Object 类型： 采用new Object();的方式创建，可以传递参数，并且参数可以参与计算

10、下面这是练习中的源代码(EditPlus 3 编写)，代码中注释很详细  运行时可以采用块注释（/* */）方法来慢慢查看效果

//alert("数据类型的练习");
/*-------------   数据类型   -------------*/
var box="abc";
alert(typeof box);// box 类型是 String； 值是 "abc";  类型的返回值是 string
alert(typeof(box));//typeof 是操作符  不是函数

var box=100;
alert(typeof box);//box 类型是Number; 值是 100； 类型的返回值是 number

var box=true;
alert(typeof box);//box 类型是Boolean；  值是true； 类型的返回值是 boolean

var box;
alert(typeof box);//类型是 Undefined; 值是唯一的 undefined；类型返回值是undefined

var age=null;
alert(typeof age);//age 类型是Null,Null类型继承自Object类型，值为null 类型的返回值为object

var box={2:3,5:3};
var age=[2,5,7];
alert(typeof box);
alert(typeof age);//类型都是 Object; 返回的类型的值都是 object

function Get(){
 alert("get函数！");
}
alert(Get);          //返回的是函数的实体
alert(typeof Get);//typeof 操作符也可以对函数进行判断 返回为function，表名是一个函数


/*------------- Undefined 类型 -------------*/
//Undefined 类型只有一个特殊的值undefined：在用var声明变量的时候没有对其进行初始化
// 声明变量的时候没有必要进行赋值为undefined 因为系统会进行一个隐士的转换

 //下面两个的类型返回值都是 undefined;但是逻辑上他们的值一个是undefined，一个报错
//古在定义变量的时候尽可能的不要只声明 不赋值
var box;
alert(typeof box);
alert(typeof age);//age is not defined


/*------------ Null 类型  ------------*/
 //Null 类型是一个只有一个值的数据类型，特殊值null,表示一个空对象引用，typeof 时会返回 object
 var box =null;
 alert(typeof box);

// 如果此处定义一个变量时为了将来保存数据最好定义成 Null 类型的
  var box=null;
  box="abc";
  if(box!=null)
  {
        alert("对象已经存在");
  }

//  undefined 是派生自 null 的，故想等性检查的时候返回为true
//  但是 并不是恒等（===） 恒等要求类型相等  故下面返回为两个false
//  故未初始化的变量和赋值为null的变量会相等，但是可以采用typeof或者恒等比较出他们呢并不想等
    alert(undefined == null);//true
    alert(undefined === null);//false
    alert(typeof undefined == typeof null);//false
    var box;
    var age=null;
    alert(box==age);//true
    alert(typeof box==typeof age);//false
    alert(box === age);//false



/*-------------- Boolean ------------*/
//    Boolean 只有两个值 true，false 由于区分大小写 故True False 都不是Boolean的值
//    任何类型都都有对应的值准换成boolean的值
//    显示转换：
    var hello="hello word";
    var hello2 = Boolean(hello);
    alert(typeof hello);//string
    alert(typeof hello2);//boolean
    alert(hello2);//true
//    隐式转换：String类型当字符串为空转换为false，
//              Number非0数转换成true,包括无穷大，0和NaN转换成false
//              Object类型  任何对象转换都为 true，除了 null;
//              Undefined 类型只有一种值 转换后始终为 false
        var box="strings";
        if(box)//box 不为空  隐试转换为true
        {
            alert('真');
        }else{
            alert('假');
        }
        var box2='';
        if(box2)//box2 为空  隐试转换为false
        {
            alert('真');
        }else{
            alert('假');
        }

        var num=0;
        if(num)//num 为0  隐试转换为false
        {
            alert('真');
        }else{
            alert('假');
        }
        var num2=NaN;
        if(num2)//num 为N2N  隐试转换为false
        {
            alert('真');
        }else{
            alert('假');
        }

/*-----------   空对象和空的对象   -----------*/

//空的对象 表示声明了  但是还未初始化
var box={};//box 的类型是Object；值是 object Object；类型返回值是object
alert(box);//object        
alert(typeof box);//object Object
//空对象  表示没有创建 就是一个null值
var age=null;
alert(age);//null
alert(typeof age);//object

//这个表示，你还没有创建对象，但先声明了对象引用而必须初始化的结果
//你还没有来得及创建对象，先声明一个对象的变量放在那边，默认初始化为null
var heighe=null;
//在不知道存放什么值的时候 字符串默认声明成空字符串  Number为0，Boolean为false或者true都可
 var str='';//表示为空的对象
if(str!=null){
    alert('不为空');
}else{
    alert('为空');
}

/*----------  Number 类型  -------------*/
var box=250;    //十进制数据
alert(box);//250
//八进制数据必须以0开头  并且后面每一位数不能够比7大，如果大于7会自动去掉前导0，处理为十进制数据
var box=065;    //八进制数据
alert(box);//53        //十进制输出
var age=078;    //十进制数据
alert(age);//78
//十六进制数据必须以 0x 开头   后面包含 0~9，a~f(可以大小写)
var box=0x1f;    //十六进制
alert(box);//31 //十进制输出
var box =0x1A;
alert(box);

//浮点数 必须包含小数点 并且必须包含以为小数
var box=3.8;
alert(box);
//var age=03.8; //error  浮点数不能够包含前导 0
//alert(age);
var height=.8;    //JS支持这中写法  但是最好不要这样写
alert(height);//0.8

//由于浮点数保存要比整数占的内存大一倍左右  故ECMAScript会自动将可以转换成整形数据的浮点数转换成整数
var num1=8.;
alert(num1);//8        //小数点后面没有数据  自动转换成8
var num2=12.0;
alert(num2);//12    //小数点后面为 0 自动转换成整形数据
//对于过大或者过小的数据采用科学计数法表示  e后面的数代表的是10的多少次方
var box=12.3e5;
alert(box);//1230000
var age=12.3e-5;
alert(age);//0.000123
//虽然浮点数最大可以保存17位小数，但是算术运算中可能会不精确，
//故在做判断的时候一定要考虑次问题，特别是整形判断
alert(0.3+0.4);//0.7
alert(0.1+0.2);//0.30000000000000004;

//浮点数的范围的最大值或者是最小值
alert(Number.MIN_VALUE);//5E-324  //必须将后面的写为大写
alert(Number.MAX_VALUE);
//超过其范围就会显示为 Infinity  和  -Infinity
alert(100e100);//1e102;
alert(100e1000);//Infinity
alert(-100e1000);// -Infinity

//通过  Number.POSITIVE_INFINITY 和 Number.NEGATIVE_INFINITY 得到正负无穷大
alert(Number.POSITIVE_INFINITY);//Infinity
alert(Number.NEGATIVE_INFINITY);// -Infinity

//通过 函数 isFinite(num) 判断一个数 num 是否是超过了范围 是返回true
alert(isFinite(100e1000));//false
alert(isFinite(100e100));//true

// NaN 即非数字(Not a Number)，是指本来要返回一个数值的  但是却没有返回一个数值
// 于是就返回一个 NaN，这样就不会报错  在其他高级语言中是会报错的
// 在其他语言中 除数是不能够为 0的，但是ECMAScript中则可以为0 可以看出JS是一种弱语言
alert(5/0);//Infinity;
alert(2/0);//Infinity;
alert(0/0);//NaN
alert(5/0*0);//NaN
//可以通过Number.NaN操作来得到一个 NaN 数字 NaN与任何数据计算都是NaN 并且NaN 不与任何数据相等 包括本身
alert(Number.NaN);//NaN
alert(Number.NaN+4);//NaN
alert(Number.NaN == Number.NaN);//false
alert(0/0+5);//NaN
alert(NaN == NaN);//false
//可以通过函数 isNaN() 函数来判断一个数是否是NaN
alert(isNaN(0/0));//true
alert(isNaN(2/0));//false
alert(isNaN(5/0*0));//true
alert(isNaN("Lee"));//true        全字符的字符串不能够转换成数字
alert(isNaN('25'));//false        '25' 先转换成数值 25 故不是NaN
alert(isNaN('25Lee'));//true    含有字符的字符串不能够成功转换成数字
alert(isNaN(true));//false        true能够转换成数字1
//isNaN() 函数也适用与对象  在调用isNaN() 函数的过程中会首先调用 valueOf()
    //方法，确定返回值能否转换成数值对象  如果不能够就基于这个返回值再调用 toString()方法
var box={};//true
alert(isNaN(box));
var age={
    toString:function(){
        return '123';
    }
}
alert(isNaN(age));//false
alert(age);//123


/* ---- 三个数值转换函数 Number(),parseInt(),parseFloat(),----    */
    //Number()是转型函数可以把任何类型转换成Number类型，但是另外两个只能够转换字符串
alert(Number(true));//1
alert(Number(25));//25    数值类型的数据直接返回
alert(Number(null));// 0
alert(Number(undefined));//NaN undefined类型转换以后返回的是NaN

// ---------     如果是只包含字符串则遵循以下规则
//1、如果是数值型的字符串，则会直接转换成十进制数据  同时去掉前导0
    alert(Number('0234'));//234
//2、只是包含浮点数值的字符串 会自动将字符串转换成浮点数 并且去掉前导和后导0
    alert(Number('06.80'));//6.8
    alert(Number('005.7800'));//5.78
    alert(Number('005.78.700'));//NaN
//3、如果字符串是空字符串  则直接转换成 0
    alert(Number(''));//0
//4、如果不是上面三种类型的话 则直接返回 NaN
    alert(Number('abc123'));//NaN
    alert(Number('12abc'));//NaN
    alert(Number('12hu45'));//NaN
//5、如果是对象  首先会调用这个方法的 valueOf()方法，然后确定返回值是否能够转换成数值
//    如果转换的结果是NaN  在基于这个返回值再调用 toSring()方法  在测试返回值
    var age={
        toString:function(){
            return '123';
        }
    }
    alert(Number(age));//123
    var box={
        toString:function(){
            return 'abc';
        }
    }
    alert(typeof box);//object
    alert(Number(box));//NaN

//Number()函数在转换字符串的时候比较复杂且不怎么合理 故常用的是parseInt()和parseFloat()

alert(parseInt('123'));//123
alert(parseInt('123abc'));//123        会返回整数部分
alert(parseInt('abc123'));//NaN        如果第一个字符不是数字就返回为NaN
alert(parseInt('45abc123'));//45    从第一个开始取  到最后一个连续数值结束为止
alert(parseInt('56.12'));//56        小数点不是数值
alert(parseInt('056.12'));//56        自动去掉前导0
alert(parseInt(56.12));//56            
alert(parseInt(''));//NaN            空值返回NaN，和全部是字符一个道理
var box={
        toString:function(){
            return '123';
        }
    }
alert(parseInt(box));//123
//识别八进制和十六进制  添加第二个参数 8,16
//如果为八进制数据是十六进制可以不添加的第二个参数，但是必须带上前导0x
//如果添加了第二个参数为 16 前面的前导0x就可以去掉， 
//为了后期维护方便最好添加第二个参数的同时也添加上前导 0x
alert(parseInt('045'));//45
alert(parseInt('0x34'));52
alert(parseInt('070'));70
alert(parseInt('0x1fg'));//31
alert(parseInt('045',8));//37 
alert(parseInt('45',8));//37
alert(parseInt('0x1fg',16));//31
alert(parseInt('1fg',16));//31
alert(parseInt('1e3'));//1    //不认识科学计数法
 
//parseFloat()和parseInt()是一样的  只是不认识八进制和十六进制 
    //只是认识一个小数点    认识科学计数法
alert(parseFloat('123abc'));//123
alert(parseFloat('0xa'));//0    //不认识十六进制
alert(parseFloat('0xa',16));//0    //不认识十六进制
alert(parseFloat('5.8h'));//5.8    
alert(parseFloat('12.3.4'));//12.3    //只是认识一个小数点
alert(parseFloat('012.300'));//12.3    //自动去掉前导和后导0
alert(parseFloat('1.2e3'));//1200    //将科学计数法转换成普通的数值
alert(parseFloat('a5.8h'));//NaN

/*---------- String 类型 -------------*/
//String类型用于表示由0个或者多个16为的Unicode字符组成的字符序列，即字符串
//字符串可以用双引号或者单引号表示

//单引号和双引号都可以表示中间是一段字符串  但是必须成对使用不能嵌套使用
    var box="string";
    var age='string';
    alert(age+'abcd');
    alert(box+"abcd");
    alert('abcd'+"abcd");
    //alert('abcd");    //error

// JS 中同样以反斜杠 \ 代表转义字符
    alert("ab\tcd");//制表符
    alert("eg\rji");//回车符
    alert("ss\nji");//换行符
    alert("ac\bcd");//空格符
    alert("ab\fcd");//进纸符
    alert("ab\\cd");//ab\cd
    alert("a\"b\'cd");//a"b'cd
    // \xnn    表示以十六进制nn表示的一个字符(由ASCII码计算而得)
    alert("\x41");//A 
    //\unnn    表示以十六进制代码 nnn 表示的一个Unicode字符
    alert("\u03a3");//Σ  

// JS 中的字符串变量的值同样是不可以改变的，若要改变某个变量保存的字符串的值
//首先要销毁原来的字符串，然后再用另外一个包含新的值的字符串变量来填充该变量
    var box="abcd";
    var age=box+"abcd";
    alert(box);//abcd
    box=age;
    alert(box);//abcdabcd

//任何类型的数据都可以转换成字符串类型 x.toString()和 String(x)方法
    var box=200;
    alert(typeof box);//number
    alert(typeof box.toString());//string
    alert(typeof box);//number
    alert(box.toString());// '200'  输出的内容是在内存中带了单引号的 '200'
    box=true;
    alert(typeof box);// boolean
    alert(box.toString());// 'true'  是带了引号的 'true'

//一般进行 toString() 的时候是不需要传递参数的，但是在进行数值转化成字符串的时候，可以进行参数的传递
    var box=12;
    alert(box.toString());    //'12'
    alert(box.toString(2));    //'1100'
    alert(box.toString(8));    //'14'
    alert(box.toString(16));//'c'
    alert(box.toString(10));//'12'

// x.toString() 方法是无法将 Undefined 和 Null 类型进行转化的
    var box=null;
    alert(typeof box);
    //alert(box.toString());//error
    var age;
    //alert(age.toString());//error

// 对于 Null 和 Undefined 类型的变量采用 String(x)方法将其进行转换
//String(x) 能够将任何类型的变量x进行转化成字符串类型
    var box=null;
    alert(String(box));//null
    var age;
    alert(age);//undefined
//如果值有 toString()方法 则调用该方法并返回相应的结果 如果是null或者undefined则返回null和undefined



/* 简单了解 Object 类型  */
//ECMAScript 中的对象其实就是一组数据和功能的集合，对象可以通过new操作符后
    //跟上要创建的对象的类型名称类创建
    var box=new Object();
    alert(typeof box);// object
//Object()是对象构造 如果初始化的时候不需要传递参数 可以不写括号 但是最好不要这样写
    var box=new Object;
    alert(typeof box);// object

//Object()里面可以传递任何的对象，可以传递数值 字符串 布尔值 而且还可以进行计算
    var box=new Object(2);
    alert(typeof box);//object
    var age=box+3;
    alert(age);//5
    alert(typeof age);//number  //age的类型还是根据里面的值来定

    var box=new Object(true);
    var age=1;
    if(box){ // box 类型是object 里面放的是布尔值 用于计算为 true
        age++;
    }else{
        age--;
    }
    alert(age);// 2

//同样可以使用这种 new 操作符来创建其他的类型
    var box=new Number(5);    //或者是new Boolean(),new String()
    alert(typeof box);//object
    box++;
    alert(box);//6