关于javascript:字符串string创建方法

字符串的创立

1.new String()

let stringObj = new String("123")
console.log(stringObj) // object

这个是字符串对象，尽量不要这么做!!!!

2. 创立根本的字符串值

let stringStr = "123"
console.log(stringStr) // string

字符串的办法

1. 查找办法

a)charAt(index)

作用：返回指定地位的字符。

留神：字符串中第一个字符的下标是 0。如果参数 index 不在 0 与 string.length 之间，该办法将返回一个空字符串。

let str = "1123"
console.log(str.charAt(0)) // "1"
console.log(str.charAt(5)) // ""

b)charCodeAt(index)

作用：返回在指定的地位的字符的 Unicode 编码。

留神：字符串中第一个字符的下标是 0。如果 index 是正数，或大于等于字符串的长度，则 charCodeAt() 返回 NaN。

let str = "1123"
console.log(str.charCodeAt(0)) // 49
console.log(str.charCodeAt(5)) // NaN
console.log(str.charCodeAt(5)) // NaN

c)formCharCode(Unicode,Unicode,Unicode)

作用：用 Unicode 编码创立一个字符串。

参数：一个或多个 Unicode 值，即要创立的字符串中的字符的 Unicode 编码。

留神：该办法是 String 的静态方法，字符串中的每个字符都由独自的数字 Unicode 编码指定。它不能作为您已创立的 String 对象的办法来应用。因而它的语法应该是 String.fromCharCode()，而不是 myStringObject.fromCharCode()。该办法返回一个字符串，而不是一个 String 对象。

console.log(String.fromCharCode(189, 43, 190, 61)); // "½+¾="
String.fromCharCode(65, 66, 67);   // "ABC"
String.fromCharCode(0x2014);       // "—"
String.fromCharCode(0x12014);      // "—"; 数字 1 被剔除并疏忽
String.fromCharCode(8212);         // "—"; 8212 是 0x2014 的十进制示意

2. 地位办法

a)indexOf(searchValue，fromIndex)

作用: indexOf() 办法可返回某个指定的字符串值在字符串中首次呈现的地位。如果没有找到匹配的字符串则返回 -1。

留神：indexOf() 办法辨别大小写。searchvalue 必须。规定需检索的字符串值。fromIndex 可选的整数参数。规定在字符串中开始检索的地位。它的非法取值是 0 到 string Object.length – 1。如省略该参数，则将从字符串的首字符开始检索。

语法: string.indexOf(searchvalue,start)

let str="Hello world, welcome to Beijing.";
console.log(str.indexOf("welcome")); // 13

b)lastIndexOf(searchValue，fromIndex)

作用: lastIndexOf() 办法可返回一个指定的字符串值最初呈现的地位，如果指定第二个参数 start，则在一个字符串中的指定地位从后向前搜寻。

留神：该办法将从后向前检索字符串，但返回是从起始地位 (0) 开始计算子字符串最初呈现的地位。看它是否含有字符串。

开始检索的地位在字符串的 start 处或字符串的结尾（没有指定 start 时）。

如果没有找到匹配字符串则返回 -1

lastIndexOf() 办法是辨别大小写的！

let str="I am from runoob，welcome to runoob site.";
console.log(str.lastIndexOf("runoob")); // 28

3. 匹配办法

a)match(regexp)

作用: 办法检索返回一个字符串匹配正则表达式的后果。

参数:regexp 一个正则表达式对象。如果传入一个非正则表达式对象，则会隐式地应用 new RegExp(obj) 将其转换为一个 RegExp。如果你没有给出任何参数并间接应用 match() 办法，你将会失去一 个蕴含空字符串的 Array：[“”]。

返回值: 如果应用 g 标记，则将返回与残缺正则表达式匹配的所有后果，但不会返回捕捉组。
如果未应用 g 标记，则仅返回第一个残缺匹配及其相干的捕捉组（Array）。在这种状况下，返回的我的项目将具备如下所述的其余属性。

let str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
let regexp = /[A-E]/gi;

console.log(str.match(regexp));// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']
console.log(str.match());   // [""]

