Зачем переопределять этот основной файл & ldquo; Magento \ Quote \ Model \ ShippingMethodManagement.php & rdquo; вызывает ошибки

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

let actor = {name: 'RajiniKanth', age: 68};

let oldWayStr = "<p>My name is " + actor.name + ",</p>\n" +
  "<p>I am " + actor.age + " old</p>\n";

let newWayHtmlStr =
 `<p>My name is ${actor.name},</p>
  <p>I am ${actor.age} old</p>`;

console.log(oldWayStr);
console.log(newWayHtmlStr);

Как вы можете видеть, мы использовали ... `` вокруг ряда символов, которые интерпретируется как строковый литерал, но любые выражения формы ${..} анализируются и сразу вычисляются inline.

Очень хорошее преимущество интерполированных строковых литералов заключается в том, что им разрешено разбивать несколько строк:

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!

Интерполированные выражения

Любое допустимое выражение разрешено появляться внутри ${..} в интерполированной строке lit‐ eral, включая вызовы функций, вызовы выражения встроенной функции и даже другие interpo‐ lated string literals !

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", в отличие от того, кто + "s". Также, чтобы сохранить примечание, интерполированный строковый литерал - это просто lexically scoped, где он появляется, а не dynamically scoped каким-либо образом

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!"

Использование template literal для 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>`

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

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

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

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

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

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

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

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

argument(s), собранные в нашем массиве значений, являются результатами уже оцененных интерполяционных выражений найденный в строковом литерале. A tagged string literal подобен этапу обработки после того, как интерполяции оцениваются, но до того, как окончательное значение строки будет скомпилировано, что позволит вам более эффективно управлять строкой из литерала. Давайте посмотрим на пример создания re-usable templates.

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

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

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

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

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

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