模板字符串描述：

模板字符串使用反引号 (``) 来代替普通字符串中的用双引号和单引号。模板字符串可以包含特定语法（${expression}）的占位符。占位符中的表达式和周围的文本会一起传递给一个默认函数，该函数负责将所有的部分连接起来，如果一个模板字符串由表达式开头，则该字符串被称为带标签的模板字符串，该表达式通常是一个函数，它会在模板字符串处理后被调用，在输出最终结果前，你都可以通过该函数来对模板字符串进行操作处理。在模版字符串内使用反引号（`）时，需要在它前面加转义符（\）。
//以前的字符串写法
var name='大毛',color='黄色';
var str=name+'是一只'+color+'的猫';
console.log(str)  //大毛是一只黄色的猫
​
//模板字符串的写法
var template=`${name}是一只${color}的猫`;
console.log(template);//大毛是一只黄色的猫
//页面输出的时候
var templateStr=`<div>
        <p>${name}是一只${color}的猫</p>
    </div>`;
console.log(templateStr);    
// <div>
//       <p>大毛是一只黄色的猫</p>
//    </div>
//使得代码的结构可读性更强

插入表达式和嵌套模板
<script>
    var cat={
        name:'大毛',
        color:'黄色',
        todos:[
            {name:'睡觉',completed:false},
            {name:'吃饭',completed:false},
            {name:'晒太阳',completed:true}
        ]
    };
    //循环调用的写一个函数提取出来大毛每天要做的事
    var tempStr=function (todos) {
       return  `<ul>
          ${todos.map((todo) => `<li>
          ${todo.name} 
          //这里嵌套一个三元表达式来说明要做的事是否完成
          ${todo.name?'√':'×'}</li>`).join('')}
      </ul>`
    };
    
    var template=`
      <div>
      <p>${cat.name}是一只${cat.color}的猫。</p>
      <p>每天要做的事情</p>
        ${tempStr(cat.todos)}
      </div>`;
    document.body.innerHTML=template
</script>

标签的模板字符串
更高级的形式的模板字符串是带标签的模板字符串。标签使您可以用函数解析模板字符串。标签函数的第一个参数包含一个字符串值的数组。其余的参数与表达式相关。最后，你的函数可以返回处理好的的字符串（或者它可以返回完全不同的东西 , 如下个例子所述）。用于该标签的函数的名称可以被命名为任何名字。
var person = 'Mike';
var age = 28;
function myTag(strings, personExp, ageExp) {
  var str0 = strings[0]; // "that "
  var str1 = strings[1]; // " is a "
  var ageStr;
  if (ageExp > 99){
    ageStr = 'centenarian';
  } else {
    ageStr = 'youngster';
  }
  return str0 + personExp + str1 + ageStr;
}
var output = myTag`that ${ person } is a ${ age }`;
console.log(output);
// that Mike is a youngster

NaN:not a number

1.js里面的数据类型：

原始(基本)数据类型：number(数字) string(字符串) boolean(布尔) undefined(未定义) null(空)

任何数据类型与字符串连在一起都是字符串

字符串类型必须加引号,加引号的一定是字符串

如果加号前后有字符串参与了，那都是字符串的拼接

布尔值：true false

未定义：undefined 自动初始化未赋值的变量

空：null 空对象指针

引用数据类型：

2.js里面的隐式类型转换

字符串和数字一起运算，那么数字会自动转为string类型

字符串和布尔一起运算，那么布尔会自动转为string类型

字符串和undefined布尔一起运算,那么undefined会自动转为string类型

数字和布尔运算的时候，true会自动转为1,false会自动转为0

3.运算符	：程序进行计算的符号

算术运算符：+ - * / % ++ –

i++单独使用，那么放前放后都一样

i++在表达式中,前++，先+1，再参与表达式

后++，先用旧值参与表达式，表达式结束之后再+1;

关系运算符：> < 	>= <= ==(允许) =(不允许)(值和类型都相等 !=(允许)  !(不允许)

逻辑运算符：&& || ！

赋值运算符：= +=	 -= *= /= %=

字符串连接运算符：+

特殊运算符：typeof(数据)

三目(元)运算符：条件?条件成立时候的值:条件不成立时候的值 结果一定是个值 	

if语句：	if(条件){条件成立时候执行的代码}else if(条件2){条件不成立时候执行的代码} 多重条件判断；

三目运算符能实现多重条件判断吗		

条件?条件成立时候的值:(表达式)

条件判断里面，只有六种情况算false，其他的全true

false 0 undefined null NaN “”

4.函数(方法)：封装执行一项专门任务的代码段	

语法：function 方法名(参数){干啥事}

心得：var a=5 是语句，a=5是表达式

if(条件){条件成立时候执行的代码}else if(条件2){条件不成立时候执行的代码} 这是多重条件判断。



三目也能多重

一句话总结功能：

使用#把宏参数变为一个字符串,用##把两个宏参数粘连到一起
##用来连接前后两个参数,拼接符号。可以是符号拼符号，可以是数字拼符号，可以是数字拼数字

#用来对后面的宏参数进行字符串化操作，简单来说就是相当于在宏变量的两边各加上一个双引号使其变成一个字符串

注意，##和#只可用在宏定义中，这只是给编译器看的。(语句体中不可直接用##和#)

功能总结很简单，但实际应用方式却多种多样，可谓非常强大。
一、基础应用：

例1：使用 # ，把一个宏参数变成对应的字符串
#include<stdio.h>

#define PRINT(X) printf("the "#X" value is %d\n",X)

int main()
{
	int a = 2;

	PRINT(a);

	return 0;
}

输出：

the a value is 2

上面的  PRINT(a)  展开相当于  printf(“the " “a” " value is %d\n”,a)

注意里面有三个字符串，打印的时候会拼到一起
例2：##可以把位于它两边的符号合成一个符号。 它允许宏定义从分离的文本片段创建标识符
#include<stdio.h>

#define A(X,Y) X##Y 

int main()
{
	int tmp123 = 123;
	printf("%d\n", A(tmp, 123));
	return 0;
}

输出：

123

上面的 printf("%d\n", A(tmp, 123)); 相当于 printf("%d\n", tmp123);
例3：
＃include<stdio.h> 
＃include<limits.h> 
 
#define STR(s)     #s 
#define CONS(a,b)  (int)(a##e##b) 
 
int main() 
{ 
    printf(STR(vck));           // 输出字符串"vck" 
    printf("%d\n", CONS(2,3));  // 2e3 输出:2000   2e3是科学计数法  2 * 10 ^3
    return 0; 
}

二、当有##、#的宏定义时，宏中的参数若还是宏定义，此时该宏不会被展开
#define X  2
#define MAX_NUM 7000

#define INT(x)  #x

#define CON(x)  int(x##x)

printf("%s", INT(MAX_NUM));
printf("%d", CON(X));
 
//宏定义展开后：
//printf("%s", "MAX_NUM");
//printf("%d", int(XX));
//很明显，未达到目的

解决方法：加多一层中间转换宏

加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏 (_INT) (_CON) 就能得到正确的宏参数.
#define X  2
#define MAX_NUM 7000

#define _STR(x) #x        //转换宏
#define STR(x)  _STR(x)

#define _CON(x) int(x##x)
#define CON(x)  _CON(x)    //转换宏

printf("%s", INT(MAX_NUM));
printf("%d", CON(X));
 
//宏定义展开
//printf("%s", "7000");
//printf("%d", 22);

CON(X) =》_CON(X) =》int(22)

STR(MAX_NUM) =》_STR(MAX_NUM) =》“7000”
三、应用举例
1、合并匿名变量名
#define  ___ANONYMOUS1(type, var, line)  type  var##line 
#define  __ANONYMOUS0(type, line)  ___ANONYMOUS1(type, _anonymous, line) 
#define  ANONYMOUS(type)  __ANONYMOUS0(type, __LINE__) 

例：ANONYMOUS(static int);  即: static int _anonymous70;  70表示该行行号；

第一层：ANONYMOUS(static int);  =》  __ ANONYMOUS0(static int, __LINE __ );

第二层：                        =》  ___ANONYMOUS1(static int, _anonymous, 70);

第三层：                        =》  static int  _anonymous70;

即每次只能解开当前层的宏，所以__LINE__在第二层才能被解开；
2、填充结构
#define  FILL(a)   {a, #a} 
 
enum IDD{OPEN, CLOSE}; 
typedef struct MSG{ 
  IDD id; 
  const char * msg; 
}MSG; 

MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};

相当于：
MSG _msg[] = {{OPEN, "OPEN"}, 
              {CLOSE, "CLOSE"}}; 

3、记录文件名
#define  _GET_FILE_NAME(f)   #f 
#define  GET_FILE_NAME(f)    _GET_FILE_NAME(f) 
static char  FILE_NAME[] = GET_FILE_NAME(__FILE__); 

4、得到一个数值类型所对应的字符串缓冲大小
#define  _TYPE_BUF_SIZE(type)  sizeof #type 
#define  TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type) 
char  buf[TYPE_BUF_SIZE(INT_MAX)]; 

=》  char  buf[_TYPE_BUF_SIZE(2147483647)];

=》  char  buf[sizeof(“2147483647”)];
这里相当于：

char  buf[11];

模板字符串
语法
描述
多行字符串
插入表达式
嵌套模板
带标签的模板字符串
原始字符串
带标签的模版字面量及转义序列

模板字面量 是允许嵌入表达式的字符串字面量。你可以使用多行字符串和字符串插值功能。它们在ES2015规范的先前版本中被称为“模板字符串”。
语法
`string text`

`string text line 1
 string text line 2`

`string text ${expression} string text`

tag `string text ${expression} string text`

描述
模板字符串使用反引号 () 来代替普通字符串中的用双引号和单引号。模板字符串可以包含特定语法（${expression}）的占位符。占位符中的表达式和周围的文本会一起传递给一个默认函数，该函数负责将所有的部分连接起来，如果一个模板字符串由表达式开头，则该字符串被称为带标签的模板字符串，该表达式通常是一个函数，它会在模板字符串处理后被调用，在输出最终结果前，你都可以通过该函数来对模板字符串进行操作处理。在模版字符串内使用反引号（`）时，需要在它前面加转义符（\）。
`\`` === "`" // --> true

