JS-String - 散人博客

字符串的截取
字符串的查找
字符串的拼接
字符串转数组
字符串的替换
字符串的相关

1

2

3

4

5

6

字符串的截取

字符串的查找

字符串的拼接

字符串转数组

字符串的替换

字符串的相关

定义和用法：
substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符
语法：str.substr(start,length)
start：
开始提取字符的位置。
如果为负值，则被看作 strLength + start，
其中 strLength 为字符串的长度（例如，如果 start 为 -3，则被看作 strLength + (-3)）
length：可选。提取的字符数。必须是数值。
如果省略了该参数，那么返回从 str 的开始位置到结尾的字串。

描述：
start 是一个字符的索引。首字符的索引为 0，最后一个字符的索引为 字符串的长度减去1。
substr 从 start 位置开始提取字符，提取 length 个字符（或直到字符串的末尾）。
如果 start 为正值，且大于或等于字符串的长度，则 substr 返回一个空字符串。
如果 start 为负值，则 substr 把它作为从字符串末尾开始的一个字符索引。
如果 start 为负值且 abs(start) 大于字符串的长度，则 substr 使用 0 作为开始提取的索引。
如果 length 为 0 或负值，则 substr 返回一个空字符串。如果忽略 length，则 substr 提取字符，直到字符串末尾。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

定义和用法：

substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符

语法：str.substr(start,length)

start：

开始提取字符的位置。

如果为负值，则被看作 strLength + start，

其中 strLength 为字符串的长度（例如，如果 start 为 -3，则被看作 strLength + (-3)）

length：可选。提取的字符数。必须是数值。

如果省略了该参数，那么返回从 str 的开始位置到结尾的字串。

描述：

start 是一个字符的索引。首字符的索引为 0，最后一个字符的索引为字符串的长度减去1。

substr 从 start 位置开始提取字符，提取 length 个字符（或直到字符串的末尾）。

如果 start 为正值，且大于或等于字符串的长度，则 substr 返回一个空字符串。

如果 start 为负值，则 substr 把它作为从字符串末尾开始的一个字符索引。

如果 start 为负值且 abs(start) 大于字符串的长度，则 substr 使用 0 作为开始提取的索引。

如果 length 为 0 或负值，则 substr 返回一个空字符串。如果忽略 length，则 substr 提取字符，直到字符串末尾。

var 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):

1

2

3

4

5

6

7

var 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):

定义和用法 ：
substring() 方法返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集
语法：
str.substring(indexStart,indexEnd)

indexStart：一个 0 到字符串长度之间的整数。

indexEnd：可选。一个 0 到字符串长度之间的整数。

返回值：包含给定字符串的指定部分的新字符串。

描述:
substring 提取从 indexStart 到 indexEnd（不包括）之间的字符，特别地：
如果 indexStart 等于 indexEnd，substring 返回一个空字符串。
如果省略 indexEnd，substring 提取字符一直到字符串末尾。
如果任一参数小于 0 或为 NaN，则被当作 0。
如果任一参数大于 stringName.length，则被当作 stringName.length。
如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

定义和用法：

substring() 方法返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集

语法：

str.substring(indexStart,indexEnd)

indexStart：一个 0 到字符串长度之间的整数。

indexEnd：可选。一个 0 到字符串长度之间的整数。

返回值：包含给定字符串的指定部分的新字符串。

描述:

substring 提取从 indexStart 到 indexEnd（不包括）之间的字符，特别地：

如果 indexStart 等于 indexEnd，substring 返回一个空字符串。

如果省略 indexEnd，substring 提取字符一直到字符串末尾。

如果任一参数小于 0 或为 NaN，则被当作 0。

如果任一参数大于 stringName.length，则被当作 stringName.length。

如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。

var 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));

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

var 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));

定义和用法 ：
slice() 方法提取一个字符串的一部分，并返回一新的字符串。
语法：
str.slice(beginSlice, endSlice)

