字符串方法

字符串

常用方法记录

String.fromCharCode()

静态 String.fromCharCode() 方法返回使用指定的Unicode值序列创建的字符串。该方法返回一个字符串，而不是一个 String 对象。这个方法不能识别 32 位的 UTF-16 字符

由于 fromCharCode 是 String 的静态方法，所以应该像这样使用：String.fromCharCode()，而不是作为你创建的 String 对象的方法

String.fromCharCode(65,66,67)
// 不要在一个字符串后面接这个方法，它是静态方法

String.fromCodePoint()

也是一个静态方法，用法同上

String.prototype.indexOf()

indexOf() 方法返回调用 String 对象中第一次出现的指定值的索引，开始在 fromIndex进行搜索
如果未找到该值，则返回-1

str.indexOf(searchValue[, fromIndex])

searchValue
一个字符串表示被查找的值
fromIndex 开始索引，默认为0

"Blue Whale".indexOf("Blue");     // returns  0
"Blue Whale".indexOf("Blute");    // returns -1
"Blue Whale".indexOf("Whale", 0); // returns  5
"Blue Whale".indexOf("Whale", 5); // returns  5
"Blue Whale".indexOf("", 9);      // returns  9
"Blue Whale".indexOf("", 10);     // returns 10
"Blue Whale".indexOf("", 11);     // returns 10

String.prototype.charAt()

charAt() 方法从一个字符串中返回指定的字符。

str.charAt(index)

index 是对应字符的索引，没有提供索引时默认为0，超出索引范围也将为0

let data = "hello world"
for(let i=0; i< data.length; i++;) {
   console.log("output:" + data.charAt(i))   
}

String.prototype.charCodeAt()

charCodeAt() 方法返回0到65535之间的整数，表示给定索引处的UTF-16代码单元，charCodeAt 总是返回一个小于 65,536 的值，

str.charCodeAt(index)

index 超出索引则会返回NaN

"ABC".charCodeAt(0) // returns 65:"A"
    
"ABC".charCodeAt(1) // returns 66:"B"
    
"ABC".charCodeAt(2) // returns 67:"C"
    
"ABC".charCodeAt(3) // returns NaN

String.prototype.codePointAt()

codePointAt() 方法返回一个 Unicode 编码点值的非负整数,四个字节存储的字符能够正确处理它

str.codePointAt(pos)

pos 表示索引，索引处没有对应元素则返回 undefined

'ABC'.codePointAt(1);          // 66
'\uD800\uDC00'.codePointAt(0); // 65536
    
let s = '𠮷a';
s.codePointAt(0) // 134071
s.codePointAt(1) // 57271
    
'XYZ'.codePointAt(42); // undefined

String.prototype.concat()

concat() 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。不改变原字符串

str.concat(string2, string3[, ..., stringN])
    
var hello = "Hello, "
console.log(hello.concat("Kevin", " have a nice day."))
/* Hello, Kevin have a nice day. */

使用 + += 方法来替代，运算符性能较好

String.prototype.startsWith()

startsWith()方法用来判断当前字符串是否是以另外一个给定的子字符串“开头”的，根据判断结果返回 true 或 false,具体参考下面的endsWith()方法，用法一致

String.prototype.endsWith()

endsWith()方法用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false, 区分大小写

str.endsWith(searchString [, position])

position 指定用于搜索的str的长度，默认为str.length

var str = "To be, or not to be, that is the question.";
    
alert( str.endsWith("question.") );  // true
alert( str.endsWith("to be") );      // false
alert( str.endsWith("to be", 19) );  // true

String.prototype.includes()

includes() 方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false

str.includes(searchString[, position])

参数
searchString
要在此字符串中搜索的字符串。
position
可选,从当前字符串的哪个索引位置开始搜寻子字符串，默认值为0

'Blue Whale'.includes('blue'); // returns false

String.prototype.valueOf()

valueOf() 方法返回一个String对象的原始值（primitive value,String 对象的 valueOf 方法返回一个String对象的原始值。该值等同于String.prototype.toString()。该方法通常在 JavaScript 内部被调用，而不是在代码里显示调用。

String.prototype.toString()

toString() 方法返回指定对象的字符串形式。

var x = new String("Hello world")

console.log(x.toString())      // 输出 "Hello world"

String.prototype.trim()

trim() 方法会从一个字符串的两端删除空白字符。在这个上下文中的空白字符是所有的空白字符 (space, tab, no-break space 等) 以及所有行终止符字符（如 LF，CR,返回新字符串。

str.trim()
// 语法

var orig = '   foo  ';
console.log(orig.trim()); // 'foo'

// 另一个.trim()例子，只从一边删除

var orig = 'foo    ';
console.log(orig.trim()); // 'foo'

兼容问题

if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
  };
}

String.prototype.trimLeft() and String.prototype.trimRight()

分别从左边和右边删除空白

String.prototype.toUpperCase() and String.prototype.toLowerCase()

转换为大写或者小写

str.toLowerCase()
// 语法

console.log('中文简体 zh-CN || zh-Hans'.toLowerCase());
// 中文简体 zh-cn || zh-hans

console.log( "ALPHABET".toLowerCase() ); 
// "alphabet"

String.prototype.split()

split() 方法使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置,返回的是分割后的元素组成的数组

str.split([separator[, limit]])

参数
separator
指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。如果纯文本分隔符包含多个字符，则必须找到整个字符串来表示分割点。如果在str中省略或不出现分隔符，则返回的数组包含一个由整个字符串组成的元素。如果分隔符为空字符串，则将str原字符串中每个字符的数组形式返回。
limit
一个整数，指定返回的分隔出的元素数量

