鸿蒙OS&UniApp开发支持多语言的国际化组件#三方框架 #Uniapp

使用UniApp开发支持多语言的国际化组件

在全球化的今天，一个优秀的应用往往需要支持多种语言以满足不同地区用户的需求。本文将详细讲解如何在UniApp框架中实现一套完整的国际化解决方案，从而轻松实现多语言切换功能。

前言

去年接手了一个面向国际市场的电商项目，需要支持中文、英文和法文三种语言。项目采用UniApp框架开发，可一开始我们团队在国际化方面遇到了不少问题：业务逻辑与翻译文本耦合度高、切换语言后某些组件不更新、动态内容翻译困难等。

经过多次迭代和重构，我们最终开发出了一套灵活且易用的国际化解决方案。这套方案不仅解决了当前项目的需求，还具有很好的通用性和扩展性。今天就把这些经验分享给大家，希望能给正在做国际化的小伙伴提供一些参考。

技术选型

国际化（i18n）库的选择上，我们对比了几个主流方案：

1. vue-i18n：Vue生态的标准国际化解决方案
2. i18next：功能全面但体积较大
3. 自研轻量级方案：针对UniApp定制开发

考虑到UniApp的跨端特性和性能要求，最终我们选择了vue-i18n（8.x版本），它与Vue深度集成且体积适中，社区支持也比较完善。

基础配置

1. 安装依赖

# 项目根目录执行
npm install vue-i18n@8.27.0

2. 创建多语言文件

我们在项目中创建了专门的语言文件目录结构：

/lang
  /en.js     # 英文
  /zh-CN.js  # 简体中文
  /fr.js     # 法文
  /index.js  # 统一导出

以zh-CN.js为例：

export default {
  common: {
    confirm: '确认',
    cancel: '取消',
    loading: '加载中...',
    noData: '暂无数据',
  },
  login: {
    title: '用户登录',
    username: '用户名',
    password: '密码',
    remember: '记住密码',
    submit: '登录',
    forgotPassword: '忘记密码?',
  },
  // 更多模块...
}

3. 配置i18n实例

在lang/index.js中配置i18n：

import Vue from 'vue'
import VueI18n from 'vue-i18n'
import enUS from './en.js'
import zhCN from './zh-CN.js'
import fr from './fr.js'
import { getSystemLanguage } from '@/utils/system'

Vue.use(VueI18n)

// 获取系统语言或存储的语言设置
const getLanguage = () => {
  // 优先使用存储的语言设置
  const localLanguage = uni.getStorageSync('language')
  if (localLanguage) return localLanguage
  
  // 否则获取系统语言
  const systemLanguage = getSystemLanguage()
  // 映射系统语言到我们支持的语言
  const languageMap = {
    'en': 'en',
    'zh-CN': 'zh-CN',
    'fr': 'fr'
  }
  
  return languageMap[systemLanguage] || 'en' // 默认英文
}

const i18n = new VueI18n({
  locale: getLanguage(),
  messages: {
    'en': enUS,
    'zh-CN': zhCN,
    'fr': fr
  },
  silentTranslationWarn: true, // 禁用翻译警告
  fallbackLocale: 'en' // 回退语言
})

export default i18n

4. 在main.js中挂载i18n

import Vue from 'vue'
import App from './App'
import i18n from './lang'

Vue.config.productionTip = false

// 挂载i18n实例
Vue.prototype._i18n = i18n

const app = new Vue({
  i18n,
  ...App
})

app.$mount()

封装国际化组件

为了使国际化在整个应用中更加方便使用，我们封装了一个专用组件：

<!-- components/i18n-text/i18n-text.vue -->
<template>
  <text :class="['i18n-text', customClass]" :style="customStyle">
    {{ finalText }}
  </text>
</template>

<script>
export default {
  name: 'i18n-text',
  props: {
    // i18n键名
    i18n: {
      type: String,
      default: ''
    },
    // 参数对象，用于替换占位符
    params: {
      type: Object,
      default: () => ({})
    },
    // 不使用i18n时的直接文本
    text: {
      type: String,
      default: ''
    },
    // 自定义类名
    customClass: {
      type: String,
      default: ''
    },
    // 自定义样式
    customStyle: {
      type: String,
      default: ''
    }
  },
  computed: {
    finalText() {
      // 优先使用i18n键名进行翻译
      if (this.i18n) {
        return this.$t(this.i18n, this.params)
      }
      // 否则直接使用传入的文本
      return this.text
    }
  }
}
</script>