beginSlice：
从该索引（以 0 为基数）处开始提取原字符串中的字符。
如果值为负数，会被当做 sourceLength + beginSlice 看待，
这里的sourceLength 是字符串的长度 (例如,如果beginSlice 是-3则看作是: sourceLength - 3)

endSlice：
可选。在该索引（以 0 为基数）处结束提取字符串。如果省略该参数，slice会一直提取到字符串末尾。
如果该参数为负数，则被看作是 sourceLength + endSlice，
这里的 sourceLength 就是字符串的长度(例如，如果 endSlice 是 -3，则是, sourceLength - 3)。

返回值：返回一个从原字符串中提取出来的新字符串

描述:
slice() 从一个字符串中提取字符串并返回新字符串。在一个字符串中的改变不会影响另一个字符串。
也就是说，slice 不修改原字符串，只会返回一个包含了原字符串中部分字符的新字符串
注意：slice() 提取的新字符串包括beginSlice但不包括 endSlice。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

定义和用法：

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

语法：

str.slice(beginSlice, endSlice)

beginSlice：

从该索引（以 0 为基数）处开始提取原字符串中的字符。

如果值为负数，会被当做 sourceLength + beginSlice 看待，

这里的sourceLength 是字符串的长度 (例如,如果beginSlice 是-3则看作是: sourceLength - 3)

endSlice：

可选。在该索引（以 0 为基数）处结束提取字符串。如果省略该参数，slice会一直提取到字符串末尾。

如果该参数为负数，则被看作是 sourceLength + endSlice，

这里的 sourceLength 就是字符串的长度(例如，如果 endSlice 是 -3，则是, sourceLength - 3)。

返回值：返回一个从原字符串中提取出来的新字符串

描述:

slice() 从一个字符串中提取字符串并返回新字符串。在一个字符串中的改变不会影响另一个字符串。

也就是说，slice 不修改原字符串，只会返回一个包含了原字符串中部分字符的新字符串

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

var str1 = 'The morning is upon us.';
var str2 = str1.slice(4, -2);
console.log(str2); // OUTPUT: morning is upon u
str.slice(-3);     // returns 'us.'
str.slice(-3, -1); // returns 'us'
str.slice(0, -1);  // returns 'The morning is upon us'

1

2

3

4

5

6

var str1 = 'The morning is upon us.';

var str2 = str1.slice(4, -2);

console.log(str2); // OUTPUT: morning is upon u

str.slice(-3); // returns 'us.'

str.slice(-3, -1); // returns 'us'

str.slice(0, -1); // returns 'The morning is upon us'

索引找字符
概述:
charAt() 方法从一个字符串中返回指定的字符。
语法:
str.charAt(index)
index:
一个介于0 和字符串长度减1之间的整数,(0~length-1)如果没有提供索引，charAt() 将使用0。
描述:
字符串中的字符从左向右索引，第一个字符的索引值为 0，
最后一个字符（假设该字符位于字符串 stringName 中）的索引值为 stringName.length - 1。 
如果指定的 index 值超出了该范围，则返回一个空字符串。

1

2

3

4

5

6

7

8

9

10

11

索引找字符

概述:

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

语法:

str.charAt(index)

index:

一个介于0 和字符串长度减1之间的整数,(0~length-1)如果没有提供索引，charAt() 将使用0。

描述:

字符串中的字符从左向右索引，第一个字符的索引值为 0，

最后一个字符（假设该字符位于字符串 stringName 中）的索引值为 stringName.length - 1。

如果指定的 index 值超出了该范围，则返回一个空字符串。

var str = "Brave new world";
console.log(str.charAt());//'B'
console.log(str.charAt(0));//'B'
console.log(str.charAt(1));//'r'
console.log(str.charAt(2));//a
console.log(str.charAt(3));//'v'
console.log(str.charAt(4));//'e'
console.log(str.charAt(999));//''

1

2

3

4

5

6

7

8

var str = "Brave new world";

