JavaScript字符串操作方法大全，包含ES6方法

、charAt()

返回在指定位置的字符。

var str="abc"
console.log(str.charAt(0))//a

二、charCodeAt()

返回在指定的位置的字符的 Unicode 编码。

var str="abc"
 console.log(str.charCodeAt(1))//98

三、concat()

连接字符串。

 var a = "abc";  
 var b = "def";  
 var c = a.concat(b);
 console.log(c);//abcdef

四、indexOf()

检索字符串。indexOf() 方法对大小写敏感！

var str="Hello world!"
console.log(str.indexOf("Hello"))//0
console.log(str.indexOf("World"))//-1
console.log(str.indexOf("world"))///6

五、match()

match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置。

var str="1 abc 2 def 3"
console.log(str.match(/\d+/g))//123

六、replace()

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

var str="abc Def!"
console.log(str.replace(/abc/, "CBA"))//CBA Def!

七、search()

search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。要执行忽略大小写的检索，请追加标志 i。如果没有找到任何匹配的子串，则返回 -1。

var str="abc DEF!"
console.log(str.search(/DEF/))//4

八、slice()

提取字符串的片断，并在新的字符串中返回被提取的部分。
stringObject.slice(start,end);

start :要抽取的片断的起始下标。如果是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符，-2 指倒数第二个字符，以此类推。

end：紧接着要抽取的片段的结尾的下标。若未指定此参数，则要提取的子串包括 start 到原字符串结尾的字符串。

如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。

var str="abc def ghk"
console.log(str.slice(6))//f ghk

九、split()

把字符串分割为字符串数组。

var str="abc def ghi jkl"    
console.log(str.split(" "))//["abc", "def", "ghi", "jkl"]
console.log(str.split("") )//["a", "b", "c", " ", "d", "e", "f", " ", "g", "h", "i", " ", "j", "k", "l"]
console.log(str.split(" ",3))//["abc", "def", "ghi"]

十、toLocaleLowerCase()

把字符串转换为小写。

var str="ABC def!"
console.log(str.toLocaleLowerCase())//abc def!

十一、toLocaleUpperCase()

把字符串转换为大写。

var str="ABC def!"
console.log(str.toLocaleUpperCase())//ABC DEF!

十二、toLowerCase()

把字符串转换为小写。

var str="ABC def!"
console.log(str.toLowerCase())//abc def!

十三、toUpperCase()

把字符串转换为大写。

var str="ABC def!"
console.log(str.toUpperCase())//ABC DEF!

十四、substr()

从起始索引号提取字符串中指定数目的字符。
stringObject.substr(start,length)。

start：必需。要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推。

length：可选。子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串。

var str="abc def"
console.log(str.substr(2))//c def
console.log(str.substr(2,4))// c de

十五、substring()

提取字符串中两个指定的索引号之间的字符。
stringObject.substring(start,stop)。

start ：必需。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的位置。

stop ：可选。一个非负的整数，比要提取的子串的最后一个字符在 stringObject 中的位置多 1。如果省略该参数，那么返回的子串会一直到字符串的结尾。

var str="abc def"
console.log(str.substring(2))//c def
console.log(str.substring(2,4))// c

相同点：如果只是写一个参数，两者的作用都一样：都是是截取字符串从当前下标以后直到字符串最后的字符串片段。
substr(startIndex);
substring(startIndex);

var str = '123456789';
console.log(str.substr(2));    //  "3456789"
console.log(str.substring(2)) ;//  "3456789"

不同点：第二个参数
substr（startIndex,lenth）：第二个参数是截取字符串的长度（从起始点截取某个长度的字符串）；
substring（startIndex, endIndex）：第二个参数是截取字符串最终的下标（截取2个位置之间的字符串,‘含头不含尾’）。

console.log("123456789".substr(2,5));    //  "34567"
console.log("123456789".substring(2,5)) ;//  "345"

ES6新增的操作字符串的方法

一、codePointAt()

let s = 'a';
s.codePointAt(0) // 134071
s.codePointAt(1) // 57271
s.codePointAt(2) // 97

