Détails des routines pratiques des chaînes JavaScript

Les chaînes JavaScript sont utilisées pour stocker et manipuler du texte. Par conséquent, elle est toujours avec vous lorsque vous écrivez du code JS, lorsque vous traitez les données saisies par l'utilisateur, lorsque vous lisez ou définissez les propriétés des objets DOM, lorsque vous utilisez des cookies, lorsque vous convertissez diverses dates, etc. count; et ses nombreuses API rendent toujours les gens réticents à s'en souvenir, puisque vous les utilisez fréquemment, autant parcourir 烂笔头, et d'ailleurs, cela reflète aussi la valeur de l'existence du blog, donc il y en a. Ce résumé.

Interception de chaîne

1. substring()

xString.substring(start,end)

substring() est la méthode d'interception de chaîne la plus couramment utilisée. Elle peut recevoir deux paramètres (le paramètre ne peut pas être négatif. ), qui sont respectivement la position de début et la position de fin à intercepter. Il renverra une nouvelle chaîne dont le contenu est composé de caractères du début à la fin-1. Si le paramètre de fin (end) est omis, cela signifie une interception de la position de début à la fin.

let str = 'www.jeffjade.com'
console.log(str.substring(0,3)) // www
console.log(str.substring(0))   //www.jeffjade.com
console.log(str.substring(-2))  //www.jeffjade.com (传负值则视为0)

2. slice()

stringObject.slice(start, end)

La méthode slice() est très similaire à la méthode substring(). Les deux paramètres qu'elle transmet correspondent également à la position de départ. et la fin. La différence est que le paramètre dans slice() peut être une valeur négative. Si le paramètre est un nombre négatif, le paramètre spécifie la position à partir de la fin de la chaîne. Autrement dit, -1 fait référence au dernier caractère de la chaîne.

let str = 'www.jeffjade.com'
console.log(str.slice(0, 3))    // www
console.log(str.slice(-3, -1))  // co
console.log(str.slice(1, -1))   // www.jeffjade.co
console.log(str.slice(2, 1))    // '' (返回空字符串,start须小于end)
console.log(str.slice(-3, 0))   // '' (返回空字符串,start须小于end)

3. substr()

stringObject.substr(start,length)

La méthode substr() peut extraire le nombre spécifié de caractères à partir de l'indice de début dans la chaîne. La valeur de retour est une chaîne contenant des caractères de longueur commençant au début de stringObject (y compris le caractère pointé par start). Si la longueur n'est pas spécifiée, la chaîne renvoyée contient des caractères du début à la fin de stringObject. De plus, si start est un nombre négatif, cela signifie compter à partir de la fin de la chaîne.

let str = 'www.jeffjade.com'
console.log(webStr.substr(1, 3))   // ww.
console.log(webStr.substr(0))      // www.jeffjade.com
console.log(webStr.substr(-3, 3))  // com
console.log(webStr.substr(-1, 5))  // m  (目标长度较大的话，以实际截取的长度为准)

4. split()

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

• séparateur spécifie le caractère (chaîne) utilisé pour diviser la chaîne. le séparateur peut être une chaîne ou une expression régulière. Si le séparateur est omis, un tableau de la chaîne entière est renvoyé. Si le séparateur est une chaîne vide, str renverra un tableau de chaque caractère de la chaîne d'origine.

• limit Un entier qui limite le nombre de fragments fractionnés renvoyés. La méthode split divise toujours chaque séparateur correspondant, mais le tableau renvoyé n'interceptera que jusqu'à la limite des éléments.

let str = 'www.jeffjade.com'
str.split('.')      // ["www", "jeffjade", "com"]
str.split('.', 1)   // ["www"]
str.split('.').join('') // wwwjeffjadecom

En parlant de cela, cette fonction est vraiment facile à utiliser. Souvent, les exigences d'interception de caractères dépendent d'un certain caractère et les trois fonctions ci-dessus doivent toutes connaître sa position ; . Bien sûr, nous pouvons utiliser indexOf et d'autres méthodes pour l'obtenir. Évidemment, c'est très fastidieux, mais utiliser split facilite les choses.

Méthode de classe de recherche

1. indexOf() & include()

stringObject.indexOf(searchValue,fromIndex)

indexOf() est utilisée pour récupérer la première occurrence d'une valeur de chaîne spécifiée dans un emplacement de la chaîne. Il peut recevoir deux paramètres, searchValue représente la sous-chaîne à rechercher et fromIndex représente la position de départ de la recherche. En cas d'omission, la recherche sera effectuée à partir de la position de départ.

let str = 'www.jeffjade.com'
console.log(str.indexOf('.'))     // 3
console.log(str.indexOf('.', 1))  // 3
console.log(str.indexOf('.', 5))  // 12
console.log(str.indexOf('.', 12)) // -1

