JavaScript数据类型转化-day02

1.将其他类型得数据转化为Number类型的数据

字符串类型转数字

• 把字符串转化为数字
• 主要字符串中出现了非有效数字，那结果就是NaN

• 如果是空字符串，那结果就是 0

  布尔类型转数字

• true—>1 false—>0

  Null和undefined转数字

• null—>0

• undefined—>NaN

  引用类型转数字

• 把普通对象转数字,浏览器会默认调用toString方法，先把对象转为字符串，然后在把字符串转为数字

  所有的对象转字符串都是 ‘[object Object]’ 所有的对象转数字都是NaN

把数组转化成数字

• 先把数组里的每一项都去转字符串，最后再把所有的字符串加上逗号拼接起来，再把这个总的字符串转数字
• 空数组转字符串是空字符串

• 示例代码:

  // let ary = [1,'1',true];
                // '1','1','true'--->'1,1,true'--->NaN
                // let ary = [1,{}];
                // console.log(ary.toString()); // '1,[object Object]'
                // console.log(Number(ary)); // '1,[object Object]'-->NaN
                // console.log(Number[100]);// '100'-->100
                // console.log(Number([])); // ''-->0
                // let ary = [[],{}] // ',[object Object]' -->NaN

  2.ParseFloat（Val）转化数字

  把字符串转化为数字,要把字符串从左往右依次提取,直到提取到非有效数字为止,就把找到的数字返回回去,可以识别小数点,如果需要转化的内容不是字符串类型,会默认自动转为字符串类型

• 代码示例

   // 如果转换的值不是字符串类型的，要先转字符串
        // console.log(parseFloat('1334ty556')); // 1334
        // console.log(parseFloat('tyy1334ty556')); // NaN
        // console.log(parseFloat('12.34')); // 12.34
        // console.log(parseFloat('12.34.5')); // 12.34
        console.log(parseFloat(true)); // 'true'-->NaN
        console.log(parseFloat(null)); // 'null'-->NaN

  3.PareseInt（Val）转化数字

  用法与ParseFloat一致,但是无法识别小数点

  4.val.toFixed（保留的小数位）:保留小数点位数

  保留小数点位数，返回结果是一个字符串，而且还有四舍五入的机制 ```javascript // var num = 100;

    // console.log(num.toFixed(2)); // '100.00'
    // var num = 100.456;
    // console.log(num.toFixed(2)); // '100.46'
    // Number( num.toFixed(2) )//-->Number('100.46') -->100.46

    // var num = 100.456;
    // num = num.toFixed(2); // '100.46'
    // //---------
    // num = Number(num); // 100.46
    // console.log(num); // 100.46

<a name="fGJbP"></a>
## 5.isNaN（判断是否是非有效数字）
<a name="4twjS"></a>
## 6.String类数据转化
- 拿单引号，双引号，反引号包裹起来的就是字符串
- 把其他数据类型转换为字符串 val.toString();  String(val)
-  把Number和Boolean准字符串直接加引号(基本值转字符串直接加引号)
```javascript
 // console.log( (12).toString() ); //'12'
            // console.log(true.toString()); // 'true'
            // console.log(null.toString()); // null和undefined不能直接调用toString
     // console.log(String(null)); // 这是可以的
            // console.log(String(undefined)); // 这是可以的

• 把引用值转字符串

  // 所有的普通对象转字符串都是'[object Object]'
            // let obj = {};
            // console.log(obj.toString()); // '[object Object]'
            // 数组转字符串：先把数组里的每一项都去转字符串，最后再把所有的字符串加上逗号拼接起来，
            // let ary = [1,2,3,4];
            // console.log(ary.toString()); // '1' ,'2','3','4'-->'1,2,3,4'
            console.log(String([1,2,3,4]));

  7.四则运算

• 如果运算的值不是Number类型的，要先转化为Number类在进行运算

