Lodash 源码分析

# words

# Description

拆分字符串 string 中的词为数组

# Params

(string, pattern)

{string} [string=''] 要拆分的字符串

[pattern] 匹配模式

# Return

Array

# Depend

import unicodeWords from './.internal/unicodeWords.js'

unicodeWords 源码分析

# Code

const hasUnicodeWord = RegExp.prototype.test.bind(
  /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/
)

/** Used to match words composed of alphanumeric characters. */
const reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g

function asciiWords(string) {
  return string.match(reAsciiWord)
}

function words(string, pattern) {
  if (pattern === undefined) {
    const result = hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string)
    return result || []
  }
  return string.match(pattern) || []
}

# Analyze

# 正则

  1. hasUnicodeWord
  1. reAsciiWord -- 用于匹配由字母数字字符组成的单词
  1. 定义 asciiWords 方法，用于 ascii 字符的分割， 基于 reAsciiWord 正则
  2. 首先判断是否传入了 pattern 校验规则， 用的是 ===， 传 null 的也会走自定义的逻辑
  3. 如果传入了则使用 pattern 进行 match ， 有结果时返回 结果数组，没有结果返回 空数组
  4. 如果没有传入则使用默认的正则进行 match
  5. 这里进行了 hasUnicodeWord 的判断，这个正则判断的规则，满足以下条件的都会调用 unicodeWords ，否则调用 asciiWords
    • 存在 小写字母后紧跟大写字母 [a-z][A-Z], e.g: aA
    • 存在 两个大写字母后跟小写字母 [A-Z]{2}[a-z], e.g: AAa
    • 存在 数字后跟字母 [0-9][a-zA-Z], e.g: 0A
    • 存在 字母后跟数组 [a-zA-Z][0-9], e.g: A0
    • 不在 字母数字和空格之内 [^a-zA-Z0-9 ], e.g: |
  6. 拿到 match 的结果，如果存在就返回，否则返回空数组

# Remark

  1. test MDN (opens new window)
  2. Strict equality (===) MDN (opens new window) -- ECMA (opens new window)
  3. 相等(==) MDN (opens new window)
  4. == 和 === 区别
    • 如果操作数的类型不同，则返回 false。
    • 如果两个操作数都是对象，只有当它们指向同一个对象时才返回 true。
    • 如果两个操作数都为 null，或者两个操作数都为 undefined，返回 true。
    • 如果两个操作数有任意一个为 NaN，返回 false。
    • 否则，比较两个操作数的值：
      • 数字类型必须拥有相同的数值。+0 和 -0 会被认为是相同的值。
      • 字符串类型必须拥有相同顺序的相同字符。
      • 布尔运算符必须同时为 true 或同时为 false。

全等运算符与相等运算符（==）最显著的区别是，如果操作数的类型不同，== 运算符会在比较之前尝试将它们转换为相同的类型

被比较值 B
Undefined Null Number String Boolean Object
被比较值 A Undefined true true false false false IsFalsy(B)
Null true true false false false IsFalsy(B)
Number false false A === B A === ToNumber(B) A=== ToNumber(B) A== ToPrimitive(B)
String false false ToNumber(A) === B A === B ToNumber(A) === ToNumber(B) ToPrimitive(B) == A
Boolean false false ToNumber(A) === B ToNumber(A) === ToNumber(B) A === B ToNumber(A) == ToPrimitive(B)
Object false false ToPrimitive(A) == B ToPrimitive(A) == B ToPrimitive(A) == ToNumber(B)

A === B

# Example

hasUnicodeWord('I want to go to sleep') // false
hasUnicodeWord('I want to go to sleep.') // true
words('I want to go to sleep') // [ 'I', 'want', 'to', 'go', 'to', 'sleep' ]
words('I want to go to sleep.') // [ 'I', 'want', 'to', 'go', 'to', 'sleep' ]

← xor →