Bien que indexOf() soit utilisé pour récupérer la position où la valeur de chaîne spécifiée apparaît pour la première fois dans la chaîne, il est souvent utilisé pour déterminer si la chaîne spécifiée existe dans la chaîne. Ainsi, le code le fera ; ressemble à ceci :

if (str.indexOf('yoursPecifiedStr') !== -1) {
    // do something
}

Vous devez savoir que dans un tel scénario, la méthode include() du langage ES6 est beaucoup plus élégante ; la méthode include() est utilisée pour déterminer si une chaîne est incluse dans S'il se trouve dans une autre chaîne, il renvoie vrai, sinon il renvoie faux.

str.includes(searchString[, position])

searchString La sous-chaîne à rechercher. La position est facultative. La position d'index de la chaîne actuelle pour commencer la recherche de sous-chaînes ; la valeur par défaut est 0. Il convient de noter que include() est sensible à la casse.

'Blue Whale'.includes('blue'); // returns false
'乔峰乔布斯乔帮主'.includes('乔布斯'); // returns true
if (str.includes('yoursPecifiedStr')) {
    // do something(这样写是不是更为人性化？Yeah，这是一个更趋向人性化的时代嘛)
}

2. La syntaxe lastIndexOf()

stringObject.lastIndexOf(searchValue,fromIndex)

lastIndexOf() est similaire à indexOf(). Elle renvoie la dernière position d'occurrence d'une valeur de sous-chaîne spécifiée. de l'arrière vers l'avant.

let str = 'www.jeffjade.com'
console.log(str.lastIndexOf('.'))     // 12
console.log(str.lastIndexOf('.', 1))  // -1
console.log(str.lastIndexOf('.', 5))  // 3
console.log(str.lastIndexOf('.', 12)) // 12

search()

stringObject.search(substr)
stringObject.search(regexp)

La méthode search() est utilisée pour récupérer une sous-chaîne spécifiée dans une chaîne, ou pour récupérer une sous-chaîne qui correspond à une expression régulière. Il renvoie la position de départ de la première sous-chaîne correspondante, ou -1 s'il n'y a pas de correspondance.

let str = 'www.jeffjade.com'
console.log(str.search('w'))    // 0
console.log(str.search(/j/g))   // 4
console.log(str.search(/\./g))  // 3

Méthode match()

stringObject.match(substr)
stringObject.match(regexp)

La méthode match() peut récupérer une valeur spécifiée dans une chaîne ou trouver une correspondance pour une ou plusieurs expressions régulières.

Si le paramètre transmis est une sous-chaîne ou une expression régulière qui n'effectue pas de correspondance globale, la méthode match() effectuera une correspondance depuis le début. Si aucun résultat ne correspond, null sera renvoyé. Sinon, un tableau sera renvoyé. Le 0ème élément du tableau stocke le texte correspondant. De plus, le tableau renvoyé contient également deux attributs d'objet, index et input, qui représentent respectivement l'index du caractère de départ du texte correspondant et le stringObject. Référence (c'est-à-dire chaîne d'origine).

let str = '#1a2b3c4d5e#';
console.log(str.match('A'));    //返回null
console.log(str.match('b'));    //返回["b", index: 4, input: "#1a2b3c4d5e#"]
console.log(str.match(/b/));    //返回["b", index: 4, input: "#1a2b3c4d5e#"]

Si le paramètre est passé dans une expression régulière avec correspondance globale, alors match() correspondra plusieurs fois du début à la fin. Si aucun résultat n'est trouvé, null est renvoyé. Sinon, un tableau sera renvoyé, qui stocke toutes les sous-chaînes qui répondent aux exigences et n'a aucun attribut d'index ni d'entrée.

let str = '#1a2b3c4d5e#'
console.log(str.match(/h/g))     //返回null
console.log(str.match(/\d/g))    //返回["1", "2", "3", "4", "5"]

其他方法

replace()方法

stringObject.replace(regexp/substr,replacement)

replace()方法用来进行字符串替换操作，它可以接收两个参数，前者为被替换的子字符串（可以是正则），后者为用来替换的文本。

如果第一个参数传入的是子字符串或是没有进行全局匹配的正则表达式，那么replace()方法将只进行一次替换（即替换最前面的），返回经过一次替换后的结果字符串。

let str = 'www.jeffjade.com'
console.log(str.replace('w', 'W'))   // Www.jeffjade.com
console.log(str.replace(/w/, 'W'))   // Www.jeffjade.com

如果第一个参数传入的全局匹配的正则表达式，那么replace()将会对符合条件的子字符串进行多次替换，最后返回经过多次替换的结果字符串。

let str = 'www.jeffjade.com'
console.log(str.replace(/w/g, 'W'))   // WWW.jeffjade.com

toLowerCase() & toUpperCase()

stringObject.toLowerCase()
stringObject.toUpperCase()

toLowerCase()方法可以把字符串中的大写字母转换为小写，toUpperCase()方法可以把字符串中的小写字母转换为大写。

