严格模式

最新推荐文章于 2024-04-29 09:41:43 发布

w_cyj

最新推荐文章于 2024-04-29 09:41:43 发布

阅读量116

点赞数

分类专栏： js 文章标签： js

本文链接：https://blog.csdn.net/w_cyj/article/details/107900433

版权

js 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

严格模式

<script type="module">
变量必须定义后使用

不允许参数名重复

function fn(a,a){
                console.log(a);
            }

            fn(3,5); //不允许

严格模式不允许使用with

只读属性都不是能修改

 var obj={};
            Object.defineProperty(obj,"a",{
                writable:false
            })
            obj.a=10;

严格模式八进制不能使用

不能删除不可删除的属性

 var obj={}
            Object.defineProperty(obj,"a",{
                configurable:false
            });
            delete obj.a;

反射将字符串反射为该字符串变量名的对象
eval 和 arguments 不能重新赋值
- arguments.callee 不能使用
- arguments.callee.caller 不能使用
在顶层函数中this不能执行window了，是undefined
let定义的变量仅在{}作用域内使用，只在语句块状起作用
var 和 let可以混合使用
const 常量，不可以修改值

const EVENT_ID="event_id";
const EVENT_ID;//不能这样

      const obj={a:1,b:2};
       obj={a:4,b:5};//这样做可以防止obj的引用地址发生改变
       obj.a=10;
       obj=null;//会一直存在堆中，无法销毁

箭头函数

如果函数中仅有一句话，并且这句话是return返回可以省略{}和return

        var fn=(a,b)=>a+b;

等同于
        var fn=function(a,b){
            return a+b;
        }

箭头函数中如果仅有一个参数可以省略小括号

如果没有参数，或者由一个以上的参数不能省略小括号

if(arr.every(item=>item>0)){

        }

        var bool=arr.every(function(item){
            return item>0
        });
        if(bool){

        }

var arr=arr.filter(item=>item>3);
       console.log(arr);


var sum=arr.reduce((value,item)=>value+=item);
        console.log(sum);
 
 
 arr.sort((a,b)=>b-a);
        console.log(arr);倒序
  
  
  setInterval(()=>{

        },16)

var obj={
            a:function(){
                // ES5的方法
                console.log("a")
            },
            b(){
                // ES6的方法
                console.log("b");
            },
            c:()=>{
                // ES6箭头函数
                console.log("c");
            }
        }
        obj.a();
        obj.b();
        obj.c(); 
        

document.addEventListener("click",e=>{

        })

箭头函数主要可以作为改变函数中this的指向问题

var obj={
            b:1,
            a:function(){
                document.obj=this;
                var fn=(e)=>{
                    console.log(this);//当函数换为箭头函数时，
                    // this将会被指向当前函数外this的指向
                    this.clickHandler(e);
                  
                }

                var fn=function(e){
                    console.log(this);//点击的事件对象
                }
                document.addEventListener("click",fn);
                document.addEventListener("click",e=>this.clickHandler(e));
                this.c();
            },
            clickHandler(e){
                console.log(this);//obj
                // e.currentTarget 
                document.removeEventListener("click",this.clickHandler);
            },
            c:function(){
                console.log(this);
            },
            d:()=>{
                console.log(this);
            }
         }
        obj.a();
        obj.d();

解构赋值
- 数组解析最重要的是按位解析
- 对象是按照属性名解析
- 参数解构赋值后可以跳位，不需要按照顺序写
- 将加载进来的对象中方法解构出来形成全局的函数
```
 var {a,b,c}={b:10,a:20,c:30};
        console.log(a,b,c);//20 10 30
       
       
 function fn({a,b=3,c}){
       console.log(a,b,c);
   }
        fn({a:10,c:20});
```

字符串扩展方法

判断字符在字符串中是否存在

var str="ashdjsahdwi";
        console.log(str.indexOf("j")>-1);
        console.log(str.search(/j/)>-1);
        console.log(str.match(/j/));
        console.log(/j/.test(str));
        console.log(str.includes("j"));

判断a是不是从头开始
```
console.log("abcde".startsWith("a"))
```
判断从第1位开始的是不是b

console.log("abcde".startsWith("b",1));

字符串重复
```
console.log("ab".repeat(3));
```
字符串.padStart(长度,前面补充的字符);

字符串.padEnd(长度,后面补充的字符);

 console.log("#abcde".padStart(7,Math.floor(Math.random()*16).toString(16)));
       console.log("#abcde".padEnd(7,Math.floor(Math.random()*16).toString(16)));
       console.log("#"+Math.floor(Math.random()*0xFFFFFF).toString(16).padStart(6,0))

Symbol

唯一，创建的永远没有相同的
去除魔术字符串

对象键值对中键可以是字符型也可以是Symbol型

 var a="abc";
      const KEY_1=Symbol();
      var obj={
          [a]:10,
          [KEY_1]:100
      } //   这个键名就不会被覆盖
      console.log(obj[KEY_1]);
    obj.abc=200;
    console.log(obj);

Set

Set数据类型无重复列表类型
Set没有下标，不是按照下标存储，有序，不能使用下标循环遍历
插入速度和删除速度非常快
没有重复元素，任何元素存在唯一性，遍历查找速度也非常快，但是略低于键值对类型
判断这个元素是否在列表中存在
```
console.log(ab.has(3));
```
清除所有数据
```
ab.clear();
```
set中size就是长度，没有length
```
console.log(ab.size);
```

Set使用场景

var manager={
            list:[],
            add(elem){
                if(this.list.indexOf(elem)>-1) return;
                this.list.push(elem);
            },
            remove(elem){
                var index=this.list.indexOf(elem);
                if(index<0) return;
                this.list.splice(index,1);
            },
            update(){
                for(var i=0;i<this.list.length;i++){
                    this.list[i].update();
                }
            }

        } 
      等同
      var manager={
            list:new Set(),
            add(elem){
                this.list.add(elem);
            },
            remove(elem){
                this.list.delete(elem);
            },
            update(){
                for(let value of this.list){
                    value.update();
                }
            }

        }

Map
- map是一种由长度的键值对数据结构
- hashMap 键值对的数据类型
- 具备数组的长度紧密型，又具备对象的键值对方法
- 它的获取，删除，查询，遍历速度很快
```
 var map=new Map();
        map.set("name","xietian");
        map.set("age",30);
```
  - 删除键名
```
 map.delete("name");
```
  - 清除掉所有数据
```
map.clear();
```
  - 获取某个键的值
```
console.log(map.get("age"))
```
  - 判断某个键是否存在
```
console.log(map.has("age"));
```
  - 获取所有值的列表
```
console.log(map.values());
```
  - 获取所有键的列表
```
console.log(map.keys());
```
  - map遍历
```
 map.forEach(function(value,key,map){
            console.log(value,key);
        }) 
```
  - 任何类型都可以作为键使用
  - WeakSet WeakMap 弱引用类型，
  - 弱引用，就是如果其中的强引用的类型地址设置为null，弱引用的关系会自动解除。
  - 弱引用的类型不可以遍历
  - WeakMap 存储的key必须是对象