console.log(str.charAt());//'B'

console.log(str.charAt(0));//'B'

console.log(str.charAt(1));//'r'

console.log(str.charAt(2));//a

console.log(str.charAt(3));//'v'

console.log(str.charAt(4));//'e'

console.log(str.charAt(999));//''

字符找索引

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

语法:
str.indexOf(searchValue,fromIndex)

searchValue：
一个字符串表示被查找的值。

fromIndex:可选;表示调用该方法的字符串中开始查找的位置。可以是任意整数。默认值为 0

返回值:指定值的第一次出现的索引; 如果没有找到 -1。

描述:
字符串中的字符被从左向右索引。
首字符的索引（index）为 0，字符串 stringName 的最后一个字符的索引是 stringName.length - 1。
如果 fromIndex &lt; 0 则查找整个字符串（如同传进了 0）。
如果 fromIndex &gt;= str.length，则该方法返回 -1，除非被查找的字符串是一个空字符串，
此时返回 str.length。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

字符找索引

概述:

indexOf()方法返回调用 String 对象中第一次出现的指定值的索引，开始在 fromIndex进行搜索。

如果未找到该值，则返回-1。

语法:

str.indexOf(searchValue,fromIndex)

searchValue：

一个字符串表示被查找的值。

fromIndex:可选;表示调用该方法的字符串中开始查找的位置。可以是任意整数。默认值为 0

返回值:指定值的第一次出现的索引; 如果没有找到 -1。

描述:

字符串中的字符被从左向右索引。

首字符的索引（index）为 0，字符串 stringName 的最后一个字符的索引是 stringName.length - 1。

如果 fromIndex < 0 则查找整个字符串（如同传进了 0）。

如果 fromIndex >= str.length，则该方法返回 -1，除非被查找的字符串是一个空字符串，

此时返回 str.length。

var str ="Blue Whale";
console.log(str.indexOf("Blue"));     //  0
console.log(str.indexOf("Blute"));    // -1
console.log(str.indexOf("Whale", 0)); //  5
console.log(str.indexOf("Whale", 5)); //  5
console.log(str.indexOf("", 9));      //  9
console.log(str.indexOf("", 10));     // 10
console.log(str.indexOf("", 11));     // 10
//lastIndexOf()从该字符串的后面向前查找，从 fromIndex 处开始。

1

2

3

4

5

6

7

8

9

var str ="Blue Whale";

console.log(str.indexOf("Blue")); // 0

console.log(str.indexOf("Blute")); // -1

console.log(str.indexOf("Whale", 0)); // 5

console.log(str.indexOf("Whale", 5)); // 5

console.log(str.indexOf("", 9)); // 9

console.log(str.indexOf("", 10)); // 10

console.log(str.indexOf("", 11)); // 10

//lastIndexOf()从该字符串的后面向前查找，从 fromIndex 处开始。

字符串的拼接性能：优先使用 + += 拼接字符串
概述:concat() 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。
语法:str.concat(string2, string3, ..., stringN)
string2...stringN:和原字符串连接的多个字符串
描述:
concat 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。 concat 方法并不影响原字符串。

1

2

3

4

5

6

字符串的拼接性能：优先使用 + += 拼接字符串

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

语法:str.concat(string2, string3, ..., stringN)

string2...stringN:和原字符串连接的多个字符串

描述:

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

var str ="ab";
var str1 ="cd";
console.log(str.concat(str1)); //  abcd

1

2

3

var str ="ab";

var str1 ="cd";

console.log(str.concat(str1)); // abcd

概述:
split() 方法使用指定的分隔符字符串将一个String对象分割成字符串数组,
以将字符串分隔为子字符串,以确定每个拆分的位置

语法:str.split(separator,limit)

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

limit：
一个整数，限定返回的分割片段数量。
当提供此参数时，split 方法会在指定分隔符的每次出现时分割该字符串，但在限制条目已放入数组时停止。
如果在达到指定限制之前达到字符串的末尾，它可能仍然包含少于限制的条目。新数组中不返回剩下的文本。

