web-dev-qa-db-fra.com

Quelles sont les utilisations réelles de ES6 Raw String Access?

Quelles sont les utilisations réelles de String.raw Raw String Access introduit dans ECMAScript 6?

// String.raw(callSite, ...substitutions)

function quux (strings, ...values) {
    strings[0] === "foo\n"
    strings[1] === "bar"
    strings.raw[0] === "foo\\n"
    strings.raw[1] === "bar"
    values[0] === 42
}

quux `foo\n${ 42 }bar`

String.raw `foo\n${ 42 }bar` === "foo\\n42bar"

J'ai parcouru les documents ci-dessous.

http://es6-features.org/#RawStringAccess

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/raw

http://www.2ality.com/2015/01/es6-strings.html

https://msdn.Microsoft.com/en-us/library/dn889830(v=vs.94).aspx

La seule chose que je comprends, c’est qu’il est utilisé pour obtenir la forme de chaîne brute de chaînes de modèle et est utilisé pour déboguer la chaîne de modèle.

Quand cela peut-il être utilisé dans le développement en temps réel? Ils appelaient cela une fonction de tag. Qu'est-ce que ça veut dire?

Quels cas d'utilisation concrets me manque?

javascriptecmascript-6rawstringtemplate-strings
25
Venkat.R

Les chaînes de modèles peuvent être utiles dans de nombreuses situations que je vais expliquer ci-dessous. Considérant cela, le fichier String.raw empêche l’interprétation des échappements. Cela peut être utile dans n'importe quelle chaîne de modèle dans laquelle vous voulez contenir le caractère d'échappement mais ne voulez pas l'échapper. Un exemple simple pourrait être le suivant:

var templateWithBackslash = String.raw `someRegExp displayed in template /^\//`

Il y a quelques éléments à l'intérieur qui sont agréables à noter avec des chaînes de modèle. 

  1. Ils peuvent contenir des sauts de ligne non échappés sans problème. 
  2. Ils peuvent contenir "$ {}". À l'intérieur de ces accolades, le javascript est interprété à la place.

(Remarque: leur exécution générera le résultat sur votre console [dans les outils de développement du navigateur])

Exemple utilisant des sauts de ligne:

var myTemplate = `
<div class="myClass">
  <pre>
    My formatted text
    with multiple lines
    {
      asdf: "and some pretty printed json"
    }
  </pre>
</div>
`
console.log(myTemplate)

Si vous vouliez faire ce qui précède avec une chaîne de caractères normale en Javascript, cela ressemblerait à ceci:

var myTemplate = "\
<div class="myClass">\
  <pre>\
    My formatted text\
    with multiple lines\
    {\
      asdf: "and some pretty printed json"\
    }\
  </pre>\
</div>"
console.log(myTemplate)

