Number/for...in/检索/||/&&/Syntactic Sugar/Default Parameters/Template Literals/Multiline Strings/this

1.Number

①
number.toExponential(fractionDigits)
Math.PI.toExponential(2);//"3.14e+0"
②
number.toFixed(fractionDigits)
Math.PI.toFixed(3);//"3.142"
③
number.toPrecision(precision)
Math.PI.toPrecision(3);//"3.14"
④
number.toString(radix)
Math.PI.toString(8);//"3.1103755242102643"

2.JS中%代表求余

36%10;//6
36%-10;//6
-36%10;//-6
-36%-10;//-6

3.函数可以指定一个参数列表，这些参数就像变量一样，当函数调用时由传入的实参（argument）初始化。

4.

    (variable)      (object)
for    name    in  expression

枚举一个对象所有的属性名（键名），每次循环中object的下一个属性名（字符串）赋值给variable。
为判断该属性名为对象中的成员还是来自于原型链，应使用object.hasOwnProperty(variable)
typeof(object.variable)!==’function’

5.JS中的对象是可变的键控集合（keyed collections）

6.
①在对象字面量中，如果属性名是合法的JS标识符且不是保留字，则不强制使用引号扩住属性名。

"first-name" //引号是必需的,因为连接符(-)是不合法的
first_name

②如果想要检索对象中包含的值，可以通过[]后缀中括住一个字符串表达式的方式。如果该字符串表达式是字符串字面量，同时它是一个合法的JS标识符且非保留字，那么可以使用 . 点表示法进行检索。

var person={
    name:'yyc',
    age:21
};
var dormitory={
    num:403,
    "num-a":'yyc',//因为该属性名（键名）不合法，有连接符（-），所有带括个引号
    member:{
        tuhao:{
            age:22,
            height:178
        },
        "hao-ren":{   //同上
            age:23,
            height:178
        },
    }
};
person.name;//"yyc"
dormitory.tuhao.age;//undefined
dormitory.member.tuhao.age;//22
dormitory.member.hao-ren;//ren is not defined
dormitory.member["hao-ren"];//{age: 23, height: 178}
dormitory.member.tuhao.age;//22---不过为了偷懒和避免错误，命名的名字符合字面量的规范（letter+[letter/number/_($)]）

1.利用 || 运算符的特性可以用来填充默认值，
因为 a || b ，如果a返回false，那么最终的结果就取决于b了
person.address;//undefined
var a=person.address || 'none';
a;//"none"

2.尝试从undefined的成员属性中取值会导致TypeError
person.address.road;//Uncaught TypeError: Cannot read property 'road' of undefined
var b=person.address && person.addrss.road;
b;//undefined

7.&& 和 ||妙用

①&&，用于防止出错，"平稳退化"
error && undefined

②|| ，用于初始化，"渐进增强"
undefined || 'yyc'

8.Syntactic sugar: from Wikipedia
In computer science, syntactic sugar is syntax within a programming language that is designed to make things easier to read or to express. It makes the language “sweeter” for human use: things can be expressed more clearly, more concisely, or in an alternative style that some may prefer.

9.ES6 新特性

①Default Parameters 
var link = function(height, color,url){
    var height = height || 50;
    var color = color || 'red';
    var url = url || 'http://www.dangdang.com';
}
var link = function(height=50,color='red',url='http://www.dangdang.com';){
    //do something
}


②Template Literals 
var block = '17宿';
var room = '403室';
var dormitory = 'My dormitory is ' +block+ ' ' +room+'.';
dormitory;//"My dormitory is 17宿 403室."
//注意  ` ${} white-space
dormitory = `My dormitory is ${block} ${room}.`;//"My dormitory is 17宿 403室."
dormitory = `My dormitory is ${block}${room}.`;//"My dormitory is 17宿403室."

③Muiti-line Strings
var info = 'aaaaaaaaaaaaaa,\n'
+ 'bbbbbbbbbbbbb,\n'
+ 'ccccccccccccc';
info;
/*
"aaaaaaaaaaaaaa,
bbbbbbbbbbbbb,
ccccccccccccc"
*/

//backticks反引号-----grave accent抑音符号--Wikipedia
//优点：自动换行，字符串之间不需要额外连接符
var info = `aaaaaaaaaaaaaa,
bbbbbbbbbbbbb,
ccccccccccccc`;
info;
/*
"aaaaaaaaaaaaaa,
bbbbbbbbbbbbb,
ccccccccccccc"
*/

10.通过this可取得它们所属对象的上下文的方法称为公共方法（public method）。

11.调用一个函数会暂停当前函数的执行，传递控制权和参数给新函数。除了声明时定义的形式参数，每个函数还接收两个附加的参数：this和arguments。参数this的值取决于调用的模式：
①方法调用模式
②函数调用模式
③构造器调用模式
④Apply调用模式

//1.方法调用模式---函数作为对象的一个属性，即一个方法
var yyc = {
    value : 0,
    increment : function(inc){
        this.value += typeof inc ==='number' ? inc : 1;
    }
};
yyc.increment();
yyc.value;//1
yyc.increment(2);
yyc.value;//3
yyc.increment(3);
yyc.value;//6


//2.函数调用模式
var add = function(a,b){
    return a+b;
};
var yyc = {
    value : 0,
    increment : function(inc){
        this.value += typeof inc ==='number' ? inc : 1;
    }
};
yyc.double = function(){
    console.log(this);//{value: 0, increment: ƒ, double: ƒ}
}
yyc.double();

//测试1
var value=999;
var add = function(a,b){
    return a+b;
};
var yyc = {
    value : 0,
    increment : function(inc){
        this.value += typeof inc ==='number' ? inc : 1;
    }
};
yyc.double = function(){
    var f2 = function(){
        alert(this.value);//999
    }
setTimeout(f2,1000);
}
yyc.double();

//测试2
var value=999;
var add = function(a,b){
    return a+b;
};
var yyc = {
    value : 0,
    increment : function(inc){
        this.value += typeof inc ==='number' ? inc : 1;
    }
};
yyc.increment();//对象yyc中value值为1
yyc.double = function(){
    var that = this;
    var f2 = function(){
        alert(that.value);//1
    }
setTimeout(f2,1000);
}
yyc.double();

//避免让this的值指向全局value，从而实现double也就是1+1
var value=999;
var add = function(a,b){
    return a+b;
};
var yyc = {
    value : 0,
    increment : function(inc){
        this.value += typeof inc ==='number' ? inc : 1;
    }
};
yyc.increment();//对象yyc中value值为1
yyc.double = function(){
    var that = this;
    var f2 = function(){
        that.value = add(that.value,that.value);
    }
    f2();//别忘记执行f2函数
}
yyc.double();
yyc.value;//2