如果字符串长度小于length则从左侧和右侧填充字符，如果没法平均分配，则截断超出的长度

/**
 * 如果string字符串长度小于length则从左侧和右侧填充字符，如果没法平均分配，则截断超出的长度
 * Pads `string` on the left and right sides if it's shorter than `length`.
 * Padding characters are truncated if they can't be evenly divided by `length`
 * @param {string} [string=''] The string to pad
 * @param {number} [length=0] The padding length
 * @param {string} [chars=' '] The string used as padding
 * @returns {string} Returns the padding string
 * @example
 * pad('abc', 8)
 * // => 'abc'
 * pad('abc', 8, '_-')
 * // => '_-abc_-_'
 * pad('abc', 3)
 * // => 'abc'
 */

import toString from "./toString"  //我的博客搜索【转换`value`成字符串，`null`和`undefined`返回空字符串，`-0`转成'-0'】
import toInteger from "./toInteger" //我的博客搜索【转换为整数】
import stringSize from "./stringSize"
import createPadding from "./createPadding"

function pad(string, length, chars) {
  string = toString(string)
  length = toInteger(length)

  var strLength = length ? stringSize(string) : 0
  if (!length || strLength >= length) {
    return string
  }
  var mid = (length - strLength) / 2
  return (
    createPadding(Math.floor(mid), chars) +
    string +
    createPadding(Math.ceil(mid), chars)
  )
}

export default pad

/**
 * Creates the padding for `string` based on `length`.The `chars` string
 * is truncated if the number of characters exceeds `length`
 * @param {number} length The padding length
 * @param {string} [chars=' '] The string used as padding
 * @returns {string} Returns the padding for `string`
 */

import baseToString from "./baseToString"
import baseRepeat from "./baseRepeat"
import stringSize from "./stringSize"

function createPadding(length, chars) {
  chars = chars === undefined ? " " : baseToString(chars)

  var charsLength = chars.length
  if (charsLength < 2) {
    return charsLength ? baseRepeat(chars, length) : chars
  }
  var result = baseRepeat(chars, Math.ceil(length / stringSize(chars)))
  return result.slice(0, length)
}

export default createPadding

/**
 * The base implementation of `toString` which doesn't convert nullish values to empty strings
 * @param {*} value The value to process
 * @returns {string} Returns the string
 */

// A specialized version of `map` for arrays without for iteratee shorthands
function arrayMap(array, iteratee) {
  var index = -1,
    length = array == null ? 0 : array.length,
    result = Array(length)

  while (++index < length) {
    result[index] = iteratee(array[index], index, array)
  }
  return result
}

const symbolTag = "[object Symbol]"

function isObjectLike(value) {
  return typeof value == "object" && value !== null
}

// 判断`value`是否是`Symbol`类型
function isSymbol(value) {
  return (
    typeof value === "symbol" ||
    (isObjectLike(value) && Object.prototype.toString.call(value) === symbolTag)
  )
}

function baseToString(value) {
  if (typeof value === "string") {
    return value
  }
  if (Array.isArray(value)) {
    return arrayMap(value, baseToString) + ""
  }
  if (isSymbol(value)) {
    return Symbol.prototype.toString
      ? Symbol.prototype.toString.call(value)
      : ""
  }
  var result = value + ""
  return result == "0" && 1 / value == -Infinity ? "-0" : result
}

export default baseToString

/**
 * The base implementation of `repeat` which doesn't coerce arguments
 * @param {string} string The string to repeat
 * @param {number} n The number of times to repeat the string
 * @returns {string} Returns the repeated string
 */

function baseRepeat(string, n) {
  var result = ""
  if (!string || n < 1 || n > Number.MAX_SAFE_INTEGER) {
    return result
  }

  // 通过平方算法利用取幂来实现更快的重复。
  // Leverage the exponentiation by squaring algorithm for a faster repeat.
  // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
  do {
    if (n % 2) {
      result += string
    }
    n = Math.floor(n / 2)
    if (n) {
      string += string
    }
  } while (n)

  return result
}

export default baseRepeat

/**
 * Gets the number of symbols in `string`
 * @param {string} string The string to inspect
 * @returns {number} Returns the string size
 */

import hasUnicode from "./hasUnicode"

// Used to compose unicode character classes.
var rsAstralRange = "\\ud800-\\udfff",
  rsComboMarksRange = "\\u0300-\\u036f",
  reComboHalfMarksRange = "\\ufe20-\\ufe2f",
  rsComboSymbolsRange = "\\u20d0-\\u20ff",
  rsComboRange =
    rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
  rsVarRange = "\\ufe0e\\ufe0f"

// Used to compose unicode capture groups.
var rsAstral = "[" + rsAstralRange + "]",
  rsCombo = "[" + rsComboRange + "]",
  rsFitz = "\\ud83c[\\udffb-\\udfff]",
  rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")",
  rsNonAstral = "[^" + rsAstralRange + "]",
  rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}",
  rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]",
  rsZWJ = "\\u200d"

// Used to compose unicode regexes.
var rsSymbol =
  "(?:" +
  [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join(
    "|"
  ) +
  ")"

/** Used to compose unicode regexes. */
var reOptMod = rsModifier + "?",
  rsOptVar = "[" + rsVarRange + "]?",
  rsOptJoin =
    "(?:" +
    rsZWJ +
    "(?:" +
    [rsNonAstral, rsRegional, rsSurrPair].join("|") +
    ")" +
    rsOptVar +
    reOptMod +
    ")*",
  rsSeq = rsOptVar + reOptMod + rsOptJoin

// Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode).
var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g")

// Gets the size of a Unicode `string`
function unicodeSize(string) {
  var result = 0
  reUnicode.lastIndex = 0
  while (reUnicode.test(string)) {
    ++result
  }
  return result
}

function baseProperty(key) {
  return function(object) {
    return object == null ? undefined : object[key]
  }
}

// Gets the size of an ASCII `string`
var asciiSize = baseProperty("length")

function stringSize(string) {
  return hasUnicode(string) ? unicodeSize(string) : asciiSize(string)
}

export default stringSize

/**
 * Checks if `string` contains Unicode symbols
 * 检查字符串是否包含Unicode字符
 * @param {string} string The string to inspect.
 * @returns {boolean} Returns `true` if a symbol is found, else `false`
 */

const rsZWJ = "\\u200d"
const rsAstralRange = "\\ud800-\\udfff"
const rsComboMarksRange = "\\u0300-\\u036f"
const reComboHalfMarksRange = "\\ufe20-\\ufe2f"
const rsComboSymbolsRange = "\\u20d0-\\u20ff"
const rsComboRange =
  rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange
const rsVarRange = "\\ufe0e\\ufe0f"

const reHasUnicode = new RegExp(
  "[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]"
)

function hasUnicode(string) {
  return reHasUnicode.test(string)
}

export default hasUnicode