Vous remarquerez que le premier est probablement beaucoup plus joli (pas besoin d'échapper aux sauts de ligne).

Pour la seconde, je vais utiliser le même modèle de chaîne, mais aussi insérer le JSON imprimé.

var jsonObj = {asdf: "and some pretty printed json", deeper: {someDeep: "Some Deep Var"}}
var myTemplate = `
<div class="myClass">
  <pre>
    My formatted text
    with multiple lines
    ${JSON.stringify(jsonObj, null, 2)}
  </pre>
</div>
`
console.log(myTemplate)

3
Goblinlord

Tout d'abord, quelques choses:

  • Les chaînes de modèle sont un ancien nom pour les littéraux de modèle. 
  • Une balise est une fonction. 
  • String.raw est une méthode. 
  • String.raw foo\n${ 42 }bar est un littéral de modèle balisé.
  • Les littéraux de modèle sont essentiellement des chaînes fantaisistes.
  • Les littéraux de modèle peuvent interpoler.
  • Les littéraux de modèle peuvent être multilignes sans utiliser \.
  • String.raw est requis pour échapper au caractère d'échappement \.

Essayez de placer une chaîne contenant un caractère de nouvelle ligne \n via une fonction qui utilise un caractère de nouvelle ligne.

console.log("This\nis\nawesome"); // "This\nis\nawesome"
console.log(String.raw`This\nis\nawesome`); // "This\\nis\\nawesome"

Si vous vous le demandez, console.log n'en fait pas partie. Mais alert est. Essayez de les exécuter via http://learnharmony.org/ .

alert("This\nis\nawesome");
alert(String.raw`This\nis\nawesome`);

Mais attendez, ce n'est pas l'utilisation de String.raw.

Utilisations possibles de la méthode String.raw:

  • Pour afficher une chaîne sans interprétation des caractères antislash (\ n,\t), etc.
  • Pour afficher le code pour la sortie. (Comme dans l'exemple ci-dessous)
  • A utiliser dans regex sans échapper à \.
  • Pour imprimer des emplacements Windows Director/sous-répertoires sans utiliser \\ trop. (Ils utilisent \ Remember. Aussi, lol)

Ici, nous pouvons afficher la sortie et le code correspondant dans une seule fenêtre d’alerte:

alert("I printed This\nis\nawesome with " + Sring.raw`This\nis\nawesome`);

Cependant, cela aurait été bien si Son utilisation principale aurait pu être de récupérer la chaîne d'origine. Comme:

var original = String.raw`This    is     awesome.`;

où original serait devenu: This\tis \tawesome.. Ce n'est malheureusement pas le cas.

Références:

2
user900360

L'utilisation

(Connaissances requises: tstring § .)

Au lieu de:

console.log(`\\a\\b\\c\\n\\z\\x12\\xa9\\u1234\\u00A9\\u{1234}\\u{00A9}`);

.vous pouvez:

console.log(String.raw`\a\b\c\n\z\x12\xa9\u1234\u00A9\u{1234}\u{00A9}`);

"Échapper"

<\\u> est correct, mais <\u> doit "s'échapper", par exemple:

console.log(String.raw`abc${'\\u'}abc`);

.Dit <\\x>, <\x>, <console.log(String.raw`abc${`\\x`}abc`)>;

. <\`>, <`>, <console.log(String.raw`abc${`\``}abc`)>;

. <\${>, <${&>, <console.log(String.raw`abc${`$\{`}abc`)>;

. <\\1> (jusqu'au <\\7>), <\1>, <console.log(String.raw`abc${`\\1`}abc`)>;

. <\\>, unité <\>, <console.log(String.raw`abc${`\\`}`)>.

Nb

Il y a aussi une nouvelle corde "latex". Cf § .

0
Pacerier

Dans NodeJS, il est extrêmement pratique pour gérer les chemins de fichiers:

var fs=require('fs');
var s =  String.raw`C:\Users\<username>\AppData\Roaming\SomeApp\someObject.json`;
var username = "bob"
s=s.replace("<username>",username)
fs.readFile(s,function(err,result){
    if (err) throw error;
    console.log(JSON.parse(result))
})

Cela améliore la lisibilité des chemins de fichiers sous Windows. \ est aussi un séparateur assez commun, donc je peux vraiment voir pourquoi il serait utile en général. Cependant, il est assez stupide de voir comment \ échappe encore `... Donc, finalement:

String.raw`C:\Users\` //#==> C:\Users\`
console.log(String.raw`C:\Users\`) //#==> SyntaxError: Unexpected end of input.
0
Sancarn

Je l’ai trouvé utile pour les testsmy RegExps. Dites que j'ai un RegExp qui Devrait correspondre aux commentaires de fin de ligne parce que Je veux les supprimer. MAIS, il ne doit pas faire correspondre le code source pour une expression rationnelle telle que /// . Si votre code contient ///, ce n'est pas le début D'un commentaire EOL, mais une RegExp, comme selon les règles de la syntaxe JavaScript.

Je peux tester si mon RegExp dans la variable patEOLC Correspond ou non /// avec:

String.raw`/\//` .match (patEOLC)

En d’autres termes, c’est une façon de laisser mon code "Voir" le code tel qu’il existe dans le code source .__, pas comme il existe dans la mémoire après sa lecture Dans la mémoire depuis le code source, avec toutes les barres obliques inverses supprimées.

C'est un moyen "d'échapper à la fuite" mais Sans devoir le faire séparément Pour chaque barre oblique inversée d'une chaîne, mais Pour tous en même temps.

C'est une façon de dire que, dans une barre oblique inversée chaîne Donnée., Elle doit se comporter comme tout autre caractère Elle n'a pas de signification ou d'interprétation particulière

0
Panu Logic