简介:

JavaScript中的反引号是ECMAScript 6 // ECMAScript 2015中引入的一个特性，用于制作简单的动态字符串。这个ECMAScript 6特性也被称为模板字符串文字。与普通字符串相比，它具有以下优点:

在模板字符串中允许换行，因此可以是多行。正常的字符串字面量(用" or ""声明)不允许有换行符。 我们可以使用${myVariable}语法轻松地将变量值插入到字符串中。

例子:

const name = 'Willem'; Const age = 26; Const story = ' 我的名字是:${name} 我是:${age}岁 ”; console.log(故事);

浏览器的兼容性:

所有主要浏览器厂商(Internet Explorer除外)都支持模板字符串字面值。所以在生产代码中使用它是相当安全的。浏览器兼容性的详细列表可以在这里找到。

这是一个称为模板字面量的特性。

在ECMAScript 2015规范的早期版本中，它们被称为“模板字符串”。

Firefox 34、Chrome 41和Edge 12及以上版本支持模板文字，但Internet Explorer不支持。

示例:http://tc39wiki.calculist.org/es6/template-strings/ 官方规范:ECMAScript 2015语言规范，12.2.9模板文字词汇组件(有点干)

模板字面量可以用来表示多行字符串，并可以使用“插值”来插入变量:

var a = 123, str = `---
   a is: ${a}
---`;
console.log(str);

输出:

---
   a is: 123
---

更重要的是，它们不仅可以包含变量名，还可以包含任何JavaScript表达式:

var a = 3, b = 3.1415;

console.log(`PI is nearly ${Math.max(a, b)}`);

你也可以制作模板的模板，并达到私有变量。

var a= {e:10, gy:'sfdsad'}; //global object

console.log(`e is ${a.e} and gy is ${a.gy}`); 
//e is 10 and gy is sfdsad

var b = "e is ${a.e} and gy is ${a.gy}" // template string
console.log( `${b}` );
//e is ${a.e} and gy is ${a.gy}

console.log( eval(`\`${b}\``) ); // convert template string to template
//e is 10 and gy is sfdsad

backtick( b );   // use fonction's variable
//e is 20 and gy is fghj

function backtick( temp ) {
  var a= {e:20, gy:'fghj'}; // local object
  console.log( eval(`\`${temp}\``) );
}

很多评论回答了你的大部分问题，但我主要想回答这个问题:

反勾号的行为与单引号的行为有区别吗?

我注意到模板字符串的一个不同之处是不能将其设置为对象属性。更多信息在这篇文章;从公认的答案中引用一段有趣的话:

模板字符串是表达式，不是字面量1。

但基本上，如果你想把它用作对象属性你就必须用方括号把它括起来。

// Throws error
const object = {`templateString`: true};

// Works
const object = {[`templateString`]: true};

ECMAScript 6提出了一种新的字符串文字类型，使用反勾号作为分隔符。这些字面量允许嵌入基本的字符串插值表达式，然后自动解析和求值。

let person = {name: 'RajiniKanth', age: 68, greeting: 'Thalaivaaaa!' };

let usualHtmlStr = "<p>My name is " + person.name + ",</p>\n" +
  "<p>I am " + person.age + " old</p>\n" +
  "<strong>\"" + person.greeting + "\" is what I usually say</strong>";

let newHtmlStr =
 `<p>My name is ${person.name},</p>
  <p>I am ${person.age} old</p>
  <p>"${person.greeting}" is what I usually say</strong>`;

console.log(usualHtmlStr);
console.log(newHtmlStr);

可以看到，我们在一系列字符周围使用了'，这些字符被解释为字符串字面量，但任何形式为${..}将立即内联解析和求值。

插值字符串字面量的一个非常好的好处是它们可以被分割成多行:

var Actor = {"name": "RajiniKanth"};

var text =
`Now is the time for all good men like ${Actor.name}
to come to the aid of their
country!`;
console.log(text);
// Now is the time for all good men like RajiniKanth
// to come to the aid of their
// country!

插值表达式

任何有效表达式都允许出现在${..}，包括函数调用，内联函数表达式调用，甚至其他插值字符串字面量!

function upper(s) {
  return s.toUpperCase();
}
var who = "reader"
var text =
`A very ${upper("warm")} welcome
to all of you ${upper(`${who}s`)}!`;
console.log(text);
// A very WARM welcome
// to all of you READERS!

在这里，内部的' ${who}s '插值字符串文字在组合who变量和' s '字符串时对我们来说更方便一些，而不是who + ' s '。还要注意，插值字符串文字只是在它出现的地方进行词法作用域，而不是以任何方式进行动态作用域:

(例如:一个name变量被内插在定义template-literal的作用域中的值;在foo函数的作用域中赋值将没有效果)

function foo(str) {
  var name = "foo";
  console.log(str);
}
function bar() {
  var name = "bar";
  foo(`Hello from ${name}!`);
}
var name = "global";
bar(); // "Hello from bar!"

为HTML使用模板文字肯定更易于阅读，因为它减少了麻烦。

简单的老办法:

'<div class="' + className + '">' +
  '<p>' + content + '</p>' +
  '<a href="' + link + '">Let\'s go</a>'
'</div>';

使用ECMAScript 6:

`<div class="${className}">
  <p>${content}</p>
  <a href="${link}">Let's go</a>
</div>`

字符串可以跨越多行。 你不必转义引号字符。 你可以避免这样的分组:'">' 你不需要使用加号运算符。

带标签的模板文字

我们也可以标记模板字符串，当模板字符串被标记时，字面量和替换被传递给函数，该函数返回结果值。

function myTaggedLiteral(strings) {
  console.log(strings);
}

myTaggedLiteral`test`; //["test"]

function myTaggedLiteral(strings, value, value2) {
  console.log(strings, value, value2);
}
let someText = 'Neat';
myTaggedLiteral`test ${someText} ${2 + 3}`;
//["test", ""]
// "Neat"
// 5

我们可以在这里使用展开运算符来传递多个值。第一个参数——我们称之为字符串——是所有普通字符串(任何插值表达式之间的东西)的数组。

然后，使用…将所有后续参数收集到一个名为values的数组中。虽然您当然可以像上面所做的那样，将它们作为单独的命名参数留在字符串参数后面(value1, value2，等等)。

function myTaggedLiteral(strings, ...values) {
  console.log(strings);
  console.log(values);
}

let someText = 'Neat';
myTaggedLiteral`test ${someText} ${2 + 3}`;
//["test", ""]
// "Neat"
// 5

收集到values数组中的参数是在字符串字面量中已经求值的插值表达式的结果。带标记的字符串字面值类似于插值计算之后，但在编译最终字符串值之前的处理步骤，允许您更好地控制从字面值生成字符串。让我们看一个创建可重用模板的例子。

const Actor = {
  name: "RajiniKanth",
  store: "Landmark"
}

const ActorTemplate = templater`<article>
  <h3>${'name'} is a Actor</h3>
  <p>You can find his movies at ${'store'}.</p>

</article>`;

function templater(strings, ...keys) {
  return function(data) {
    let temp = strings.slice();
    keys.forEach((key, i) => {
      temp[i] = temp[i] + data[key];
    });
    return temp.join('');
  }
};

const myTemplate = ActorTemplate(Actor);
console.log(myTemplate);

原始字符串

我们的标记函数接收第一个参数，我们称之为strings，它是一个数组。但是还包含一个额外的数据:所有字符串的原始未处理版本。你可以使用.raw属性访问这些原始字符串值，就像这样:

function showraw(strings, ...values) {
  console.log(strings);
  console.log(strings.raw);
}
showraw`Hello\nWorld`;

如您所见，字符串的原始版本保留了转义\n序列，而经过处理的字符串版本将其视为未转义的真正新行。ECMAScript 6提供了一个内置函数，可以用作字符串文字标记:string .raw(..)。它只是传递字符串的原始版本:

console.log(`Hello\nWorld`);
/* "Hello
World" */

console.log(String.raw`Hello\nWorld`);
// "Hello\nWorld"

好的部分是我们可以直接进行基本的数学运算:

坚果= 7 更多。innerHTML = ' 到目前为止你收集了${nuts} nuts ! <人力资源> 加倍，得到${nuts + nuts} nuts!! ｀ < div id = "更多" > < / div >

它在工厂函数中变得非常有用:

函数坚果(){ 返回的 你有${it}坚果!< br > 你的坚果的余义:${Math.cos(it)} <br> 三个螺母:${3 * it} <br> 你的坚果编码在BASE64:<br> ${btoa(它)} ｀ ｝ 螺母。Oninput =(函数(){ 出去了。innerHTML = nuts(nuts .value) }) < h3 >坚果计算器 <input type="number" id="nut"> < div id = "出" > < / div >