精华内容
下载资源
问答
  • 主要介绍了解决VUEX的mapState/...mapState等取值问题,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了解决Vue 给mapState中定义的属性赋值报错的问题,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了Vuex modules 模式下 mapState/mapMutations 的操作实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • ,那其实除了和vue的生命周期有关以外,还跟store取值的方式有关,下面就说一下新大陆之——mapState mapMutations mapGetters的使用 简单说一下我对mapState的理解,字面意思就是把store中state 的值遍历出来,任你...
  • 本篇文章主要介绍了详解Vuex中mapState的具体用法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了vuex state及mapState的基础用法详解,本文通过实例代码相结合的形式给大家介绍的非常详细,需要的朋友跟随
  • 然后在开发中,数据仓库这块懵逼了, 引入的vuex的辅助函数mapState、mapGetters、mapMutations、mapActions等怎么就不能用呢。苦恼之际打开D盘,一番愉悦之后,终于想通啦… 问题分析 •vuex辅助函数  首先简单说...
  • 在vuex中有四大金刚分别是State, Mutations,Actions,Getters,本文对这四大金刚做了详细介绍,本文重点是给大家介绍vuex中的 mapState,mapGetters,mapActions,mapMutations 的使用,感兴趣的朋友一起看看吧
  • MapState[K, V]保存Key-Value对。 MapState.get(key: K) MapState.put(key: K, value: V) MapState.contains(key: K) MapState.remove(key: K) 实例一:  去重计算应该是数据分析业务里面常见的指标计算,例如...

    声明:本系列博客是根据SGG的视频整理而成,非常适合大家入门学习。

    《2021年最新版大数据面试题全面开启更新》

     

    MapState[K, V]保存Key-Value对。

    • MapState.get(key: K)
    • MapState.put(key: K, value: V)
    • MapState.contains(key: K)
    • MapState.remove(key: K)

    实例一:

      去重计算应该是数据分析业务里面常见的指标计算,例如网站一天的访问用户数、广告的点击用户数等等,离线计算是一个全量、一次性计算的过程通常可以通过distinct的方式得到去重结果,而实时计算是一种增量、长期计算过程,我们在面对不同的场景,例如数据量的大小、计算结果精准度要求等可以使用不同的方案。

      此篇介绍如何通过编码方式实现精确去重,以一个实际场景为例:计算每个广告每小时的点击用户数,广告点击日志包含:广告位ID、用户设备ID(idfa/imei/cookie)、点击时间。

    实现步骤分析:

    • 为了当天的数据可重现,这里选择事件时间也就是广告点击时间作为每小时的窗口期划分
    • 数据分组使用广告位ID+点击事件所属的小时
    • 选择processFunction来实现,一个状态用来保存数据、另外一个状态用来保存对应的数据量
    • 计算完成之后的数据清理,按照时间进度注册定时器清理

    广告数据

    case class AdData(id:Int,devId:String,time:Long)

    分组数据

    case class AdKey(id:Int,time:Long)

    主流程

    val env=StreamExecutionEnvironment.getExecutionEnvironment
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    
    val kafkaConfig=new Properties()
    kafkaConfig.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"localhost:9092")
    kafkaConfig.put(ConsumerConfig.GROUP_ID_CONFIG,"test1")
    
    val consumer=new FlinkKafkaConsumer[String]("topic1",new SimpleStringSchema,kafkaConfig)
    val ds=env.addSource(consumer)
            .map(x=>{
                    val s=x.split(",")
                    AdData(s(0).toInt,s(1),s(2).toLong)
                    }
                ).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[AdData](Time.minutes(1)){
                    override def extractTimestamp(element: AdData): Long = element.time
                })
          .keyBy(x=>{
                val endTime= 
                TimeWindow.getWindowStartWithOffset(x.time, 0, Time.hours(1).toMilliseconds)+Time.hours(1).toMilliseconds
                AdKey(x.id,endTime)
          })

      指定时间时间属性,这里设置允许1min的延时,可根据实际情况调整;
      时间的转换选择TimeWindow.getWindowStartWithOffset Flink在处理window中自带的方法,使用起来很方便,第一个参数 表示数据时间,第二个参数offset偏移量,默认为0,正常窗口划分都是整点方式,例如从0开始划分,这个offset就是相对于0的偏移量,第三个参数表示窗口大小,得到的结果是数据时间所属窗口的开始时间,这里加上了窗口大小,使用结束时间与广告位ID作为分组的Key。

    去重逻辑
      自定义Distinct1ProcessFunction 继承了KeyedProcessFunction, 方便起见使用输出类型使用Void,这里直接使用打印控制台方式查看结果,在实际中可输出到下游做一个批量的处理然后在输出;
      定义两个状态:MapState,key表示devId, value表示一个随意的值只是为了标识,该状态表示一个广告位在某个小时的设备数据,如果我们使用rocksdb作为statebackend, 那么会将mapstate中key作为rocksdb中key的一部分,mapstate中value作为rocksdb中的value, rocksdb中value 大小是有上限的,这种方式可以减少rocksdb value的大小;

      另外一个ValueState,存储当前MapState的数据量,是由于mapstate只能通过迭代方式获得数据量大小,每次获取都需要进行迭代,这种方式可以避免每次迭代。

    class Distinct1ProcessFunction extends KeyedProcessFunction[AdKey, AdData, Void] {
    
      var devIdState: MapState[String, Int] = _
      var devIdStateDesc: MapStateDescriptor[String, Int] = _
      var countState: ValueState[Long] = _
      var countStateDesc: ValueStateDescriptor[Long] = _
      
      override def open(parameters: Configuration): Unit = {
        devIdStateDesc = new MapStateDescriptor[String, Int]("devIdState", TypeInformation.of(classOf[String]), TypeInformation.of(classOf[Int]))
        devIdState = getRuntimeContext.getMapState(devIdStateDesc)
        countStateDesc = new ValueStateDescriptor[Long]("countState", TypeInformation.of(classOf[Long]))
        countState = getRuntimeContext.getState(countStateDesc)
      }
    
      override def processElement(value: AdData, ctx: KeyedProcessFunction[AdKey, AdData, Void]#Context, out: Collector[Void]): Unit = {
        val currW=ctx.timerService().currentWatermark()
        if(ctx.getCurrentKey.time+1<=currW) {
            println("late data:" + value)
            return
          }
    
        val devId = value.devId
        devIdState.get(devId) match {
          case 1 => {
            //表示已经存在
          }
    
          case _ => {
            //表示不存在
            devIdState.put(devId, 1)
            val c = countState.value()
            countState.update(c + 1)
            //还需要注册一个定时器
            ctx.timerService().registerEventTimeTimer(ctx.getCurrentKey.time + 1)
          }
        }
        println(countState.value())
      }
    
      override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[AdKey, AdData, Void]#OnTimerContext, out: Collector[Void]): Unit = {
        println(timestamp + " exec clean~~~")
        println(countState.value())
        devIdState.clear()
        countState.clear()
      }
    }

    数据清理通过注册定时器方式ctx.timerService().registerEventTimeTimer(ctx.getCurrentKey.time + 1)表示当watermark大于该小时结束时间+1就会执行清理动作,调用onTimer方法。

    在处理逻辑里面加了

    val currW=ctx.timerService().currentWatermark()
    if(ctx.getCurrentKey.time+1<=currW){
            println("late data:" + value)
            return
      }

    主要考虑可能会存在滞后的数据比较严重,会影响之前的计算结果,做了一个类似window机制里面的一个延时判断,将延时的数据过滤掉,也可以使用OutputTag 单独处理。

     实例二:

      我们知道电商平台会将用户与商品的交互行为收集记录下来,行为数据主要包括几个字段:userId、itemId、categoryId、behavior和timestamp。其中userId和itemId分别代表用户和商品的唯一ID,categoryId为商品类目ID,behavior表示用户的行为类型,包括点击(pv)、购买(buy)、加购物车(cart)、喜欢(fav)等,timestamp记录行为发生时间。本文采用阿里巴巴提供的一个淘宝用户行为数据集,为了精简需要,只节选了部分数据。下面的代码使用MapState[String, Int]记录某个用户某种行为出现的次数。这里读取了数据集文件,模拟了一个淘宝用户行为数据流。

    /**
      * 用户行为
      * categoryId为商品类目ID
      * behavior包括点击(pv)、购买(buy)、加购物车(cart)、喜欢(fav)
      * */
    case class UserBehavior(userId: Long,
                              itemId: Long,
                              categoryId: Int,
                              behavior: String,
                              timestamp: Long)
    
    class MapStateFunction extends RichFlatMapFunction[UserBehavior, (Long, String, Int)] {
    
      // 指向MapState的句柄
      private var behaviorMapState: MapState[String, Int] = _
    
      override def open(parameters: Configuration): Unit = {
        // 创建StateDescriptor
        val behaviorMapStateDescriptor = new MapStateDescriptor[String, Int]("behaviorMap", classOf[String], classOf[Int])
        // 通过StateDescriptor获取运行时上下文中的状态
        behaviorMapState = getRuntimeContext.getMapState(behaviorMapStateDescriptor)
      }
    
      override def flatMap(input: UserBehavior, collector: Collector[(Long, String, Int)]): Unit = {
        var behaviorCnt = 1
        // behavior有可能为pv、cart、fav、buy等
        // 判断状态中是否有该behavior
        if (behaviorMapState.contains(input.behavior)) {
          behaviorCnt = behaviorMapState.get(input.behavior) + 1
        }
        // 更新状态
        behaviorMapState.put(input.behavior, behaviorCnt)
        collector.collect((input.userId, input.behavior, behaviorCnt))
      }
    }
    
    def main(args: Array[String]): Unit = {
    
      val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
      env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
      env.setParallelism(8)
    
      // 获取数据源
      val sourceStream: DataStream[UserBehavior] = env
      .addSource(new UserBehaviorSource("state/UserBehavior-50.csv")).assignTimestampsAndWatermarks(new AscendingTimestampExtractor[UserBehavior]() {
        override def extractAscendingTimestamp(userBehavior: UserBehavior): Long = {
          // 原始数据单位为秒,乘以1000转换成毫秒
          userBehavior.timestamp * 1000
        }
      }                                                                                            )
    
      // 生成一个KeyedStream
      val keyedStream =  sourceStream.keyBy(user => user.userId)
    
      // 在KeyedStream上进行flatMap
      val behaviorCountStream = keyedStream.flatMap(new MapStateFunction)
    
      behaviorCountStream.print()
    
      env.execute("state example")
    }
    
    class UserBehaviorSource(path: String) extends RichSourceFunction[UserBehavior] {
    
      var isRunning: Boolean = true
      // 输入源
      var streamSource: InputStream = _
    
      override def run(sourceContext: SourceContext[UserBehavior]): Unit = {
        // 从项目的resources目录获取输入
        streamSource = MapStateExample.getClass.getClassLoader.getResourceAsStream(path)
        val lines: Iterator[String] = scala.io.Source.fromInputStream(streamSource).getLines
        while (isRunning && lines.hasNext) {
          val line = lines.next()
          val itemStrArr = line.split(",")
          val userBehavior = UserBehavior(itemStrArr(0).toLong, itemStrArr(1).toLong, itemStrArr(2).toInt, itemStrArr(3), itemStrArr(4).toLong)
          sourceContext.collect(userBehavior)
        }
      }
    
      override def cancel(): Unit = {
        streamSource.close()
        isRunning = false
      }
    }

     Keyed State是针对KeyedStream的状态,必须先对一个DataStream进行keyBy操作。在本例中,我们对用户ID进行了keyBy,那么用户ID为1的行为数据共享同一状态数据,以此类推,每个用户ID的行为数据共享自己的状态数据。

      之后,我们需要实现Rich类函数,比如RichFlatMapFunction,或者KeyedProcessFunction等函数类。这些算子函数类都是RichFunction的一种实现,他们都有运行时上下文RuntimeContextRuntimeContext包含了状态数据。 在实现这些算子函数类时,一般是在open方法中声明状态。open是算子的初始化方法,它在实际处理函数之前调用。

      具体到状态的使用,我们首先要注册一个StateDescriptor。从名字中可以看出,StateDescriptor是状态的一种描述,它描述了状态的名字和状态的数据结构。状态的名字可以用来区分不同的状态,一个算子内可以有多个不同的状态,每个状态的StateDescriptor需要设置不同的名字。同时,我们也需要指定状态的具体数据结构,指定具体的数据结构非常重要,因为Flink要对其进行序列化和反序列化,以便进行Checkpoint和必要的恢复。数据结构的类型和序列化机制可以参考我之前的文章:Flink进阶教程:数据类型和序列化机制简介

      在本例中,我们使用val behaviorMapStateDescriptor = new MapStateDescriptor[String, Int]("behaviorMap", classOf[String], classOf[Int])注册了一个MapStateStateDescriptor,key为某种行为,如pv、buy等,数据类型为String,value为该行为出现的次数,数据类型为Int。此外,每种类型的状态都有对应的StateDescriptor,比如MapStateDescriptor对应MapStateValueStateDescriptor对应ValueState

      接着我们通过StateDescriptorRuntimeContext中获取状态句柄。本例中对应的代码为:behaviorMapState = getRuntimeContext.getMapState(behaviorMapStateDescriptor)。状态句柄并不存储状态,它只是Flink提供的一种访问状态的接口,状态数据实际存储在State Backend中。

    使用和更新状态发生在实际的处理函数上,比如RichFlatMapFunction中的flatMap方法,在实现自己的业务逻辑时访问和修改状态,比如通过get方法获取状态。

     

     

     

     

     

     

     

     

     

    展开全文
  • Flink MapState的实践

    2021-09-05 22:40:25
    State通过用来保存中间状态 public class TestWindows extends ... private MapState<Long, Double> mapState = null; @Override public void open(Configuration parameters) throws Exception { //

    State通过用来保存中间状态

    public class TestWindows extends RichWindowFunction<Long, Long, Long, Window> {
      
        private MapState<Long, Double> mapState = null;
    
    
        @Override
        public void open(Configuration parameters) throws Exception {
            //
            super.open(parameters);
            MapStateDescriptor<Long, Double> descriptor = new MapStateDescriptor<Long, Double>("descriptor",
                    TypeInformation.of(Long.class), TypeInformation.of(Double.class));
    
            mapState = getRuntimeContext().getMapState(descriptor);
    
        }
    
        @Override
        public void close() throws Exception {
            super.close();
            mapState = null;
        }
    
       
        @Override
        public void apply(Long aLong, Window window, Iterable<Long> input, Collector<Long> out) throws Exception {
            
            //这里面对state进行查询和修改
            Double oldValue = null;
            try {
                oldValue = mapState.get(aLong);
            } catch (Exception e) {
    
            }
     
    
            mapState.put(aLong, oldValue);
        }
    }
    
    展开全文
  • 按上一章的说明,可以在mapState的参数对象里定义多个属性来批量声明state,如果不需要对state进行额外处理的话,写法还可以进一步简化(新增文件路径为src\components\componentC.vue),代码如下: mapState...

    参考文档:https://vuex.vuejs.org/zh/guide/

    按上一章的说明,可以在mapState的参数对象里定义多个属性来批量声明state,如果不需要对state进行额外处理的话,写法还可以进一步简化(新增文件路径为src\components\componentC.vue),代码如下:

    <template>
        <div>
            <span>mapState简化写法</span>
            <br />
            <span>stete in vuex:{{param1}}</span>
        </div>
    </template>
    
    <script>
    import { mapState } from "vuex";
    export default {
        name: "component-c",
        // computed: mapState({
        //     param1: state => state.param1
        // })
        // 如果不需要对state进行额外处理,上下两种写法是等价的
        computed: mapState(["param1"])
    };
    </script>
    
    <style scoped>
    </style>
    

    如果想定义组件自己的局部计算变量,则需要调整一下写法(新增文件路径为src\components\componentD.vue),代码如下:

    <template>
        <div>
            <span>mapState与计算变量混用</span>
            <br />
            <span>stete in vuex:{{param1}}</span>
        </div>
    </template>
    
    <script>
    import { mapState } from "vuex";
    export default {
        name: "component-d",
        // 实际应用中计算变量还会包含局部计算变量,混用写法如下
        computed: {
            computedParam() {
                return "computedParam";
            },
            ...mapState(["param1"])
        }
    };
    </script>
    
    <style scoped>
    </style>
    

    引用上面创建的component-c和component-d查看效果(修改文件路径为src\main.js),代码如下:

    import Vue from 'vue'
    import store from './store'
    import ComponentA from './components/ComponentA.vue'
    import ComponentB from './components/ComponentB.vue'
    import ComponentC from './components/ComponentC.vue'
    import ComponentD from './components/ComponentD.vue'
    
    new Vue({
        el: '#app',
        store,
        components: { ComponentA, ComponentB, ComponentC, ComponentD },
        template: '<div><component-a></component-a><component-b></component-b><component-c></component-c><component-d></component-d></div>'
    });
    

    运行后查看页面可以看到通过简化写法生成的计算属性和单独定义的没有任何区别。

    展开全文
  • vuex-demo vuex中mapState、mapGetters、mapActions、mapMutations的使用
  • Vuex状态管理-mapState的基本用法详细介绍

    千次阅读 多人点赞 2020-09-30 11:54:02
    为了解决这个问题,我们可以使用 mapState 辅助函数帮助我们生成计算属性,让你少按几次键 mapState接收一个对象 mapState函数的可以接受一个对象Object。对象中可以包含字符串或函数。mapState()函数的返回结果是一...

    使用vuex集中管理状态

    • Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式。它采用集中式存储管理应用的所有组件的状态,并以相应的规则保证状态以一种可预测的方式发生变化
    // store.js
    
    /*
    vuex的核心管理对象模块:store
     */
    import Vue from 'vue'
    import Vuex from 'vuex'
    
    Vue.use(Vuex)
    // 状态对象
    const state = { // 初始化状态 这里放置的状态可以被多个组件共享
      count: 1,
      name: 'daming'
    }
    const mutations = {}
    const action = {}
    const getters = {}
    
    export default new Vuex.Store({
      state, // 状态
      mutations, // 包含多个更新state函数的对象
      actions, // 包含多个队形事件回调函数的对象
      getters // 包含多个getter计算属性函数的对象
    })
    
    
    // main.js
    
    /*
    入口JS
     */
    import Vue from 'vue'
    import App from './App.vue'
    import store from './store'
    
    // 创建vm
    /* eslint-disable no-new */
    new Vue({
      el: '#app',
      components: {App}, // 映射组件标签
      template: '<App/>', // 指定需要渲染到页面的模板
      store // 所有的组件对象都多了一个属性:$store
    })
    

    在组件中获取vuex状态

    虽然将所有的状态放入Vuex,会使状态变化更显式和易调试,但也会使代码变得冗长和不直观。如果有些状态严格属于单个组件,最好还是作为组件的局部状态,比如temp变量,tempcount,tempcount2作为组件的局部状态。

    <!-- App.vue -->
    
    <template>
      <div id="example">
        {{count}}
        {{name}}
        {{nameAlias}}
      </div>
    </template>
    
    <script>
    import { mapState } from 'vuex'   // 引入mapState
    export default {
      data () {
        return {
          // 使用 Vuex 并不意味着你需要将所有的状态放入 Vuex。虽然将所有的状态放到 Vuex 会使状态变化更显式和易调试,但也会使代码变得冗长和不直观。
          // 如果有些状态严格属于单个组件,最好还是作为组件的局部状态。你应该根据你的应用开发需要进行权衡和确定。
          // 下面的temp变量,tempcount,tempcount2作为组件的局部状态
          temp: 'hello',
          tempcount: 1,
          tempcount2: 2
        }
      },
      computed: {
          // tempCountPlusTempCount2 这个计算属性并没有涉及到vuex管理的状态
          tempCountPlusTempCount2() { 
              return this.tempcount+this.tempcount2
          } 
          
          // 由于 Vuex 的状态存储是响应式的,所以可以使用计算属性来获得某个状态
          // 当状态改变时,都会重新求取计算属性,并且触发更新相关联的 DOM
          // 通过下面的计算属性,就可以在当前组件中访问到count,name,nameAlias等了 在模板中我们通过大括号符号打印出来
          
          // 下面的计算属性涉及到了vuex管理的状态
          
    	  count () { // 这实际上是ES6中对象的简化写法 完整写法是 count: function { return this.$store.state.count }
              return this.$store.state.age
          },
          name () { // 这实际上是ES6中对象的简化写法 完整写法是 name: function { return this.$store.state.age }
              return this.$store.state.age
          },
          nameAlias () {
            return this.$store.state.name
          }
          countplustempcount: function (state) {
            return this.tempcount + this.$store.state.count
          },
          countplustempcount2 (state) {
            return this.tempcount2 + this.$store.state.count
          } 
          
          // 但有一个问题
          // 当一个组件需要获取多个状态的时候,将这些状态都声明为计算属性会有些重复和冗余。比如上面的name(),count(),nameAlias(),显得重复,代码冗长
          // 为了解决这个问题,我们可以使用 mapState 辅助函数帮助我们生成计算属性,让你少按几次键:
      }
    }
    </script>
     
    

    但有一个问题,当一个组件需要获取多个状态的时候,将这些状态都声明为计算属性会有些重复和冗余。比如上面的name(),count(),nameAlias(),显得重复,代码冗长。为了解决这个问题,我们可以使用 mapState 辅助函数帮助我们生成计算属性,让你少按几次键

    mapState接收一个对象

    mapState函数的可以接受一个对象Object<string | function>。对象中可以包含字符串或函数。mapState()函数的返回结果是一个对象。

    <template>
      <div id="example">
        {{count}}
        {{name}}
        {{nameAlias}}
      </div>
    </template>
    
    <script>
    import { mapState } from 'vuex'
    export default {
      data () {
        return {
          temp: 'hello',
          tempcount: 1,
          tempcount2: 2
        }
      },
      computed: mapState({
        count: 'count',  // string    映射 this.count 为 store.state.count的值
        // 箭头函数可使代码更简练
        name: (state) => state.name, // function   映射 this.name 为 store.state.name的值
        nameAlias: 'name', // string   映射 this.nameAlias 为 store.state.name的值
        countplustempcount: function (state) { // 用普通函数this指向vue实例,但是在箭头函数中this就不是指向vue实例了,所以这里必须用普通哈数
          return this.tempcount + state.count
        },
        countplustempcount2 (state) {
          return this.tempcount2 + state.count
        }   
      })
    }
    </script>
     
    
    • 我们继续看上面的mapState函数
    computed: mapState({
        count: 'count',  // string    映射 this.count 为 store.state.count的值
        // 箭头函数可使代码更简练
        name: (state) => state.name, // function   映射 this.name 为 store.state.name的值
        nameAlias: 'name', // string   映射 this.nameAlias 为 store.state.name的值
        countplustempcount: function (state) { // 用普通函数this指向vue实例,但是在箭头函数中this就不是指向vue实例了,所以这里必须用普通哈数
          return this.tempcount + state.count
        },
        countplustempcount2 (state) {
          return this.tempcount2 + state.count
        } 
    })
    
    • 上面mapState()函数接收了一个对象。

    对象的第一个属性是string类型的,count: 'count', 这条语句映射出了this.count, 值等于store.state.count的值。

    对象的第二个属性是一个箭头函数,name: (state) => state.name,,映射 this.name 为 store.state.name的值。

    对象的第三个属性是一个string类型,nameAlias: 'name',映射 this.nameAlias 为 store.state.name的值, 和第一个属性的用法本质是一致的,不过这里映射出的计算属性的名称与 state 的子节点名称不同。

    对象的第四个属性是一个普通函数,普通函数和箭头函数的不同之处在于,普通函数中的this指向了vue实例,因为可以访问到当前组件的局部状态,比如this.tempcount。

    对象的第五个属性是一个普通函数,第五个和第四个的用法本质是一样的,只不过第五个用了ES6中对象的简化写法。

    • 上面的mapState函数的返回值是一个对象,我们可以看作是这样的
    computed:
    { // 这个对象就是mapState的返回值
        count () {
           return this.$store.state.count
        },
        name () {
            return this.$store.state.name
        }
        nameAlias () {
            return this.$store.state.name
        }
        countplustempcount: function (state) {
          return this.tempcount + this.$store.state.count
        },
        countplustempcount2 (state) {
          return this.tempcount2 + this.$store.state.count
        } 
    }
    

    把这个对象赋值给computed不就和原始的写法一样了吗,所以mapState起到了简化的作用。但是我们可以发现比起直接给computed赋值,这里少了tempCountPlusTempCount2这个计算属性。tempCountPlusTempCount2不是有vuex状态计算而来的,是根据组件内的局部状态计算来的。

    mapState函数结合对象的扩展运算符运算符使用

    对象的扩展运算符(...)用于取出参数对象的所有可遍历属性,拷贝到当前对象之中。为什么要用扩展运算符呢,我们观察到上面直接将mapState函数的返回值赋给computed对象的话,那么computed中就只有对vuex状态的获取,而没有了当前组件的局部状态,比如tempCountPlusTempCount2就没地方放了,所以我们用扩展运算符。

    let z = { a: 3, b: 4 };
    let n = { ...z }; // 对象的扩展运算符(...)用于取出参数对象的所有可遍历属性,拷贝到当前对象之中
    n // { a: 3, b: 4 }
    

    所以利用扩展运算符将下面mapState函数的返回值对象

    computed:{
        ...mapState({
            count: 'count',  // string    映射 this.count 为 store.state.count的值
            // 箭头函数可使代码更简练
            name: (state) => state.name, // function   映射 this.name 为 store.state.name的值
            nameAlias: 'name', // string   映射 this.nameAlias 为 store.state.name的值
            countplustempcount: function (state) { // 用普通函数this指向vue实例,但是在箭头函数中this就不是指向vue实例了,所以这里必须用普通哈数
              return this.tempcount + state.count
            },
            countplustempcount2 (state) {
              return this.tempcount2 + state.count
            } 
        })
    }
    

    上面的结果

    computed:{
    	count () {
           return this.$store.state.count
        },
        name () {
            return this.$store.state.name
        }
        nameAlias () {
            return this.$store.state.name
        }
        countplustempcount: function (state) {
          return this.tempcount + this.$store.state.count
        },
        countplustempcount2 (state) {
          return this.tempcount2 + this.$store.state.count
        } 
    }
    

    于是可以将组将内的计算属性和获取vuex状态的计算属性写在一起了。

    computed:{
        tempCountPlusTempCount2() { 
              return this.tempcount+this.tempcount2
        }, 
        ...mapState({
            count: 'count',  // string    映射 this.count 为 store.state.count的值
            // 箭头函数可使代码更简练
            name: (state) => state.name, // function   映射 this.name 为 store.state.name的值
            nameAlias: 'name', // string   映射 this.nameAlias 为 store.state.name的值
            countplustempcount: function (state) { // 用普通函数this指向vue实例,但是在箭头函数中this就不是指向vue实例了,所以这里必须用普通哈数
              return this.tempcount + state.count
            },
            countplustempcount2 (state) {
              return this.tempcount2 + state.count
            } 
        })
    }
    

    这就是mapState的基本用法。

    mapState函数接受一个数组

    当映射的计算属性的名称与 state 的子节点名称相同时,我们也可以给 mapState 传一个字符串数组。

    computed: mapState([
      // 映射 this.count 为 store.state.count
      'count',
      'name'
    ])
    

    上面的写法可以看作

    computed: {
        count () {
           return this.$store.state.count
        },
        name () {
            return this.$store.state.name
        }
    }
    

    最终版的mapState

    computed: {
        tempCountPlusTempCount2() { 
              return this.tempcount+this.tempcount2
        }, 
        ...mapState(['count','name']),
        ...mapState({
            nameAlias: 'name', // string   映射 this.nameAlias 为 store.state.name的值
            countplustempcount: function (state) { // 用普通函数this指向vue实例,但是在箭头函数中this就不是指向vue实例了,所以这里必须用普通哈数
              return this.tempcount + state.count
            },
            countplustempcount2 (state) {
              return this.tempcount2 + state.count
            } 
        })
    }
    
    展开全文
  • Flink MapState TTL public class IopvDeduplicateProcessFunction extends RichFlatMapFunction<FundIopvIndicators, FundIopvIndicators> { private MapState<String, FundIopvIndicators> mapState;...
  • Vuex实践-mapState和mapGetters

    千次阅读 2020-01-14 12:34:23
     本文章是vuex系列的最后一篇,主要总结的是如何使用mapState和mapGetters访问vuex中的state和getters。 二.多个模块中mapState和mapGetters的使用  上一篇文章《Vuex实践(中)》里面我们总结的就是多模块的...
  • 1、mapState辅助函数 mapState是什么? 表面意思:mapState是state的辅助函数.这么说可能很难理解 抽象形容:mapState是state的语法糖,这么说可能你还想骂我,因为你根本不了解什么叫做语法糖,事实上我说的语法糖有...
  • 当然computed不会因为引入mapState辅助函数而失去原有的功能—用于扩展当前vue的data,只是写法会有一些奇怪,如果你已经写了一大堆的computed计算属性,做了一半发现你要引入vuex,还想使用mapState辅助函数的方便,你...
  • Flink-KeyedState-MapState结合Window进行使用
  • mapState

    2018-03-13 17:10:00
    store.js import Vue from 'vue' import Vuex from 'vuex' Vue.use(Vuex) const store = new Vuex.Store({ state: { count: 0 }, mutations: { increment (state) { state.count++ ...
  • let MapState = mapState({ count: 'count', sex: (state) => state.sex }) let json = { 'a': '我是json自带的', ...MapState } console.log(json) 这里的json可以成功将mapState return的json格式,和json自带的a...
  • mapState的实现

    2020-12-27 23:58:38
    首先,vuex暴露的就是这些接口,export default {Store, install, mapState, mapMutations, mapGetters, mapActions,createNamespacedHelpers} ,看看mapState的实现方式 1.mapState源码中,有一个函数normalizeMap,...
  • mapState 辅助函数

    千次阅读 2019-08-12 14:01:23
    为了解决这个问题,我们可以使用mapState辅助函数帮助我们生成计算属性,让你少按几次键: mapState是什么? 表面意思:mapState是state的辅助函数.这么说可能很难理解 抽象形容:mapState是state的语法糖,这么说...
  • mapState是state的辅助函数.这么说可能很难理解 抽象形容: mapState是state的语法糖,这么说可能你还想骂我,因为你根本不了解什么叫做语法糖,事实上我说的语法糖有自己的定义,什么是语法糖?我对语法糖的理解就是,用...
  • Flink MapState TTL

    2021-01-09 16:52:42
    Flink MapState TTLFlink MapState的失效时间是针对整个map还是单个key?Flink MapState 使用MapState 失效时间验证 Flink MapState的失效时间是针对整个map还是单个key? Flink MapState 使用 flink MapState 引入...
  • mapState的封装 模块

    2021-09-17 23:27:22
  • Vuex中mapState的用法

    2021-10-07 21:20:17
    今天遇到一个吭,最后使用vue mapState得以解决。 之前有说过使用mapState语法糖,在这里直接用computed返回竟然不行。然后在官网有看到相关说明:进入官网。 下面介绍一下mapState的用法。 computed: { ......

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,251
精华内容 5,300
关键字:

mapstate