<style>
.i18n-text {
  /* 可根据需要添加样式 */
}
</style>

注册为全局组件：

// components/index.js
import i18nText from './i18n-text/i18n-text.vue'

export default {
  install(Vue) {
    Vue.component('i18n-text', i18nText)
    // 其他全局组件...
  }
}

// main.js中引入并使用
import components from './components'
Vue.use(components)

实用功能开发

1. 语言切换工具类

// utils/language.js
import i18n from '@/lang'

export const switchLanguage = (lang) => {
  // 切换语言
  i18n.locale = lang
  // 持久化语言设置
  uni.setStorageSync('language', lang)
  
  // 通知所有页面语言已变更
  uni.$emit('languageChanged', lang)
  
  // 刷新当前页面
  const pages = getCurrentPages()
  const currentPage = pages[pages.length - 1]
  if (currentPage && currentPage.$vm) {
    currentPage.$vm.$forceUpdate()
  }
}

// 获取当前语言
export const getCurrentLanguage = () => {
  return i18n.locale
}

// 检查是否为RTL语言(如阿拉伯语)
export const isRTLLanguage = () => {
  const rtlLanguages = ['ar', 'he'] // 从右到左书写的语言代码
  return rtlLanguages.includes(getCurrentLanguage())
}

2. 语言选择器组件

<!-- components/language-picker/language-picker.vue -->
<template>
  <view class="language-picker">
    <view class="current-language" @tap="showOptions = true">
      <image :src="languageIcons[currentLanguage]" class="language-icon"></image>
      <text>{{ languageNames[currentLanguage] }}</text>
      <uni-icons type="bottom" size="14" color="#666"></uni-icons>
    </view>
    
    <uni-popup ref="popup" type="bottom" @change="popupChange">
      <view class="language-options">
        <view class="popup-title">
          <i18n-text i18n="settings.selectLanguage"></i18n-text>
        </view>
        <view 
          v-for="(name, code) in languageNames" 
          :key="code"
          class="language-option"
          :class="{ active: currentLanguage === code }"
          @tap="changeLanguage(code)"
        >
          <image :src="languageIcons[code]" class="language-icon"></image>
          <text>{{ name }}</text>
          <uni-icons v-if="currentLanguage === code" type="checkmarkempty" size="18" color="#007AFF"></uni-icons>
        </view>
        <view class="cancel-btn" @tap="showOptions = false">
          <i18n-text i18n="common.cancel"></i18n-text>
        </view>
      </view>
    </uni-popup>
  </view>
</template>

<script>
import { getCurrentLanguage, switchLanguage } from '@/utils/language'

export default {
  name: 'language-picker',
  data() {
    return {
      showOptions: false,
      currentLanguage: getCurrentLanguage(),
      languageNames: {
        'en': 'English',
        'zh-CN': '简体中文',
        'fr': 'Français',
      },
      languageIcons: {
        'en': '/static/flags/en.png',
        'zh-CN': '/static/flags/zh-cn.png',
        'fr': '/static/flags/fr.png',
      }
    }
  },
  watch: {
    showOptions(val) {
      if (val) {
        this.$refs.popup.open()
      } else {
        this.$refs.popup.close()
      }
    }
  },
  methods: {
    changeLanguage(lang) {
      if (this.currentLanguage === lang) {
        this.showOptions = false
        return
      }
      
      // 设置加载状态
      uni.showLoading({ title: '' })
      
      // 切换语言
      switchLanguage(lang)
      this.currentLanguage = lang
      this.showOptions = false
      
      setTimeout(() => {
        uni.hideLoading()
      }, 500)
    },
    popupChange(e) {
      this.showOptions = e.show
    }
  }
}
</script>

