JavaScript中String的API总结

增加

concat()

• 描述：将两个或多个字符串连接起来，并返回一个新的字符串。
• 语法：string.concat(string1, string2, ..., stringX)
• 参数：需要连接的字符串，可以是一个或多个字符串，用逗号分隔。
• 返回值：一个新的字符串，为连接起来的结果。
• 例子：

let str1 = 'Hello';
let str2 = 'World';
let newStr = str1.concat(' ', str2);
console.log(newStr); // 输出：'Hello World'

concat()使用较少，实际中常使用加号（+）运算符连接两个字符串

var str1 = "Hello";
var str2 = " World";
var str3 = "!";
var result = str1.concat(str2, str3);
console.log(result); // output: "Hello World!"

• V8伪代码实现

function concat() {
  // 计算总长度
  let totalLength = 0;
  for (let i = 0; i < arguments.length; i++) {
    totalLength += arguments[i].length;
  }

  // 创建新字符串对象
  let result = new String("");
  result.length = totalLength;

  // 复制字符到新字符串对象
  let offset = 0;
  for (let i = 0; i < arguments.length; i++) {
    let str = arguments[i];
    for (let j = 0; j < str.length; j++) {
      result[offset + j] = str.charAt(j);
    }
    offset += str.length;
  }

  // 返回新字符串对象
  return result;
}

repeat()

• 描述：返回一个新字符串，其值为原字符串重复 n 次。
• 语法：string.repeat(count)
• 参数：count 是一个非负整数，表示要将原字符串重复的次数。
• 返回值：一个新的字符串，为重复 count 次原字符串的结果。
• 例子：

let str = 'abc';
let newStr = str.repeat(3);
console.log(newStr); // 输出：'abcabcabc'

• V8伪代码实现

// 用于实现字符串重复功能的函数，返回重复后的字符串
function StringRepeat(count) {
  // 如果count不大于0，则返回空字符串
  if (count <= 0) {
    return '';
  }
  
  // 初始化结果和当前字符串
  let result = '';
  let current = this.valueOf();
  
  // 循环重复字符串
  while (count > 1) {
    // 如果count是奇数，则将当前字符串添加到结果中
    if (count & 1) {
      result += current;
    }
    // 右移一位等于除以2，将当前字符串重复一倍
    count >>= 1;
    current += current;
  }
  
  // 将最后的当前字符串添加到结果中
  return result + current;
}

padStart()

• 描述：在字符串的开头添加指定的字符串，直到字符串达到指定长度。
• 语法：string.padStart(targetLength [, padString])
• 参数：targetLength 是字符串需要达到的长度；padString 是要添加的字符串，可选，默认为 ' '。
• 返回值：一个新的字符串，为添加了指定字符串之后的结果。
• 例子：

let str = 'abc';
let newStr = str.padStart(6, '0');
console.log(newStr); // 输出：'000abc'

• V8伪代码实现

function StringPadEnd(targetLength, padString) {
  // 获取当前字符串的长度
  let len = this.length;
  
  // 如果指定长度小于等于当前长度，直接返回原字符串
  if (targetLength <= len) {
    return this;
  }
  
  // 如果指定了填充字符，则使用填充字符填充字符串，否则使用空格填充
  padString = padString || ' ';
  
  // 计算需要填充的字符个数
  let padLen = targetLength - len;
  
  // 如果需要填充的字符个数大于填充字符长度，则重复填充字符
  if (padLen > padString.length) {
    padString += padString.repeat(padLen / padString.length);
  }
  
  // 返回填充后的字符串
  return this + padString.slice(0, padLen);
}

padEnd()

• 描述：在字符串的结尾添加指定的字符串，直到字符串达到指定长度。
• 语法：string.padEnd(targetLength [, padString])
• 参数：targetLength 是字符串需要达到的长度；padString 是要添加的字符串，可选，默认为 ' '。
• 返回值：一个新的字符串，为添加了指定字符串之后的结果。
• 例子：

let str = 'abc';
let newStr = str.padEnd(6, '0');
console.log(newStr); // 输出：'abc000'

• V8伪代码实现

function StringPadEnd(targetLength, padString) {
  // 获取当前字符串的长度
  let len = this.length;
  
  // 如果指定长度小于等于当前长度，直接返回原字符串
  if (targetLength <= len) {
    return this;
  }
  
  // 如果指定了填充字符，则使用填充字符填充字符串，否则使用空格填充
  padString = padString || ' ';
  
  // 计算需要填充的字符个数
  let padLen = targetLength - len;
  
  // 如果需要填充的字符个数大于填充字符长度，则重复填充字符
  if (padLen > padString.length) {
    padString += padString.repeat(padLen / padString.length);
  }
  
  // 返回填充后的字符串
  return this + padString.slice(0, padLen);
}