返回值:返回源字符串以分隔符出现位置分隔而成的一个 Array 

描述:
找到分隔符后，将其从字符串中删除，并将子字符串的数组返回。
如果没有找到或者省略了分隔符，则该数组包含一个由整个字符串组成的元素。
如果分隔符为空字符串，则将str转换为字符数组。
如果分隔符出现在字符串的开始或结尾，或两者都分开，分别以空字符串开头，结尾或两者开始和结束。
因此，如果字符串仅由一个分隔符实例组成，则该数组由两个空字符串组成。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

概述:

split() 方法使用指定的分隔符字符串将一个String对象分割成字符串数组,

以将字符串分隔为子字符串,以确定每个拆分的位置

语法:str.split(separator,limit)

separator:

指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。

如果纯文本分隔符包含多个字符，则必须找到整个字符串来表示分割点。

如果在str中省略或不出现分隔符，则返回的数组包含一个由整个字符串组成的元素。

如果分隔符为空字符串，则将str原字符串中每个字符的数组形式返回。

limit：

一个整数，限定返回的分割片段数量。

当提供此参数时，split 方法会在指定分隔符的每次出现时分割该字符串，但在限制条目已放入数组时停止。

如果在达到指定限制之前达到字符串的末尾，它可能仍然包含少于限制的条目。新数组中不返回剩下的文本。

返回值:返回源字符串以分隔符出现位置分隔而成的一个 Array

描述:

找到分隔符后，将其从字符串中删除，并将子字符串的数组返回。

如果没有找到或者省略了分隔符，则该数组包含一个由整个字符串组成的元素。

如果分隔符为空字符串，则将str转换为字符数组。

如果分隔符出现在字符串的开始或结尾，或两者都分开，分别以空字符串开头，结尾或两者开始和结束。

因此，如果字符串仅由一个分隔符实例组成，则该数组由两个空字符串组成。

var str ="abcdefg";
console.log(str.split()); 	// ["abcdefg"]
console.log(str.split('')); // "a", "b", "c", "d", "e", "f", "g"]
console.log(str.split('d')); //  ["abc", "efg"]
console.log(str.split('d',1)); //  ["abc"]

1

2

3

4

5

var str ="abcdefg";

console.log(str.split()); // ["abcdefg"]

console.log(str.split('')); // "a", "b", "c", "d", "e", "f", "g"]

console.log(str.split('d')); // ["abc", "efg"]

console.log(str.split('d',1)); // ["abc"]

var str ="abcdefg";
var reverseStr=str.split('').reverse().join('');
console.log(reverseStr)//gfedcba

1

2

3

var str ="abcdefg";

var reverseStr=str.split('').reverse().join('');

console.log(reverseStr)//gfedcba

概述:

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

语法:str.replace(regexp|substr, newSubStr|function)

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

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

newSubStr (replacement):
用于替换掉第一个参数在原字符串中的匹配部分的字符串。该字符串中可以内插一些特殊的变量名。
参考使用字符串作为参数。

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

返回值:一个部分或全部匹配由替代模式所取代的新的字符串。

描述:
该方法并不改变调用它的字符串本身，而只是返回一个新的替换后的字符串。
在进行全局的搜索替换时，正则表达式需包含 g 标志。