<style lang="scss">
.language-picker {
  .current-language {
    display: flex;
    align-items: center;
    padding: 6rpx 16rpx;
    border-radius: 8rpx;
    background-color: rgba(0, 0, 0, 0.05);
    
    .language-icon {
      width: 36rpx;
      height: 36rpx;
      margin-right: 8rpx;
      border-radius: 50%;
    }
  }
  
  .language-options {
    background-color: #fff;
    border-radius: 16rpx 16rpx 0 0;
    padding-bottom: env(safe-area-inset-bottom);
    
    .popup-title {
      text-align: center;
      padding: 30rpx 0;
      font-size: 32rpx;
      font-weight: 500;
      border-bottom: 1rpx solid #eee;
    }
    
    .language-option {
      display: flex;
      align-items: center;
      padding: 30rpx 40rpx;
      border-bottom: 1rpx solid #f5f5f5;
      
      .language-icon {
        width: 50rpx;
        height: 50rpx;
        margin-right: 20rpx;
        border-radius: 50%;
      }
      
      &.active {
        background-color: #f9f9f9;
      }
    }
    
    .cancel-btn {
      text-align: center;
      padding: 30rpx 0;
      color: #007AFF;
      font-size: 32rpx;
    }
  }
}
</style>

实战应用

1. 在页面中使用

<!-- pages/home/home.vue -->
<template>
  <view class="home">
    <view class="header">
      <i18n-text i18n="home.title" class="title"></i18n-text>
      <language-picker></language-picker>
    </view>
    
    <view class="content">
      <view class="welcome-message">
        <i18n-text i18n="home.welcome" :params="{ username: userInfo.nickname }"></i18n-text>
      </view>
      
      <view class="product-list">
        <view class="product-item" v-for="(item, index) in productList" :key="index">
          <image :src="item.image" mode="aspectFill"></image>
          <view class="product-info">
            <!-- 产品标题可能来自接口，需要动态翻译 -->
            <text class="product-title">{{ getProductTitle(item) }}</text>
            <text class="product-price">{{ formatCurrency(item.price) }}</text>
          </view>
        </view>
      </view>
    </view>
  </view>
</template>

<script>
export default {
  data() {
    return {
      userInfo: {
        nickname: '张三'
      },
      productList: []
    }
  },
  onLoad() {
    this.fetchProductList()
    
    // 监听语言变化刷新数据
    uni.$on('languageChanged', this.handleLanguageChange)
  },
  onUnload() {
    uni.$off('languageChanged', this.handleLanguageChange)
  },
  methods: {
    async fetchProductList() {
      // 模拟接口请求
      const res = await this.$api.product.getList()
      this.productList = res.data
    },
    handleLanguageChange() {
      // 语言变化时刷新数据
      this.fetchProductList()
    },
    // 根据当前语言获取正确的产品标题
    getProductTitle(item) {
      const lang = this.$i18n.locale
      const titleKey = `title_${lang.replace('-', '_')}`
      
      // 如果接口返回了对应语言的标题，优先使用
      if (item[titleKey]) {
        return item[titleKey]
      }
      
      // 否则使用默认语言标题
      return item.title
    },
    // 根据当前语言格式化货币
    formatCurrency(price) {
      const lang = this.$i18n.locale
      const currencyMap = {
        'zh-CN': 'CNY',
        'en': 'USD',
        'fr': 'EUR'
      }
      
      return new Intl.NumberFormat(lang, {
        style: 'currency',
        currency: currencyMap[lang] || 'USD'
      }).format(price)
    }
  }
}
</script>

2. 处理动态内容和API数据

在实际项目中，我们经常需要处理来自API的多语言数据，以下是一些常用策略：

// 处理API返回的多语言内容
export const processMultiLangContent = (data) => {
  const currentLang = getCurrentLanguage()
  const result = {}
  
  // 递归处理对象
  const processObject = (obj) => {
    const newObj = {}
    
    Object.keys(obj).forEach(key => {
      const value = obj[key]
      
      // 如果是多语言字段对象 { zh-CN: '中文', en: 'English' }
      if (value && typeof value === 'object' && !Array.isArray(value) && value[currentLang]) {
        newObj[key] = value[currentLang]
      } 
      // 如果是普通对象，递归处理
      else if (value && typeof value === 'object' && !Array.isArray(value)) {
        newObj[key] = processObject(value)
      }
      // 如果是数组，处理数组中的每个对象
      else if (Array.isArray(value)) {
        newObj[key] = value.map(item => {
          if (typeof item === 'object') {
            return processObject(item)
          }
          return item
        })
      }
      // 其他情况直接赋值
      else {
        newObj[key] = value
      }
    })
    
    return newObj
  }
  
  return processObject(data)
}

