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

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

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

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

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

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

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

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

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"]

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

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

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

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

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

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

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

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

let s = '""


上面代码中，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 提供了两种方法。一种是直接提供带重音符号的字符，比如"htmlcode">

'\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}"htmlcode">

$('#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"


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


const tmpl = addrs => `
 <table>
 ${addrs.map(addr => `
 <tr><td>${addr.first}</td></tr>
 <tr><td>${addr.last}</td></tr>
 `).join('')}
 </table>
`;


PS: 文中ES6的内容，主要来自于阮一峰的《ES6标准入门》。