let str = 'www.jeffjade.com'
console.log(str.toLowerCase())   // www.jeffjade.com
console.log(str.toUpperCase())   // WWW.JEFFJADE.COM

模板字符串

这个也是 ES6 才引入进来的新语法，来解决传统输出String模板的蹩脚问题；其功能之强大，设计之贴心，着实令人得到极大满足感，好如久旱逢甘霖一般的舒畅。更何况，在当今 MVVM 前端框架大行其道的时代，使用 ES6 语法也是不用自己个儿去操心兼容性问题，对于塑造 Dom Template 更是如虎添翼，令人爱不释手。

对于她的使用，阮一峰在ECMAScript 6 入门有过详细的描述以及示例，在此就不赘述。只需要明白我们可以像这样去操作了，试问爽否？

function ncieFunc() {
  return "四海无人对夕阳";
}
var niceMan = "陈寅恪";
var jadeTalk = `一生负气成今日 \n ${ncieFunc()} ,
语出 ${niceMan} 的《忆故居》。
`
console.log(jadeTalk)

运行之，Chrome Console 输出结果如下：

一生负气成今日
四海无人对夕阳 ,
语出 陈寅恪 的《忆故居》。

组合其法

细看 JavaScript 提供的String Api，还是有蛮多的，也有些许废弃的，也有将在未来版本会出来的；这其中不乏很多也挺有用的，譬如： charAt(x)、charCodeAt(x)、concat(v1, v2,…)、fromCharCode(c1, c2,…) 等等,还有 ES6 对字符串的扩展，比如 字符串的遍历器接口，repeat() 等等，这可以参见 ES6-string，这里就不多赘述。

在实际代码生产中，很多时候需要用这些提供的基本方法，来打出一套组合拳，以解决其需求所需。很显然又可以借助 prototype 属性，将自造的各路拳法，其归置于 String 对象，然后天亮啦。这一步就看个人喜好了，这里抛出一二段，以引大玉。

字符串反转

String.prototype.reverse = function () {
	return this.split('').reverse().join('')
}

去除空白行

String.prototype.removeBlankLines = function () {
	return this.replace(/(\n[\s\t]*\r*\n)/g, '\n').replace(/^[\n\r\n\t]*|[\n\r\n\t]*$/g, '')
}

String转化为数组

1, 转化为一维数组

场景是根据某子字符串转化，直接就用 split 就好；如果转换规则不统一，那么请自求多福吧。

let Str = '陈寅恪,鲁迅,钱钟书,胡适,王国维,梁启超,吴宓,季羡林'
let hallAllOfFameArr = Str.split(',')
console.log(hallAllOfFameArr)
// ["陈寅恪", "鲁迅", "钱钟书", "胡适", "王国维", "梁启超", "吴宓", "季羡林"]

2, 转化为二维数组

String.prototype.removeBlankLines = function () {
	return this.replace(/(\n[\s\t]*\r*\n)/g, '\n').replace(/^[\n\r\n\t]*|[\n\r\n\t]*$/g, '')
}
String.prototype.strTo2dArr = function(firstSplit, secondSplit){
	var contentStr = this.removeBlankLines(),
		contentStrArr = contentStr.split(firstSplit),
		resultArr = contentStrArr.map((element) => {
            return element.split(secondSplit)
        })
	return resultArr
}
var str = `
渺渺钟声出远方,依依林影万鸦藏。
一生负气成今日,四海无人对夕阳。
破碎山河迎胜利,残馀岁月送凄凉。
松门松菊何年梦,且认他乡作故乡。
`
console.log(str.strTo2dArr('\n', ','))

运行之，输出结果如下：

[ [ ‘渺渺钟声出远方’, ‘依依林影万鸦藏。’ ],
[ ‘一生负气成今日’, ‘四海无人对夕阳。’ ],
[ ‘破碎山河迎胜利’, ‘残馀岁月送凄凉。’ ],
[ ‘松门松菊何年梦’, ‘且认他乡作故乡。’ ] ]

抗战时期，陈寅恪先生在给傅斯年的信中，说了这样一段话：“弟之生性，非得安眠饱食，不能作文，非是既富且乐，不能作诗，平生偶有安眠饱食之时，故偶可为文，而一生从无既富且乐之日，故总做不好诗。” 虽是以调侃的以言说，恐也是寄之感慨的悟道之语。自由独立的经济生活，是自由思想与独立人格的坚强后盾与实际保障。写博这事儿，也是一样，整日疲于需求之成改，熬时碌碌，生为糊口；偶有的闲时气力，哪儿是能经得起折腾的？唯是在垒码的间隙，略做记录，积而成篇。而这番为得的糊口的奋争，也是希望将来的某天——能有既富且乐之时，谈那些想谈的，做那些想做的事，如此而已。

 以上就是JavaScript 字符串实用常操纪要详情的内容，更多相关内容请关注PHP中文网（www.php.cn）！