使用字符串作为参数，替换字符串可以插入下面的特殊变量名：
变量名	代表的值
$$	插入一个 "$"。
$&	插入匹配的子串。
$`	插入当前匹配的子串左边的内容。
$'	插入当前匹配的子串右边的内容。
$n	假如第一个参数是 RegExp对象，并且 n 是个小于100的非负整数，那么插入第 n 个括号匹配的字符串。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

概述:

replace（）方法返回一个由替换值替换一些或所有匹配的模式后的新字符串。

模式可以是一个字符串或者一个正则表达式, 替换值可以是一个字符串或者一个每次匹配都要调用的函数。

语法:str.replace(regexp|substr, newSubStr|function)

regexp (pattern):

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

substr (pattern)：

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

newSubStr (replacement):

用于替换掉第一个参数在原字符串中的匹配部分的字符串。该字符串中可以内插一些特殊的变量名。

参考使用字符串作为参数。

function (replacement):

一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。

参考指定一个函数作为参数。

返回值:一个部分或全部匹配由替代模式所取代的新的字符串。

描述:

该方法并不改变调用它的字符串本身，而只是返回一个新的替换后的字符串。

在进行全局的搜索替换时，正则表达式需包含 g 标志。

使用字符串作为参数，替换字符串可以插入下面的特殊变量名：

变量名代表的值

$$ 插入一个 "$"。

$& 插入匹配的子串。

$` 插入当前匹配的子串左边的内容。

$' 插入当前匹配的子串右边的内容。

$n 假如第一个参数是 RegExp对象，并且 n 是个小于100的非负整数，那么插入第 n 个括号匹配的字符串。

//一般用法
var str='ABCDAFG';
var newstr=str.replace('A','|')
console.log(newstr)//|BCDAFG    只能替换掉第一个 后面的无法替换

1

2

3

4

//一般用法

var str='ABCDAFG';

var newstr=str.replace('A','|')

console.log(newstr)//|BCDAFG 只能替换掉第一个后面的无法替换

//全局匹配替换
var str='ABCDAFGa';
var newstr=str.replace(/A/gi,'|')
console.log(newstr)// |BCD|FG| 全局替换

1

2

3

4

//全局匹配替换

var str='ABCDAFGa';

var newstr=str.replace(/A/gi,'|')

console.log(newstr)// |BCD|FG| 全局替换

//交换位置
var re = /(\w+)\s(\w+)\s(\w+)/;
var str = "John and Smith";
var newstr = str.replace(re, "$3, $2, $1");
console.log(newstr);// Smith, and, John

1

2

3

4

5

//交换位置

var re = /(\w+)\s(\w+)\s(\w+)/;

var str = "John and Smith";

var newstr = str.replace(re, "$3, $2, $1");

console.log(newstr);// Smith, and, John

/*字符串替换-其他方法
替换掉字符串里所有指定的字符串: 
swtichParse('abc=def=hjk','||') => 'abc||def||hjk' 
*/
var str='abc=def=hjk'; //字符串
var replaceStrting='=';//被替换字符串
var targetString='||';//代替的字符串
function swtichParse(str,replaceStrting,targetString){
    return str.split(replaceStrting).join(targetString)
}
console.log(swtichParse(str,replaceStrting,targetString)) //abc||def||hjk

1

2

3

4

5

6

7

8

9

10

11

/*字符串替换-其他方法

替换掉字符串里所有指定的字符串:

swtichParse('abc=def=hjk','||') => 'abc||def||hjk'

*/

var str='abc=def=hjk'; //字符串

var replaceStrting='=';//被替换字符串

var targetString='||';//代替的字符串

function swtichParse(str,replaceStrting,targetString){

return str.split(replaceStrting).join(targetString)

}

console.log(swtichParse(str,replaceStrting,targetString)) //abc||def||hjk

var str = 'To be, or not to be, that is the question.';
function totalCount(str){
	var count = 0;
	var pos = str.indexOf('e');
	while (pos !== -1) {
	  count++;
	  pos = str.indexOf('e', pos + 1);
	}
	return count
}
function totalCount1(str,searchStr){
	return str.split(searchStr).length-1
}
console.log(totalCount(str)); //  4
console.log(totalCount1(str,'e')); //  4  这种方法更加简单 博主无意琢磨出来的 嘿嘿 可以随意指定字符

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

var str = 'To be, or not to be, that is the question.';

function totalCount(str){

var count = 0;

var pos = str.indexOf('e');

while (pos !== -1) {

count++;

pos = str.indexOf('e', pos + 1);

}

return count

}

