javascript中parseFloat(x)、parseInt(num,radix)、Promise、ReferenceError、Reflect、get和set

parseFloat(x)对象：

将传入的字符转化为浮点数，若传入的字符不能被转化为数字型，则返回NaN

	<script>
        console.log(parseFloat(0.0314E+2)); //3.14
    </script>

parseInt(num,radix)对象：

将num看成radix某进制的数后转化为十进制整数，radix的取值范围为2-36

	<script>
        console.log(parseInt(0.0314E+2)); //3
        console.log(parseInt(123, 16)); //291
    </script>

Promise对象：

为了解决回调地狱问题带来的代码不好维护问题，可以使用promise对象解决这个问题,promise有三种状态：pending异步操作未完成、resolved异步操作已完成、rejected异步操作失败，从开始到结束三种状态之间有两种模式，这两种模式分别是promise中传入回调函数中的第一个参数和第二个参数；

	var fs = require('fs');
    // 1.创建promise容器：一旦创建这个容器就会执行里面的代码
    new Promise(function(resolve,rejecte){
      fs.readFile('./data/c.txt', 'utf8', function (err, data) {
        if (err) {
          rejecte(err)
        }else{
          resolve(data)
        };
      });//2.在容器中放一个函数并在其中执行异步操作
    });
    
    var p1 = new Promise(function (resolve, reject) {
      fs.readFile('./data/a.txt', 'utf8', function (err, data) {
        if (err) {
          reject(err)
        } else {
          resolve(data)
        }
      })
    })
    
    var p2 = new Promise(function (resolve, reject) {
      fs.readFile('./data/b.txt', 'utf8', function (err, data) {
        if (err) {
          reject(err)
        } else {
          resolve(data)
        }
      })
    })
    
    var p3 = new Promise(function (resolve, reject) {
      fs.readFile('./data/c.txt', 'utf8', function (err, data) {
        if (err) {
          reject(err)
        } else {
          resolve(data)
        }
      })
    })
    
    p1
      .then(function (data) {
        console.log(data)
        // 当 p1 读取成功的时候
        // 当前函数中 return 的结果就可以在后面的 then 中 function 接收到
        // 当你 return 123 后面就接收到 123
        //      return 'hello' 后面就接收到 'hello'
        //      没有 return 后面收到的就是 undefined
        // 上面那些 return 的数据没什么卵用
        // 真正有用的是：我们可以 return 一个 Promise 对象
        // 当 return 一个 Promise 对象的时候，后续的 then 中的 方法的第一个参数会作为 p2 的 resolve
        // 
        return p2
      }, function (err) {
        console.log('读取文件失败了', err)
      })
      .then(function (data) {
        console.log(data)
        return p3
      })
      .then(function (data) {
        console.log(data)
        console.log('end')
      })

其相关属性和方法如下：

