全面解析Composable

发布时间：2023-05-18

Composable是一种设计模式

Composable是一种设计模式，它将复杂的应用程序拆分成可重复使用和相互组合的小块。这些小块称为Composables，它们可以像搭积木一样组装起来，用于创建各种类型的应用程序。Composable可以在不同的应用程序中重复使用，从而使代码更易于维护和扩展。

一、Composables

Composables是应用程序的基本构建块。一个Composable通常只执行一个特定的任务，并返回一个值，这个值可以与其他Composables组合在一起达到更高级别的功能。Composables可以是函数，也可以是具有状态的对象。 在Vue 3中，我们可以使用函数式组件将组件分解成更小的组成部分。这些组成部分可以作为Composable使用。

import { computed, reactive } from 'vue'
export default function useCounter(initialValue) {
  const state = reactive({
    count: initialValue,
  })
  const increment = () => {
    state.count++
  }
  const decrement = () => {
    state.count--
  }
  const double = computed(() => {
    return state.count * 2
  })
  return {
    state,
    increment,
    decrement,
    double,
  }
}

上面的代码演示了一个简单的计数器Composable。它接受一个初始值作为参数，并返回一个响应性的状态对象和三个方法。 increment和decrement方法用于增加和减少计数器的值，double是一个计算属性，用于计算计数器的两倍。

二、composable lora

Composable Lora是一个基于Composable的开源JavaScript库，用于创建大量的可重用UI组件。它主要为Vue 3开发提供了支持。使用Composable Lora可以简化UI开发过程，并减少代码重复。 Composable Lora支持导出多个Composables，并提供了一些有用的工具函数来简化UI开发。Composable Lora还支持自定义主题和访问性。以下是一个简单的使用Composable Lora的代码示例：

import { createApp } from 'vue'
import { defineComponent } from 'vue'
import { createNamespace } from '@/components/utils/namespace'
import {
  useResult,
  useIntersectionObserver,
  onMountedOrActivated,
} from 'composable-lora'
const { createComponent } = createNamespace('Table')
export default createComponent({
  name: 'Table',
  setup(props, context) {
    const [result, setResult] = useResult()
    const onIntersection = useIntersectionObserver((result) => {
      if (result.isIntersecting) {
        setResult({ type: 'success' })
      }
    })
    onMountedOrActivated(onIntersection)
    return {
      result,
    }
  },
})

上面的代码演示了如何使用Composable Lora的useResult和useIntersectionObserver Composables。useResult用于处理异步请求，useIntersectionObserver用于观察DOM元素的交叉。此代码将在元素被交叉后显示成功消息。

三、Composable Kernel

Composable Kernel是一种极简的状态管理方案，它使用响应式状态和Composables来处理状态管理。它没有类似于Vuex或Redux的全局状态树，而是将状态管理分解成更小的Composables。 Composable Kernel支持类似于Vuex的操作和订阅响应式状态的变化。 Composable Kernel还提供了一些有用的工具函数，例如useAction和useGetters。使用Composable Kernel可以简化状态管理过程，并增强代码的可维护性和可重用性。以下是一个简单的使用Composable Kernel的代码示例：

import { createKernel, useGetter, useAction } from '@vue/composable-kernel'
const initialState = {
  count: 0,
}
const mutationTypes = {
  INCREMENT: 'increment',
  DECREMENT: 'decrement',
}
const getters = {
  doubledCount: (state) => state.count * 2,
}
const actions = {
  increment: ({ commit }) => {
    commit(mutationTypes.INCREMENT)
  },
  decrement: ({ commit }) => {
    commit(mutationTypes.DECREMENT)
  },
}
const {
  state,
  commit,
} = createKernel(initialState, { getters, actions, mutationTypes })
export function useCount() {
  const count = useGetter('count')
  const increment = useAction('increment')
  const decrement = useAction('decrement')
  return {
    count,
    increment,
    decrement,
  }
}