多行字符串
在新行中插入的任何字符都是模板字符串中的一部分，使用普通字符串，你可以通过以下的方式获得多行字符串：
console.log('string text line 1\n' +
'string text line 2');
// "string text line 1
// string text line 2"

要获得同样效果的多行字符串，只需使用如下代码：
console.log(`string text line 1
string text line 2`);
// "string text line 1
// string text line 2"

插入表达式
在普通字符串中嵌入表达式，必须使用如下语法：
var a = 5;
var b = 10;
console.log('Fifteen is ' + (a + b) + ' and\nnot ' + (2 * a + b) + '.');
// "Fifteen is 15 and
// not 20."

现在通过模板字符串，我们可以使用一种更优雅的方式来表示：
var a = 5;
var b = 10;
console.log(`Fifteen is ${a + b} and
not ${2 * a + b}.`);
// "Fifteen is 15 and
// not 20."

嵌套模板
在某些时候，嵌套模板是具有可配置字符串的最简单也是更可读的方法。 在模板中，只需在模板内的占位符 ${ } 内使用它们，就可以轻松地使用内部反引号。 例如，如果条件 a 是真的，那么返回这个模板化的文字。
ES5:
var classes = 'header'
classes += (isLargeScreen() ?
   '' : item.isCollapsed ?
     ' icon-expander' : ' icon-collapser');