删除

slice()

• 描述：从字符串中提取一个新字符串，返回提取的部分。

• 语法：string.slice(startIndex, endIndex)

• 参数：

  • startIndex：要提取的起始位置。如果是负数，那么从字符串结尾开始算起。
  • endIndex：提取终止位置的下标。若不提供，则默认提取到字符串末尾。如果是负数，则将其视为从字符串结尾开始倒数的位置。如果省略该参数，则将提取到字符串的最后一个字符。

• 返回值：一个新的字符串，包含从 startIndex 开始，到 endIndex（不包含）之间的所有字符。

• 示例：

const str = "hello world";
const res = str.slice(6, 11); // "world"

• V8伪代码实现

// slice(start, end)
function mySlice(str, start = 0, end = str.length) {
if (start < 0) {
 start = str.length + start;
}
if (end < 0) {
 end = str.length + end;
}
let result = '';
for (let i = start; i < end && i < str.length; i++) {
 result += str[i];
}
return result;
}

substring()

• 描述：从字符串中提取一个新字符串，返回提取的部分。与 slice() 方法类似，但是不接受负数作为参数。

• 语法：string.substring(startIndex, endIndex)

• 参数：

  • startIndex：要提取的起始位置。
  • endIndex：提取终止位置的下标。若不提供，则默认提取到字符串末尾。

• 返回值：一个新的字符串，包含从 startIndex 开始，到 endIndex（不包含）之间的所有字符。

• 示例：

const str = "hello world";
const res = str.substring(6, 11); // "world"

• V8伪代码实现

// substring(start, end)
function mySubstring(str, start, end = str.length) {
if (start < 0) {
 start = 0;
}
if (end < 0) {
 end = 0;
}
if (start > end) {
 let temp = start;
 start = end;
 end = temp;
}
let result = '';
for (let i = start; i < end && i < str.length; i++) {
 result += str[i];
}
return result;
}

substr()

• 描述：从字符串中提取一个新字符串，返回提取的部分。与 slice() 方法类似，但是接受负数作为参数。

• 语法：string.substr(startIndex, length)

• 参数：

  • startIndex：要提取的起始位置。如果是负数，则该参数表示从字符串末尾开始的位置。
  • length：要提取的字符数。

• 返回值：一个新的字符串，包含从 startIndex 开始，长度为 length 的字符。

• 示例：

const str = "hello world";
const res1 = str.substr(6, 5); // "world"
const res2 = str.substr(-5, 5); // "world"

• V8伪代码实现

// substr(start, length)
function mySubstr(str, start, length = str.length - start) {
if (start < 0) {
 start = str.length + start;
}
if (length < 0) {
 length = 0;
}
let result = '';
for (let i = start; i < start + length && i < str.length; i++) {
 result += str[i];
}
return result;
}

trim()

• 描述：去除字符串的首尾空格。
• 语法：string.trim()
• 参数：无
• 返回值：去除空格后的新字符串。
• 例子：

var str = "   Hello World!   ";
var trimmedStr = str.trim();
console.log(trimmedStr); // output: "Hello World!"

• V8伪代码实现

function trim(str) {
  let start = 0;
  let end = str.length - 1;

  // 去除前导空格
  while (start < str.length && str[start] === ' ') {
    start++;
  }

  // 去除尾随空格
  while (end >= 0 && str[end] === ' ') {
    end--;
  }

  // 返回修剪后的字符串
  return str.slice(start, end + 1);
}

修改

replace():

• 描述：该API用于将字符串中的指定子串替换为新的字符串，并返回新的字符串。

• 语法：str.replace(searchValue, newValue)

• 参数：

  • searchValue：需要被替换的子串。
  • newValue：用于替换的新字符串。

• 返回值：替换后的新字符串。

• 例子：

let str = "Hello, World!";
let newStr = str.replace("World", "ChatGPT");
console.log(newStr); // Output: "Hello, ChatGPT!"

• V8伪代码实现

function replace(str, searchValue, replaceValue) {
  let index = str.indexOf(searchValue);

  while (index !== -1) {
    // 用新字符串替换旧字符串
    str = str.slice(0, index) + replaceValue + str.slice(index + searchValue.length);

    // 搜索下一个匹配项
    index = str.indexOf(searchValue, index + replaceValue.length);
  }

  return str;
}

toUpperCase():

