utilisation de base
laisser un message = `Bonjour World`; console.log (message);Si vous arrive d'utiliser l'anti-apostrophe dans la chaîne, vous pouvez utiliser l'évasion de barre oblique inverse:
laisser un message = `Bonjour \` World`; console.log (message);Il est à noter que, dans la chaîne de modèle, espaces, tirets, les sauts de ligne seront conservés:
laisser un message = ` < ul > < li > 1 < / Li > < li > 2 < / Li > < / ul > `; console.log (message);
Notez que les résultats de la première ligne d'impression est un saut de ligne, vous pouvez utiliser la fonction de garniture pour éliminer wrap:
laisser un message = ` < ul > < li > 1 < / Li > < li > 2 < / Li > < / ul > `.Trim (); console.log (message);
variables intégrées
Supports intégrés variables de chaîne de modèle, écrivez simplement les noms de variables dans $ {} en fait, plus d'une variable, les expressions JavaScript arbitraires sont possibles:
soit x = 1, y = 2; laisser un message = ` < ul > < li > $ {X} < / Li > < li > $ {X + y} < / Li > < / ul > `; console.log (message); // < ul > < li > 1 < / Li > < li > 3 < / Li > < / ul >Il est une valeur que la mention chaîne supporte modèle imbriqué:
laisser arr = ; laisser un message = ` < ul > $ {Arr.map ((article) = > { retour ` < li > $ {} Item.value < / Li > ` })} < / ul > `; console.log (message);Imprimer les résultats sont les suivants:
On notera que, dans le milieu d'une virgule li multi-étiquette, ceci est parce que quand les accolades lorsque la valeur est une chaîne de caractères, qui sera convertie en une chaîne, par exemple un tableau seront automatiquement converties en 1, 2, 3, est produite par des virgules.
Si vous voulez supprimer cette virgule, vous pouvez d'abord rejoindre:
laisser arr = ; laisser un message = ` < ul > $ {Arr.map ((article) = > { retour ` < li > $ {} Item.value < / Li > ` }). Joignez-vous à ( '')} < / ul > `; console.log (message);Imprimer les résultats sont les suivants:
Modèles d'étiquettes
étiquette de modèle est une capacité très importante, immédiatement après la chaîne de modèle peut être un nom de fonction, la fonction sera appelée à faire face à cette chaîne de modèle, par exemple:
soit x = 'Salut', y = 'Kevin'; var res = message` $ {x}, je suis $ {y} `; CONSOLE.LOG (res);Nous pouvons personnaliser la fonction de message pour gérer la chaîne retournée:
// texte de littéraux // Notez que le premier élément et le dernier élément de littéraux chaîne vide dans ce cas un message de fonction (littéraux, valeur1, valeur2) { console.log (littéraux); // console.log (valeur1); // Salut console.log (valeur2); // Kevin }Nous utilisons ce paramètre pour mettre sur pied en arrière:
un message de fonction (littéraux, ... valeurs) { laisser result = ''; pour (soit i = 0; i < values.length; i ++) { résultat + = littéraux ; entraîner + = valeurs ; } résultat + = littéraux ; résultat retour; }Vous pouvez également écrire:
un message de fonction (littéraux, ... valeurs) { laisser result = literals.reduce ((précédent, suivant, i) = > { Apprécions = valeurs ; retour préc + + valeur suivante; }); résultat retour; }Apprenez à mettre en place est de retour une chose très importante, parce que nous sommes soumis à divers traitements, en fin de compte ont encore à se battre ......
oNELINE
Fini la fondation, nous pouvons examiner certains besoins pratiques:
laisser un message = ` Salut, Daisy! Je suis Kevin. `;Pour faciliter la lecture ou d'autres raisons, je voudrais écrire quand il enveloppé, mais le caractère est le résultat final de la ligne, ce qui nécessite l'aide de balises de modèle à atteindre, et nous avons essayé d'écrire une fonction comme ceci:
// ONELINE première édition fonction ONELINE (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; retour préc + + expression suivante; }); entraîner = result.replace (/ (\ s +) / g, ""); entraîner = result.trim (); résultat retour; }Le principe est simple, et une pluralité de sauts de ligne de retour de séparation tels que des espaces, boîte, etc. remplacé par un espace.
Utiliser comme suit:
laisser un message = ONELINE ` Salut, Daisy! Je suis Kevin. `; console.log (message); // Salut, Daisy Je suis Kevin !.Mais vous trouverez un problème et ensuite, si vous mettez des espaces multiples entre les personnages font? Par exemple:
laisser un message = oneLine` Préserver phrases, par exemple. Double espaces à l'intérieur des lignes d'entrée. `;Si cette méthode de mise en correspondance, des phrases. Double l'espace entre les deux sera remplacé par un espace.
On peut alors optimiser, ce que nous voulons est de remplacer plusieurs espaces devant chaque ligne dans un espace, en fait, devrait être adapté plus d'espaces derrière les sauts de ligne et les sauts de ligne, puis de le remplacer par un espace, nous vous pouvez être une lecture régulière:
entraîner = result.replace (/ (\ n \ s *) / g, "");Il peut correspondre au code. Le code final est le suivant:
// ONELINE Deuxième édition fonction ONELINE (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; retour préc + + expression suivante; }); entraîner = result.replace (/ (\ n \ s *) / g, ""); entraîner = result.trim (); résultat retour; }stripIndents
Imaginez une section de HTML:
laisser html = ` < envergure > 1 < envergure > < envergure > 2 < envergure > < envergure > 3 < envergure > `;Afin de maintenir la lisibilité, je veux entrer dans le motif final est le suivant:
< envergure > 1 < envergure > < envergure > 2 < envergure > < envergure > 3 < envergure >En match de fait en face de chaque espace de ligne, puis le remplacer par une chaîne vide.
// stripIndents première édition stripIndents de fonction (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; retour préc + + expression suivante; }); entraîner = result.replace (/ \ n * / g, '\ n'); entraîner = result.trim (); résultat retour; }Peut-être est le plus difficile expressions régulières:
entraîner = result.replace (/ \ n * / g, '\ n');\ S qui correspond à un caractère non-blanc
représente les caractères non-correspondants autres que les espaces et les sauts de ligne, en fait, il est à supprimer des caractères de saut de ligne whitespace
\ N * représente un caractère de saut de ligne et un flan comprenant une pluralité de sauts de ligne après le saut de ligne
remplacer (/ \ n * / g, « \ n ») indique un saut de ligne et la pluralité de sauts de ligne contiennent après le caractère de saut de ligne vierge remplacé par un saut de ligne, en fait, est le éliminer l'espace blanc après la signification nouvelle ligne
En fait, il, ne pas écrire trop de problèmes, on peut aussi écrire:
entraîner = result.replace (/ ^ + / g, '');Semble un simple bit, a pu écrire en raison du motif correspondant, vous trouverez, en plus d'égaler la situation générale, cette fois-ci nous correspond également à plusieurs lignes, m drapeau est utilisé pour spécifier la chaîne d'entrée multiples doit être pris en compte une pluralité de rangées, et si le drapeau est utilisé m ^ et affichent $ le début ou la fin de chaque ligne de la chaîne d'entrée, plutôt que la totalité de la chaîne de début ou de fin.
représente une mise en correspondance de caractères en blanc supprimé nouvelle ligne
^ + indique correspond au caractère de saut de ligne pour supprimer le vide ou une pluralité de caractères au début de
result.replace (/ ^ + / g, « ») indique le début de chaque ligne un ou plusieurs caractères en blanc saut de ligne supprimé remplacé par une chaîne de zéro, d'atteindre le but également.
Le code final est le suivant:
// stripIndents Deuxième édition stripIndents de fonction (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; retour préc + + expression suivante; }); entraîner = result.replace (/ ^ + / g, ''); entraîner = result.trim (); résultat retour; }stripIndent
Notez cette stripIndent une lettre moins le titre de rapport au-dessus d'un, et les caractéristiques que nous voulons atteindre est la suivante:
laisser html = ` < ul > < li > 1 < / Li > < li > 2 < / Li > < li > 3 < / Li > < ul > `;
En effet, soit la suppression d'une partie de la nouvelle ligne et la première ligne de chaque tiret de la ligne.
Ce trouble de la volonté de mise en uvre un peu, parce que nous devons calculer le nombre de chaque ligne à la fin pour supprimer des espaces caractères.
Des idées pour atteindre les résultats suivants:
Code est mis en uvre comme suit:
laisser html = ` < ul > < li > 1 < / Li > < li > 2 < / Li > < li > 3 < / Li > < ul > `; fonction stripIndent (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; retour préc + + expression suivante; }); correspondance const = result.match (/ ^ * (= \ S) / g?); console.log (jeu); // Tableau const indent = correspondre && Math.min (... match.map (el = > el.length)); console.log (tiret); // 4 si (tiret) { const regexp = new RegExp ( `^ {$ tiret {}}`, 'g'.); console.log (regexp); // /^.{4}/gm entraîner = result.replace (regexp, ''); } entraîner = result.trim (); résultat retour; }Ils sont à noter que nous pensons généralement que dans régulièrement. Les moyens correspond à tout caractère correspond en fait à un seul caractère à l'exception d'une nouvelle ligne.
Le code simplifié final est le suivant:
fonction stripIndent (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; retour préc + + expression suivante; }); correspondance const = result.match (/ ^ * (= \ S) / g?); const indent = correspondre && Math.min (... match.map (el = > el.length)); si (tiret) { const regexp = new RegExp ( `^ {$ tiret {}}`, 'g'.); entraîner = result.replace (regexp, ''); } entraîner = result.trim () résultat retour; }includeArrays
Afin d'éviter ce qui précède, nous avons mentionné les expressions $ {} retourne un tableau, une pluralité de conversion automatique peut causer des problèmes par des virgules, tous les besoins de tableau pour finalement rejoindre ( « »), une autre lecture à travers des exemples:
laisser arr = ; laisser un message = ` < ul > $ {Arr.map ((article) = > { retour ` < li > $ {} Item.value < / Li > ` }). Joignez-vous à ( '')} < / ul > `; console.log (message);Utilisez les modèles d'étiquettes, on peut facilement résoudre ce problème:
includeArrays de fonction (modèle, ... expressions) { laisser result = template.reduce ((précédent, suivant, i) = > { laisser expression = expressions ; si (Array.isArray (expression)) { expression = expression.join ( ''); } retour préc + + expression suivante; }); entraîner = result.trim (); résultat retour; }