在ES2015中使用模板文字而没有嵌套：

const classes = `header ${ isLargeScreen() ? '' :
    (item.isCollapsed ? 'icon-expander' : 'icon-collapser') }`;
 

在ES2015的嵌套模板字面量中：
const classes = `header ${ isLargeScreen() ? '' :
 `icon-${item.isCollapsed ? 'expander' : 'collapser'}` }`;
 

带标签的模板字符串
更高级的形式的模板字符串是带标签的模板字符串。标签使您可以用函数解析模板字符串。标签函数的第一个参数包含一个字符串值的数组。其余的参数与表达式相关。最后，你的函数可以返回处理好的的字符串（或者它可以返回完全不同的东西 , 如下个例子所述）。用于该标签的函数的名称可以被命名为任何名字。
var person = 'Mike';
var age = 28;

function myTag(strings, personExp, ageExp) {

  var str0 = strings[0]; // "that "
  var str1 = strings[1]; // " is a "

  // There is technically a string after
  // the final expression (in our example),
  // but it is empty (""), so disregard.
  // var str2 = strings[2];

  var ageStr;
  if (ageExp > 99){
    ageStr = 'centenarian';
  } else {
    ageStr = 'youngster';
  }

  return str0 + personExp + str1 + ageStr;

}

var output = myTag`that ${ person } is a ${ age }`;