• 描述：该API用于将字符串转换为大写形式，并返回新的字符串。
• 语法：str.toUpperCase()
• 参数：无
• 返回值：转换为大写形式的新字符串。
• 例子：

let str = "hello, world!";
let upperStr = str.toUpperCase();
console.log(upperStr); // Output: "HELLO, WORLD!"

• V8伪代码实现

// toLowerCase()
// toUpperCase()
function myToUpperCase(str) {
  let result = '';
  for (let i = 0; i < str.length; i++) {
    let charCode = str.charCodeAt(i);
    if (charCode >= 97 && charCode <= 122) { // a-z
      result += String.fromCharCode(charCode - 32);
    } else {
      result += str[i];
    }
  }
return result;
  }

toLowerCase():

• 描述：该API用于将字符串转换为小写形式，并返回新的字符串。

• 语法：str.toLowerCase()

• 参数：无

• 返回值：转换为小写形式的新字符串。

• 例子：

let str = "HELLO, WORLD!";
let lowerStr = str.toLowerCase();
console.log(lowerStr); // Output: "hello, world!"

• V8伪代码实现

// toLowerCase()
function myToLowerCase(str) {
let result = '';
for (let i = 0; i < str.length; i++) {
  let charCode = str.charCodeAt(i);
  if (charCode >= 65 && charCode <= 90) { // A-Z
    result += String.fromCharCode(charCode + 32);
  } else {
    result += str[i];
  }
}
return result;
}

查询

charAt():

• 描述：该API用于返回指定位置的字符。

• 语法：str.charAt(index)

• 参数：

  • index：需要返回字符的位置，从0开始。

• 返回值：指定位置的字符。

• 例子：

let str = "Hello, World!";
let char = str.charAt(1);
console.log(char); // Output: "e"

• V8伪代码实现

function charAt(str, index) {
  if (index < 0 || index >= str.length) {
    // 如果索引越界，返回空字符串
    return '';
  } else {
    // 返回指定索引位置的字符
    return str[index];
  }
}

charCodeAt():

• 描述：该API用于返回指定位置字符的 Unicode 编码。

• 语法：str.charCodeAt(index)

• 参数：

• • index：需要返回Unicode编码的字符的位置，从0开始。

• 返回值：指定位置字符的Unicode编码。

• 例子：

let str = "Hello, World!";
let unicode = str.charCodeAt(1);
console.log(unicode); // Output: 101

• V8伪代码实现

function charCodeAt(str, index) {
  if (index < 0 || index >= str.length) {
    // 如果索引越界，返回 NaN
    return NaN;
  } else {
    // 返回指定索引位置的字符的 Unicode 编码
    return str.charCodeAt(index);
  }
}

indexOf():

• 描述：该API用于返回字符串中第一个匹配的子串的索引位置。如果没有找到匹配的子串，则返回-1。

• 语法：str.indexOf(searchValue, fromIndex)

• 参数：

  • searchValue：需要匹配的子串。
  • fromIndex（可选）：从哪个位置开始查找，默认为0。

• 返回值：第一个匹配的子串的索引位置，如果没有找到则返回-1。

• 例子：

let str = "Hello, World!";
let index = str.indexOf("World");
console.log(index); // Output: 7

• V8伪代码实现

// indexOf(searchValue, fromIndex)
function myIndexOf(str, searchValue, fromIndex = 0) {
if (fromIndex < 0) {
 fromIndex = 0;
}
for (let i = fromIndex; i < str.length; i++) {
 if (str.substring(i, i + searchValue.length) === searchValue) {
   return i;
 }
}
return -1;
}

lastIndexOf():

• 描述：该API用于返回字符串中最后一个匹配的子串的索引位置。如果没有找到匹配的子串，则返回-1。

• 语法：str.lastIndexOf(searchValue, fromIndex)

• 参数：

  • searchValue：需要匹配的子串。
  • fromIndex（可选）：从哪个位置开始查找，默认为字符串的末尾。

• 返回值：最后一个匹配的子串的索引位置，如果没有找到则返回-1。

• 例子：

let str = "Hello, World!";
let index = str.lastIndexOf("l");
console.log(index); // Output: 10

• V8伪代码实现

// lastIndexOf(searchValue, fromIndex)
function myLastIndexOf(str, searchValue, fromIndex = str.length - 1) {
if (fromIndex >= str.length) {
 fromIndex = str.length - 1;
}
for (let i = fromIndex; i >= 0; i--) {
 if (str.substring(i, i + searchValue.length) === searchValue) {
   return i;
 }
}
return -1;
}

includes():

• 描述：该API用于判断字符串是否包含指定的子串。