b)replace(regexp|substr, newSubStr|function)

作用: replace() 办法返回一个由替换值（replacement）替换局部或所有的模式（pattern）匹配项后的新字符串。模式能够是一个字符串或者一个正则表达式，替换值能够是一个字符串或者一个每次匹配都要调用的回调函数。如果 pattern 是字符串，则仅替换第一个匹配项。

参数:

regexp (pattern)
一个 RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。

substr (pattern)
一个将被 newSubStr 替换的 字符串。其被视为一整个字符串，而不是一个正则表达式。仅第一个匹配项会被替换。

newSubStr (replacement)
用于替换掉第一个参数在原字符串中的匹配局部的字符串。该字符串中能够内插一些非凡的变量名。参考上面的应用字符串作为参数。

function (replacement)
一个用来创立新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的后果。参考上面的指定一个函数作为参数。

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

let re = /apples/gi;
let str = "Apples are round, and apples are juicy.";
let newstr = str.replace(re, "oranges");
console.log(newstr);// oranges are round, and oranges are juicy.

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

作用: split() 办法应用指定的分隔符字符串将一个 String 对象宰割成子字符串数组，以一个指定的宰割字串来决定每个拆分的地位。

参数:

separator
指定示意每个拆分应产生的点的字符串。separator 能够是一个字符串或正则表达式。如果纯文本分隔符蕴含多个字符，则必须找到整个字符串来示意宰割点。如果在 str 中省略或不呈现分隔符，则返回的数组蕴含一个由整个字符串组成的元素。如果分隔符为空字符串，则将 str 原字符串中每个字符的数组模式返回。

limit
一个整数，限定返回的宰割片段数量。当提供此参数时，split 办法会在指定分隔符的每次呈现时宰割该字符串，但在限度条目已放入数组时进行。如果在达到指定限度之前达到字符串的开端，它可能依然蕴含少于限度的条目。新数组中不返回剩下的文本。

留神：如果应用空字符串 (“) 作为分隔符，则字符串不是在每个用户感知的字符 (图形素集群) 之间，也不是在每个 Unicode 字符 (代码点) 之间，而是在每个 UTF-16 代码单元之间。这会捣毁代理对。

let names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand";
console.log(names); // Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand 
let re = /\s*(?:;|$)\s*/;
let nameList = names.split(re);
console.log(nameList); // ["Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand", ""]

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

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

4. 拼接办法

a)str.concat(str2, [, …strN])

作用: concat() 办法将一个或多个字符串与原字符串连贯合并，造成一个新的字符串并返回。

返回值: 一个新的字符串，蕴含参数所提供的连贯字符串。

留神：用 ” + ” 运算符来进行字符串的连贯运算通常会更简便一些。

let hello = 'Hello,'
console.log(hello.concat('Kevin', '. Have a nice day.')) // Hello, Kevin. Have a nice day.

let greetList = ['Hello', '','Venkat','!']"".concat(...greetList)  // "Hello Venkat!"

"".concat({})    // [object Object]"".concat([])    // """".concat(null)  // "null"
"".concat(true)  //"true""".concat(4, 5)  // "45"

5. 依据下标截取子串办法

a)str.slice(beginIndex[, endIndex])

作用: slice() 办法提取某个字符串的一部分，并返回一个新的字符串，且不会改变原字符串。

参数:

beginIndex
从该索引（以 0 为基数）处开始提取原字符串中的字符。如果值为正数，会被当做 strLength + beginIndex 对待，这里的 strLength 是字符串的长度（例如，如果 beginIndex 是 -3 则看作是：strLength – 3）

endIndex
可选。在该索引（以 0 为基数）处完结提取字符串。如果省略该参数，slice() 会始终提取到字符串开端。如果该参数为正数，则被看作是 strLength + endIndex，这里的 strLength 就是字符串的长度(例如，如果 endIndex 是 -3，则是, strLength – 3)。

返回值: 返回一个从原字符串中提取进去的新字符串

留神：

一个新的字符串。包含字符串 stringObject 从 start 开始（包含 start）到 end 完结（不包含 end）为止的所有字符。