console.log(output);
// that Mike is a youngster

正如下面例子所展示的，标签函数并不一定需要返回一个字符串。
function template(strings, ...keys) {
  return (function(...values) {
    var dict = values[values.length - 1] || {};
    var result = [strings[0]];
    keys.forEach(function(key, i) {
      var value = Number.isInteger(key) ? values[key] : dict[key];
      result.push(value, strings[i + 1]);
    });
    return result.join('');
  });
}

var t1Closure = template`${0}${1}${0}!`;
t1Closure('Y', 'A');  // "YAY!" 
var t2Closure = template`${0} ${'foo'}!`;
t2Closure('Hello', {foo: 'World'});  // "Hello World!"

原始字符串
在标签函数的第一个参数中，存在一个特殊的属性raw ，我们可以通过它来访问模板字符串的原始字符串，而不经过特殊字符的替换。
function tag(strings) {
  console.log(strings.raw[0]);
}

tag`string text line 1 \n string text line 2`;
// logs "string text line 1 \n string text line 2" ,
// including the two characters '\' and 'n'

另外，使用String.raw() 方法创建原始字符串和使用默认模板函数和字符串连接创建是一样的。
var str = String.raw`Hi\n${2+3}!`;
// "Hi\n5!"

str.length;
// 6

str.split('').join(',');
// "H,i,\,n,5,!"

带标签的模版字面量及转义序列
自ES2016起，带标签的模版字面量遵守以下转义序列的规则：


Unicode字符以"\u"开头，例如\u00A9


Unicode码位用"\u{}"表示，例如\u{2F804}


十六进制以"\x"开头，例如\xA9


八进制以""和数字开头，例如\251


这表示类似下面这种带标签的模版是有问题的，因为对于每一个ECMAScript语法，解析器都会去查找有效的转义序列，但是只能得到这是一个形式错误的语法：
latex`\unicode`
// 在较老的ECMAScript版本中报错（ES2016及更早）
// SyntaxError: malformed Unicode character escape sequence

ES2018关于非法转义序列的修订

带标签的模版字符串应该允许嵌套支持常见转义序列的语言（例如DSLs、LaTeX）。ECMAScript提议模版字面量修订(第4阶段，将要集成到ECMAScript 2018标准) 移除对ECMAScript在带标签的模版字符串中转义序列的语法限制。
不过，非法转义序列在"cooked"当中仍然会体现出来。它们将以 undefined 元素的形式存在于"cooked"之中：
function latex(str) { 
 return { "cooked": str[0], "raw": str.raw[0] }
} 

latex`\unicode`

// { cooked: undefined, raw: "\\unicode" }

值得注意的是，这一转义序列限制只对带标签的模板字面量移除，而不包括不带标签的模板字面量：
let bad = `bad escape sequence: \unicode`;