Vue3 shared模块下的工具函数有哪些

本篇内容主要讲解“vue3 shared模块下的工具函数有哪些”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Vue3 shared模块下的工具函数有哪些”吧!

Vue3的工具函数对比于Vue2的工具函数变化还是很大的，个人感觉主要还是体现在语法上，已经全面拥抱es6了；

对比于工具类的功能变化并没有多少，大多数基本上都是一样的，只是语法上和实现上有略微的区别。

所有工具函数

• makeMap: 生成一个类似于Set的对象，用于判断是否存在某个值

• EMPTY_OBJ: 空对象

• EMPTY_ARR: 空数组

• NOOP: 空函数

• NO: 返回false的函数

• isOn: 判断是否是on开头的事件

• isModelListener: 判断onUpdate开头的字符串

• extend: 合并对象

• remove: 移除数组中的某个值

• hasOwn: 判断对象是否有某个属性

• isArray: 判断是否是数组

• isMap: 判断是否是Map

• isSet: 判断是否是Set

• isDate: 判断是否是Date

• isRegExp: 判断是否是RegExp

• isFunction: 判断是否是函数

• isString: 判断是否是字符串

• isSymbol: 判断是否是Symbol

• isObject: 判断是否是对象

• isPromise: 判断是否是Promise

• objectToString: Object.prototype.toString

• toTypeString: Object.prototype.toString的简写

• toRawType: 获取对象的类型

• isPlainObject: 判断是否是普通对象

• isIntegerKey: 判断是否是整数key

• isReservedProp: 判断是否是保留属性

• isBuiltInDirective: 判断是否是内置指令

• camelize: 将字符串转换为驼峰

• hyphenate: 将字符串转换为连字符

• capitalize: 将字符串首字母大写

• toHandlerKey: 将字符串转换为事件处理的key

• hasChanged: 判断两个值是否相等

• invokeArrayFns: 调用数组中的函数

• def: 定义对象的属性

• looseToNumber: 将字符串转换为数字

• toNumber: 将字符串转换为数字

• getGlobalThis: 获取全局对象

• genPropsAccessExp: 生成props的访问表达式

这其中有大部分和Vue2的工具函数是一样的，还有数据类型的判断，使用的是同一种方式，因为有了之前Vue2的阅读经验，所以这次快速阅读；而且这次是直接源码，ts版本的，不再处理成js，所以直接阅读ts源码。

正式开始

makeMap

export function makeMap(  str: string,  expectsLowerCase?: boolean): (key: string) => boolean {  const map: Record<string, boolean> = Object.create(null)  const list: Array<string> = str.split(',')  for (let i = 0; i < list.length; i++) {    map[list[i]] = true  }  return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]}

makeMap的源码在同级目录下的makeMap.ts文件中，引入进来之后直接使用export关键字导出，实现方式和Vue2的实现方式相同；

EMPTY_OBJ & EMPTY_ARR

export const EMPTY_OBJ: { readonly [key: string]: any } = __DEV__  ? Object.freeze({})  : {}export const EMPTY_ARR = __DEV__ ? Object.freeze([]) : []

EMPTY_OBJ和EMPTY_ARR的实现方式和Vue2的emptyObject相同，都是使用Object.freeze冻结对象，防止对象被修改；

NOOP

export const NOOP = () => {}

和Vue2的noop实现方式相同，都是一个空函数，移除了入参；

NO

export const NO = () => false

和Vue2的no实现方式相同，都是一个返回false的函数，移除了入参；

isOn

const onRE = /^on[^a-z]/export const isOn = (key: string) => onRE.test(key)

判断是否是on开头的事件，并且on后面的第一个字符不是小写字母；

isModelListener

export const isModelListener = (key: string) => key.startsWith('onUpdate:')

判断是否是onUpdate:开头的字符串；

参考：startWith

extend

export const extend = Object.assign

直接拥抱es6的Object.assign，Vue2的实现方式是使用for in循环；

remove

export const remove = <T>(arr: T[], el: T) => {  const i = arr.indexOf(el)  if (i > -1) {    arr.splice(i, 1)  }}

对比于Vue2删除了一些代码，之前的快速删除最后一个元素的判断不见了；

猜测可能是因为有bug，因为大家都知道Vue2的数组响应式必须使用Array的api，那样操作可能会导致数组响应式失效；

hasOwn

const hasOwnProperty = Object.prototype.hasOwnPropertyexport const hasOwn = (  val: object,  key: string | symbol): key is keyof typeof val => hasOwnProperty.call(val, key)

使用的是Object.prototype.hasOwnProperty，和Vue2相同；

isArray

export const isArray = Array.isArray

使用的是Array.isArray，和Vue2相同；

isMap & isSet & isDate & isRegExp

export const isMap = (val: unknown): val is Map<any, any> =>  toTypeString(val) === '[object Map]'export const isSet = (val: unknown): val is Set<any> =>  toTypeString(val) === '[object Set]'export const isDate = (val: unknown): val is Date =>  toTypeString(val) === '[object Date]'export const isRegExp = (val: unknown): val is RegExp =>  toTypeString(val) === '[object RegExp]'

都是使用Object.toString来判断类型，对比于Vue2新增了isMap和isSet和isDate，实现方式没变；

