Javascript学习笔记-1(类型、变量、for语句、数组、字符串、原型对象、函数对象)

一.javascript类型

js弱类型，声明定义时不需指定类型，系统自动识别。系统内部共7种类型：

6种原始类型：
Number,Boolean,Null,Undefined,String,Symbol(ECMAScript 6 新定义)

其他类型： Object

//系统内部类型：
var x = 1.0;       //不区分整数和浮点数，都是Number类型
var x = " i'm ";   //字符串类型
var x = true;      //布尔类型
null             //空值
undefined       //未定义值

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

typeof OBJ: 返回Obj的类型字符

二.变量及作用域：

javascript只有一个全局作用域window，所有全局变量其实都是绑定到window对象的
对函数这个一等公民，命名函数可以先使用，后声明。

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

三、语句：

javascript语句和 CPP或java等语言差不多，但for语句有些特别

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

四.数组对象Array

数组对象 Array，下标是key，

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

五、.字符和字符串：

若字符串中有”，则用 ”，若有’，则用” “，若都有，则用转义符 \ 转义

字符：ASCII字符可用\x##代替，Unicode字符，可用\u####代替

“字符’串“
‘字符”串’
`可换行字符串`

六、.对象和原型：

js中的对象是{key:value} 组成的无序集合，其中key隐式必须是字符串(系统自动加”“)

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

//javascript中没有class的概念，但有构造函数的概念。构造函数格式：

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

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


//构造函数有一个prototype属性，指向另一个对象(叫做原型对象)，所有由构造函数构造的对象，都可以共享访问prototype对象的属性和方法

//默认情况下：prototype对象是一个当前构造函数的匿名空对象temp,
//同时  temp有一个constructor属性，指向构造函数（写代码的时候一定要搞清楚这条原型链）　　


----------


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

七、函数对象Function和闭包

function F(args){}   //命名函数，js引擎会将声明提升文件顶部，所以可以"先使用后声明定义"。无返回值时，返回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...递归下去




//javascript中的函数很特别，自动就是可变参数：

//1.可以传入部分参数，也可以传入多余形参数量的参数：每个函数有一个 arguments 对象，存有实参列表

//2.自己手动获取可变参数：function F(arg1, ...args); 

//3.每个函数，其实都是某个对象内部的方法，全局函数是全局对象window的方法，函数都有this指针，指向它的当前对象

//4.函数内部可以再定义函数（因为函数本身也是一个对象），内部函数可以访问外部函数的变量，实现闭包结构

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 



//5.函数对象的两个方法：apply、call：

//将函数临时绑定到对象上，
//apply的参数必须是Array形式[]，call的参数是按顺序传入
//若是普通函数，obj=null

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

八、正则表达式：

具体语法见其他博客，仅说明如何使用javascript的正则表达式

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分割为数组