SQL Server Management Studio - использование нескольких фильтров в списке таблиц?

ES6 предлагает новый тип строкового литерала, используя обратный тик в качестве разделителя. Эти литералы позволяют встроить встроенные интерполяционные выражения строки, которые затем автоматически анализируются и оцениваются.

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
// 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". Кроме того, чтобы сохранить примечание, интерполированный строковый литерал просто лексически ограничен, где он появляется, но не динамически ограничен каким-либо образом

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>';

С ES6:

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

• Ваша строка может охватывать несколько строк.
• Вам не нужно скрывать символы котировки.
• Вы можете избежать группировок, таких как: '">'
• Вам не нужно использовать оператор plus.

Литералы с метками шаблонов

Мы также можем пометить строку шаблона, когда тега шаблона помечена, литералы и подстановки передаются функции, которая возвращает результирующее значение.

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

Мы можем использовать оператор спреда здесь, чтобы передать несколько значений. Первый аргумент - мы называем его строками - это массив всех простых строк (материал между любыми интерполированными выражениями).

, мы затем собираем все последующие аргументы в массив, называемый значения, используя ... gather/rest operator, хотя вы могли бы, конечно, оставить их как индивидуальные именованные параметры, следуя параметру строк, как это было сделано выше (value1, value2 etc).

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

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

Аргумент (ы), собранный в наши значения array - это результаты уже оцененных интерполяционных выражений, найденных в строковом литерале. Идентифицированный строковый литерал похож на этап обработки после вычисления интерполяций, но до того, как окончательное значение строки будет скомпилировано, что позволит вам более эффективно управлять строкой из литерала. Давайте посмотрим на пример создания повторно используемых шаблонов.

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);

Raw Strings

наши функции тега получают первый аргумент, который мы назвали строками, который является массивом. Но есть дополнительный бит данных: необработанные необработанные версии всех строк. Вы можете получить доступ к этим исходным строковым значениям, используя свойство .raw, например:

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

Как вы можете видеть, необработанная версия строки сохраняет escape-последовательность \n, а обработанная версия строки ссылается на него как на неэксклюзивную новую новую строку. ES6 поставляется со встроенной функцией, которая может использоваться как тег строкового литерала: String.raw(..). Он просто проходит через исходные версии строк:

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

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