精华内容
下载资源
问答
  • es6 解构赋值

    千次阅读 2019-05-05 17:45:39
    ES6解构赋值传统的变量赋值:变量的解构赋值:数组的解构赋值:对象的解构赋值:`(和数组解构赋值类似)`字符串的解构赋值:数值和布尔值的解构赋值:`解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。...

    ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)。

    传统的变量赋值:

    	var arr = [1,2,3]; //把数组的值分别赋给a,b,c几个变量
    	var a = arr[0];
    	var b = arr[1];
    	var c = arr[2];
    
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //3
    

    变量的解构赋值:

    	var [a,b,c] = [1,2,3]; //把数组的值分别赋给a,b,c几个变量
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //3
    

    数组的解构赋值:

    1.数组结构赋值可以嵌套的

    	var [ a,b [ c,d ] ] = [ 1,2 [ 3,4 ] ]
    	console.log(c); //3
    	console.log(d); //4 
    

    2.不完全解构

    	var [a,b,c] = [1,2];
    	console.log(a); //1
    	console.log(b); //2
    

    3.赋值不成功,变量的值为undefined

    	var [a,b,c] = [1,2];
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //undefined
    

    4.可以设置默认值

    	var [a,b,c=3] = [1,2];
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //3
    

    注意:如果右边的对应变量值不为undefined,则会覆盖默认值

    	var [a,b,c=3] = [1,2,4];
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //4
    

    对象的解构赋值:(和数组解构赋值类似)

    1.对象解构赋值也可以嵌套

    	var {a:{b}} = {"a":{"b":1}};
    	console.log(b); //1
    

    2.可以设置默认值

    	var {a,b=2} = {"a":1}
    	console.log(b); //2
    

    3.赋值不成功,变量的值为undefined

    	var {a,b,c} = {"a":1,"b":2};
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //undefined
    

    4.对象解构赋值不受属性的排列次序影响(但是数组会有影响)

    	var {a,b,c} = {"a":1,"c":3,"b":2};
    	console.log(a); //1
    	console.log(b); //2
    	console.log(c); //3
    

    注意:如果要将一个已经声明的变量用于解构赋值,必须非常小心。

    	let x;
    	{x} = {"x":1}; //SyntaxError: syntax error
    

    上面代码的写法会报错,因为 JavaScript 引擎会将{x}理解成一个代码块,从而发生语法错误。只有不将大括号写在行首,避免 JavaScript 将其解释为代码块,才能解决这个问题

    SO:正确的写法

    	let x;
    	({x} = {x: 1});
    

    字符串的解构赋值:

    	var [a,b,c,d,e,f,g,h] = "字符串的解构赋值";
    	console.log(a); //字
    	console.log(b); //符
    	console.log(c); //串
    	console.log(d); //的
    	console.log(e); //解
    	console.log(f); //构
    	console.log(g); //赋
    	console.log(h); //值
    

    数值和布尔值的解构赋值:解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。

    	let {toString: s} = 123;
    	s === Number.prototype.toString // true
    
    	let {toString: x} = true;
    	x === Boolean.prototype.toString // true
    ----------------------------------------------------------------------------
    	数值和布尔值的包装对象都有`toString`属性,因此变量`s/x`都能取到值。
    

    解构赋值的规则是,只要等号右边的值不是对象数组,就先将其转为对象。由于undefinednull无法转为对象,所以对它们进行解构赋值,都会报错

    	let { prop: x } = undefined; // TypeError
    	let { prop: y } = null; // TypeError
    

    函数参数的解构赋值:

    	function add([x, y]){
      		return x + y;
    	}
    
    	add([1, 2]); // 3
    

    函数参数解构也可设置默认值

    	function fn({x, y} = { x: 0, y: 0 }) {
    	  return [x, y];
    	}
    	
    	fn({x: 3, y: 8}); // [3, 8]
    	fn({x: 3}); // [3, undefined]
    	fn({}); // [undefined, undefined]
    	fn(); // [0, 0]
    

    变量的解构赋值用途:

    1.交换变量的值

    	let a = 1;
    	let b = 2;
    	let [a,b] = [b,a]; // a=2  b=1 
    

    2.从函数返回多个值

    	//返回一个数组
    	function arr(){
    		return [1,2,3] 
    	}
    	let [a,b,c] = arr() // a=1 b=2 c=3
    
    	//返回一个对象
    	function obj(){
    		return {"d":4,"e":5,"f":6}
    	}
    	let {d,e,f} = obj() // d=4 e=5 f=6
    

    3.定义函数参数

    	// 参数是一组有次序的值 (数组受次序影响)
    	function arr([x, y, z]) {
    		console.log(x,y,z); // x=1 y=2 z=3
    	}
    	arr([1, 2, 3]);
    	
    	// 参数是一组无次序的值 (对象不受次序影响)
    	function obj({a, b, c}) {
    		console.log(a,b,c); // a=1 b=2 c=3
    	}
    	obj({c:3, b:2, a:1});
    

    4.提取 JSON 数据

    	let div = {
    		width:"10px",
    		height:"20px",
    		id:1,
    		text:['aa','bb','cc']
    	}
    	let {width,height,id,text:t} = div
    	console.log(width,height,id,t); // width="10px" height="20px" id=1 t=['aa','bb','cc']
    

    5.函数参数的默认值

    	function demo({name="张三"}){
            console.log("姓名:"+name); // 姓名:张三
        }
        demo({});
    

    6.遍历 Map 结构

    	let map = new Map();
    	map.set('a', 'A');
    	map.set('b', 'B');
    	
    	for (let [key, value] of map) {
    	  console.log(key + " is " + value); //a is A   // b is B
    	}
    
    	//如果只想获取键名和键值
    	// 获取键名
    	for (let [key] of map) {
    	  // ...
    	}
    	
    	// 获取键值
    	for (let [,value] of map) {
    	  // ...
    	}
    

    7.输入模块的指定方法

    	const { SourceMapConsumer, SourceNode } = require("source-map");
    
    展开全文
  • es6解构赋值

    2020-11-23 18:48:14
    一.es6解构赋值 定义:解构赋值语法是一种 Javascript 表达式。通过解构赋值, 可以将属性/值从对象/数组中取出,赋值给其他变量。 语法: 1.默认值 2.交换变量 3.忽略你不感兴趣的返回值 4.将剩余数组赋值给一个...

    一.es6解构赋值

    定义:解构赋值语法是一种 Javascript 表达式。通过解构赋值, 可以将属性/值从对象/数组中取出,赋值给其他变量。
    语法:在这里插入图片描述
    1.默认值
    在这里插入图片描述
    2.交换变量
    在这里插入图片描述
    3.忽略你不感兴趣的返回值
    在这里插入图片描述
    4.将剩余数组赋值给一个变量
    在这里插入图片描述
    5.给新的变量名赋值
    在这里插入图片描述
    6.For of 迭代和解构
    在这里插入图片描述

    展开全文
  • ES6解构赋值

    2019-09-27 18:03:32
    ES6解构赋值 1. 数组的解构赋值  基本用法  以前给变量赋值只能指定值:    ES6允许这样写:    上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值。  本质上,这种写法属于...

    1. 数组的解构赋值

      基本用法

        以前给变量赋值只能指定值:

        

         ES6允许这样写:

        

         上面代码表示,可以从数组中提取值,按照对应位置,对变量赋值。

        本质上,这种写法属于“模式匹配”,只要等号两边的模式相同,左边的变量就会被赋予对应的值。下面是一些使用嵌套数组进行解构的例子。

        

         如果解构不成功,变量的值就等于undefined。

        另一种情况是不完全解构,即等号左边的模式,只匹配一部分的等号右边的数组。这种情况下,解构依然可以成功。

        

         如果等号的右边不是数组(或者严格地说,不是可遍历的结构,参见ES6《Iterator》一章),那么将会报错。

        

         上面的语句都会报错,因为等号右边的值,要么转为对象以后不具备 Iterator 接口(前五个表达式),要么本身就不具备 Iterator 接口(最后一个表达式)。

        事实上,只要某种数据结构具有 Iterator 接口,都可以采用数组形式的解构赋值。

      默认值

        解构赋值允许指定默认值。

        

         注意,ES6 内部使用严格相等运算符(===),判断一个位置是否有值。所以,只有当一个数组成员严格等于undefined,默认值才会生效。

        

         上面代码中,如果一个数组成员是“ ”,默认值就不会生效,因为“ ”不严格等于undefined

        如果默认值是一个表达式,那么这个表达式是惰性求值的,即只有在用到的时候,才会求值。

        

         上面代码中,因为x能取到值,所以函数 fin 根本不会执行。上面的代码其实等价于下面的代码。

        

         默认值可以引用解构赋值的其他变量,但该变量必须已经声明。

        

     2.对象解构赋值

      简介

        解构不仅可以用于数组,还可以用于对象。

        

         对象的解构与数组有一个重要的不同。数组的元素是按次序排列的,变量的取值由它的位置决定;而对象的属性没有次序,变量必须与属性同名,才能取到正确的值。

        

         上面代码中,等号左边的两个变量的次序,与等号右边两个同名属性的次序不一致,但是对取值完全没有影响。第三个变量没有对应的同名属性,导致取不到值,最后等于undefined。如果解构失败,变量的值等于undefined

        对象的解构赋值,可以很方便地将现有对象的方法,赋值到某个变量。

        

        

         上面代码将Math对象的对数、正弦、余弦三个方法,赋值到对应的变量上,使用起来就会方便很多。

         如果变量名与属性名不一致,必须写成下面这样。

        

         上面代码中,foo是匹配的模式,baz才是变量。真正被赋值的是变量baz,而不是模式foo

        对象的解构赋值的内部机制,是先找到同名属性,然后再赋给对应的变量。真正被赋值的是后者,而不是前者。

        与数组一样,解构也可以用于嵌套结构的对象。

        

         注意,这时p是模式,不是变量,因此不会被赋值。如果p也要作为变量赋值,可以写成下面这样。

        

         下面是嵌套赋值的例子。

        

         如果解构模式是嵌套的对象,而且子对象所在的父属性不存在,那么将会报错。

        

         

         注意,对象的解构赋值可以取到继承的属性。

        

         上面代码中,对象obj1的原型对象是obj2foo属性不是obj1自身的属性,而是继承自obj2的属性,解构赋值可以取到这个属性。

      默认值

        对象的解构也可以指定默认值。

        

         默认值生效的条件是,对象的属性值严格等于undefined

      注意点

        (1)如果要将一个已经声明的变量用于解构赋值,必须非常小心。

        

         上面代码的写法会报错,因为 JavaScript 引擎会将{x}理解成一个代码块,从而发生语法错误。只有不将大括号写在行首,避免 JavaScript 将其解释为代码块,才能解决这个问题。

        

         上面代码将整个解构赋值语句,放在一个圆括号里面,就可以正确执行。关于圆括号与解构赋值的关系,参见下文。

        (2)解构赋值允许等号左边的模式之中,不放置任何变量名。因此,可以写出非常古怪的赋值表达式。

        

         上面的表达式虽然毫无意义,但是语法是合法的,可以执行。

        (3)由于数组本质是特殊的对象,因此可以对数组进行对象属性的解构。

        

         上面代码对数组进行对象解构。数组arr0键对应的值是1[arr.length - 1]就是2键,对应的值是3。方括号这种写法,属于“属性名表达式”。

    3. 字符串解构赋值

        字符串也可以解构赋值。这是因为此时,字符串被转换成了一个类似数组的对象。

        

         类似数组的对象都有一个length属性,因此还可以对这个属性解构赋值。

    4. 数值和布尔值的解构赋值

        解构赋值时,如果等号右边是数值和布尔值,则会先转为对象。

         

        上面代码中,数值和布尔值的包装对象都有toString属性,因此变量s都能取到值。

        解构赋值的规则是,只要等号右边的值不是对象或数组,就先将其转为对象。由于undefinednull无法转为对象,所以对它们进行解构赋值,都会报错。

    5. 函数参数解构赋值

        函数的参数也可以解构赋值

        

     

         上面代码中,函数add的参数表面上是一个数组,但在传入参数的那一刻,数组参数就被解构成变量xy。对于函数内部的代码来说,它们能感受到的参数就是xy

        函数参数的解构也可以使用默认值。

        

     

         上面代码中,函数 add 的参数是一个对象,通过对这个对象进行解构,得到变量xy的值。如果解构失败,xy等于默认值。

        注意,下面的写法会得到不一样的结果。

        

        上面代码是为函数move的参数指定默认值,而不是为变量xy指定默认值,所以会得到与前一种写法不同的结果。

        undefined就会触发函数参数的默认值。

    6. 圆括号问题

      不能使用圆括号的情况

        以下三种情况不能使用圆括号

        (1)变量声明语句

        

     

         变量声明语句,模式不能使用圆括号。

        (2)函数参数

        函数参数也属于变量声明,因此不能带有圆括号。

        

     

         (3)赋值语句模式

        

     

       可以使用圆括号的情况

        可以使用圆括号的情况只有一种:赋值语句的非模式部分,可以使用圆括号。

        

     

         上面三行语句都可以正确执行,因为首先它们都是赋值语句,而不是声明语句;其次它们的圆括号都不属于模式的一部分。

        第一行语句中,模式是取数组的第一个成员,跟圆括号无关;

        第二行语句中,模式是p,而不是d

        第三行语句与第一行语句的性质一致。

    7. 用途

      (1)交换变量的值

        

     

      (2)从函数返回多个值

        函数只能返回一个值,如果想返回多个值就要放在一个数组或对象中返回,解构赋值方便了取这些值。

        

     

      (3)函数参数的定义

        解构赋值可以方便地将一组参数与变量名对应起来。

        

     

      (4)提取 json 数据

        

    posted on 2019-09-26 09:50  duerduer 阅读( ...) 评论( ...) 编辑 收藏

    转载于:https://www.cnblogs.com/g-1024/p/11552063.html

    展开全文
  • Es6解构赋值

    2020-12-16 21:18:56
    es6解构赋值 定义: 解构赋值就是从目标对象或数组中提取自己想要的变量。最常用的场景是:element-ui,vant-ui按需引入,请求接口返回数据,提取想要数据。 语法: //数组结构 var a, b, rest; [a, b] = [10, 20]; ...

    es6解构赋值
    定义:
    解构赋值就是从目标对象或数组中提取自己想要的变量。最常用的场景是:element-ui,vant-ui按需引入,请求接口返回数据,提取想要数据。

    语法:

    数组结构

    var a, b, rest;
    [a, b] = [10, 20];
    console.log(a); // 10
    console.log(b); // 20
    

    对象解构

    ({ a, b } = { a: 10, b: 20 });
    console.log(a); // 10
    console.log(b); // 20
    

    …rest 解构数组

    [a, b, ...rest] = [10, 20, 30, 40, 50];
    console.log(a); // 10
    console.log(b); // 20
    console.log(rest); // [30, 40, 50]
    

    …rest 解构对象(最新)

    ({a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40});
    console.log(a); // 10
    console.log(b); // 20
    console.log(rest); // {c: 30, d: 40}
    

    解析一个从函数返回

    function f() {
      return [1, 2];
    }
    
    var a, b; 
    [a, b] = f(); 
    console.log(a); // 1
    console.log(b); // 2
    

    更多应用场景

    默认值

    var a, b;
    
    [a=5, b=7] = [1];
    console.log(a); // 1
    console.log(b); // 7
    

    交换变量

    var a = 1;
    var b = 3;
    
    [a, b] = [b, a];
    console.log(a); // 3
    console.log(b); // 1
    

    忽略你不感兴趣的返回值

    function f() {
      return [1, 2, 3];
    }
    
    var [a, , b] = f();
    console.log(a); // 1
    console.log(b); // 3
    

    将剩余数组赋值给一个变量
    当解构一个数组时,可以使用剩余模式,将数组剩余部分赋值给一个变量。

    var [a, ...b] = [1, 2, 3];
    console.log(a); // 1
    console.log(b); // [2, 3]
    

    给新的变量名赋值
    可以从一个对象中提取变量并赋值给和对象属性名不同的新的变量名。

    var o = {p: 42, q: true};
    var {p: foo, q: bar} = o;
     
    console.log(foo); // 42 
    console.log(bar); // true
    

    For of 迭代和解构

    var people = [
      {
        name: 'Mike Smith',
        family: {
          mother: 'Jane Smith',
          father: 'Harry Smith',
          sister: 'Samantha Smith'
        },
        age: 35
      },
      {
        name: 'Tom Jones',
        family: {
          mother: 'Norah Jones',
          father: 'Richard Jones',
          brother: 'Howard Jones'
        },
        age: 25
      }
    ];
    
    for (var {name: n, family: {father: f}} of people) {
      console.log('Name: ' + n + ', Father: ' + f);
    }
    
    // "Name: Mike Smith, Father: Harry Smith"
    // "Name: Tom Jones, Father: Richard Jones"
    

    ES6中的 class继承

    父类(基类)

    子类

    extends 关键字

    class 相当于es5中构造函数 class中定义方法时,前后不能加function,全部定义在class的protopyte属性中
    class中定义的所有方法是不可枚举的 class中只能定义方法,不能定义对象,变量等 class和方法内默认都是严格模式
    es5中constructor为隐式属性

    父类

    class People{
      constructor(name='wang',age='27'){
        this.name = name;
        this.age = age;
      }
      eat(){
        console.log(`${this.name} ${this.age} eat food`)
      }
    }
    

    子类
    通过extends 继承父类

    class Woman extends People{ 
       constructor(name = 'ren',age = '27'){ 
         //继承父类属性
         super(name, age); 
       } 
        eat(){ 
         //继承父类方法
          super.eat() 
        } 
    } 
    let wonmanObj=new Woman('xiaoxiami'); 
    wonmanObj.eat();
    
    展开全文
  • ES6解构赋值实例详解

    2020-08-28 23:41:24
    主要介绍了ES6解构赋值,结合实例形式较为详细的分析了ES6结构赋值的基本概念、原理与使用方法,需要的朋友可以参考下
  • 主要介绍了ES6解构赋值的功能与用途,结合实例形式分析了ES6结构赋值针对函数参数、赋值、json等相关操作使用技巧,需要的朋友可以参考下
  • ES6 解构赋值

    2019-12-02 19:01:13
    解构赋值是两个名词:解构,赋值 解构的意义:使数据访问更便捷 对象和数组字面量是js中两种最常用的数据结构,在实际的编码过程中我们常常会定义使用它们,然后有组织的从中提取相关的信息片段,ES6 语法添加了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,635
精华内容 9,054
关键字:

es6解构赋值