精华内容
下载资源
问答
  • windows store安装包

    2018-07-16 09:36:09
    windows store安装包,适合某些没有win store的win版本
  • .DS_Store文件泄漏利用python脚本,自动检测下载.DS_Store类型泄露源码。
  • 解决win10专业版没有应用商店,使用 Windows PowerShell命令行无法安装
  • vuex中的Store

    千次阅读 2020-07-07 08:52:45
    在了解Store之前,我们先来看看Vuex是个什么东西。Vuex本质上就是一个Vue.js的插件,是用于对复杂应用进行状态管理用的,打印Vuex以后输出: { ​ Store: function Store(){}, ​ mapActions: function(){}, // ...

    1. Vuex是什么

    在了解Store之前,我们先来看看Vuex是个什么东西。Vuex本质上就是一个Vue.js的插件,是用于对复杂应用进行状态管理用的,打印Vuex以后输出:

    {
    
    ​ Store: function Store(){},
    
    ​ mapActions: function(){}, // 对应Actions的结果集
    
    ​ mapGetters: function(){}, // 对应Getters的结果集
    
    ​ mapMutations: function(){}, // 对应Mutations的结果集
    
    ​ mapState: function(){}, // 对应State的结果集
    
    ​ install: function install(){},
    
    ​ installed: true
    
    }

    Vuex和单纯的全局对象有以下两点不同:

    • Vuex的状态存储是响应式的。当Vue 组件从 Store 中读取状态的时候,若 Store 中的状态发生变化,那么相应的组件也会相应地得到高效更新。
    • 不能直接改变 Store 中的状态。改变Store 中的状态的唯一途径就是显式地提交 mutation

    2. Store

    每一个Vuex应用的核心就是Store(仓库),我们可以说Store是一个容器,Store里面的状态与单纯的全局变量是不一样的,无法直接改变Store中的状态。想要改变Store中的状态,只有一个办法,显式地提交mutation。

    3. 一个完整的Store结构

    const store = new Vuex.Store({
      state: {
        // 存放状态
      },
      getters: {
        // state的计算属性
      },
      mutations: {
        // 更改state中状态的逻辑,同步操作
      },
      actions: {
        // 提交mutation,异步操作
      },
      // 如果将store分成一个个的模块的话,则需要用到modules。
       //然后在每一个module中写state, getters, mutations, actions等。
      modules: {
        a: moduleA,
        b: moduleB,
        // ...
      }
    });

    4. 状态管理的几个核心概念

    1. state

    state是状态数据,可以通过this.$store.state来直接获取状态,也可以利用vuex提供的mapState辅助函数将state映射到计算属性(computed)中去。用data接收的值不能及时响应更新,用computed就可以:

    export default {
      data () {
        return {
          dataCount: this.$store.state.count //用data接收
        }
      },
      computed:{
        count(){
          return this.$store.state.count //用computed接收
        }
      }
    }
    

    mapState 辅助函数:

    mapState是state的语法糖,当一个组件需要获取多个状态时候,将这些状态都声明为计算属性会有些重复和冗余。为了解决这个问题,我们可以使用 mapState 辅助函数帮助我们生成计算属性,让你少按几次键:

    // 在单独构建的版本中辅助函数为 Vuex.mapState
    import { mapState } from 'vuex'
    
    export default {
      // ...
      computed: mapState({
        // 箭头函数可使代码更简练
        count: state => state.count,
    
        // 传字符串参数 'count' 等同于 `state => state.count`
        countAlias: 'count',
    
        // 为了能够使用 `this` 获取局部状态,必须使用常规函数
        countPlusLocalState (state) {
          return state.count + this.localCount
        }
      })
    }

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

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

         2.getter

    getters本质上是用来对状态进行加工处理。Getters与State的关系,就像Vue.js的computed与data的关系。getter 的返回值会根据它的依赖被缓存起来,且只有当它的依赖值发生了改变才会被重新计算。可以通过this.$store.getters.valueName对派生出来的状态进行访问。或者直接使用辅助函数mapGetters将其映射到本地计算属性中去。

    mapGetters 辅助函数:

    mapGetters 辅助函数仅仅是将 store 中的 getter 映射到局部计算属性:

    import { mapGetters } from 'vuex'
    export default {
      // ...
      computed: {
      // 使用对象展开运算符将 getter 混入 computed 对象中
        ...mapGetters([
          'doneTodosCount',
          'anotherGetter',
          // ...
        ])
      }
    }

    mapGetters实际上是一个方法Vuex对象上的一个方法,这从本文开头打印的那个Vuex对象的内容可以看出来。…这个符号是ES2015的一个新的语法糖,即将mapGetters处理后的内容展开后填入。

    如果你想将一个 getter 属性另取一个名字,使用对象形式:

    mapGetters({
      // 映射 `this.doneCount` 为 `store.getters.doneTodosCount`
      doneCount: 'doneTodosCount'
    })

           3.mutation

    mutations的中文意思是“变化”,利用它可以更改状态。事实上,更改 Vuex 的 store 中的状态的唯一方法就是提交 (commit)mutation。不过,mutation触发状态改变的方式有一点特别,所谓commit一个mutation,实际是像触发一个事件一样,传入一个mutation的类型以及携带一些数据(称作payload,载荷)。

    mutations: {   //放置mutations方法
    	increment(state, payload) {
    		//在这里改变state中的数据
    		state.count = payload.number;
    	}
    },

    那commit一个mutation在代码层面怎么表示呢?

    this.$store.commit('increment', {
      amount: 10
    })
    //或者这样
    this.$store.commit({
      type: 'increment',
      amount: 10
    })

    除了这种使用 this.$store.commit('xxx') 提交 mutation的方式之外,还有一种方式,即使用 mapMutations 辅助函数将组件中的 methods 映射为 this.$store.commit例如:

    import { mapMutations } from 'vuex'
    
    export default {
      // ...
      methods: {
        ...mapMutations([
          'increment', // 将 `this.increment()` 映射为 `this.$store.commit('increment')`
    
          // `mapMutations` 也支持载荷:
          'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.commit('incrementBy', amount)`
        ]),
        ...mapMutations({
          add: 'increment' // 将 `this.add()` 映射为 `this.$store.commit('increment')`
        })
      }
    }

    经过这样的映射之后,就可以通过调用方法的方式来触发其对应的(所映射到的)mutation commit了,比如,上例中调用add()方法,就相当于执行了this.$store.commit('increment')了。

    考虑到触发的mutation的type必须与mutations里声明的mutation名称一致,比较好的方式是把这些mutation都集中到一个文件(如mutation-types)中以常量的形式定义,在其它地方再将这个文件引入,便于管理。而且这样做还有一个好处,就是整个应用中一共有哪些mutation type可以一目了然。就像下面这样:

    // mutation-types.js
    export const SOME_MUTATION = 'SOME_MUTATION'
    
    // store.js
    import Vuex from 'vuex'
    import { SOME_MUTATION } from './mutation-types'
    
    const store = new Vuex.Store({
      state: { ... },
      mutations: {
        // 我们可以使用 ES2015 风格的计算属性命名功能来使用一个常量作为函数名
        [SOME_MUTATION] (state) {
          // mutate state
        }
      }
    })

             4.action

    action可以提交mutation,在action中可以执行store.commit,而且action中可以有任何的异步操作:

    const store = new Vuex.Store({
      state: {
        count: 0
      },
      mutations: {
        increment (state) {
          state.count++
        }
      },
      actions: {
        increment (context) {
          context.commit('increment')
        }
      }
    })

    或者用ES2015的参数解构,可以简写成:

    actions: {
        increment ({commit}) {
          	commit('increment')
        }
    }

    和mutation类似,我们像上面这样生命action的处理函数。它接收的第一个参数是一个与 store 实例具有相同方法和属性的 context 对象,因此你可以调用 context.commit 提交一个 mutation,或者通过 context.state 和 context.getters 来获取 state 和 getters。

    不过,mutation处理函数中所做的事情是改变state,而action处理函数中所做的事情则是commit mutation。

    怎么触发action呢?按照Vuex的叫法,这叫分发(dispatch),我们反正知道它实际上是触发的意思就行了。具体的触发方法是this.$store.dispatch(actionType, payload)。所传的两个参数一个是要触发的action的类型,一个是所携带的数据(payload),类似于上文所讲的commit mutation时所传的那两个参数。具体如下:

    // 以载荷形式分发
    this.$store.dispatch('incrementAsync', {
      amount: 10
    })
    
    或
    
    // 以对象形式分发
    this.$store.dispatch({
      type: 'incrementAsync',
      amount: 10
    })

    还有一种方法是使用 mapActions 辅助函数将组件的 methods 映射为 this.$store.dispatch 调用。如下:

    import { mapActions } from 'vuex'
    
    export default {
      // ...
      methods: {
        ...mapActions([
          'increment', // 将 `this.increment()` 映射为 `this.$store.dispatch('increment')`
    
          // `mapActions` 也支持载荷:
          'incrementBy' // 将 `this.incrementBy(amount)` 映射为 `this.$store.dispatch('incrementBy', amount)`
        ]),
        ...mapActions({
          add: 'increment' // 将 `this.add()` 映射为 `this.$store.dispatch('increment')`
        })
      }
    }

    另外,还需要知道, this.$store.dispatch 可以处理被触发的 action 的处理函数返回的 Promise,并且 this.$store.dispatch 仍旧返回 Promise。

    再来看一些组合性的异步操作:

    actions: {
      actionA ({ commit }) {
        return new Promise((resolve, reject) => {
          setTimeout(() => {
            commit('someMutation')
            resolve()
          }, 1000)
        })
      }
    }

    现在你可以:

    $this.store.dispatch('actionA').then(() => {
      // ...
    })

    在另外一个 action 中也可以:

    actions: {
      // ...
      actionB ({ dispatch, commit }) {
        return dispatch('actionA').then(() => {
          commit('someOtherMutation')
        })
      }
    }

    最后,如果我们利用 async / await 这个 JavaScript 即将到来的新特性,我们可以像这样组合 action:

    // 假设 getData() 和 getOtherData() 返回的是 Promise
    actions: {
      async actionA ({ commit }) {
        commit('gotData', await getData())
      },
      async actionB ({ dispatch, commit }) {
        await dispatch('actionA') // 等待 actionA 完成
        commit('gotOtherData', await getOtherData())
      }
    }

    接着来看一个更加实际的购物车示例,涉及到调用异步 API 和分发多重 mutation

    actions: {
      checkout ({ commit, state }, products) {
        // 把当前购物车的物品备份起来
        const savedCartItems = [...state.cart.added]
        // 发出结账请求,然后乐观地清空购物车
        commit(types.CHECKOUT_REQUEST)
        // 购物 API 接受一个成功回调和一个失败回调
        shop.buyProducts(
          products,
          // 成功操作
          () => commit(types.CHECKOUT_SUCCESS),
          // 失败操作
          () => commit(types.CHECKOUT_FAILURE, savedCartItems)
        )
      }
    }

              5.module

    module是对于store的一种切割。由于Vuex使用的是单一状态树,这样整个应用的所有状态都会集中到一个比较大的对象上面,那么,当应用变得非常复杂时,store 对象就很可能变得相当臃肿!它解决了当state中很臃肿的时候,module可以将store分割成模块,每个模块中拥有自己的state、mutation、action和getter。就像下面这样:

    const moduleA = {
      state: { ... },
      mutations: { ... },
      actions: { ... },
      getters: { ... }
    }
    
    const moduleB = {
      state: { ... },
      mutations: { ... },
      actions: { ... }
    }
    
    const store = new Vuex.Store({
      modules: {
        a: moduleA,
        b: moduleB
      }
    })
    
    store.state.a // -> moduleA 的状态
    store.state.b // -> moduleB 的状态
    • 模块的局部状态

    对于每个模块内部的 mutation 和 getter,接收的第一个参数就是模块的局部状态对象。

    const moduleA = {
      state: { count: 0 },
      mutations: {
        increment (state) {
          // 这里的 `state` 对象是模块的局部状态
          state.count++
        }
      },
    
      getters: {
        doubleCount (state) {
          return state.count * 2
        }
      }
    }

    同样,对于模块内部的 action,局部状态通过 context.state 暴露出来,根节点状态则为 context.rootState

    const moduleA = {
      // ...
      actions: {
        incrementIfOddOnRootSum ({ state, commit, rootState }) {
          if ((state.count + rootState.count) % 2 === 1) {
            commit('increment')
          }
        }
      }
    }

    对于模块内部的 getter,根节点状态会作为第三个参数暴露出来:

    const moduleA = {
      // ...
      getters: {
        sumWithRootCount (state, getters, rootState) {
          return state.count + rootState.count
        }
      }
    }
    • 命名空间

    默认情况下,模块内部的 action、mutation 和 getter 是注册在全局命名空间的——这样使得多个模块能够对同一 mutation 或 action 作出响应。

    如果希望你的模块具有更高的封装度和复用性,你可以通过添加 namespaced: true 的方式使其成为命名空间模块。当模块被注册后,它的所有 getter、action 及 mutation 都会自动根据模块注册的路径调整命名。例如:

    const store = new Vuex.Store({
      modules: {
        account: {
          namespaced: true,
    
          // 模块内容(module assets)
          state: { ... }, // 模块内的状态已经是嵌套的了,使用 `namespaced` 属性不会对其产生影响
          getters: {
            isAdmin () { ... } // -> getters['account/isAdmin']
          },
          actions: {
            login () { ... } // -> dispatch('account/login')
          },
          mutations: {
            login () { ... } // -> commit('account/login')
          },
    
          // 嵌套模块
          modules: {
            // 继承父模块的命名空间
            myPage: {
              state: { ... },
              getters: {
                profile () { ... } // -> getters['account/profile']
              }
            },
    
            // 进一步嵌套命名空间
            posts: {
              namespaced: true,
    
              state: { ... },
              getters: {
                popular () { ... } // -> getters['account/posts/popular']
              }
            }
          }
        }
      }
    })

    启用了命名空间的 getter 和 action 会收到局部化的 getterdispatch 和 commit

    • 在命名空间模块内访问全局内容(Global Assets)

    如果你希望使用全局 state 和 getter,rootState 和 rootGetter 会作为第三和第四参数传入 getter,也会通过 context 对象的属性传入 action。

    若需要在全局命名空间内分发 action 或提交 mutation,将 { root: true } 作为第三参数传给 dispatch 或 commit即可。

    modules: {
      foo: {
        namespaced: true,
    
        getters: {
          // 在这个模块的 getter 中,`getters` 被局部化了
          // 你可以使用 getter 的第四个参数来调用 `rootGetters`
          someGetter (state, getters, rootState, rootGetters) {
            getters.someOtherGetter // -> 'foo/someOtherGetter'
            rootGetters.someOtherGetter // -> 'someOtherGetter'
          },
          someOtherGetter: state => { ... }
        },
    
        actions: {
          // 在这个模块中, dispatch 和 commit 也被局部化了
          // 他们可以接受 `root` 属性以访问根 dispatch 或 commit
          someAction ({ dispatch, commit, getters, rootGetters }) {
            getters.someGetter // -> 'foo/someGetter'
            rootGetters.someGetter // -> 'someGetter'
    
            dispatch('someOtherAction') // -> 'foo/someOtherAction'
            dispatch('someOtherAction', null, { root: true }) // -> 'someOtherAction'
    
            commit('someMutation') // -> 'foo/someMutation'
            commit('someMutation', null, { root: true }) // -> 'someMutation'
          },
          someOtherAction (ctx, payload) { ... }
        }
      }
    }
    • 命名空间的绑定函数

    当使用 mapStatemapGettersmapActions 和 mapMutations 这些函数来绑定命名空间模块时,写起来可能比较繁琐:

    computed: {
      ...mapState({
        a: state => state.some.nested.module.a,
        b: state => state.some.nested.module.b
      })
    },
    methods: {
      ...mapActions([
        'some/nested/module/foo',
        'some/nested/module/bar'
      ])
    }

    对于这种情况,你可以将模块的空间名称字符串作为第一个参数传递给上述函数,这样所有绑定都会自动将该模块作为上下文。于是上面的例子可以简化为:

    computed: {
      ...mapState('some/nested/module', {
        a: state => state.a,
        b: state => state.b
      })
    },
    methods: {
      ...mapActions('some/nested/module', [
        'foo',
        'bar'
      ])
    }

    而且,你可以通过使用 createNamespacedHelpers 创建基于某个命名空间辅助函数。它返回一个对象,对象里有新的绑定在给定命名空间值上的组件绑定辅助函数:

    import { createNamespacedHelpers } from 'vuex'
    
    const { mapState, mapActions } = createNamespacedHelpers('some/nested/module')
    
    export default {
      computed: {
        // 在 `some/nested/module` 中查找
        ...mapState({
          a: state => state.a,
          b: state => state.b
        })
      },
      methods: {
        // 在 `some/nested/module` 中查找
        ...mapActions([
          'foo',
          'bar'
        ])
      }
    }
    • 给插件开发者的注意事项

    如果你开发的插件(Plugin)提供了模块并允许用户将其添加到 Vuex store,可能需要考虑模块的空间名称问题。对于这种情况,你可以通过插件的参数对象来允许用户指定空间名称:

    // 通过插件的参数对象得到空间名称
    // 然后返回 Vuex 插件函数
    export function createPlugin (options = {}) {
      return function (store) {
        // 把空间名字添加到插件模块的类型(type)中去
        const namespace = options.namespace || ''
        store.dispatch(namespace + 'pluginAction')
      }
    }
    
    • 模块动态注册

    在 store 创建之后,你可以使用 store.registerModule 方法注册模块:

    // 注册模块 `myModule`
    store.registerModule('myModule', {
      // ...
    })
    // 注册嵌套模块 `nested/myModule`
    store.registerModule(['nested', 'myModule'], {
      // ...
    })

    之后就可以通过 store.state.myModule 和 store.state.nested.myModule 访问模块的状态。

    模块动态注册功能使得其他 Vue 插件可以通过在 store 中附加新模块的方式来使用 Vuex 管理状态。例如,vuex-router-sync 插件就是通过动态注册模块将 vue-router 和 vuex 结合在一起,实现应用的路由状态管理。

    你也可以使用 store.unregisterModule(moduleName) 来动态卸载模块。注意,你不能使用此方法卸载静态模块(即创建 store 时声明的模块)。

    • 模块重用

    有时我们可能需要创建一个模块的多个实例,例如:

        (1)创建多个 store,他们公用同一个模块

        (2)在一个 store 中多次注册同一个模块

    如果我们使用一个纯对象来声明模块的状态,那么这个状态对象会通过引用被共享,导致状态对象被修改时 store 或模块间数据互相污染的问题。

    实际上这和 Vue 组件内的 data 是同样的问题。因此解决办法也是相同的——使用一个函数来声明模块状态(仅 2.3.0+ 支持):

    const MyReusableModule = {
      state () {
        return {
          foo: 'bar'
        }
      },
      // mutation, action 和 getter 等等...
    }

    5. store与$store的区别

    $store 是挂载在 Vue 实例上的(即Vue.prototype),组件也是一个Vue实例,在组件中可使用 this 访问原型上的属性。template 中可直接通过 {{ $store.state.userName }} 访问,等价于 script 中的 this.$store.state.userName
    至于 {{ store.state.userName }},script 中的 data 需声明过 store 才可访问。

     

    总之,有以下要注意的:

    (1)在功能上:

           state保存的是数据

           getters是对state进行二次加工

           action的处理函数的功能最终是commit mutation

           mutation处理函数的功能最终是改变state

    (2)在流程上:

           vue component—-dispatch—->actions—-commit—->mutations—-mutate—->state—-render—->vue component。从而形成闭环。

    (3)辅助方法的映射上:

           mapGetters、mapState 都是用在computed声明里面;

           mapActions、mapMutations则都是用在methods声明里面。

    展开全文
  • Openssl X509_STORE_CTX系列函数

    千次阅读 2021-11-16 21:29:51
    DESCRIPTION These functions initialise anX509_STORE_CTXstructure for subsequent use by X509_verify_cert(). X509_STORE_CTX_new() ...X509_STORE_CTX_cleanup() internally cleans up anX509_STORE_CTXstruc...

    /*
     * This is a used when verifying cert chains.  Since the gathering of the
     * cert chain can take some time (and have to be 'retried', this needs to be
     * kept and passed around.
     */
    struct x509_store_ctx_st {      /* X509_STORE_CTX */
        X509_STORE *ctx;
        /* The following are set by the caller */
        /* The cert to check */
        X509 *cert;
        /* chain of X509s - untrusted - passed in */
        STACK_OF(X509) *untrusted;
        /* set of CRLs passed in */
        STACK_OF(X509_CRL) *crls;
        X509_VERIFY_PARAM *param;
        /* Other info for use with get_issuer() */
        void *other_ctx;
        /* Callbacks for various operations */
        /* called to verify a certificate */
        int (*verify) (X509_STORE_CTX *ctx);
        /* error callback */
        int (*verify_cb) (int ok, X509_STORE_CTX *ctx);
        /* get issuers cert from ctx */
        int (*get_issuer) (X509 **issuer, X509_STORE_CTX *ctx, X509 *x);
        /* check issued */
        int (*check_issued) (X509_STORE_CTX *ctx, X509 *x, X509 *issuer);
        /* Check revocation status of chain */
        int (*check_revocation) (X509_STORE_CTX *ctx);
        /* retrieve CRL */
        int (*get_crl) (X509_STORE_CTX *ctx, X509_CRL **crl, X509 *x);
        /* Check CRL validity */
        int (*check_crl) (X509_STORE_CTX *ctx, X509_CRL *crl);
        /* Check certificate against CRL */
        int (*cert_crl) (X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x);
        /* Check policy status of the chain */
        int (*check_policy) (X509_STORE_CTX *ctx);
        STACK_OF(X509) *(*lookup_certs) (X509_STORE_CTX *ctx, X509_NAME *nm);
        STACK_OF(X509_CRL) *(*lookup_crls) (X509_STORE_CTX *ctx, X509_NAME *nm);
        int (*cleanup) (X509_STORE_CTX *ctx);
        /* The following is built up */
        /* if 0, rebuild chain */
        int valid;
        /* number of untrusted certs */
        int num_untrusted;
        /* chain of X509s - built up and trusted */
        STACK_OF(X509) *chain;
        /* Valid policy tree */
        X509_POLICY_TREE *tree;
        /* Require explicit policy value */
        int explicit_policy;
        /* When something goes wrong, this is why */
        int error_depth;
        int error;
        X509 *current_cert;
        /* cert currently being tested as valid issuer */
        X509 *current_issuer;
        /* current CRL */
        X509_CRL *current_crl;
        /* score of current CRL */
        int current_crl_score;
        /* Reason mask */
        unsigned int current_reasons;
        /* For CRL path validation: parent context */
        X509_STORE_CTX *parent;
        CRYPTO_EX_DATA ex_data;
        SSL_DANE *dane;
        /* signed via bare TA public key, rather than CA certificate */
        int bare_ta_signed;
    };
     #include <openssl/x509_vfy.h>
    
     X509_STORE_CTX *X509_STORE_CTX_new(void);
     void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx);
     void X509_STORE_CTX_free(X509_STORE_CTX *ctx);
    
     int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store,
                             X509 *x509, STACK_OF(X509) *chain);
    
     void X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
    
     void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x);
     STACK_OF(X509) *X509_STORE_CTX_get0_chain(X509_STORE_CTX *ctx);
     void X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *chain);
     void X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk);
    
     X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx);
     void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param);
     int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name);
    
     STACK_OF(X509)* X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx);
     void X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk);
    
     int X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx);
    
     typedef int (*X509_STORE_CTX_verify_fn)(X509_STORE_CTX *);
     void X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, X509_STORE_CTX_verify_fn verify);

    DESCRIPTION

    These functions initialise an X509_STORE_CTX structure for subsequent use by X509_verify_cert().

    X509_STORE_CTX_new() returns a newly initialised X509_STORE_CTX structure.

    X509_STORE_CTX_cleanup() internally cleans up an X509_STORE_CTX structure. The context can then be reused with a new call to X509_STORE_CTX_init().

    X509_STORE_CTX_free() completely frees up ctx. After this call ctx is no longer valid. If ctx is NULL nothing is done.

    X509_STORE_CTX_init() sets up ctx for a subsequent verification operation. It must be called before each call to X509_verify_cert(), i.e. a ctx is only good for one call to X509_verify_cert(); if you want to verify a second certificate with the same ctx then you must call X509_STORE_CTX_cleanup() and then X509_STORE_CTX_init() again before the second call to X509_verify_cert(). The trusted certificate store is set to store, the end entity certificate to be verified is set to x509 and a set of additional certificates (which will be untrusted but may be used to build the chain) in chain. Any or all of the storex509 and chain parameters can be NULL.

    X509_STORE_CTX_set0_trusted_stack() sets the set of trusted certificates of ctx to sk. This is an alternative way of specifying trusted certificates instead of using an X509_STORE.

    X509_STORE_CTX_set_cert() sets the certificate to be verified in ctx to x.

    X509_STORE_CTX_set0_verified_chain() sets the validated chain used by ctx to be chain. Ownership of the chain is transferred to ctx and should not be free'd by the caller. X509_STORE_CTX_get0_chain() returns the internal pointer used by the ctx that contains the validated chain.

    X509_STORE_CTX_set0_crls() sets a set of CRLs to use to aid certificate verification to sk. These CRLs will only be used if CRL verification is enabled in the associated X509_VERIFY_PARAM structure. This might be used where additional "useful" CRLs are supplied as part of a protocol, for example in a PKCS#7 structure.

    X509_STORE_CTX_get0_param() retrieves an internal pointer to the verification parameters associated with ctx.

    X509_STORE_CTX_get0_untrusted() retrieves an internal pointer to the stack of untrusted certificates associated with ctx.

    X509_STORE_CTX_set0_untrusted() sets the internal point to the stack of untrusted certificates associated with ctx to sk.

    X509_STORE_CTX_set0_param() sets the internal verification parameter pointer to param. After this call param should not be used.

    X509_STORE_CTX_set_default() looks up and sets the default verification method to name. This uses the function X509_VERIFY_PARAM_lookup() to find an appropriate set of parameters from name.

    X509_STORE_CTX_get_num_untrusted() returns the number of untrusted certificates that were used in building the chain following a call to X509_verify_cert().

    X509_STORE_CTX_set_verify() provides the capability for overriding the default verify function. This function is responsible for verifying chain signatures and expiration times.

    A verify function is defined as an X509_STORE_CTX_verify type which has the following signature:

     int (*verify)(X509_STORE_CTX *);

    This function should receive the current X509_STORE_CTX as a parameter and return 1 on success or 0 on failure.

    展开全文
  • vue简单的store

    千次阅读 2021-10-24 14:31:13
    vue中的store最简单的应用就是全局存储了。 我这里使用了两个组件在相互跳转(Helloworld.vue和twopage.vue),前者是用来向store中放数据的,后者是从store取数据的。 首先需要安装vuex: npm install vuex --save ...

    vue中的store最简单的应用就是全局存储了。

    我这里使用了两个组件在相互跳转(Helloworld.vuetwopage.vue),前者是用来向store中放数据的,后者是从store取数据的。

    首先需要安装vuex: npm install vuex --save
    因为要跳转所以少不了安装路由router:npm install vue-router --save

    新建store文件夹在里面新建modules文件夹、getters.jsindex.js
    在modules建mystate.js

    在这里插入图片描述
    mystate中放我们的变量msg:

    const state = {
        msg: '这是我的状态',
    }
    
    export default {
        state
    }
    
    

    getters放我们操作变量的键值对:

    const getters  = {
        msg:state => state.mystate.msg,
    }
    
    export default getters
    

    index中是用来配置并且创建vuex.store的:

    import Vue from 'vue'
    import Vuex from 'vuex'
    import getters from './getters'
    
    Vue.use(Vuex)
    
    // https://webpack.js.org/guides/dependency-management/#requirecontext
    const modulesFiles = require.context('./modules', true, /\.js$/)
    
    // 它将自动要求模块文件中的所有vuex模块
    // you do not need `import app from './modules/app'`
    // it will auto require all vuex module from modules file
    const modules = modulesFiles.keys().reduce((modules, modulePath) => {
      // set './app.js' => 'app'
      const moduleName = modulePath.replace(/^\.\/(.*)\.\w+$/, '$1')
      const value = modulesFiles(modulePath)
      modules[moduleName] = value.default
      return modules
    }, {})
    
    
    const store = new Vuex.Store({
      modules,
      getters,
    })
    
    export default store
    
    

    需要在main.js的vue实例中调用store和router(两个页面的路由在后面):

    import Vue from 'vue'
    import App from './App'
    import router from './router'
    import store from './store'
    
    
    Vue.config.productionTip = false
    
    /* eslint-disable no-new */
    new Vue({
      el: '#app',
      router,
      store,
      render: h => h(App)
    })
    
    

    router下的index.js中配置两个路由:

    import Vue from 'vue'
    import Router from 'vue-router'
    import HelloWorld from '@/components/HelloWorld'
    import Two from '@/components/twopage'
    
    Vue.use(Router)
    
    export default new Router({
      routes: [
        {
          path: '/',
          name: 'HelloWorld',
          component: HelloWorld
        },
        {
          path: '/two',
          name: 'TwoPage',
          component: Two
        }
      ]
    })
    
    

    App.vue中使用路由视图:

    <template>
      <div id="app">
       <router-view></router-view>
      </div>
    </template>
    
    <script>
    export default {
      name: 'App'
    }
    </script>
    
    <style>
    #app {
      font-family: 'Avenir', Helvetica, Arial, sans-serif;
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;
      text-align: center;
      color: #2c3e50;
      margin-top: 60px;
    }
    </style>
    
    

    最后就是两个页面组件了,HelloWorld.vue
    双向绑定并且监听msg,将msg的新值放入全局变量中。
    监听触发的方法是setstate;
    sessionStorage.setItem('msg', value)是用来把value的值放入叫msg的键所对应的值里,也就是getters.js存放的的键值对。

    <template>
      <div class="hello">
        <img src="../assets/logo.png" />
        <br />
        <input v-model="msg"/>
        <h2>{{ msg }}</h2>
        <router-link to="/two">我去要去第二个页面</router-link>
      </div>
    </template>
    
    <script>
    export default {
      name: "HelloWorld",
      data() {
        return {
          msg: "Welcome to 新的vue项目",
        };
      },
      methods: {
        setstate(value) {
          sessionStorage.setItem('msg', value);
        },
      },
      watch: {
        msg(newName, oldName) {
          this.setstate(newName);
        },
      },
    };
    </script>
    
    <!-- Add "scoped" attribute to limit CSS to this component only -->
    <style scoped>
    a {
      color: #42b983;
    }
    </style>
    
    

    在第二个页面组件twopage.vue中需要把存的msg拿出来:
    sessionStorage.getItem('msg')获取msg键所对应的值。

    <template>
      <div>
        这是第二个页面
        <h2>{{ msg }}</h2>
        <router-link to="/">我要回去</router-link>
      </div>
    </template>
    
    
    <script>
    export default {
      data() {
        return {
          msg: "",
        };
      },
      methods: {
        setmsg() {
            this.msg = sessionStorage.getItem('msg');
        },
      },
      created(){
          this.setmsg()
      }
    };
    </script>
    

    目录结构:

    在这里插入图片描述

    演示:

    初始状态:

    在这里插入图片描述

    使输入框的内容发生变化:

    在这里插入图片描述

    前往第二个页面:

    在这里插入图片描述

    展开全文
  • vue3中router路由和vuex的store使用方法,获取对象基本使用详细教程vue3中router和store使用方法Router配全局配置Router获取及使用Route获取及使用Store全局配置Store获取及使用功能快捷键 绝对精华,绝对值得珍藏,...

    绝对精华,绝对值得珍藏,看完感谢点赞,谢谢

    vue3中router和store使用方法

    因为在vue3setup内不能使用this对象,所有所有直接通过this来访问的方法都不能使用了。

    那么在vue3中怎么访问this. r o u t e r 或 者 t h i s . router 或者 this. routerthis.route呢?

    记住一条规则:vue3中基本上所有通过this来访问的对象都换成useXxx的方式来获取。

    比如说router,可以通过useRouteruseRoute来获取routerroute对象

    1、企业开发Router全局配置

    企业开发中在src/router/index.js中全局配置,并在main.js中添加到Vue对象

    import { createRouter, createWebHistory } from "vue-router";
    // 路由规则
    const routes = [
      {
        path: "/",
        name: "主页",
        meta: ["istabbar"],
        component: () => import("../views/Home.vue"),
      },
    ];
    //根据路由规则创建路由
    const router = createRouter({
      history: createWebHistory(""),
      routes,
    });
    export default router;
    

    main.js中添加到Vue对象

    import { createApp } from "vue";
    import App from "./App.vue";
    import router from "./router"; // 添加路由router引入
    // 创建VUE对象
    createApp(App)
      .use(router) // 使用.use(router)添加路由router
      .mount("#app");
    
    

    配置完后就可以全局使用了

    1.1、Router获取及使用

    先引入vue-router,再获取对象:

    1. import { useRouter } from “vue-router”;
    2. const router = useRouter();

    但是这也不是唯一的方法,传统的和VUE3的使用方法如下:
    这里提供了三种方法用于获取 router 对象

    <template>
      <div class="page">
        因为在setup内部没有this访问权限,不能直接使用this访问this.$router 或者
        this.$route。所有使用useRouter, useRoute来获取
      </div>
    </template>
    <script>
    import { getCurrentInstance } from "vue";
    import { useRouter } from "vue-router";
    export default {
      setup() {
        // 第一种方法:获取路由对象 router 的方法1
        const vue = getCurrentInstance();
        const router1 = vue.ctx.$router;
        // 第二种方法:获取路由对象 router 的方法2
        const router2 = useRouter();
          
        // 下面提供了router对应的方法使用大全
        // ------------------------------------------------------
        // router1.addRoute(parentOrRoute, route)
        // router1.afterEach(回调函数)
        // router1.back() 等价于 go(-1)
        // router1.beforeEach(回调函数)
        // router1.beforeResolve(回调函数)
        // router1.currentRoute 获取当前路由:如: {_rawValue: {…}, _shallow: true, __v_isRef: true, _value: {…}}
        // router1.forward() 等价于 go(1)
        // router1.getRoutes: ƒ getRoutes()
        // router1.go(delta) 等价于 routerHistory.go(delta) 跳到指定历史记录
        // router1.hasRoute(name) 判断是否有对应的路由
        // router1.isReady() 判断路由是否准备跳转
        // router1.onError(回调函数) 当发生错误的时候执行的
        // router1.options 获取所有路由信息 {history: {…}, routes: Array(5)}
        // router1.push(to) 跳转到指定路由对应的页面,有历史记录
        // router1.removeRoute(name) 动态的删除某个路由
        // router1.replace(to) 直接跳转到指定路由页面,没有历史记录
        // router1.resolve(rawLocation, currentLocation)  可以自定义跳转参数的方法
        return {};
      },
      mounted() {
        // 第三种方法:获取路由对象 router 的方法3
        console.log(this.$router);
      },
    };
    </script>
    

    1.2、Route获取及使用

    先引入vue-router,再获取对象:

    1. import { useRouter } from “vue-router”;
    2. const router = useRouter();

    但是这也不是唯一的方法,传统的和VUE3的使用方法如下:
    这里提供了三种方法用于获取 router 对象

    <template>
      <div class="page">
        因为在setup内部没有this访问权限,不能直接使用this访问this.$router 或者
        this.$route。所有使用useRouter, useRoute来获取
      </div>
    </template>
    <script>
    import { getCurrentInstance } from "vue";
    import { useRoute } from "vue-router";
    export default {
      setup() {
        // 第一种方法:获取路由对象 router 的方法1
        const vue = getCurrentInstance();
        const route1 = vue.ctx.$router.currentRoute.value;
        console.log(route1);
        // 第二种方法:获取路由对象 router 的方法2
        const route2 = useRoute();
        console.log(route2);
    
        // 下面提供了route对应的属性使用大全
        // ------------------------------------------------------
        // fullPath: "/user"  完整路由路径
        // hash: "" 锚点部分
        // href: "/user"  跳转来的时候的路径
        // matched: [{…}]   路由匹配日规则数组
        // meta: {0: "istabbar"}  路由附加的元数据
        // name: "个人中心" 路由的名称
        // params: {}   路由跳转时带过来的附加参数,如果是对象需要转换成JSON格式
        // path: "/user"  编码 URL 的 pathname 部分,与路由地址有关
        // query: {}   地址附带的参数
        // redirectedFrom: undefined  重定向跳转过来之前的地址,如果没有重定向,则为 undefined。
        return {};
      },
      mounted() {
        // 第三种方法:获取路由对象 router 的方法3
        console.log(this.$route);
      },
    };
    </script>
    

    2、企业开发Store全局配置

    企业开发中在src/store/index.js中全局配置,并在main.js中添加到Vue对象

    import { createStore } from "vuex";
    //创建存储对象
    export default createStore({
      // 需要存储的值都放在这里面
      state() {
        return {
          count: 0,	// 在视图中通过$store.state.count来获取
        };
      },
      // 在其他视图中通过 $store.commit('setState', 10) 使用,用于修改stor存的值
      mutations: {
        setState(state, count) {	// 只能接受两个参数,用于修改store存的值
          state.count = count;
        },
      },
      // 相当于组件的计算属性 通过 $store.getters.doubleCount 获取计算后的值
      getters: {
        doubleCount(state) {
          return state.count * 2;
        },
      },
      // 异步任务 不会改变state 通过 $store.dispath('doubleCount') 使用
      actions: {
        doubleCount(context) {
          context.commit("doubleCount");
        },
      },
      // store的下级store 方便大型项目复杂数据管理,这里面相当于可以在放置一个和外面这些一样的模块
      modules: {},
    });
    

    main.js中添加到Vue对象

    import { createApp } from "vue";
    import App from "./App.vue";
    import router from "./router"; // 添加路由router引入
    import store from "./store"; // 添加全局存储vuex引入
    // 创建VUE对象
    createApp(App)
      .use(router) // 使用.use(router)添加路由router
      .use(store) // 使用.use(store)添加全局存储vuex
      .mount("#app");
    

    配置完后就可以全局使用了

    2.1、Store获取及使用

    先引入vuex,再获取对象:

    1. import { useStore } from “vuex”;
    2. const store = useStore();

    这里提供了三种方法用于获取 router 对象

    <template>
      <div class="page">
        因为在setup内部没有this访问权限,不能直接使用this访问this.$router 或者
        this.$route。所有使用useRouter, useRoute来获取
      </div>
    </template>
    <script>
    import { getCurrentInstance } from "vue";
    import { useStore } from "vuex";
    export default {
      setup() {
        // 第一种方法:获取路由对象 router 的方法1
        const vue = getCurrentInstance();
        const store1 = vue.ctx.$store;
        console.log(store1);
        // 第二种方法:获取路由对象 router 的方法2
        const store2 = useStore();
        console.log(store2);
    
        // 下面提供了:store 对应的属性使用大全
        // ------------------------------------------------------
        // commit(type, payload, options2) 在其他视图中使用mutations中定义的方法
        // dispatch(type, payload) 异步任务 不会改变state 在其他视图中使用actions中定义的方法
        // getters: {}  相当于组件的计算属性 通过 $store.getters.doubleCount 获取计算后的值
        // state: (...)  store中存储的值,就是通过这个在视图中获取store存储的值
        return {};
      },
      mounted() {
        // 第三种方法:获取路由对象 store的方法3
        console.log(this.$store);
      },
    };
    </script>
    

    推荐

    Java企业开发全套系列教程价值19800元:2021新版Java零基础新手速学教程网络编程多线程面向接口项目实战

    功能快捷键

    撤销:Ctrl/Command + Z
    重做:Ctrl/Command + Y
    加粗:Ctrl/Command + B
    斜体:Ctrl/Command + I
    标题:Ctrl/Command + Shift + H
    无序列表:Ctrl/Command + Shift + U
    有序列表:Ctrl/Command + Shift + O
    检查列表:Ctrl/Command + Shift + C
    插入代码:Ctrl/Command + Shift + K
    插入链接:Ctrl/Command + Shift + L
    插入图片:Ctrl/Command + Shift + G
    查找:Ctrl/Command + F
    替换:Ctrl/Command + G

    展开全文
  • Vuex的store中的Module

    千次阅读 2021-01-01 15:49:21
    Vuex的store中的Module 1.单一状态树: 什么是单一状态树呢?单一状态树可以简单得理解成整个vuex中只有一个store对象。 这是官方对单一状态树的解释: Vuex 使用单一状态树——是的,用一个对象就包含了全部的应用...
  • vue store之状态管理

    万次阅读 2019-05-15 15:00:38
    store作为Vue的选项,这样Vue会将store“注入”到每一个子组件中,也就是说每个组件都可以通过this.$store来访问全局单例对象store。 Foo.vue    Foo.vue <button @click="increment">+    ...
  • 内存屏障今生之Store Buffer, Invalid Queue

    千次阅读 多人点赞 2020-08-03 23:23:34
    本文章将介绍cpu的优化过程,你将了解到硬件层面的优化——Store Buffer, Invalid Queue,以及软件层面的优化——cpu内存屏障指令。最原始的架构性能优化之旅——Store Buffer当cpu需要的数据在其他cpu的cache内时,...
  • Vue使用Vuex一步步封装并使用store

    千次阅读 2020-05-12 23:38:48
    文章目录一、安装Vuex依赖二、一步步封装store1. main.js中全局引入store仓库(下一步创建)2. this.$store3. this.$store.state4. this.\$store.getters(this.\$store.state的升级)5. this.$store.commit('...
  • Extjs中store的多种操作

    千次阅读 2019-09-08 22:41:54
    对Extjs中store的多种操作 先来个声明,看着不错,贴过来的,没都测试过。 Store.getCount()返回的是store中的所有数据记录,然后使用for循环遍历整个store,从而得到每条记录。 除了使用getCount()的方法外,还...
  • Vue 中 store 使用方法讲解

    千次阅读 2021-04-25 17:39:53
    vuex 包含有五个基本的对象: state:存储状态。也就是变量; getters:派生状态。也就是set、get中的get,有两个可选参数:state、getters分别可以获取state中的变量和其他的getters。...外部调用方式:store.co
  • vuex中store 的mutation

    千次阅读 2020-12-27 01:14:46
    vuex中store 的mutation 1.mutation 官方解释mutation: 更改 Vuex 的 store 中的状态的唯一方法是提交 mutation。Vuex 中的 mutation 非常类似于事件:每个 mutation 都有一个字符串的 事件类型 (type) 和 一个 回...
  • ios应用内跳转到AppStore或者iTunes

    热门讨论 2012-08-18 14:16:28
    1.多数应用中的评价功能都是基于此方法实现 2.可以跳转到AppStore或者iTunes 3.只能在真机上测试,模拟器没有AppStore和iTunes
  • iOS15之StoreKit 2

    千次阅读 2021-06-18 16:28:31
    文章目录引言I 、StoreKit 2 只支持 iOS 15+1.1 Choosing a StoreKit API for In-App Purchase 引言 I 、StoreKit 2 只支持 iOS 15+ StoreKit 2 for Swift only! ... Manage in-app purchases on your server ...
  • win10Microsoft Store登录不了怎么办?Microsoft Store是电脑中的软件商店,但是很多用户在使用时发现自己无法登陆,下面就和小编一起来看看吧!1、打开控制面板,右上角搜索“疑难解答”并点开,点击“硬件和声音”...
  • 重置 清除 vuex store

    千次阅读 2019-08-03 16:02:59
    export const store = new Vuex.Store({ state, /* getters, mutations, etc. */ }) export function resetState() { store.replaceState(initialStateCopy) } Then in your vue component (or anywhere) ...
  • Vue 中 store 基本用法

    千次阅读 2021-01-14 13:50:55
    这个文件就不需要太多东西...经过我测试,最开始的时候我也是胡乱在弄,直接在需要调用的地方写:this.$store.demo.setDemoValue(value);this.$store.demo. getDemoValue ;当然是给我报错,提示undefined。于是我断...
  • Aurora Store

    千次阅读 2021-09-02 16:46:58
    我相信有许多小伙伴们和小编一样都喜欢在Google PlayStore下载APP,但是安装Google PlayStore需要谷歌全家桶,对于用华为的小伙伴们,极不方便。所以呢,今天小编给小伙伴们介绍一款第三方Google PlayStore——...
  • ext中store的使用

    千次阅读 2018-06-11 10:02:14
    因为上次用过Ext.data.Store,觉得挺重要的, 故转载了一篇http://blog.csdn.net/davidxj/archive/2009/04/23/4103647.aspxExt.data.Store的基本用法在使用之前,首先要创建一个Ext.data.Store的实例,如下面的代码...
  • 最近win10系统用户反馈,在用Microsoft Store打开网页,提示Microsoft Store需要联网,你似乎没有联网。无法打开应用商店,microsoft store连不上网怎么回事?其实这可能是系统中设置不当导致的。接下来就让小编教你...
  • Unity Asset Store里有大量优质的艺术家与开发者提供资源,所以下面我从每个分类里挑选出比较优秀的开发者来介绍如何高效的使用Unity Asset Store。本打算5大分类里分别列出10家开发商的,一共列举50家。写了几个后...
  • 无法连接到iTunes Store的解决方案

    千次阅读 2021-08-12 03:54:43
    很多朋友反映到在App Store上下载应用不成功,并提示“无法连接到itunes store”,无法连接到iTunes Store怎么办,接下来是小编为大家收集的无法连接到iTunes Store的解决方案,希望能帮到大家。无法连接到iTunes ...
  • 原文链接: Access the Redux Store Outside a React Component 你有过在 React 组件之外用到 Redux store 的需求吗 ? 问题有点奇怪甚至在某种程度上带一点反讽,store 是一个全局的数据,有时我却没有合适的方法去...
  • DS_Store文件泄漏

    千次阅读 2020-04-26 19:27:19
    什么DS_Store .DS_Store是Mac OS保存文件夹的自定义属性的隐藏文件,如文件的图标位置或背景色,相当于Windows的desktop.ini。 其删除以后的副作用就是这些信息的失去。 和别人交换文件(或你做的网页需要上传的时候...
  • App Store Connect新手指导

    千次阅读 2020-08-28 20:05:29
    App Store Connect是一套以网页为基础的工具,用于管理在App Store上销售的面向 iPhone、iPad、Mac、Apple Watch、Apple TV和 iMessage 的 app。作为Apple DeveloperProgram 的成员,我将使用App Store Connect提交...
  • vue 的状态管理vuex中store的使用

    千次阅读 2019-04-16 09:49:37
    store/index.js文件中新建vuex 的store实例 *as的意思是 导入这个文件里面的所有内容,就不用一个个实例来导入了。 import Vue from 'vue' import Vuex from 'vuex' import * as getters from './getters'...
  • import store from './store'; ////////////////// //中间代码省略了 ///////////////// new Vue({ el: '#app', store, router: router, render: h => h(App) }); ``` login.vue ``` import {...
  • vuex中的store和$store的区别

    万次阅读 2019-04-30 18:15:50
    这里写自定义目录标题 <router-link to="/login...{{ $store.state.userName }}</router-link> <router-link to="/login">{{ store.state.userName }}</router-link> <router-link to="/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 871,152
精华内容 348,460
关键字:

store

友情链接: XMLParser.zip