function totalCount1(str,searchStr){

return str.split(searchStr).length-1

}

console.log(totalCount(str)); // 4

console.log(totalCount1(str,'e')); // 4 这种方法更加简单博主无意琢磨出来的嘿嘿可以随意指定字符

//getIndexArr(str,'a')  = > [0, 7, 11, 16, 20]
var str = 'To be, or not to be, that is the question.';
function getIndexArr(str,targetStr){
    var indexArr=[];
    for(var i=0;i<str.length;i++){ 
        if(str[i]===targetStr){ 
            indexArr.push(i); 
        }
    }
    return indexArr;
}
console.log(getIndexArr(str,'e')); //  [4, 18, 31, 35]

1

2

3

4

5

6

7

8

9

10

11

12

//getIndexArr(str,'a') = > [0, 7, 11, 16, 20]

var str = 'To be, or not to be, that is the question.';

function getIndexArr(str,targetStr){

var indexArr=[];

for(var i=0;i<str.length;i++){

if(str[i]===targetStr){

indexArr.push(i);

}

return indexArr;

}

console.log(getIndexArr(str,'e')); // [4, 18, 31, 35]

var str = "border-left-color";
function swtichHump(str){
	return str.replace(/-(\w)/g,function(match,r1){
		return r1.toUpperCase()
	})
}
console.log(swtichHump(str))//borderLeftColor

1

2

3

4

5

6

7

var str = "border-left-color";

function swtichHump(str){

return str.replace(/-(\w)/g,function(match,r1){

return r1.toUpperCase()

})

}

console.log(swtichHump(str))//borderLeftColor

function swtichHump(str){
	var arr=str.split('-');
	for(var i=1;i<arr.length;i++){
		arr[i]=arr[i].charAt(0).toUpperCase()+arr[i].substr(1)
	}
	return arr.join('')
}
console.log(swtichHump(str))//borderLeftColor

1

2

3

4

5

6

7

8

function swtichHump(str){

var arr=str.split('-');

for(var i=1;i<arr.length;i++){

arr[i]=arr[i].charAt(0).toUpperCase()+arr[i].substr(1)

}

return arr.join('')

}

console.log(swtichHump(str))//borderLeftColor

//查找字符串中出现最多的字符和个数
var str =" fdadffddfdffj";
function more(str){
	var obj={},max=0,maxStr;
	for(var i=0;i<str.length;i++){
		if(!obj[str[i]]){
			obj[str[i]]=1
		}else{
			obj[str[i]]+=1
		}
	}
	for(var k in obj){
		if(obj[k]>max){
			max=obj[k];
			maxStr=k
		}
	}
	return {maxStr:maxStr,maxNum:max}
}
console.log(more(str))//{maxStr: "f", maxNum: 6}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

//查找字符串中出现最多的字符和个数

var str =" fdadffddfdffj";

function more(str){

var obj={},max=0,maxStr;

for(var i=0;i<str.length;i++){

if(!obj[str[i]]){

obj[str[i]]=1

}else{

obj[str[i]]+=1

}

for(var k in obj){

if(obj[k]>max){

max=obj[k];

maxStr=k

}

return {maxStr:maxStr,maxNum:max}

}

console.log(more(str))//{maxStr: "f", maxNum: 6}

var str ="fdadffddfdffj";
function more(str){
	var newArr=str.split('').sort().join(''),max=0,maxStr;
	newArr.replace(/(\w)\1+/g,function(match,r1){
		if(match.length>max){
			max=match.length
			maxStr=r1
		}
	})
	return {maxStr: maxStr, maxNum: max}	
}
console.log(more(str))//{maxStr: "f", maxNum: 6}
// /(\w)\1+/g:在这个例子里表示匹配到子串并且子串长度大于1
// 成功匹配的match:ddddd ffffff  而a只有一个不满足故没有上榜
// r1是子串里的字母 d  f

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

var str ="fdadffddfdffj";

function more(str){

var newArr=str.split('').sort().join(''),max=0,maxStr;

newArr.replace(/(\w)\1+/g,function(match,r1){

if(match.length>max){

max=match.length

maxStr=r1

}

})

return {maxStr: maxStr, maxNum: max}

}

console.log(more(str))//{maxStr: "f", maxNum: 6}

// /(\w)\1+/g:在这个例子里表示匹配到子串并且子串长度大于1

// 成功匹配的match:ddddd ffffff 而a只有一个不满足故没有上榜

// r1是子串里的字母 d f

//此种方法博主无意琢磨出来的 嘿嘿 觉得思路更加清晰
var str = '123235549949945';//235,549,949,945
function thousands(str){
	var len=str.length;
	//是否刚好被3除尽   
	var isDiv=len%3==0
	//可以几等分
	var iNum=parseInt(len/3)
	//不能均等分时 前面的位数 可能是1位或2位
	var frontNum=len%3
	var arr=[];
	if(isDiv){//刚好被3除尽 
		for(var i=0;i<len;i++){
			if(i%3==0){
				arr.push(str.slice(i,i+3))
			}
		}
		return arr.join(',')
	}else{//被3除不尽 
		var firstStr=str.substr(0,frontNum)
		var secoundStr=str.substr(frontNum)
		for(var i=0;i<secoundStr.length;i++){
			if(i%3==0){
				arr.push(secoundStr.slice(i,i+3))
			}
		}
		return firstStr+','+arr.join(',')
	}
}
console.log(thousands(str));

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

//此种方法博主无意琢磨出来的嘿嘿觉得思路更加清晰

var str = '123235549949945';//235,549,949,945

function thousands(str){

var len=str.length;

//是否刚好被3除尽

var isDiv=len%3==0

//可以几等分

var iNum=parseInt(len/3)

//不能均等分时前面的位数可能是1位或2位

var frontNum=len%3

var arr=[];

if(isDiv){//刚好被3除尽

for(var i=0;i<len;i++){

if(i%3==0){

arr.push(str.slice(i,i+3))

}

return arr.join(',')

}else{//被3除不尽

var firstStr=str.substr(0,frontNum)

var secoundStr=str.substr(frontNum)

for(var i=0;i<secoundStr.length;i++){

if(i%3==0){

arr.push(secoundStr.slice(i,i+3))

}

return firstStr+','+arr.join(',')

}

console.log(thousands(str));

var str = '235549949945';
function test(str){
    var reg =/(?=(?!\b)(\d{3})+$)/g;
    return str.replace(reg,',')
}
console.log(test(str));

1

2

3

4

5

6

var str = '235549949945';

function test(str){

var reg =/(?=(?!\b)(\d{3})+$)/g;

return str.replace(reg,',')

}

console.log(test(str));

var str = '35549949945';
function test(str){
	var iNum = str.length%3;
	var prev = '';
	var arr=[];
	var tmp ='';
	var iNow =0;
	if(iNum !=0){
		prev = str.substring(0,iNum);
		arr.push(prev);
	}
	str = str.substring(iNum);
	for(var i=0;i<str.length;i++){
		iNow++;
		tmp +=str[i];
		if(iNow ==3&&tmp){
			arr.push(tmp);
			tmp='';
			iNow=0;
		}
	}
	return arr.join(',');
}
console.log(test(str));

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

var str = '35549949945';

function test(str){

var iNum = str.length%3;

var prev = '';

var arr=[];

var tmp ='';

var iNow =0;

if(iNum !=0){

prev = str.substring(0,iNum);

arr.push(prev);

}

str = str.substring(iNum);

for(var i=0;i<str.length;i++){

iNow++;

tmp +=str[i];

if(iNow ==3&&tmp){

arr.push(tmp);

tmp='';

iNow=0;

}

return arr.join(',');

}

console.log(test(str));

/*

One Hundred Years of Solitude