属性或方法	描述	案例
Promise.all()方法	将多个promise实例包装成一个promise实例，all中可以接收一个数组作为参数(这个参数可以不是数组，但是必须是lterator接口，即可迭代对象)，数组中的每一项都是一个promise的对象实例，对象实例的执行结果将以一个数组的形式展现出来	var arr = [1, 2];var obj = {str: ‘hello’};var num = 8;Promise.all([arr, obj, num]).then(function(e) {console.log(e);}); //[Array(2), {…}, 8]
Promise.allSettled(promises)方法	将一个在所有给定的promise都已经fulfilled或rejected后的promise参数（参数也是 iterable型），用一个带有对象的数组返回	var arr = [1, 2];var obj = {str: ‘hello’};var num = 8;Promise.allSettled([arr, obj, num]).then(function(e) {console.log(e);}); //[{…}, {…}, {…}]—0: {status: “fulfilled”, value: Array(2)}
Promise.any(iterable)方法	传入一个可迭代的promise对象，只要其中一个promise是成功的，就返回这个成功的promise，若迭代对象中没有一个成功的promise对象，则返回一个失败的promise对象， 和AggregateError类型的实例，它是Error的一个子类，用于把单一的错误集合起来，本质上和Promise.all()是相反的	var arr = [1, 2];var obj = {str: ‘hello’};var num = 8;Promise.any([arr, obj, num]).then(function(e) {console.log(e);}); //[1, 2]
promise.catch()方法	返回一个promise，并且处理拒绝的情况（catch方法中传入一个函数，函数中传入一个参数用于接收promise失败的原因，并对它进行处理），只有当promise失败的时候才调用此方法	var p1 = new Promise(function(resolve, reject) {fs.readFile(‘./data/c.txt’, ‘utf8’, function(resolv, reject) {if (resolv) {rejecte(resolv);} else {resolve(reject);};});});p1.then(function(value) {console.log(value);}).catch(function(e) {console.log(e);}); //fs is not defined，调用catch方法并打印了e
promise.finally()方法	返回一个promise，在promise结束时，无论结果是fulfilled或rejected都会执行指定的回调函数，它可以不用分情况解决问题	var promise = new Promise(function(resolve, reject) {window.setTimeout(function() {if (false) {resolve(‘huangbiao’);} else {debuggerreject(‘error’);};}, 1000)}).then(function() {console.log(‘success’);}).catch(function() {console.log(‘catch’);}).finally(function() {console.log(‘finally’);});//[Violation] ‘setTimeout’ handler took 218231ms
Promise.race(iterable)方法	迭代中某个对象的状态发生改变，则发生改变的这个对象就会被返回，这个被返回的值用回调函数接收	Promise.race([‘promise1’, ‘promise2’]).then((value) => {console.log(value);}); //promise1
Promise.reject()方法	当promise的状态成 rejected时，会调用 rejected状态的回调函数，回调函数中的参数就是 rejected状态时的理由	var p = new Promise(function(resolve, reject) {reject(‘出错了’);});p.then(null, function(s) {console.log(s);});//出错了,等同于 var p = Promise.reject(‘出错了’);
Promise.resolve()方法	调用时不带参数，直接返回一个resolved状态的 Promise 对象	var promise1 = Promise.resolve(123);promise1.then((value) => {console.log(value);});//123
Promise.then()方法	它最多有两个参数，分别是promise的成功和失败的回调函数，当异步操作完成，然后执行callback函数	var promise1 = new Promise((resolve, reject) => {resolve(‘Success!’);});promise1.then(value => {console.log(value);}, reason => {console.error(reason);});
RangeError范围报错：

RangeError当一个值不在其所允许的范围或者集合中时报错，其实例对象需要new RangeError(a,b,c);可以接收三个可选参数，第一个参数是用来描述错误的信息，第二个参数是说明造成错误的文件名，第三个参数指报错的行数，如：

<script>
    var err = new RangeError('no find!', 'index.html', '10');
    if (true) throw err;//控制台报错： Uncaught RangeError: no find!  at test.html:18
</script>

ReferenceError引用错误：

ReferenceError一个不存在的变量被引用是报错，同样通过new创建实例化对象，同样可传入三个可选参数，1错误描述，2错误的文件，3错误行数，如：

	<script>
        try {
            throw new ReferenceError('Hello', 'someFile.js', 10);
        } catch (e) {
            console.log(e instanceof ReferenceError); // true
            console.log(e.message); // "Hello"
            console.log(e.name); // "ReferenceError"
            console.log(e.fileName); // undefined
            console.log(e.lineNumber); // undefined
            console.log(e.columnNumber); //undefined
            console.log(e.stack); // "@Scratchpad/2:2:9\n"
        }
    </script>

Reflect拦截javascript操作的方法：
Reflect是一个静态的对象，不需要通过new创建的对象，它支持很多实用静态的方法，如下表：