var myString = "Hello World. How are you doing?";
var splits = myString.split(" ", 3);

console.log(splits); // ["Hello", "World.", "How"]

String.prototype.slice()

slice() 方法提取一个字符串的一部分，并返回一新的字符串,

str.slice(beginSlice[, endSlice])
// 参数为负是从右往左数

slice() 从一个字符串中提取字符串并返回新字符串。在一个字符串中的改变不会影响另一个字符串。也就是说，slice 不修改原字符串，只会返回一个包含了原字符串中部分字符的新字符串。

注意：slice() 提取的新字符串包括beginSlice但不包括 endSlice。

例1：str.slice(1, 4) 提取新字符串从第二个字符到第四个 (字符索引值为 1, 2, 和 3)。

例2：str.slice(2, -1) 提取第三个字符到倒数第二个字符

// 创建新字符串
var str1 = 'The morning is upon us.';
var str2 = str1.slice(4, -2);
console.log(str2); // OUTPUT: morning is upon u

// 使用负值索引
var str = 'The morning is upon us.';
str.slice(-3);     // returns 'us.'
str.slice(-3, -1); // returns 'us'
str.slice(0, -1);  // returns 'The morning is upon us'

String.prototype.replace()

replace() 方法返回一个由替换值替换一些或所有匹配的模式后的新字符串。模式可以是一个字符串或者一个正则表达式, 替换值可以是一个字符串或者一个每次匹配都要调用的函数,不会改变原字符串

str.replace(regexp|substr, newSubStr|function)

参数

第一个参数
regexp ：正则表达式，用于匹配所需的字符串，全局使用 g
substr ：字符串，直接匹配对应的字符串

第二个参数
newSubstr : 用于替换的字符串
function ：用于生成并返回字符串的函数

function replacer(match, p1, p2, p3, offset, string) {
  // p1 is nondigits, p2 digits, and p3 non-alphanumerics
  return [p1, p2, p3].join(' - ');
}
var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer);
console.log(newString);  // abc - 12345 - #$*%

String.prototype.repeat()

repeat() 构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本，

"abc".repeat(-1)     // RangeError: repeat count must be positive and less than inifinity
"abc".repeat(0)      // ""
"abc".repeat(1)      // "abc"
"abc".repeat(2)      // "abcabc"
"abc".repeat(3.5)    // "abcabcabc" 参数count将会被自动转换成整数.
"abc".repeat(1/0)    // RangeError: repeat count must be positive and less than inifinity

({toString : () => "abc", repeat : String.prototype.repeat}).repeat(2)   
//"abcabc",repeat是一个通用方法,也就是它的调用者可以不是一个字符串对象.

参数不能使负数，返回新的字符串

String.prototype.search()

search() 方法执行正则表达式和 String对象之间的一个搜索匹配，如果匹配成功，则 search() 返回正则表达式在字符串中首次匹配项的索引。否则，返回 -1。

str.search(regexp)

参数

regexp

一个正则表达式（regular expression）对象。如果传入一个非正则表达式对象，则会使用 new RegExp(obj) 隐式地将其转换为正则表达式对象

当你想要知道字符串中是否存在某个模式（pattern）时可使用 search，类似于正则表达式的 test 方法。当要了解更多匹配信息时，可使用 match（会更慢），该方法类似于正则表达式的 exec 方法

function testinput(re, str){
  var midstring;
  if (str.search(re) != -1){
    midstring = " contains ";
  } else {
    midstring = " does not contain ";
  }
  console.log (str + midstring + re);
}

// 如果匹配成功，即返回的是索引，函数返回对应的值

String.prototype.match()

当一个字符串与一个正则表达式匹配时， match()方法检索匹配项，如果字符串匹配到了表达式，会返回一个数组，数组的第一项是进行匹配完整的字符串，之后的项是用圆括号捕获的结果，如果没有匹配到，返回null。

str.match(regexp);

参数
regexp
一个正则表达式对象。如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp 。如果你未提供任何参数，直接使用 match() ，那么你会得到一个包含空字符串的 Array ：[""]

使用

如果正则表达式不包含 g 标志，则 str.match() 会返回和 RegExp.exec() 相同的结果。而且返回的 Array 拥有一个额外的 input 属性，该属性包含被解析的原始字符串。另外，还拥有一个 index 属性，该属性表示匹配结果在原字符串中的索引（以0开始）。

如果正则表达式包含 g 标志，则该方法返回一个 Array ，它包含所有匹配的子字符串而不是匹配对象。捕获组不会被返回(即不返回index属性和input属性)。如果没有匹配到，则返回 null

var str = 'For more information, see Chapter 3.4.5.1';
var re = /see (chapter \d+(\.\d)*)/i;
var found = str.match(re);

console.log(found);

// 输出 [ 'see Chapter 3.4.5.1',
//        'Chapter 3.4.5.1',
//        '.1',
//        index: 22,
//        input: 'For more information, see Chapter 3.4.5.1' ]

// 'see Chapter 3.4.5.1' 是整个匹配。
// 'Chapter 3.4.5.1' 被'(chapter \d+(\.\d)*)'捕获。
// '.1' 是被'(\.\d)'捕获的最后一个值。
// 'index' 属性(22) 是整个匹配从零开始的索引。
// 'input' 属性是被解析的原始字符串。

全文摘自mdn资料，还请自行查阅

posted on 2018-08-24 17:48 2481 阅读(117) 评论(0) 编辑收藏举报

刷新页面返回顶部

你好，GeekDD~