通常交换两个变量的方法需要一个额外的临时变量,来看看例子:
let a = 1;
let b = 2;
let temp;
temp = a;
a = b;
b = temp;
a; // => 2
b; // => 1
temp是一个临时变量,它先保存a的值。然后把b的值赋值给a,接着将temp值赋给 b。
如果使用解构的方式会更简单,不需要什么鬼的 temp 变量。
let a = 1;
let b = 2;
[a, b] = [b, a];
a; // => 2
b; // => 1
[a,b] = [b,a]是解构赋值,右边,创建了一个数组[b, a],即[2,1]。这个数组2被赋值了给a,1被赋值给了b。
虽然这种方式也创建了临时数组,但这种方式给看起来至少更简洁,使用解构咱们还可以交换2个以上的变量。
let zero = 2;
let one = 1;
let two = 0;
[zero, one, two] = [two, one, zero];
zero; // => 0
one; // => 1
two; // => 2
有种场景,咱们可能有一个为空的项数组。并且希望访问数组的第一个、第二个或第n个项,但如果该项不存在,则使用指定默认值。
通常会使用数组的length属性来判断
const colors = [];
let firstColor = 'white';
if (colors.length > 0) {
firstColor = colors[0];
}
firstColor; // => 'white'
使用数组解构,可以更简洁的实现同样的效果:
const colors = [];
const [firstColor = 'white'] = colors;
firstColor; // => 'white'
const [firstColor = 'white'] = colors 解构将colors数组的第一个元素赋给firstColor变量。如果数组在索引0处没有任何元素,则分配“white”默认值。
当然还可以更灵活,如果只想访问第二个元素,可以这么做。
const colors = [];
const [, secondColor = 'black'] = colors;
secondColor; // => 'black'
注意解构左侧的逗号:它表示忽略第一个元素,secondColor使用colors数组中索引为1的元素进行赋值。
当我开始使用react和Redux时,被迫编写了一些遵守不可变性的代码。虽然一开始有些困难,但后来我看到了它的好处:更容易处理单向数据流。
不变性要求不能改变原始对象。幸运的是,解构可以以不可变的方式轻松实现某些操作。
const numbers = [1, 2, 3];
const [, ...fooNumbers] = numbers;
fooNumbers; // => [2, 3]
numbers; // => [1, 2, 3]
解构 [, ... fooNumbers] = numbers创建一个新的数组fooNumbers,fooNumbers 包含 numbers 元素,除了第一个元素。
numbers 数组没有发生变化,保持操作不变性。
以同样不可变的方式,可以从对象中删除属性,接着试着从对象big中删除foo属性:
const big = {
foo: 'value Foo',
bar: 'value Bar'
};
const { foo, ...small } = big;
small; // => { bar: 'value Bar' }
big; // => { foo: 'value Foo', bar: 'value Bar' }
在前面几个例子中,对数组使用了解构,但是咱们可以对任何实现可迭代协议( iterable protocol)的对象进行解构。
许多原生基本类型和对象都是可迭代的: array, string, typed arrays, set 和 map。
如果不想局限于基本类型,通过实现可迭代协议,可以定制解构逻辑。
movies包含一个movie对象列表。在解构movies时,将title作为字符串获取是非常棒的。让咱们实现一个自定义迭代器。
const movies = {
list: [
{ title: 'Heat' },
{ title: 'Interstellar' }
],
[Symbol.iterator]() {
let index = 0;
return {
next: () => {
if (index < this.list.length) {
const value = this.list[index++].title;
return { value, done: false };
}
return { done: true };
}
};
}
};
const [firstMovieTitle] = movies;
console.log(firstMovieTitle); // => 'Heat'
movies对象通过定义Symbol.iterator方法来实现可迭代协议,迭代器迭代title。
遵循iterable协议允许将movies对象分解为title,具体方法是读取第一个movies的title:const [firstMovieTitle] = movies。
根据经验,通过属性对对象进行解构比数组解构更常见。
对象的解构看起来很更简单:
const movie = { title: 'Heat' };
const { title } = movie;
title; // => 'Heat'
const {title} = movie创建一个变量title,并将属性movie.title的值赋给它。
到对象解构时,我有点惊讶于咱们不必静态地知道属性名,可以使用动态属性名称来解构对象。
为了了解动态解构如何工作的,编写一个greet函数:
function greet(obj, nameProp) {
const { [nameProp]: name = 'Unknown' } = obj;
return `Hello, ${name}!`;
}
greet({ name: 'Batman' }, 'name'); // => 'Hello, Batman!'
greet({ }, 'name'); // => 'Hello, Unknown!'
使用2个参数调用greet() 函数:对象和属性名称。
在greet()内部,解构赋值const {[nameProp]:name ='Unknown'} = obj使用方括号的形式 [nameProp]读取动态属性名称,name变量接收动态属性值。
更好的做法是,如果属性不存在,可以指定默认值“Unknown”。
解构可以用在函数传递参数的过程中。我先先来看一下没有用到解构参数的例子,之后我们把它改造成解构参数。在这个例子里面我们使用解构参数改写了函数声明
交换变量:通常交换两个变量的方法需要一个额外的临时变量,来看看例子;访问数组中元素有种场景,咱们可能有一个为空的项数组。并且希望访问数组的第一个、第二个或第n个项
解构的同时赋予初始值(使用 =),2.使用的变量名与解构目标的key不一致或要使用多个变量(使用 : ),解构中的 rest(变量由多变少) 与spread(变量由少变多)
解构:从数组和对象中提取值,对变量进行赋值。数组的解构赋值1.数组的元素是按次序排列的,变量的取值由它的位置决定;对象的解构赋值1.对象的属性没有次序,变量必须与属性同名,才能取到正确的值。
解构的作用:简化书写长度,提升开发效率。在开发中我们常用到使用ajax请求数据,并且把数据渲染到页面上。可能这个数据返回的对象或数组。
解构: ES6 中允许按照一定的模式从数组和对象中提取值,然后对变量进行赋值,这被称为解构(Destructuring).本质上,这种写法属于“模式匹配”,只要等号两边的模式相同,左边的变量就会被赋予相应的值。
ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构。它在语法上比ES5所提供的更加简洁、紧凑、清晰。它不仅能减少你的代码量,还能从根本上改变你的编码方式。
解构可以用于数组,还可以用于对象。对象的解构赋值,可以很方便地将现有对象的方法,赋值到某个变量。
es6新增了一种从数组或者对象中获取指定元素的方式,这种方式就是我们今天要说的解构。在有解构之前呢,我们获取数组中的指定元素通常是根据索引去做的:
相比于传统方法需要一个额外变量来进行值交换,使用解构进行值交换十分方便。但是我想到几个问题:解构赋值有没有节省空间呢?
内容以共享、参考、研究为目的,不存在任何商业目的。其版权属原作者所有,如有侵权或违规,请与小编联系!情况属实本人将予以删除!