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('为空');
 }

typeof;Undefined; Null;Boolean

 /*----------  Number 类型  -------------*/
 var box=250;    //十进制数据
 alert(box);//
 //八进制数据必须以0开头  并且后面每一位数不能够比7大，如果大于7会自动去掉前导0，处理为十进制数据
 var box=065;    //八进制数据
 alert(box);//53        //十进制输出
 var age=078;    //十进制数据
 alert(age);//
 //十六进制数据必须以 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);//
 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);//

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

 // ---------     如果是只包含字符串则遵循以下规则
 //1、如果是数值型的字符串，则会直接转换成十进制数据  同时去掉前导0
     alert(Number('0234'));//
 //2、只是包含浮点数值的字符串 会自动将字符串转换成浮点数 并且去掉前导和后导0
     alert(Number('06.80'));//6.8
     alert(Number('005.7800'));//5.78
     alert(Number('005.78.700'));//NaN
 //3、如果字符串是空字符串  则直接转换成 0
     alert(Number(''));//
 //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));//
     var box={
         toString:function(){
             return 'abc';
         }
     }
     alert(typeof box);//object
     alert(Number(box));//NaN

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

 alert(parseInt('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));//
 //识别八进制和十六进制  添加第二个参数 8,16
 //如果为八进制数据是十六进制可以不添加的第二个参数，但是必须带上前导0x
 //如果添加了第二个参数为 16 前面的前导0x就可以去掉，
 //为了后期维护方便最好添加第二个参数的同时也添加上前导 0x
 alert(parseInt('045'));//
 alert(parseInt('0x34'));52
 alert(parseInt('070'));70
 alert(parseInt('0x1fg'));//
 alert(parseInt('045',8));//37
 alert(parseInt('45',8));//
 alert(parseInt('0x1fg',16));//
 alert(parseInt('1fg',16));//
 alert(parseInt('1e3'));//1    //不认识科学计数法

 //parseFloat()和parseInt()是一样的  只是不认识八进制和十六进制
     //只是认识一个小数点    认识科学计数法
 alert(parseFloat('123abc'));//
 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

Number

 /*---------- 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);//
     alert(typeof age);//number  //age的类型还是根据里面的值来定

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

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

String;Object