codePointAt方法的参数，是字符在字符串中的位置（从 0 开始）。

上面代码中，JavaScript 将“a”视为三个字符，codePointAt 方法在第一个字符上，正确地识别了“”，返回了它的十进制码点 134071（即十六进制的20BB7）。

在第二个字符（即“”的后两个字节）和第三个字符“a”上，codePointAt方法的结果与charCodeAt方法相同。

二、String.fromCodePoint()

ES5 提供String.fromCharCode方法，用于从码点返回对应字符，但是这个方法不能识别 32 位的 UTF-16 字符（Unicode 编号大于0xFFFF）。

String.fromCharCode(0x20BB7)
// "ஷ"

上面代码中，String.fromCharCode不能识别大于0xFFFF的码点，所以0x20BB7就发生了溢出，最高位2被舍弃了，最后返回码点U+0BB7对应的字符，而不是码点U+20BB7对应的字符。

ES6 提供了String.fromCodePoint方法，可以识别大于0xFFFF的字符，弥补了String.fromCharCode方法的不足。

在作用上，正好与codePointAt方法相反。

String.fromCodePoint(0x20BB7)
// ""
String.fromCodePoint(0x78, 0x1f680, 0x79) === 'x\uD83D\uDE80y'
// true

三、字符串的遍历器接口 for of

for (let codePoint of 'abc') {
  console.log(codePoint)
}
// "a"
// "b"
// "c"

除了遍历字符串，这个遍历器最大的优点是可以识别大于0xFFFF的码点，传统的for循环无法识别这样的码点。

四、at（）

at方法可以识别Unicode 编号大于0xFFFF的字符，返回正确的字符。

‘abc’.at(0)//"a"
'吉'.at(0)//"吉"

五、normalize()

许多欧洲语言有语调符号和重音符号。为了表示它们，Unicode 提供了两种方法。一种是直接提供带重音符号的字符，比如Ǒ（u01D1）。

另一种是提供合成符号（combining character），即原字符与重音符号的合成，两个字符合成一个字符，比如O（u004F）和ˇ（u030C）合成Ǒ（u004Fu030C）。

这两种表示方法，在视觉和语义上都等价，但是 JavaScript 不能识别。

'\u01D1'==='\u004F\u030C' //false    
'\u01D1'.length // 1
'\u004F\u030C'.length // 2

上面代码表示，JavaScript 将合成字符视为两个字符，导致两种表示方法不相等。
ES6 提供字符串实例的normalize()方法，用来将字符的不同表示方法统一为同样的形式，这称为 Unicode 正规化。

'\u01D1'.normalize() === '\u004F\u030C'.normalize()
// true

六、includes(), startsWith(), endsWith()

传统上，JavaScript 只有indexOf方法，可以用来确定一个字符串是否包含在另一个字符串中。ES6 又提供了三种新方法。

**includes()**：返回布尔值，表示是否找到了参数字符串。
**startsWith()**：返回布尔值，表示参数字符串是否在原字符串的头部。
**endsWith()**：返回布尔值，表示参数字符串是否在原字符串的尾部。
let s = 'Hello world!';    
s.startsWith('Hello') // true
s.endsWith('!') // true
s.includes('o') // true

这三个方法都支持第二个参数，表示开始搜索的位置。

let s = 'Hello world!';    
s.startsWith('world', 6) // true
s.endsWith('Hello', 5) // true
s.includes('Hello', 6) // false

上面代码表示，使用第二个参数n时，endsWith的行为与其他两个方法有所不同。它针对前n个字符，而其他两个方法针对从第n个位置直到字符串结束。

七、repeat()

repeat方法返回一个新字符串，表示将原字符串重复n次。

'x'.repeat(3) // "xxx"
'hello'.repeat(2) // "hellohello"
'na'.repeat(0) // ""

参数如果是小数，会被取整。

'na'.repeat(2.9) // "nana"

如果repeat的参数是负数或者Infinity，会报错。

'na'.repeat(Infinity)
// RangeError
'na'.repeat(-1)
// RangeError

八、padStart()，padEnd()

