The complete Vue 3 + TypeScript development guide is being adopted more and more widely in frontend development. This article dives into its core principles and best practices from real projects.
Basic Usage
The key lies in understanding the core logic:
javascript
import { ref, computed, watch, onMounted } from 'vue'
export default {
setup() {
const count = ref(0)
const doubled = computed(() => count.value * 2)
watch(count, (newVal, oldVal) => {
console.log(`count: ${oldVal} -> ${newVal}`)
})
onMounted(() => { console.log('组件已挂载') })
return { count, doubled }
}
}
Performance optimization should be tailored to specific scenarios; not all cases require over-optimization.
Advanced Usage
We can improve it in the following ways:
javascript
type UnwrapPromise<T> = T extends Promise<infer U> ? U : T
async function fetchUser(id: string) {
const res = await fetch(`/api/users/${id}`)
return res.json() as Promise<{ id: string; name: string; email: string }>
}
type User = UnwrapPromise<ReturnType<typeof fetchUser>>
// 类型安全的事件系统
interface EventMap {
login: { userId: string; timestamp: number }
logout: { userId: string }
}
class TypedEmitter<T extends Record<string, any>> {
private handlers = new Map<keyof T, Set<Function>>()
on<K extends keyof T>(event: K, handler: (payload: T[K]) => void) {
if (!this.handlers.has(event)) this.handlers.set(event, new Set())
this.handlers.get(event)!.add(handler)
}
emit<K extends keyof T>(event: K, payload: T[K]) {
this.handlers.get(event)?.forEach(h => h(payload))
}
}
Practical Cases
Let's start with the basic implementation:
javascript
type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T
interface AppConfig {
api: { baseUrl: string; timeout: number; retries: number }
ui: { theme: 'light' | 'dark'; language: string; pageSize: number }
}
type PartialConfig = DeepPartial<AppConfig>
function mergeConfig(defaults: AppConfig, overrides: PartialConfig): AppConfig {
const result = { ...defaults }
for (const key of Object.keys(overrides) as (keyof AppConfig)[]) {
if (overrides[key] && typeof overrides[key] === 'object') {
result[key] = { ...defaults[key], ...overrides[key] } as any
}
}
return result
}
This code demonstrates the basic usage. In real projects, you also need to consider error handling and edge cases.
Performance Optimization
Building on this foundation, we can further optimize:
javascript
import { reactive, toRefs, computed } from 'vue'
function useCounter(initial = 0) {
const state = reactive({ count: initial, history: [initial] })
const doubled = computed(() => state.count * 2)
function increment() {
state.count++
state.history.push(state.count)
}
return { ...toRefs(state), doubled, increment }
}
This pattern is very practical in large projects and can significantly reduce maintenance costs.
Summary
- Stay updated with the community; technical solutions need continuous iteration
- Don't adopt new technology just for the sake of it
- Code examples are for reference only and need to be adjusted according to your business scenario
- The Vue 3 + TypeScript guide isn't a silver bullet; choose it based on your project's size and tech stack