上面的代码演示了如何使用Composable Kernel创建一个简单的计数器应用。它定义了初始状态、变异类型、getter和action，并将其传递给createKernel函数。然后，它导出了一个名为useCount的自定义Hook，该Hook读取计数器的状态和增加和减少计数器数量的操作。

四、Composable Applications

Composable Applications是一种基于Composable的应用程序架构，它将应用程序拆分成小型的、可重用的模块。每个模块都负责执行一个特定的任务，并使用Composables实现其特定领域逻辑。Composable Applications支持使用依赖注入、事件总线和插件等开发模式。 Composable Applications使我们能够开发高度可维护、可扩展的应用程序。以下是一个简单的使用Composable Applications的代码示例：

// app.js
import { createApp } from 'vue'
import { createRouter, createWebHistory } from 'vue-router'
import { createAppComposable, App } from 'composable-app'
import { useAuth, provideAuth } from './auth'
import { useNotification, provideNotification } from './notification'
const router = createRouter({
  history: createWebHistory(),
  routes: [{ path: '/', component: Home }],
})
const { appComposable } = createAppComposable({
  use: [provideRouter(router), provideAuth(), provideNotification()],
})
createApp(App)
  .use(router)
  .use(appComposable)
  .mount('#app')
// auth.js
import { provide, inject } from 'composable-app'
// state
const state = reactive({ user: null })
// mutations
const mutations = {
  setUser(user) {
    state.user = user
  },
}
// actions
const actions = {
  login() {
    // perform login logic
    mutations.setUser({ name: 'Alice' })
  },
  logout() {
    mutations.setUser(null)
  },
}
// getters
const getters = {
  isLoggedIn() {
    return !!state.user
  },
}
// composable
export function useAuth() {
  const isLoggedIn = useGetter('isLoggedIn')
  const login = useAction('login')
  const logout = useAction('logout')
  return {
    isLoggedIn,
    login,
    logout,
  }
}
// provide/inject
function provideAuth() {
  provide('auth', { state, mutations, actions, getters })
}
function injectAuth() {
  return inject('auth')
}

上面的代码演示了一个基于Composable的简单Web应用程序。它定义了一个名为App的主组件，并在其中使用了Composable Applications的核心功能。使用依赖注入，我们处理了auth状态，通知，路由等。

五、Composable Finance

Composable Finance是基于Composable架构的DeFi平台。它的目的是为区块链应用程序提供简单、可组合的金融功能。Composable Finance将复杂的金融逻辑拆分成各个独立的Composable，然后将这些Composables组合在一起实现高级金融操作。 Composable Finance支持多个区块链平台和协议，包括Ethereum、Binance Smart Chain和Polygon。它提供了交易、借贷、保险、衍生品等功能。以下是一个简单的使用Composable Finance的代码示例：

// Sample code for trading tokens
import { compose } from 'composable-finance'
import { swap } from 'composable-finance/trade'
import { calculateMaxSlippage } from 'composable-finance/utils'
const tradingParams = {
  fromToken: 'ETH',
  toToken: 'USDT',
  amount: 1,
}
const maxSlippage = 0.01 // 1%
const slippage = calculateMaxSlippage(tradingParams, maxSlippage)
const tx = await compose([
  provideSigner(signer),
  provideWallet(wallet),
  provideSlippage(slippage),
})(swap)(tradingParams)

上面的代码演示了如何使用Composable Finance的swap Composable来交换代币。我们将输入参数和一个最大滑点值传递给swap Composable，然后使用compose将多个Composables组合在一起。最后，我们将组合后的函数应用于我们的输入参数，生成一个交易事务。

结语

Composable架构是一种简单而强大的开发模式。通过将应用程序拆分成可重用的模块（即Composables），我们可以实现更可维护和高效的代码。Composable为我们提供了极大的灵活性和可重用性，并可用于构建各种类型的应用程序，包括Web应用程序、DeFi平台等。

推荐文章