• 只要在数学运算过程中出现了NaN，那最后的结果就是NaN ```javascript // // console.log(12+35*12);

        // console.log(null+true+false); // 0+1+0->1
        // console.log(null+1+true); // 0 + 1+ 1 = >2
        // console.log(null +undefined); // 0 + NaN --> NaN
        // console.log(true*null); // 0
    // 在加法运算过程中，会出现两种情况
        // 正常运算
        // 字符串拼接：在加法中一旦加号和引号相遇了，那就不在是正常的数学运算，就是字符串拼接了
                    // 如果是基本值就直接拼接，不用进行数据类型的转换
        console.log(1 + '11'); // '111'
        console.log(true + '11'); // 'true11'
        console.log(1 + 'wer'); // '1wer'
        console.log(1 - 'wer');// 1-NaN -->NaN
        console.log(1+2+3+'23'); // 6+'23'-->'623'
        console.log(1+2+3+"23"+1+1); // 6 + '23' +1 +1 --> '623' + 1+ 1-->'6231' + 1-->'62311'
        console.log(1 + true + null + undefined + 'erYa' +true);
        //         1+1-->2
        //          2+ 0
        //           2+ NaN
        //            NaN + 'erYa'
        //              'NaNerYa' + true
        //                'NaNerYatrue'  
        console.log(35 + 678 + undefined -true +'erYa' + true + undefined);

        let a = 1 + null + true + [] +undefined + '森哥'+ null + {} + 10 + false;
               //         '2undefined森哥null[object Object]10false'
        // 'NaN森哥null10false'
        console.log('1'+undefined); // '1undefined'
         // 引用值的拼接
    // console.log(1+[]); // 1  '1'
    // 引用值在转数字的过程中，要先转字符串，转成字符串以后加号和引号相遇了，那就直接拼接了
    // 1 + '' ---> '1'
    // 如果在拼接过程中遇到了引用值，也要进行数据类型的转换
    // console.log([] + []); // '' + []-->''+''--> ''
    // console.log({} + {}); // '[object Object]' + {}-->'[object Object]' + '[object Object]'  -->'[object Object][object Object]'
    // console.log({} + []); // '[object Object]' + []--->'[object Object]' + ''-->'[object Object]'
    // console.log(1*{}); // 1-NaN-->NaN
    // []+1*[]-->[]+0-->''+0-->'0'
    // console.log([]+1*[]);
    // console.log(1 +true +null + undefined + 'erYa' +[] +{});
    // //             NaN +'erYa'-->'NaNerYa' +[]-->'NaNerYa'+{}--> 'NaNerYa' +'[object Object]' -->'NaNerYa[object Object]'
    // console.log(10 + null + true + [] + '珠峰' + [] + null + {} + false);
    //           11 +''-->'11' +'珠峰'-->'11珠峰'-->'11珠峰' +[]-->'11珠峰'+null--> '11珠峰null'-->'11珠峰null' +'[object Object]'-->'11珠峰null[object Object]false'

<a name="rnzlh"></a>
## 8.Boolean类型的转化
- 只有这些转化成Boolean类型是false:NaN  null   undefined   0   '',其余都是ture
- !val:先将其转化成Boolean类型,然后取反
```javascript
  /* 
        Boolean true false
            1、把其他数据类型转化为布尔类型 Boolean(val)
                // 把其他数据类型转布尔有且只有 NaN、null、undefined、0、''是false,其余的都是true
        */
            // console.log(Boolean(NaN));
            // console.log(Boolean(null));
            // console.log(Boolean(undefined));
            // console.log(Boolean(''));
            // console.log(Boolean(0));
        // !val:先把val转布尔然后在取反
        // !!val:先把val转布尔，然后然后取反再取反，等价Boolean(val)
        console.log(!1); // false
        console.log(!isNaN(0)); // true
        console.log(!isNaN(![1,2,3])); //  !isNaN(false) // true
        console.log(!isNaN(undefined)); // false
        // !isNaN(![1,2,3])
        // !isNaN(false)
        // !false-->true

9.普通对象Object

任何一个对象都是拿大括号进行包裹,而且里边存放的是0到多组键值对，每一组键值对之间拿逗号分隔,每一个键值对由属性名和属性值组成,
属性名的类型是字符串或者数字,
属性值是js数据类型的任意一种

 let person = {
            name:'linPeng',
            age:18,
            sex:'boy',
            hobby:'girl',
            isMoney: true,
            2:'1111'
        };
        console.log(person);
        // 对象的增删改查
        // 查：获取对象中属性名对应的属性值
            // 对象名.属性名
            // 对象名['属性名']
            // 如果属性名是数字，那只能用 对象名['属性名']  去获取 
           //属性名如果一样,下面的会覆盖上面的
        // console.log(person.name); // 'linPeng'
        // console.log(person['name']);
        // console.log(person.age); // 18
        console.log(person[2]); // '1111' 加不加引号都可以
   // 增：给对象新增键值对
            // 对象名.属性名 = xxx
             // 对象名['属性名'] = xxx
            // person.friend = 'laowang';
            // person['friend'] = 'laowang';
            // console.log(person);
        // 改：修改对象中属性名对应的属性值
            // person.name = 'monkey';
            // console.log(person);
        // 删除键值对
            // 假删除
                // person.name = null;
                // console.log(person);
            // 真删除
                // delete 对象名.属性名
                delete person.name
                console.log(person);
            // 获取对象中属性名对应的属性值获取不到，那就是unedfined