ES2017 引入了字符串补全长度的功能。如果某个字符串不够指定长度，会在头部或尾部补全。padStart()用于头部补全，padEnd()用于尾部补全。

'x'.padStart(5, 'ab') // 'ababx'
'x'.padStart(4, 'ab') // 'abax'


'x'.padEnd(5, 'ab') // 'xabab'
'x'.padEnd(4, 'ab') // 'xaba'

上面代码中，padStart和padEnd一共接受两个参数，第一个参数用来指定字符串的最小长度，第二个参数是用来补全的字符串。

如果原字符串的长度，等于或大于指定的最小长度，则返回原字符串。

'xxx'.padStart(2, 'ab') // 'xxx'
'xxx'.padEnd(2, 'ab') // 'xxx'

如果用来补全的字符串与原字符串，两者的长度之和超过了指定的最小长度，则会截去超出位数的补全字符串。

'abc'.padStart(10, '0123456789')
// '0123456abc'

如果省略第二个参数，默认使用空格补全长度。

'x'.padStart(4) // '   x'
'x'.padEnd(4) // 'x   '

padStart的常见用途是为数值补全指定位数。下面代码生成 10 位的数值字符串。

'1'.padStart(10, '0') // "0000000001"
'12'.padStart(10, '0') // "0000000012"
'123456'.padStart(10, '0') // "0000123456"

另一个用途是提示字符串格式。

'12'.padStart(10, 'YYYY-MM-DD') // "YYYY-MM-12"
'09-12'.padStart(10, 'YYYY-MM-DD') // "YYYY-09-12"

九、matchAll()

matchAll方法返回一个正则表达式在当前字符串的所有匹配。

十、字符串模板

模板字符串（template string）是增强版的字符串，用反引号（`）标识。它可以当作普通字符串使用，也可以用来定义多行字符串，或者在字符串中嵌入变量。-----字符串模板，工作中用到比较多。

// 普通字符串
`In JavaScript '\n' is a line-feed.`


// 多行字符串
`In JavaScript this is
 not legal.`


console.log(`string text line 1
string text line 2`);


// 字符串中嵌入变量
let name = "Bob", time = "today";
`Hello ${name}, how are you ${time}?`

上面代码中的模板字符串，都是用反引号表示。如果在模板字符串中需要使用反引号，则前面要用反斜杠转义。

let greeting = `\`Yo\` World!`;

如果使用模板字符串表示多行字符串，所有的空格和缩进都会被保留在输出之中。

$('#list').html(`
<ul>
  <li>first</li>
  <li>second</li>
</ul>
`);

上面代码中，所有模板字符串的空格和换行，都是被保留的，比如<ul>标签前面会有一个换行。如果你不想要这个换行，可以使用trim方法消除它。

$('#list').html(`
<ul>
  <li>first</li>
  <li>second</li>
</ul>
`.trim());

模板字符串中嵌入变量，需要将变量名写在${}之中。

function authorize(user, action) {
  if (!user.hasPrivilege(action)) {
    throw new Error(
      // 传统写法为
      // 'User '
      // + user.name
      // + ' is not authorized to do '
      // + action
      // + '.'
      `User ${user.name} is not authorized to do ${action}.`);
  }
}

大括号内部可以放入任意的 JavaScript 表达式，可以进行运算，以及引用对象属性。

let x = 1;
let y = 2;


`${x} + ${y} = ${x + y}`
// "1 + 2 = 3"


`${x} + ${y * 2} = ${x + y * 2}`
// "1 + 4 = 5"


let obj = {x: 1, y: 2};
`${obj.x + obj.y}`
// "3"

模板字符串之中还能调用函数。

function fn() {
  return "Hello World";
}    
`foo ${fn()} bar`
// foo Hello World bar

如果大括号中的值不是字符串，将按照一般的规则转为字符串。比如，大括号中是一个对象，将默认调用对象的toString方法。

如果模板字符串中的变量没有声明，将报错。

// 变量place没有声明
let msg = `Hello, ${place}`;
// 报错

由于模板字符串的大括号内部，就是执行 JavaScript 代码，因此如果大括号内部是一个字符串，将会原样输出。

