javascript学习笔记(1)-类型、

//系统内部类型：
var x = 1.0;       //不区分整数和浮点数，都是Number类型
var x = " i‘m ";   //字符串类型
var x = true;      //布尔类型

null             //空值
undefined       //未定义值

//特殊值：
NaN             //Not a Number，，，不与任何数字相等，包括自己，isNaN(NaN)
Infinity       //无穷大


typeof OBJ: 返回Obj的类型字符

x=1;	        //不写var默认为全局变量，在js代码第一行写： "use strict:" 使用strict模式，必须加上var
var x=1;	//默认为局部变量，函数作用域内部的局部变量；
let x=1;	//for\while等块作用域
const PI;	//定义常量

arr  = [0,1,2];     //arr[0]、arr[1]、arr[2]

for(let i =0; i<arr.length; ++i){}   //普通的for循环


//

//特别需要注意的是，对arr添加属性arr["name"]或arr.name后：   arr.length不会增加，for-in却能访问到，，，而for-of不能
//同时，，，arr[4] = "li"，则length会增加到 5（因为从0开始），arr[3]为undefined，for-in不会访问undefined，而for-of会

arr.name = "li";

for(i in arr) //for-in循环，遍历所有的下标 
{ 
     arr[3] = 3;    // 循环过程中是不能访问到arr[3]的， 
     arr[2] = 20; // 循环过程中 可以 访问到 arr[2]，所以改变能"看到" 
} 
for(i of arr) //for-of 循环，遍历所有的值 
{ 
     arr[3] = 3; //循环能访问到arr[3] 
}


obj.forEach(func);      //对obj的每一个元素调用指定函数func ，   iterable对象才有(数组、map等)

arr = [1,2,3];
arr = new Array(1,2,3);
arr = new Array(length);

Array.map(func)：　　　　//对每个元素，调用func映射，返回结果
Array.reduce(func):　　//累积调用
Array.filter(func)：　　//对每个函数调用func，根据返回结果是true/false，保留/舍弃元素
Array.sort(func)：　　//默认的func，把元素先转化为String，再排序。func(x,y)根据返回值 >0：x>y

var obj = {
    name:"li",
    age:20  }
obj.name　　//访问属性的两种方式
obj["age"]　　//

function F(agrs)
{
     this.agrs = args;
     return this;    //系统默认会自动添加这一句，可省略  
}

a = new F(params);//用new 调用函数，则当做构造函数使用，this指向新建对象
b = F(params);    //普通调用，this指向全局对象window

/*//默认情况下：
F.prototyp == temp;
temp.constructor == F;
*/
proto = {}
F.prototype = proto;             //改变了F的prototype对象，而proto.constructor指向的是另一个构造函数（此例中为Object）
F.prototype.constructor = F;     //将constructor属性指向当前构造函数，才合乎情理

function F(args){}                      //无返回值时，返回undefined
var F = function(args){}                //匿名函数对象，赋值给F，F指向函数对象
var result = ( function(x){} )(3)       //创建一个匿名函数并立即执行,实参是3，注意把fun括起来
(args)=>{ body; }　　　　　　　　　　　　　　//lambda表达式，若只有一个参数，参数括号可省略，若只有一条语句的单表达式，return关键字可省略，默认返回表达式的结果
function*G(args){}                      //generator函数：返回多次的函数
G.next(args);          //执行第一次，返回结果temp1;
G.next(args);　　　　　　//在temp1的基础上执行第二次，返回结果temp2...递归下去

function outFun(n)
{
    var x = n;
    function inFun()
    {
          return x+1;      //内部函数访问外部函数的变量
    }
    return inFun;         //将函数当做对象返回
}

fi = outFun(5);        //这时候，fi = inFun(5)，惰性求值，并没有运行inFun函数，同时inFun持有的"outFun.x" 数据  被返回到 外部了，这种情况叫”闭包“
var result = fi()　　　 //当调用返回的函数时，才真正的进行了计算, return 5+1 

//将函数临时绑定到对象上，

//apply的参数必须是Array形式[]，call的参数是按顺序传入
//若是普通函数，obj=null

fun.apply(obj,args[]);   //指明函数应用到哪个对象上，
fun.call(obj,args)   ;     

var reg = /xxx/;	     //不用考虑转义问题
var reg = new RegExp("xxx")     //要考虑转义问题

/xxx/g ==new RgeExp("xxx",g);     //g 全局匹配模式，每运行一次exec，更新lastIndex，下一次exec就从lastIndex开始匹配，，i模式表示忽略大小写

reg.test(str)              //判断str是否能被匹配
reg.exec(str)              //对str匹配，并返回 按分组匹配后 的数组对象，注意元素[0]是group(0)即整个reg匹配结果

str.split(reg)             //str按reg分割为数组