每天记录一个小知识4-----数据的处理

数据的处理：
     

JavaScript值类型（基本类型）

1.       字符串（String）
2.       唯一（Symbol）：ES6 引入了一个新的数据类型 Symbol，Symbol 可以创建一个独一无二的值（但并不是字符串）。
3.       未定义（Undefined）：Undefined类型也只有一个值，即undefined。当声明的变量还未被初始化时，变量的默认值为undefined。
4.       数字（Number）
5.       布尔（Boolean）：布尔（逻辑）只能有两个值：true 或 false，其常用在条件测试中。
6.       空（Null）：Null类型只有一个值，即null。null用来表示尚未存在的对象，常用来表示函数企图返回一个不存在的对象。
7.       大整数bigint():可以用任意精度表示整数，超出Number的安全整数限制，也可以安全地存储和操作大整数.注意：当使用BigInt时，带小数的运算会被取整.参数：可以是字符串或者整数。

     

JavaScript引用数据类型（对象类型）

      1.对象(Object)
      2.数组(Array)
      3.函数(Function)
      4.正则（RegExp）
      5.日期（Date）
     

一.数据类型的转换：

        1.转换成字符串型

• 调用被转换数据的toString()方法:注意：这个方法不适用于null和undefined,由于这两个类型的数据中没有方法，所以调用toString()时会报错
• 调用String()函数:对于null值，直接转换为字符串"null"。对于undefined直接转换为字符串"undefined"
• 为任意的数据类型 +""

        2.转换成数字型

                 调用Number

          (1) 字符串转换为数字：空字符串转为0，如果出现的是任何非有效数字字符，结果都是NaN 。Number('') -> 0 Number('12c') -> NaN
          (2) 布尔值转换为数字：true -> 1 , false -> 0
          (3) null -> 0 , undefined -> NaN
          (4) Symbol无法转换为数字，会报错：Uncaught TypeError: Cannot convert a Symbol value to a number
          (5) BigInt去除'n'（超过安全数字的，会按照科学计数法处理）  Number(10n) -> 10

         调用parseInt()或parseFloat()这两个函数专门用来将一个字符串转换为数字的,可以将一个字符串中的有效的整数位提取出来，并转换为Number。
         使用一元的+来进行隐式的类型转换 var a = "123";  a = +a;

        3.转换成布尔型
          使用Boolean()函数

            (1)字符串 > 布尔:除了空串其余全是true
            (2)数值 > 布尔:除了0和NaN其余的全是true
            (3)null、undefined > 布尔:都是false
            (4)对象 > 布尔:都是true

          为任意的数据类型做两次非运算，即可将其转换为布尔值.var a = "hello";  a = !!a; //true
 

  二.Object.keys()、Object.values()、Object.entries()用法总结

        1.Object.keys(obj):

            参数：返回其枚举自身属性的对象
            返回值：一个表示给定对象的所以可枚举属性的字符串数组
            处理对象，返回可枚举的属性数组

 let person = {name:"张三",age:25,address:"浙江",getName:function(){}};
Object.keys(person) // ["name", "age", "address","getName"]

            处理数组，返回索引值数组

 let arr = [1,2,3,4,5,6]
Object.keys(arr) // ["0", "1", "2", "3", "4", "5"]

            处理字符串，返回索引值数组

 let str = "字符串"
Object.keys(str) // ["0", "1", "2"]

            实用技巧：

            let list=[];
            let person = {name:"张三",age:25,address:"浙江",getName:function(){}};
            let a=Object.values(person);
            Object.keys(person).map((key)=>{
            　　list.push(person[key]) // 获取到属性对应的值，做一些处理
            })
            console.log(a,list) //a与list的结果相同["张三", 25, "浙江", ƒ]

        2.Object.values():

          返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值

          let obj = {
              foo : "bar",
              baz : 20
          };
          console.log(Object.values(obj));  // ["bar", 20]

          返回数组的成员顺序，与属性的遍历部分介绍的排列规则一致

          const obj = {100 : "a",9 : "b", 20 : "c"};
          console.log(Object.values(obj));   //["b", "c", "a"]
         

        Object.values()只会遍历对象自身的可遍历属性

          const obj = Object.create({},{p : {value : 10}});
          console.log(Object.values(obj));    // []

          改：因为p的属性描述对象的enumerable默认是false，Object.values不会返回这个属性。

          const obj = Object.create({},{p:{
               value : 20,
               enumerable : true,
               configurable : true,
               writable : true,
          }})
          console.log(Object.values(obj));    //[20]

         

         Object.values会过滤属性名为 Symbol 值的属性

          //如果Object.values方法的参数是一个字符串，会返回各个字符组成的一个数组。
          Object.values({ [Symbol()]: 123, foo: 'abc' });
          console.log(Object.values('foo'));  //["f", "o", "o"]
          或：
          let arr= { [Symbol()]: 123, foo: 'abc' };
           console.log(Object.values(arr));  //["abc"]

        如果参数不是对象，Object.values会先将其转为对象

          console.log(Object.values(12));  // []
          console.log(Object.values(true));  // []
          console.log(Object.values(undefined));   //error
          console.log(Object.values(null));   //error

        3.Object.entries():

          返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组
          如果原对象的属性名是一个 Symbol 值，该属性会被省略

console.log(Object.entries({ [Symbol()]: 123, foo: 'abc' }));  // [ [ 'foo', 'abc' ] ]

          遍历对象的属性

let obj = {
              one : 1,
              two : 2,
          }
          for(let [k , v] of Object.entries(obj)){
               console.log(`${JSON.stringify(k)} : ${JSON.stringify(v)}`);
          }

          将对象转为真正的Map结构

 const obj = {foo : "bar", baz : 10};
 const map = new Map(Object.entries(obj));
 console.log(map);

          实现Object.entries方法:

 const entries = (obj) => {
               let result = [];
               const objType = typeof(obj);
               if(obj === undefined || obj === null){
                    throw new TypeError();
               }
               if(objType === "number" || objType === "boolean"){
                   return [];
               }
               for(let k of Object.keys(obj)){
                   result.push([k,obj[k]]);
               }
               return result
          }

      三.Json格式转换
        1.JSON.stringify() 把 json 对象、数组转换成为 json 字符串

var data={name:'张三'}
JSON.stringify(data)  //结果是：'{"name":"张三"}'

        2.JSON.parse() 把 json 字符串转换成为 json 对象

 var data='{"name":"张三"}'
 ​JSON.parse(data)       // 结果是： ​name:"张三"

四.平时遇到过的

 let arr={
        conter:'hsjgg',
        name:'zhangsan'
      };
      let arr1={};
      arr1[arr.conter]=arr.name
    console.log(arr, arr1,'222222')

 

学习记录   如有侵权请联系删除