方法	描述	案例
Reflect.apply(a,b,c)	可传入三个参数，第一个表示被apply请求的方法，第二个参数表示这个被请求方法的使用对象，第三个参数表示这个方法中传入的参数，如： Reflect.apply(console.log, undefined, [1, 2]); //1 2	var res = Reflect.apply(new String().charAt, ‘ponies’, [2]);console.log(res); //n
Reflect.construct(a,…b)	对构造函数实例化，相当于new操作，第一参数是构造函数，第二个参数接收一个数组，数组元素均为函数的参数	function Person(name, age) {this.name = name;this.age = age;};var per = Reflect.construct(Person, [‘jack’, ‘18’]);console.log(per.name + ‘—’ + per.age); //jack—18
Reflect.defineProperty(a,b,c)	给对象a添加一个属性b，b属性的属性值是{value:c}，其本身返回一个布尔值	var obj = {};var bool = Reflect.defineProperty(obj, ‘name’, {value: ‘jack’});console.log(obj.name + ‘—’ + bool);//jack—true
Reflect.deleteProperty(a,b)	删除数组索引为b的元素或对象的b属性，本身返回一个布尔值	var obj = {name: ‘jack’};var bool = Reflect.deleteProperty(obj, ‘name’);var arr = [1, 2, 3];var boolear = Reflect.deleteProperty(arr, 1);console.log(obj + ‘:’ + bool + ‘—’ + arr + ‘:’ + boolear); //{}:true—1,3:true
Reflect.get(a,b)	获取a对象b属性的值或a数组索引b的元素，并返回这个值	var obj = {name: ‘jack’};var bool = Reflect.get(obj, ‘name’);var arr = [1, 2, 3];var boolear = Reflect.get(arr, 1);console.log(bool + ‘—’ + boolear); //jack—2
Reflect. getOwnPropertyDescriptor(a,b)	判断对象a中是否有属性b，有则返回属性的描述，无则返回undefined	var obj = {‘age’: 18};var result = Reflect.getOwnPropertyDescriptor(obj, ‘age’);console.log(result);//{value: 18, writable: true, enumerable: true, configurable: true}
Reflect.has(a,b)	判断a对象中是否有属性b，若有则返回true，否则返回false	var obj = {‘age’: 18};var result = Reflect.has(obj, ‘age’);console.log(result); //true
Reflect.isExtensible(a)	判断一个对象a是否可以添加新属性，返回布尔值	var obj = {‘age’: 18};var result = Reflect.isExtensible(obj);console.log(result); //true
Reflect.ownKeys(a)	里面传入一个数组或对象，以数组的形式返回一个这个对象的键或这个数组的所有元素，数组的最后多了length项	const object1 = {age: 18,name: ‘jack’};var resultObj = Reflect.ownKeys(object1);const array1 = [1, ‘2’, 3, ‘4’];var resultArr = Reflect.ownKeys(array1); console.log(resultObj); console.log(resultArr); // [“age”, “name”][“0”, “1”, “2”, “3”, “length”],注意，这里数组最后多了个length
Reflect.preventExtensions(a)	禁止向添加此方法的对象a后面添加新属性或方法	const object1 = {};object1.height = 170;Reflect.preventExtensions(object1);object1.weight = 20;console.log(object1.height); console.log(object1.weight); //170 undefined，被添加此方法后，此方法后面将不能在给对象添加属性或方法了
Reflect.set(a,b,c)	给数组添加元素或对象添加属性和方法，本身返回布尔值，第一个参数表示被添加的目标对象，第二个参数表示属性或索引，在数组中给某索引的元素添加新值，可以覆盖之前的值，第三个参数表示添加属性或元素的值	var obj = {};var objResult = Reflect.set(obj, “name”, “jack”);console.log(objResult);console.log(obj);var arr = [“1”, 2, “3”];var arrResult = Reflect.set(arr, arr.length, “s”);console.log(arrResult);console.log(arr);//true {name: “jack”} true [“1”, 2, “3”, “s”]
Reflect.setPrototypeOf(a,b)	改变a对象的原型指向为b.prototype，并返回一个布尔值	var obj = {};var bool = Reflect.setPrototypeOf(obj, Array.prototype);console.log(obj);console.log(bool) //Array {} true

Proxy 对象：

用于创建一个对象的代理，从而实现基本操作的拦截和自定义，语法：let p = new Proxy(target,handler);target指的是要代理的object或者function；handler指的是对代理对象进行各种操作行为处理

	<script>
        let test = {
            name: "小红"
        };
        testRes = new Proxy(test, {
            get(target, key) {
                console.log('获取了getter属性'); //获取了getter属性
                return target[key];
            }
        });
        console.log(testRes.name); //小红
    </script>

get和set:

get指得到对象的某个属性的值的方法，set指设置对象的某个属性的值的方法，如：

	<script>
        var o = {
            a: 7,
            get b() {
                return this.a + 1;
            },
            set c(x) {
                this.a = x / 2
            }
        };
        console.log(o.b); // 8
        o.c = 50;
        console.log(o.a); // 25
    </script>

提示：本文图片等素材来源于网络，若有侵权，请发邮件至邮箱：810665436@qq.com联系笔者 删除。
笔者：苦海