isFunction & isString & isSymbol & isObject

export const isFunction = (val: unknown): val is Function =>  typeof val === 'function'export const isString = (val: unknown): val is string => typeof val === 'string'export const isSymbol = (val: unknown): val is symbol => typeof val === 'symbol'export const isObject = (val: unknown): val is Record<any, any> =>  val !== null && typeof val === 'object'

和Vue2的实现方式相同，都是使用typeof来判断类型，新增了isSymbol；

isPromise

export const isPromise = <T = any>(val: unknown): val is Promise<T> => {  return isObject(val) && isFunction(val.then) && isFunction(val.catch)}

和Vue2对比修改了实现方式，但是判断逻辑没变；

objectToString

export const objectToString = Object.prototype.toString

直接是Object.prototype.toString；

toTypeString

export const toTypeString = (value: unknown): string =>  objectToString.call(value)

对入参执行Object.prototype.toString；

toRawType

export const toRawType = (value: unknown): string => {  // extract "RawType" from strings like "[object RawType]"  return toTypeString(value).slice(8, -1)}

和Vue2的实现方式相同；

isPlainObject

export const isPlainObject = (val: unknown): val is object =>  toTypeString(val) === '[object Object]'

和Vue2的实现方式相同；

isIntegerKey

export const isIntegerKey = (key: unknown) =>  isString(key) &&  key !== 'NaN' &&  key[0] !== '-' &&  '' + parseInt(key, 10) === key

判断一个字符串是不是由一个整数组成的；

isReservedProp

export const isReservedProp =  makeMap(  // the leading comma is intentional so empty string "" is also included  ',key,ref,ref_for,ref_key,' +    'onVnodeBeforeMount,onVnodeMounted,' +    'onVnodeBeforeUpdate,onVnodeUpdated,' +    'onVnodeBeforeUnmount,onVnodeUnmounted')

使用makeMap生成一个对象，用于判断入参是否是内部保留的属性；

isBuiltInDirective

export const isBuiltInDirective =  makeMap(  'bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo')

使用makeMap生成一个对象，用于判断入参是否是内置的指令；

cacheStringFunction

const cacheStringFunction = <T extends (str: string) => string>(fn: T): T => {  const cache: Record<string, string> = Object.create(null)  return ((str: string) => {    const hit = cache[str]    return hit || (cache[str] = fn(str))  }) as T}

同Vue2的cached相同，用于缓存字符串；

camelize

const camelizeRE = /-(\w)/gexport const camelize = cacheStringFunction((str: string): string => {  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))})

将-连接的字符串转换为驼峰式，同Vue2的camelize相同；

capitalize

const hyphenateRE = /\B([A-Z])/gexport const hyphenate = cacheStringFunction((str: string) =>  str.replace(hyphenateRE, '-$1').toLowerCase())

将驼峰式字符串转换为-连接的字符串，同Vue2的hyphenate相同；

capitalize

export const capitalize = cacheStringFunction(  (str: string) => str.charAt(0).toUpperCase() + str.slice(1))

将字符串首字母大写，同Vue2的capitalize相同；

toHandlerKey

export const toHandlerKey = cacheStringFunction((str: string) =>  str ? `on${capitalize(str)}` : ``)

将字符串首字母大写并在前面加上on；

hasChanged

// compare whether a value has changed, accounting for NaN.export const hasChanged = (value: any, oldValue: any): boolean =>  !Object.is(value, oldValue)

和Vue2相比，移除了polyfill，直接使用Object.is；

invokeArrayFns

export const invokeArrayFns = (fns: Function[], arg?: any) => {  for (let i = 0; i < fns.length; i++) {    fns[i](arg)  }}

批量调用传递过来的函数列表，如果有参数，会将参数传递给每个函数；

def

export const def = (obj: object, key: string | symbol, value: any) => {  Object.defineProperty(obj, key, {    configurable: true,    enumerable: false,    value  })}

使用Object.defineProperty定义一个属性，并使这个属性不可枚举；

looseToNumber

export const looseToNumber = (val: any): any => {  const n = parseFloat(val)  return isNaN(n) ? val : n}

将字符串转换为数字，如果转换失败，返回原字符串；

通过注释知道主要用于v-model的.number修饰符；

toNumber

export const toNumber = (val: any): any => {  const n = isString(val) ? Number(val) : NaN  return isNaN(n) ? val : n}

将字符串转换为数字，如果转换失败，返回原数据；

getGlobalThis

let _globalThis: anyexport const getGlobalThis = (): any => {  return (    _globalThis ||    (_globalThis =      typeof globalThis !== 'undefined'        ? globalThis        : typeof self !== 'undefined'        ? self        : typeof window !== 'undefined'        ? window        : typeof global !== 'undefined'        ? global        : {})  )}

获取全局对象，根据环境不同返回的对象也不同；

genPropsAccessExp

const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/export function genPropsAccessExp(name: string) {  return identRE.test(name)    ? `__props.${name}`    : `__props[${JSON.stringify(name)}]`}

生成props的访问表达式，如果name是合法的标识符，直接返回__props.name，否则返回通过JSON.stringify转换后的__props[name]。

到此，相信大家对“Vue3 shared模块下的工具函数有哪些”有了更深的了解，不妨来实际操作一番吧！这里是编程网网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！