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

/**
 * Always return false.
 */
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.hasOwnProperty
export 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 = /*#__PURE__*/ 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 = /*#__PURE__*/ 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)/g
/**
 * @private
 */
export const camelize = cacheStringFunction((str: string): string => {
  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))
})

將-連接的字符串轉換為駝峰式，同Vue2的camelize相同；

capitalize

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

將駝峰式字符串轉換為-連接的字符串，同Vue2的hyphenate相同；

capitalize

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

將字符串首字母大寫，同Vue2的capitalize相同；

toHandlerKey

/**
 * @private
 */
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

/**
 * "123-foo" will be parsed to 123
 * This is used for the .number modifier in v-model
 */
export const looseToNumber = (val: any): any => {
  const n = parseFloat(val)
  return isNaN(n) ? val : n
}

將字符串轉換為數字，如果轉換失敗，返回原字符串；

通過注釋知道主要用于v-model的.number修飾符；

toNumber

/**
 * Only conerces number-like strings
 * "123-foo" will be returned as-is
 */
export const toNumber = (val: any): any => {
  const n = isString(val) ? Number(val) : NaN
  return isNaN(n) ? val : n
}

將字符串轉換為數字，如果轉換失敗，返回原數據；

getGlobalThis

let _globalThis: any
export 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模塊下的工具函數有哪些”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！