`Hello ${'World'}`
// "Hello World"

模板字符串甚至还能嵌套。

符串的常用方法

●我们操作字符串，也有一堆的方法来帮助我们操作

●字符串和数组有一个一样的地方，也是按照索引来排列的

●注意：所有字符串常用方法, 都不会改变原始字符串, 都是以返回值的形式出现结果

字符串常用方法之 charAt

●作用：charAt() 是找到字符串中指定索引位置的内容返回

●语法：字符串.charAt(索引)

●返回值：该索引位置对应的字符

○如果有该索引位置, 那么就是该索引位置的字符

○如果没有该索引位置, 那么就是空字符串('')

var str = 'hello world'
// 使用 charAt 找到字符串中的某一个内容
var index = str.charAt(2)
console.log(index) // l
//查找索引为 13 的内容，因为没有返回是一共空字符串
var index1 = str.charAt(13)
console.log(index1); // ''

字符串常用方法之 charCodeAt

●作用：charCodeAt() 就是返回对应索引位置的 unicode 编码

●语法：字符串.charCodeAt(索引)

●返回值：该索引位置的对应字符的编码(十进制)

var str = 'hello world'

// 使用 charAt 找到字符串中的某一个内容
var index = str.charCodeAt(4)
console.log(index) // 111
○因为 0 在 unicode 对照表里面存储的是 111，所以就会返回 111

字符串常用方法之 indexOf

●作用：indexOf 就是按照字符找到对应的索引

●语法：字符串.indexOf(要查找的字符，开始索引)

●返回值：

○如果有该字符内容, 那么就是该字符的索引位置

○如果没有该字符内容, 就是 -1

var str = 'hello world'

// 使用 indexOf 找到字符串中的某一个内容
var index = str.indexOf('l', 0)
console.log(index) // 2 返回第一个找到的内容的下标后面的就不查找了

var index1 = str.indexOf('w', 3)
console.log(index1); // 6 不管从那个索引开始，索引的位置不变

var index2 = str.indexOf('w', 7)
console.log(index2); // -1 从索引7开始查找没有找到返回-1

字符串常用方法之 lastIndexOf

●作用：lastIndexOf 是从后向前检测该字符在字符串内的索引位置

●语法：字符串.indexOf(要查找的字符，开始索引)

●返回值：

○如果有该字符内容, 那么就是该字符的索引位置

○如果没有该字符内容, 就是 -1

var str = 'hello world'

// 使用 lastIndexOf 找到字符串中的某一个内容
var index = str.lastIndexOf('l')
console.log(index) //9 返回第一个找到的内容的下标后面的就不查找了,索引的位置不变

var index = str.lastIndexOf('l', 8)
console.log(index) //3 返回第一个找到的内容的下标后面的就不查找了，索引的位置不变

var index = str.lastIndexOf('w', 5)
console.log(index) //-1 从后开始查找，开始的索引是5 但是前面没有找到w 返回-1

字符串常用方法之 substring

●作用：substring 是用来截取字符串使用的

●语法： substring(从哪个索引开始，到哪个索引截止)，包含开始索引，不包含结束索引

●返回值：返回截取到的内容

var str = 'hello world'

// 使用 substring截取字符串中的某一个内容
var res = str.substring(2, 8)
console.log(res); //llo wo

字符串常用方法之 substr

●作用：substr 也是用来截取字符串的

●语法：substr(从哪个索引开始，截取多少个)

●返回值：截取到的内容

var str = 'hello world'

// 使用 substr截取字符串中的某一个内容
var res = str.substr(2, 7)//从索引2开始，截取7个
console.log(res); //llo wor

○这个方法和 substring 不一样的是，第二个参数是截取多少个

字符串常用方法之 toLowerCase 和 toUpperCase

●作用：这两个方法分别是用来给字母格式的字符串转成小写字母和大写字母的

●语法：

○字符串.toLowerCase()

○字符串.toUpperCase()

var str = 'hello world'

// 使用 toUpperCase 转换成大写
var upper = str.toUpperCase()
console.log(upper) // HELLO WORLD