String 对象的办法 slice()、substring() 和 substr()（不倡议应用）都可返回字符串的指定局部。slice() 比 substring() 要灵便一些，因为它容许应用正数作为参数。slice() 与 substr() 有所不同，因为它用两个字符的地位来指定子串，而 substr() 则用字符地位和长度来指定子串。还要留神的是，String.slice() 与 Array.slice() 类似。

let str1 = 'The morning is upon us.', // str1 的长度 length 是 23。str2 = str1.slice(1, 8),
    str3 = str1.slice(4, -2),
    str4 = str1.slice(12),
    str5 = str1.slice(30);
console.log(str2); // "he morn"
console.log(str3); // "morning is upon u"
console.log(str4); // "is upon us."
console.log(str5); // ""let str6 ='The morning is upon us.';
str6.slice(-3);     // "us."
str6.slice(-3, -1); // "us"
str6.slice(0, -1);  // "The morning is upon us"

b)str.substring(indexStart[, indexEnd])

作用: substring() 办法返回一个字符串在开始索引到完结索引之间的一个子集, 或从开始索引直到字符串的开端的一个子集。

参数：start 必须。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的地位。stop 可选。一个非负的整数，比要提取的子串的最初一个字符在 stringObject 中的地位多 1。如果省略该参数，那么返回的子串会始终到字符串的结尾。

返回值：一个新的字符串，该字符串值蕴含 stringObject 的一个子字符串，其内容是从 start 处到 stop-1 处的所有字符，其长度为 stop 减 start。

阐明：substring() 办法返回的子串包含 start 处的字符，但不包含 stop 处的字符。如果参数 start 与 stop 相等，那么该办法返回的就是一个空串（即长度为 0 的字符串）。如果 start 比 stop 大，那么该办法在提取子串之前会先替换这两个参数。

let anyString = "Mozilla";

// 输入 "Moz"
console.log(anyString.substring(0,3));
console.log(anyString.substring(3,0));
console.log(anyString.substring(3,-3));
console.log(anyString.substring(3,NaN));
console.log(anyString.substring(-2,3));
console.log(anyString.substring(NaN,3));

// 输入 "lla"
console.log(anyString.substring(4,7));
console.log(anyString.substring(7,4));

// 输入 ""
console.log(anyString.substring(4,4));

// 输入 "Mozill"
console.log(anyString.substring(0,6));

// 输入 "Mozilla"
console.log(anyString.substring(0,7));
console.log(anyString.substring(0,10));

6. 依据长度截取子串

a)str.substr(start[, length])

作用: substr() 办法返回一个字符串中从指定地位开始到指定字符数的字符。

正告：只管 String.prototype.substr(…) 没有严格被废除 (as in “removed from the Web standards”), 但它被认作是遗留的函数并且能够的话应该防止应用。它并非 JavaScript 外围语言的一部分，将来将可能会被移除掉。如果能够的话，应用 substring() 代替它.

参数:

start
开始提取字符的地位。如果为负值，则被看作 strLength + start，其中 strLength 为字符串的长度（例如，如果 start 为 -3，则被看作 strLength + (-3)）。

length
可选。提取的字符数。

返回值：一个新的字符串，蕴含从 stringObject 的 start（包含 start 所指的字符）处开始的 length 个字符。如果没有指定 length，那么返回的字符串蕴含从 start 到 stringObject 的结尾的字符。

提醒和正文：正文：substr() 的参数指定的是子串的开始地位和长度，因而它能够代替 substring() 和 slice() 来应用。

let str = "abcdefghij";

console.log("(1,2):"    + str.substr(1,2));   // "(1,2): bc"
console.log("(-3,2):"   + str.substr(-3,2));  // "(-3,2): hi"
console.log("(-3):"     + str.substr(-3));    // "(-3): hij"
console.log("(1):"      + str.substr(1));     // "(1): bcdefghij"
console.log("(-20, 2):" + str.substr(-20,2)); // "(-20, 2): ab"
console.log("(20, 2):"  + str.substr(20,2));  // "(20, 2):"

字符串 string 创立, 办法