• 语法：str.includes(searchValue, fromIndex)

• 参数：

  • searchValue：需要匹配的子串。
  • fromIndex（可选）：从哪个位置开始查找，默认为0。

• 返回值：如果找到匹配的子串，则返回true，否则返回false。

• 例子

let str = "Hello, World!";
let result = str.includes("World");
console.log(result); // Output: true

• V8伪代码实现

function includes(str, searchValue, startIndex) {
  startIndex = startIndex || 0;
  return str.indexOf(searchValue, startIndex) !== -1;
}

startsWith():

• 描述：该API用于判断字符串是否以指定的子串开头。

• 语法：str.startsWith(searchValue, length)

• 参数：

  • searchValue：需要匹配的子串。
  • length（可选）：需要比较的长度，默认为searchValue的长度。

• 返回值：如果字符串以指定的子串开头，则返回true，否则返回false。

• 例子

let str = "Hello, World!";
let result = str.startsWith("Hello");
console.log(result); // Output: true

• V8伪代码实现

function startsWith(str, searchValue, startIndex) {
  startIndex = startIndex || 0;
  return str.indexOf(searchValue, startIndex) === startIndex;
}

endsWith():

• 描述：该API用于判断字符串是否以指定的子串结尾。

• 语法：str.endsWith(searchValue, length)

• 参数：

  • searchValue：需要匹配的子串。
  • length（可选）：需要比较的长度，默认为searchValue的长度。

• 返回值：如果字符串以指定的子串结尾，则返回true，否则返回false。

• 例子：

let str = "Hello, World!";
let result = str.endsWith("!");
console.log(result); // Output: true

• V8伪代码实现

function endsWith(str, searchValue, length) {
  length = length || str.length;
  return str.lastIndexOf(searchValue) === length - searchValue.length;
}

match():

• 描述：在字符串中搜索指定的子串或正则表达式，并返回找到的子串。
• 语法：string.match(regexp)
• 参数：regexp，一个正则表达式对象或者字符串。
• 返回值：匹配结果数组或者null。
• 例子：

  var str = "The quick brown fox jumps over the lazy dog.";
  var regex = /quick/;
  var res = str.match(regex);
  console.log(res); //output: ["quick"]

• V8伪代码实现

function match(str, pattern) {
  return str.match(pattern);
}

search():

• 描述：在字符串中搜索指定的子串或正则表达式，并返回第一个匹配的位置。
• 语法：string.search(regexp)
• 参数：regexp，一个正则表达式对象或者字符串。
• 返回值：第一个匹配的位置或者-1。
• 例子：

var str = "The quick brown fox jumps over the lazy dog.";
var regex = /quick/;
var res = str.search(regex);
console.log(res); //output: 4

• V8伪代码实现

  function match(str, regexp) {
  return str.match(regexp) || [];
}

split()

• 描述：split() 方法将一个字符串分割成一个字符串数组，将字符串划分为多个子字符串，返回的数组中包含子字符串的集合，每个子字符串之间使用指定的分隔符进行分割。

• 语法：str.split(separator, limit)

  • separator（可选）：指定字符串分隔符，用于将字符串分割成多个子字符串。如果省略 separator 参数，则将字符串划分为单个字符数组。分隔符可以是字符串、正则表达式、字符组等，如果 separator 参数为空字符串，则将字符串分割为单个字符的数组。
  • limit（可选）：一个整数，用于指定分隔出的子字符串的最大数量。如果省略 limit 参数，则 split() 方法将分隔字符串中的所有元素。如果指定的 limit 参数小于 0 或等于 Infinity，则将忽略该参数。

• 参数：

  • separator：指定字符串分隔符。
  • limit：一个整数，用于指定分隔出的子字符串的最大数量。

• 返回值：返回一个数组，其中包含根据指定分隔符分隔的子字符串集合。如果字符串不包含分隔符，则返回包含整个字符串的单元素数组。

• V8 引擎的伪代码实现：

function split(separator, limit) {
  const source = String(this);
  const result = [];
  let count = 0;

  if (separator === undefined || separator === null) {
    result.push(source);
    return result;
  }

  if (typeof separator === 'string') {
    if (separator === '') {
      for (let i = 0; i < source.length; i++) {
        result.push(source[i]);
        if (count++ === limit - 1) {
          break;
        }
      }
    } else {
      let start = 0;
      let end = source.indexOf(separator);

      while (end !== -1 && count++ < limit - 1) {
        result.push(source.slice(start, end));
        start = end + separator.length;
        end = source.indexOf(separator, start);
      }

      result.push(source.slice(start));
    }
  }

  return result;
}