// 使用 toLowerCase 转换成小写
var lower = upper.toLowerCase()
console.log(lower) // hello world

字符串常用方法之 slice

●作用：截取字符串

●语法：字符串.slice(起始索引，结束索引)

○包含开始的索引对应的内容，不包含结束索引对应的内容

○结束索引不写就直接截取到末尾

●返回值：截取出来的字符串

var str = 'hello world'

// 使用 slice 截取字符串
var res = str.slice(1, 4) //ell
console.log(res);
//没有结束的索引直接截取到末尾
var res1 = str.slice(1) //ello world
console.log(res1);

字符串常用方法之 replace

●作用：用指定的内容替换掉字符串中的内容

●语法：字符串.repalce(被替换的内容，要替换的内容)

○被替换内容 => 换下内容

○要替换内容 => 换上内容

●返回值：替换好的字符串

●注意：内容只能被替换一次，从索引0 的位置开始

var str = 'hello world'

// 使用 replace 替换字符串中的内容

var res = str.replace('l', 'M')

console.log(res); // heMlo world
console.log(str); // hello world

字符串常用方法之 split

●作用：按照切割符号, 把字符串切割开, 放在一个数组里面.

●语法：字符串.split('指定的切割符')

○切割符可以不传递，就会和整体当做一个字符串