进阶技巧

1. 请求拦截器添加语言参数

为了让后端能够返回对应语言的内容，我们在请求拦截器中添加语言参数：

// request.js
import { getCurrentLanguage } from '@/utils/language'

// 请求拦截
export const requestInterceptor = (config) => {
  // 添加语言参数
  config.header = {
    ...config.header,
    'Accept-Language': getCurrentLanguage()
  }
  return config
}

2. 处理消息提示

封装消息提示方法，自动应用翻译：

// utils/message.js
import i18n from '@/lang'

export const showToast = (messageKey, params = {}) => {
  uni.showToast({
    title: i18n.t(messageKey, params),
    icon: 'none'
  })
}

export const showModal = (titleKey, contentKey, params = {}) => {
  return new Promise((resolve, reject) => {
    uni.showModal({
      title: i18n.t(titleKey),
      content: i18n.t(contentKey, params),
      confirmText: i18n.t('common.confirm'),
      cancelText: i18n.t('common.cancel'),
      success: (res) => {
        if (res.confirm) {
          resolve(true)
        } else {
          resolve(false)
        }
      },
      fail: reject
    })
  })
}

常见问题及解决方案

1. 组件未响应语言变化

解决方案：使用事件总线通知组件重新渲染

// 切换语言时触发全局事件
uni.$emit('languageChanged', newLang)

// 在组件中监听
created() {
  this.unsubscribe = uni.$on('languageChanged', this.handleLanguageChange)
},
beforeDestroy() {
  this.unsubscribe()
},
methods: {
  handleLanguageChange() {
    this.$forceUpdate()
  }
}

2. 日期格式化问题

解决方案：封装日期格式化工具函数

// utils/date.js
import { getCurrentLanguage } from './language'

export const formatDate = (date, format = 'short') => {
  const targetDate = new Date(date)
  const lang = getCurrentLanguage()
  
  const options = {
    'short': { year: 'numeric', month: 'short', day: 'numeric' },
    'long': { year: 'numeric', month: 'long', day: 'numeric', weekday: 'long' },
    'time': { hour: '2-digit', minute: '2-digit' },
    'full': { 
      year: 'numeric', month: 'long', day: 'numeric', 
      weekday: 'long', hour: '2-digit', minute: '2-digit' 
    }
  }
  
  return new Intl.DateTimeFormat(lang, options[format]).format(targetDate)
}

性能优化

为了提高应用性能，我们采取了以下措施：

1. 按需加载语言包：根据用户设置的语言只加载需要的语言包
2. 缓存翻译结果：对频繁使用的翻译进行缓存
3. 避免过度翻译：只翻译用户可见内容，非关键内容使用默认语言

// lang/loader.js - 动态加载语言包
export const loadLanguage = async (lang) => {
  let messages = {}
  
  try {
    // 动态导入语言包
    const module = await import(/* webpackChunkName: "[request]" */ `./${lang}.js`)
    messages = module.default
  } catch (e) {
    console.error(`Could not load language pack: ${lang}`, e)
    // 加载失败时使用备用语言
    const fallbackModule = await import(/* webpackChunkName: "en" */ './en.js')
    messages = fallbackModule.default
  }
  
  return messages
}

总结

通过本文，我们详细介绍了UniApp中实现国际化的完整方案，从基础配置到组件封装，再到实际应用和性能优化。这套方案具有以下特点：

1. 易用性：通过组件化设计，使翻译使用变得简单
2. 灵活性：支持静态翻译和动态内容翻译
3. 可扩展性：轻松添加新语言支持
4. 性能优化：按需加载和缓存机制保证性能

希望这篇文章能对大家在UniApp项目中实现国际化有所帮助。如果有任何问题或建议，欢迎在评论区留言交流！

参考资料

1. vue-i18n官方文档
2. UniApp全局组件开发文档
3. Web国际化API