JS 理清字符串的用法

方法

String.fromCharCode()

• 该方法返回由指定的 utf-16代码单元序列创建的字符串

let str1 = String.fromCharCode(65, 66, 67)
console.log(str1) // ABC

String.prototype.charAt()

• 从一个字符串中返回指定的字符

let str2 = 'protein'
console.log(str1.charAt(3)) // t
console.log(str1[3]) // t

String.prototype.charCodeAt()

• 返回字符的 utf-16 代码单元值的数字

console.log('ABC'.charCodeAt(0)) // 65
console.log('ABC'.charCodeAt(10)) // NaN
console.log('ABC'.charCodeAt(-1)) // NaN

String.prototype.codePointAt()

• 返回字符的 unicode 编码值的非负整数

String.prototype.concat()

• 同数组的 concat 方法，接收多个参数，将其合并成一个字符串

let str3 = 'protein'
let str4 = str3.concat('banana', 'apple')
console.log(str4) // proteinbananaapple

String.prototype.includes()

• 同数组的 includes 方法用来判断该字符串是否包含在另一个字符串里面，返回一个 boolean 值
• 接收第二个参数 index 并根据它来判断起始查找位置

let str5 = 'protein'
console.log(str5.includes('te')) // true
console.log(str5.includes('te', 1)) // true
console.log(str5.includes('te', 10)) // false

String.prototype.search()

• 判断字符串是否包含另一个字符串，区别 includes 方法返回对应的下标，如果不存在返回 -1，可以传入正则或者字符串，而 includes 方法只能传入字符串

let str51 = 'protein2020'
let reg51 = /\d+/
console.log(str51.search(reg51)) // 7
console.log(str51.search('2020')) // 7

String.prototype.endsWith()

• 判断当前字符串是否以另一个字符串作为结尾
• 接收第二个可选参数，作为判断当前字符串的 length，默认为字符串的 length，注意此处没有 -1

let str6 = 'protein tomato potato'
console.log(str6.endsWith('potato')) // true
console.log(str6.endsWith('tomato')) // false
console.log(str6.endsWith('tomato', 14)) // true

String.prototype.startsWith()

• 方法与 endsWith 相反，判断字符串的开头

String.prototype.indexOf()

• 方法返回字符串第一次出现位置的索引值
• 接收第二个可选参数 index 为判断的起始位置

let str7 = 'protein tomato potato'
console.log(str7.indexOf('tomato')) // 8
console.log(str7.indexOf('tomato', 0)) // 8
console.log(str7.indexOf('tomato', 10)) // -1
console.log(str7.indexOf('tomato', 100)) // -1

// 统计一个字符串中某个字母出现的次数
let str8 = 'ptoteintomatopotatobanana'
let count = 0
let someString = str8.indexOf('o')
while(someString !== -1) {
    count++
    someString = str8.indexOf('o', someString + 1)
}
console.log(count) // 5

String.prototype.lastIndexOf()

• 与 indexOf 相反为返回字符串的最后一个出现位置的索引值
• 接收第二个可选参数 index 为判断的起始位置，从右向左开始查找

let str9 = 'protein tomato potato'
console.log(str9.lastIndexOf('potato')) // 15
console.log(str9.lastIndexOf('potato', 100)) // 15
console.log(str9.lastIndexOf('potato', 10)) // -1

String.prototype.localeCompare()

• 返回一个数字来比较两个字符串的大小，如果相等则为 0

let str10 = 'protein'
let str101 = 'potato'
console.log(str10.localeCompare(str101)) // 1

String.prototype.match()

• 方法返回一个字符串匹配正则表达式的结果

let str11 = 'protein2019bear2020'
let reg11 = /\d+/
console.log(str11.match(reg11)) // [ '2019', index: 7, input: 'protein2019bear2020', groups: undefined ]
reg11 = /\d+/g
console.log(str11.match(reg11)) // [ '2019', '2020' ]

String.prototype.normalize()

• 返回指定 Unicode 的形式

let str12 = '\u0066\u0066'
console.log(str12.normalize()) // ff

String.prototype.repeat()

• 复制

let str13 = 'protein'
// console.log(str13.repeat(-1)) // RangeError: repeat count must be positive and less than inifinity
console.log(str13.repeat(0)) // ''
console.log(str13.repeat(1)) // protein
console.log(str13.repeat(2)) // proteinprotein

String.prototype.replace()

• 返回一个根据正则匹配替换的新字符串，原字符串不会改变
• 第一个参数为匹配正则或者要被替换的字符串
• 第二个参数为要替换成的字符串或者一个回调函数

let str14 = 'protein is a protein'
let str141 = str14.replace('protein', 'potato')
console.log(str141) // potato is a protein
console.log(str14) // protein is a protein
let str142 = str141.replace(/\bp[a-z]*n\b/, 'potato')
console.log(str142) // potato is a potato
let str143 = 'protein potato'
let str144 = str143.replace(/(\w+)\s(\w+)/, '$2 $1')
console.log(str144) // potato protein 

String.prototype.slice()

• 方法同数组的 slice 接收两个 index 第一个代表起始位置，第二个代表结束下标，截取部分不包含第二个参数代表的位置，如果为负数则用 length 加上对应的 index
• 返回一个新的字符串，原字符串不变

let str15 = 'protein'
let str151 = str15.slice(1, 1)
let str152 = str15.slice(1, 2)
let str153 = str15.slice(1, 10)
console.log(str15) // protein
console.log(str151) // ''
console.log(str152) // r
console.log(str153) // rotein

String.prototype.split()

• 用制定字符将字符串分割成数组
• 对应数组的 join 方法
• 接收第二个可选参数用来限制生成数组的长度

let str16 = 'protein,jfla'
let arr16 = str16.split(',')
let arr161 = str16.split(',', 1)
console.log(arr16) // [ 'protein', 'jfla' ]
console.log(arr161) // [ 'protein' ]
console.log(arr16.join()) // protein,jfla

String.prototype.toLowerCase()

• 返回字符串的小写形式，toLocaleLowerCase 方法可以传入指定的编码形式

String.prototype.toUpperCase()

• 返回字符串的大写形式，toLocaleUpperCase 方法可以传入指定的编码形式

String.prototype.substr()

• 方法返回切割的新字符串，原字符串不变
• 区别 slice 方法，第二个参数为要切割的数量而非下标值
• 如果第一个参数为负值，则从 length - 1 + index 位置开始

let str17 = 'protein'
console.log(str17.slice(1, 2)) // r
console.log(str17.substr(1, 2)) // ro
console.log(str17.substr(-6, 2)) // ro

String.prototype.substring()

• 方法同 slice 返回两个参数之间的字符串，原字符串不变且不包含第二个参数的值
• 区别与 slice 如果为负数则做 0 处理，如果超过 length 则做 length 处理

let str18 = 'protein'
console.log(str18.slice(1, 2))
console.log(str18.substring(1, 2))