○(''）空字符串会一位一位的切割

○(' ') 字符串中有空格会按照原字符串中的空格切割

●返回值：一个用指定切割符切割好的数组

var str = 'hello world'

// 使用 split 切割成一个数组
var res = str.split()
console.log(res); //['hello world']

var res1 = str.split('')
console.log(res1); //['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

var res2 = str.split(' ')
console.log(res2); //['hello', 'world']

字符串常用方法之 concat

●作用：字符串拼接也可以说是字符串合并

●语法：字符串.concat(字符串)

●返回值：拼接后的字符串

var str = 'hello world '

var str1 = 'ni hao'

// 使用 concat 切割成一个数组
var res = str.concat('ni hao')
console.log(res); // hello world ni hao

var res1 = str.concat(str1)
console.log(res1); // hello world ni hao

字符串常用方法之 trim

●作用：取出字符串头尾的空白内容

●语法：字符串.trim()

●返回值：去除空白内容以后的字符串

var str = ' hello world '

// 使用 trim 切割成一个数组
var res = str.trim()
console.log(res); // hello world

字符串常用方法之 trimStart / trimLeft

●作用：去除字符串头部的空白内容

●语法：

○字符串.trimStart()

○字符串.trimLeft()

●返回值：去除空白内容以后的字符串

var str = ' hello world '

// 使用 trimStart 后者trimLeft去除头部的空白内容
var res = str.trimStart()
console.log(res); //hello world

var res1 = str.trimLeft()
console.log(res1); //hello world

字符串常用方法之 trimEnd / trimRight

●作用：去除字符串尾部的空白内容

●语法：

○字符串.trimtrimEnd()

○字符串.trimRight()

●返回值：去除空白内容以后的字符串

var str = ' hello world '

// 使用 trimEnd 后者trimRight去除尾部的空白内容
var res = str.trimEnd()
console.log(res); // hello world

var res1 = str.trimRight()
console.log(res1); // hello world

文章推荐：

jQuery是什么？如何使用？

IDEA常用快捷键大全汇总

数据分析必备，常用的Execl函数与公式大全！

更多IT程序员资讯/技术类干货，关注@千锋教育

态规则，是指在不重启服务器的前提下使业务规则发生变化，且不影响服务器的正常使用，从而实现动态业务变化的规则。

如果还不了解drools的情况下，请先查看作者其他两篇关于drools的文章。

drools动态规则的实现主要有两种方式：字符串拼接方式和构建kjar两种。

字符串拼接的方式

一个drools的规则文本如下：

```
package rules.rulesHelo
import com.pojo.Person
	rule “规则1"
		when 
			eval(true);
		then 
			System.out.println(“hello world”);
	end
	rule “规则2"
		when 
			$p:Person();
		then 
			System.out.println(“对象” + $p);
	end
```

原理：

1.可以将规则文本以字符串的形式存储在数据库中。

2.然后定时从数据库中拉取最新的规则文本的字符串。

3.将规则文本一次性加载到内存中。

4.基于业务取选择覆盖或者新增，重新build，然后进行全局缓存。

具体实现：

public KieContainer loadForRule(String drlStr) {
        KieServices ks = KieServices.Factory.get();
        KieRepository kr = ks.getRepository();
        KieFileSystem kfs = ks.newKieFileSystem();

        kfs.write("src/main/resources/rules/" + drlStr.hashCode() + ".drl", drlStr);
        
        // 将KieFileSystem加入到KieBuilder
        KieBuilder kb = ks.newKieBuilder(kfs);

        // 编译此时的builder中所有的规则
        kb.buildAll();
        if (kb.getResults().hasMessages(Message.Level.ERROR)) {
            throw new RuntimeException("Build Errors:\n" + kb.getResults().toString());
        }

        return ks.newKieContainer(kr.getDefaultReleaseId());
    }

后续从缓存中加载规则：

KieSession kieSession = kContainer.newKieSession();

构建kjar

生成kjar的动态规则与拼接字符串的方式有相似之处，核心思想与Workbench构建kjar相似，kjar的核心思想是kmodule.xml配置文件，而Kie为开发人员提供了这样的API。

原理：

规则引擎服务中并不包含规则，服务启动时，将从Maven存储库中拉取kjar包（实际上就是一个约定好的jar包），并加载其中的规则。

启动以后，规则引擎服务将不停的监视Maven存储库中的规则kjar包是否更新（轮训监控，监控时间为kScanner 中配置），如果更新则更新其中新的规则，规则引起服务本身不需重新启动。

核心实现：

private KieContainer kContainer;

    @PostConstruct
    public void setUp() {
        KieServices ks = KieServices.Factory.get();

        ReleaseId releaseId = ks.newReleaseId("com.amao.drools", "rules-kjar", "1.0-SNAPSHOT");

        kContainer = ks.newKieContainer(releaseId);
        KieScanner kScanner = ks.newKieScanner(kContainer);

        //定时轮训（单位，毫秒）仓库中对应的jar包
        kScanner.start(10000L);
    }

rules-kjar包是一个kjar项目，其中包含了kmodule.xml文件和Drools规则.drl文件。kjar项目是指引入了kie-maven-plugin插件，并指定打包为kjar，在打包的过程中，插件会校验以drl定义的规则是否可以正常编译。

drools官方文档

https://docs.jboss.org/drools/release/7.6.0.Final/drools-docs/html_single/index.html#_kiescanner

在线咨询

上一篇：前端开发之用以处理表单的jQuery控件之AJAX请求
下一篇：HTML5 新增的标签

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

JavaScript字符串操作方法大全，包含ES6方法

、charAt()

二、charCodeAt()

三、concat()

四、indexOf()

五、match()

六、replace()

七、search()

八、slice()

九、split()

十、toLocaleLowerCase()

十一、toLocaleUpperCase()

十二、toLowerCase()

十三、toUpperCase()

十四、substr()

十五、substring()

ES6新增的操作字符串的方法

一、codePointAt()

二、String.fromCodePoint()

三、字符串的遍历器接口 for of

四、at（）

五、normalize()

六、includes(), startsWith(), endsWith()

七、repeat()

八、padStart()，padEnd()

九、matchAll()

十、字符串模板

符串的常用方法

字符串常用方法之 charAt

字符串常用方法之 charCodeAt

字符串常用方法之 indexOf

字符串常用方法之 lastIndexOf

字符串常用方法之 substring

字符串常用方法之 substr

字符串常用方法之 toLowerCase 和 toUpperCase

字符串常用方法之 slice

字符串常用方法之 replace

字符串常用方法之 split

字符串常用方法之 concat

字符串常用方法之 trim

字符串常用方法之 trimStart / trimLeft

字符串常用方法之 trimEnd / trimRight

字符串拼接的方式

构建kjar

您的项目需求