Js基础

Js中有7种类型(ES6后新增一种)分别为
1.数值(Number)
2.字符串(string)
3.布尔值(Boolean)
4.undefined
5.null
6.object
7.Symbol (这个一个es6种用来指定唯一标记的东西)
其中object又可以分为
狭义(object)
数组(array)
方法(function)

判断配型的方法有3种分别为
1.typeof
typeof 无法区别array和object需要使用instanceof

　　　//只等于new 出来的
            let dom1 = 1;
            let dom2 = '233';
            let dom3 = true
            let dom4 = new Number(1);
            let dom5 = new String('233');
            let dom6 = new Boolean(true);
            console.log(dom1 instanceof Number); //false
            console.log(dom2 instanceof String); //false
            console.log(dom3 instanceof Boolean);//false
            console.log(dom4 instanceof Number); //true
            console.log(dom5 instanceof String); //true
            console.log(dom6 instanceof Boolean); //true
            //function 不等于 object
            let dom7 = function ss() { }
            let dom8 = new dom7();
            let dom9 = new dom7();
            console.log(dom7 instanceof Function); //true
            console.log(dom8 instanceof dom7); //true
            console.log(dom8 instanceof Function); //false
            console.log(dom8 instanceof Object); //true
            //可以判断继承
            let dom10 = function s1() { }
            let dom11 = function s2() { }
            dom10.prototype = new dom11();
            let dom12 = new dom10();
            console.log('--------------------');
            console.log(dom12 instanceof dom10); //true
            console.log(dom12 instanceof dom11); //true
3.Object.prototype.toString.call

            //可以很好的判断一个object是否为数组
            let dom1 = 1;
            let dom2 = '233';
            let dom3 = true
            let dom4 = undefined;
            let dom5 = null;
            let dom6 = { a: 1 }
            let dom7 = [{ a: 1 }, { a: 1 }]
            let dom8 = function a() { }
            console.log(Object.prototype.toString.call(dom1));//[object Number]
            console.log(Object.prototype.toString.call(dom2));//[object String]
            console.log(Object.prototype.toString.call(dom3));//[object Boolean]
            console.log(Object.prototype.toString.call(dom4));//[object Undefined]
            console.log(Object.prototype.toString.call(dom5));//[object Null]
            console.log(Object.prototype.toString.call(dom6));//[object Object]
            console.log(Object.prototype.toString.call(dom7));//[object Array]
            console.log(Object.prototype.toString.call(dom8));//[object Function]

Boolean类型的判断，以下几种数据都会返回false其他都为true
        1.undefined
        2.null
        3.''或者""
        4.false
        5.NAN
        6.0
        []和{}显示为true

数值
1. js的所有数值都是64位浮点数要小心计算
2.数值的进值表达
        十进值无前导
        8进值 0O
        16进值 0X
        2进值 0B
3.NAN类型
        字符串转换错误会得到NAN
        NAN不等于任何值包括自身
        和NAN计算都是NAN
        NAN的类型还是number
[].indexof(NaN)返回-1

            if (NaN != NaN) {
                console.log("NAN不等于NaN")
            }
            var a = 5 - NaN;
            console.log(`和NAN计算还是${a}`);
            var b = [NaN].indexOf(NaN);
            console.log(`数组NaN indexOf为${b}`);

4. 和数值有关的全局方法
parseInt

