const对象解析赋值-箭头函数用法-Object.keys、Object.values、Object.entries、Object.assign

1、const的对象解析赋值

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

let { bar, foo } = { foo: 'aaa', bar: 'bbb' };
foo // "aaa"
bar // "bbb"

let { baz } = { foo: 'aaa', bar: 'bbb' };
baz // undefined

如果解构失败，变量的值等于undefined。等号右边的对象没有foo属性，所以变量foo取不到值，所以等于undefined。

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

let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
baz // "aaa"

let obj = { first: 'hello', last: 'world' };
let { first: f, last: l } = obj;
f // 'hello'
l // 'world'

这实际上说明，对象的解构赋值是下面形式的简写

let { foo: foo, bar: bar } = { foo: 'aaa', bar: 'bbb' };

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

let { foo: baz } = { foo: 'aaa', bar: 'bbb' };
baz // "aaa"
foo // error: foo is not defined

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

原文来自：https://es6.ruanyifeng.com/#docs/destructuring

第二种方式：箭头函数用法 

export default class PageView extends Component {
   onScrollToUpper() {}
   render() {
       <ScrollView  onScrollToUpper={this.onScrollToUpper.bind(this)}></ScrollView>
   }
}

或者此用法也可以

export default class PageView extends Component {
   // or 使用箭头函数
   onScrollToUpper = () => {}
   render() {
       // 使用箭头函数的时候 可以这样写
       <ScrollView  onScrollToUpper={this.onScrollToUpper}></ScrollView>
   }
}

 再可用法也可以

export default class PageView extends Component {
  constructor(props) {
    super(props);
    this.state={};
     this.onScrollToUpper=this.onScrollToUpper.bind(this)
  }
   onScrollToUpper() {}
   render() {
       // 使用箭头函数的时候 可以这样写
       <ScrollView  onScrollToUpper={this.onScrollToUpper}></ScrollView>
   }
}

 第三种方式：Object.keys方法：返回一个遍历器对象，用来遍历所有的键名

ES6 的数组、Set、Map 都部署了以下三个方法，调用后都返回遍历器对象。

• entries() 返回一个遍历器对象，用来遍历[键名, 键值]组成的数组。对于数组，键名就是索引值；对于 Set，键名与键值相同。Map 结构的 Iterator 接口，默认就是调用entries方法。
• keys() 返回一个遍历器对象，用来遍历所有的键名。
• values() 返回一个遍历器对象，用来遍历所有的键值。

在实际开发中，我们有时需要知道对象的所有属性;
ES5 引入了Object.keys方法，成员是参数对象自身的（不含继承的）所有可遍历（ enumerable ）属性的键名。

传入对象，返回属性名

var data={a:1,b:2,c:9,d:4,e:5};
    console.log(Object.keys(data));//["a", "b", "c", "d", "e"]
    Object.keys(data).map((key,item)=>{
        console.log(key,data[key]);//key=>属性名    data[key]=>属性值
});

传入字符串，返回索引

var str = 'ab1234';
console.log(Object.keys(obj));  //[0,1,2,3,4,5]

传入数组 返回索引

var arr = ["a", "b", "c"];
    console.log(Object.keys(arr)); // console: ["0", "1", "2"]

Object.entries()

Object.entries() 方法返回一个给定对象自身可枚举属性的键值对数组，其排列与使用 for...in 循环遍历该对象时返回的顺序一致（区别在于 for-in 循环也枚举原型链中的属性）。

通俗点就是 Object.entries() 可以把一个对象的键值以数组的形式遍历出来，结果和 for...in 一致，但不会遍历原型属性。

传入对象

const obj = { foo: 'bar', baz: 'abc' }; 
console.log(Object.entries(obj));  // [['foo', 'bar'], ['baz', 'abc']]

传入数组

const arr = [1, 2, 3]; 
console.log(Object.entries(arr));  // [['0', 1], ['1', '2'], ['2', '3']]

传入数组（数组中包含对象）

const arr1 = [{ a: 1 }, 2, 3]; 
console.log(Object.entries(arr1));  // [['0', { a: 1 }], ['1', '2'], ['2', '3']]

传入数组（数组中的值全部为对象）

const arr2 = [{ a: 1 }, { b: 2 }, { c: 3 }]; 
console.log(Object.entries(arr2));  // [['0', { a: 1 }], ['1', { b: 2 }], ['2', { c: 3 }]]

传入字符串

const str = '123'; 
console.log(Object.entries(str));  // [['0', '1'], ['1', '2'], ['2', '3']]

Object.values()：方法返回一个给定对象自己的所有可枚举属性值的数组，值的顺序与使用for...in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

<script>
    var obj = {
        10: 'a',
        1: 'b',
        2: 'c'
    };
    console.log(Object.values(obj));
    // ['b', 'c', 'a']

    var obj1 = {
        0: 'a',
        1: 'b',
        2: 'c'
    };
    console.log(Object.values(obj1));
    // ['a', 'b', 'c']
</script>

 Object.assign：方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。第一个参数是目标对象，后面的参数都是源对象。

注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

const target = { a: 1, b: 1 };

const source1 = { b: 2, c: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}

 

 

第四种方式：forEach与for ... in 、for...of比较

数组提供内置的forEach方法，缺点：无法中途跳出forEach循环，break命令或return命令都不能奏效。

myArray.forEach(function (value) {
  console.log(value);
});

for...in循环主要是为遍历对象而设计的，不适用于遍历数组

for...of 不同于forEach方法，它可以与break、continue和return配合使用。优点：使用break语句跳出for...of循环

for (var n of fibonacci) {
  if (n > 1000)
    break;
  console.log(n);
}

 

第五种方式：filter方式

ES5 对空位的处理，已经很不一致了，大多数情况下会忽略空位。

• forEach(), filter(), reduce(), every() 和some()都会跳过空位。
• map()会跳过空位，但会保留这个值
• join()和toString()会将空位视为undefined，而undefined和null会被处理成空字符串。

// forEach方法
[,'a'].forEach((x,i) => console.log(i)); // 1

// filter方法
['a',,'b'].filter(x => true) // ['a','b']

// every方法
[,'a'].every(x => x==='a') // true

// reduce方法
[1,,2].reduce((x,y) => x+y) // 3

// some方法
[,'a'].some(x => x !== 'a') // false

// map方法
[,'a'].map(x => 1) // [,1]

// join方法
[,'a',undefined,null].join('#') // "#a##"

// toString方法
[,'a',undefined,null].toString() // ",a,,"

ES6 则是明确将空位转为undefined

 

第六种方式：数组实例的 find() 和 findIndex()

find方法：用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined

[1, 4, -5, 10].find((n) => n < 0)
// -5

面代码找出数组中第一个小于 0 的成员。

[1, 5, 10, 15].find(function(value, index, arr) {
  return value > 9;
}) // 10

findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1

[1, 5, 10, 15].findIndex(function(value, index, arr) {
  return value > 9;
}) // 2