　　 //parseInt的返回值只有两种可能，要么是一个十进制整数，要么是NaN。
                //转字符串
                var dom1 = parseInt('111');
                console.log(dom1);
                //能过滤空格
                var dom2 = parseInt(' 222 ');
                console.log(dom2);
                //从左到后一个个转换如果后续的不能转换返回已经转换好的数值
                let dom3 = parseInt('22xa2');
                console.log(dom3);
                //如果从左开始第一个就不能转换则返回NaN
                let dom4 = parseInt('x3333');
                console.log(dom4);
                //如果按照0X开头按照16进值解析返回10进值
                let dom5 = parseInt('0X23');
                console.log(dom5); //35
                //可以接收第二个参数用来进值转换范围2-36
                let dom6 = parseInt('1000', 2);
                let dom7 = parseInt('1000', 8);
                let dom8 = parseInt('1000', 16);
                console.log(dom6);//8
                console.log(dom7);//512
                console.log(dom8);//4096
                //如果第二个参数不在2-36种返回NaN 如果第一个参数不能符合第二个参数的进值返回NaN
                let dom9 = parseInt('1000', 37);
                let dom10 = parseInt('3000', 2);
                console.log(dom9);
                console.log(dom10);
        parseFloat

                //能转换一个浮点型字符串
                let dom1 = parseFloat('3.14')
                console.log(dom1);//3.14
                //可以转科学计数法的字符串
                let dom2 = parseFloat('314e-2');
                console.log(dom2);//3.14
                 //能过滤空格
                var dom3 = parseFloat(' 3.222 ');

                console.log(dom3);//3.222
                //从左到后一个个转换如果后续的不能转换返回已经转换好的数值
                let dom4 = parseFloat('3.14xasd');
                console.log(dom4);//3.14
                //如果从左开始第一个就不能转换则返回NaN
                let dom5 = parseFloat('a3.14xasd');
                console.log(dom5);//NaN
        isNaN

                //判断一个数是否为Nan
                let dom1 = isNaN(233);//false
                let dom2 = isNaN(NaN);//true
                console.log(dom1);
                console.log(dom2);
                //如果传入的不是数字则会先转为数字并做判断如果传入的不能转为数字也是NaN
                let dom3 = isNaN('aaa');
                let dom4 = isNaN({});
                console.log(dom3);//true
                console.log(dom4);//true
                //以下几个传入会得到false
                let dom5 = isNaN([]);
                let dom6 = isNaN([123]);
                let dom7 = isNaN(['123']);
                let dom8 = isNaN('');
                console.log(dom5);//false
                console.log(dom6);//false
                console.log(dom7);//false
                console.log(dom8);//false
                //所以使用的时候最好判断下类型
                function MyIsNaN(value) {
                    return typeof value === 'number' && isNaN(value);
                }
                //或者使用NaN不等于自身的特性
                function MyIsNaN(value) {
                    return value !== value;
                }
        isFinite

                //以下几个会返回false 其他都返回true
                //NaN undefined Infinity -Infinity
                //还有传入后转为以上几个类型的
                let dom1 = isFinite(NaN);
                let dom2 = isFinite(Infinity);
                let dom3 = isFinite(-Infinity);
                let dom3 = isFinite(undefined);
                console.log(dom1);//false
                console.log(dom2);//false
                console.log(dom3);//false
                console.log(dom4);//false

字符串

            //字符串可以看成一个字符数组但不能按照数组的样子修改
            let dom1 = 'hello'
            for (var i = 0; i < dom1.length;i++) {
                console.log(dom1[i]); //分别打印h e l l o
            }
            //es6种可以这样反转字符串
            var dom2 = [...dom1].reverse().join('');
            console.log(dom2); //olleh

object

//如果属性的key是数字类型的不能用.必须用[] []里可以有表达式
            let dom1 = {
                123: 5,
                dom123:10
            }
            console.log(dom1[123]); //5
            console.log(dom1['dom' + '123']); //10
            //查看所有属性
            let dom2 =
            {
                key1: 1,
                key2: 2,
                key3:3
            }
            console.log(Object.keys(dom2));// ["key1", "key2", "key3"]
            //delete 删除属性无论是否含有删除的属性都返回true 除了只读返回false 并且不能删除继承的属性
            let dom3 = {
                key:5
            }
            let res = delete dom3.key;
            console.log(res);
            //in 判断属性是否在其中但不能判断是否是继承的
            let dom4 = {
                p: 2
            }
            console.log('p' in dom4);//true
            console.log('a' in dom4);//false
            //for ... in 遍历全部属性包括继承的属性
            let dom5 = {
                key1: 10,
                key2: 20,
                key3:30
            }
            for (var i in dom5)
            {
                console(i);
            }

数组

　　　　//什么都可以放进数组
            //本质是一个特殊的数组typeof 返回 object 特殊在于key是连续的数字
            //数组的lenght 返回数组的个数可以修改
            let dom1 = ['a', 'b', 'c'];
            console.log(dom1.length);//3
            //如果设置比数组原本小的值会导致数组清楚长度超过的值
            let dom2 = ['a', 'b', 'c', 'd']
            dom2.length = 2;
            console.log(dom2)//['a','b']
            //如果length 设置查过原本的数组个数会增加数组长度增加的位置为空
            let dom3 = ['a', 'b'];
            dom3.length = 5;
            console.log(dom3);//undefined
            //for...in 可以遍历数组但也会遍历数组的非数字键
            //可以使用forEach遍历数组
            let dom4 = ['1', '2', 'a', 'f'];
            dom4.forEach(x => {
                console.log(x);
            })//'1', '2', 'a', 'f'

　　　 //数组的空位 2个逗号中不存在任务东西就是空位
            let dom5 = ['1', , '2'];
            //读取空位返回undefined
            console.log(dom5[1])//undefined
            //delete 删除的数组内容会变空位返回undefined
            let dom6 = ['1', 'a', '4', '3'];
            delete dom6[2];
            console.log(dom6[2])//undefined
            //空位会被 for...in forEach等遍历略过
            let dom7 = ['1', 'a', , '3'];
            for (var v in dom7) {
                console.log(v); //1，a,3
            }
            dom7.forEach(x => {
                console.log(x);//1，a,3
            })

posted @ 2020-10-21 14:27 wujh123 阅读(107) 评论(0) 收藏举报

刷新页面返回顶部

wujh123

Js基础

公告