个人复习记录之-js

1变量：内存中储存一个数据的储存空间。

　使用：声明，赋值，取值。注 不能以数字开头，不能用保留字

　*声明提前：在程序正式执行前，都会将所有var声明的变量提前到开始位置，集中创建***赋值留在原地***

console.log(a);//undefind
var a=10;
console.log(a);//

2常量：一旦声明并初始化后，值不可改变的量！如π.。

const 常量名=值//(常量名全大写)

3数据类型：内存中储存不同数据的储存格式。

　1原始类型：值保存再变量本地的数据类型。

　2引用类型：值不保存在变量本地的数据类型，如：number、string、Boolean、undefined、null

　number：舍入误差：计算机无法表示1/10。

　　如2-1.6=0.39999999

　　需使用 .tofixed(2)  //按两位小数四舍五入。

　string：专门保存一串字符的序列，必须带引号。

4数据转换：

　转字符串：var str=x.toString();

　　　　　　var str=String(x);

　转数字：var n=parseInt(str);//碰到小数点自动停止

　　　　　var n=parseFloat(str);//浮点数（小数），认第一个小数点

　转布尔：var bool=Boolean(x);//x只有为这五个值会被转为false: " "，undefined，NaN，0，null。

5运算符：+  -  *  /  ++  --  %

　%：取余数  何时使用：1判断奇偶  2确保一个运算的结果，不超过一个最大值。

　n++：将n的值+1，返回旧值

　++n：将n的值+1，返回新值

var n=3;
console.log(n++);//
console.log(n);//

var t=4;
console.log(++t);//

　关系运算：将两个值做比较：>  <  >=  <=  == ！=  ===

　　隐式转换：将所有的类型都转为number类型，再比较。

　　只能返回：true  或  false。

　　特殊情况：1两字符串比较，依次pk每一格字符的Unicode编号，只要有一位字符分出大小，就不再比较。

　　　　　　　2NaN  NaN和任何数据做大小或等于比较返回false，和任何数据做不等于比较永远返回true。

　　　　　　　　isNaN(num)：专门判断number是否是NaN，是NaN返回true，不是NaN返回false。

　　===：全等比较，数据类型是否相同，再比较是否相等，不带隐式转换。

　短路逻辑：

　　&&：而且，两个为true则为true，（第一个满足才做后边的事情）

　　||：或者，一个为true就为true（第一个不满足才做后边的事情）

　　！：颠倒true和false

　扩展赋值运算：+=  -=  *=  /=  %=

　　n+=2等于n=n+2

　三目运算：

　　条件1？值1：

　　条件2？值2：

　　　　默认值；

笔试题：

alert(4&&5);//5   等于alert(boolean(4)&&boolean(5))//先判断前边的，为true，再判断第二个。

aletr(4||5);//4  和上同理，第一个对了，就不会判断后边的了。

var n=10;
var r=n--    +   --n   +   n--;
      表达式返回：10
      n：9
                 表达式返回8
                 n=8
                           表达式返回8
                           n=7
console.log(n);//
console.log(r);//10+8+8=26       

var n=10;
var m=10;
var r=n++>10&&++m>10;//第一个为false，就不会执行后边的++m。
console.log(r);//false
console.log(m);//

6函数:

　函数的参数：

　　定义：function 函数名(变量1，变量2)；

　　调用：函数名(值1，值2)；

　返回值：return 要返回的数据

　　单独使用代表：退出函数的意思。仅负责返回，不负责接收。

　js中的变量：

　　全局变量：直接在任何函数外部声明的变量，都属于window。无论在任何位置，为从未声明过的变量赋值时，自动在全局创建同名全局变量

　　局部变量：函数内部定义的变量。参数变量天生就是局部变量。

　*声明提前：

　　在执行函数或函数被调用前，将var声明的变量和function声明的函数，提前到作用域的顶部，集中创建。强调：仅声明提前，赋值留在原地。

function fun1(){console.log(1)};
fun1();//
function fun1(){console.log(2)};

　按值传递：js中无论是变量间赋值或使用变量传递参数时，都是讲变量中的值，复制一个给对方。

　全局函数：可直接被调用的函数

　　如：parseInt(str);

7分支结构

　if(){}else if{}else{};//不多写

　三目运算；

　switch  case结构：用switch中的表达式的值和case中的值做全等比较

switch("1"){
    case "1":aletr("1");
    break;
    case "2":alert("2");
    break;
    default:alert("over");
}

　循环：

　　循环条件  循环变量  循环体

　　for循环：for(){}

　　while循环：

var r=0;
while(r<3){
    console.log("转一周");
    r++;
}

　取随机数公式：parseInt(Math.random()*(max-min+1)+min)

　退出循环：自然退出  加break

8数组

　创建：1  var 变量名=[]     2  var 变量名=[值1，值2]    3  var arr=new Array()    4  var  arr=new Array(n)

　赋值：数组变量[i]=新值；

　取值：数组变量[i]；

　引用类型的最大特点，谁改了其内容，都会影响原来的数据。

　null：主动释放一个变量的引用对象（可切断变量名与数组的关系）。

　.length属性：

　　arr[arr.length-1]：获取到最后一个元素

　　arr[arr.length]：向数组末尾追加一个新元素

　　改小length的值可以删除末尾元素

　数组遍历：

　　从下标为0的位置开始，依次取出每个元素，反复执行相同的操作。不多写

　关联数组：

　　创建：var fbb=[];

　　　　　fbb["sname"]="范冰冰";

　　遍历关联数组：for(var key in arr){}//key：仅取得当前元素的下标。arr[key]：可以得到当前元素的值。

9API（应用程序编程的接口，已经实现的，现成的对象和方法）

　数组API：

　　var str=arr.toString();

　　var str=arr.join("链接符");

　　var newArr=arr.concat(新值1，另一个数组，新值2);//重新拼和成一个新数组，不影响原数组。

　　var subStr=arr.slice(start,end);//end可有可无，截取不包活end位置的元素。含头不含尾。且可为负数。

　　arr.splice(start,n,替换值);：（从几开始，删几个，替换为什么）。

　　arr.reverse();//原样颠倒位置。

　　arr.sort();//数组的排序，默然为字符串

　　　　比较数字：arr.sort(compareNum);    function compareNum(a,b){return a-b;};

　　　　颠倒比较器结果的正负，可改升序为降序：function compareNum(a,b){return -(a-b);};

　　arr.push(新值1，新值2...)//末尾压入新值；

　　var last=arr.pop();//取到最后一个值；

　　arr.unshift(新值1，新值2....);//从开始压入新值；

　　var first=arr.shift();//取到第一个值；

　　队列：只允许从末尾进入数组，从开头出数组。

　　　　arr.push();等于arr[arr.length]="新值"；

　　　　var first=arr.shift()；

　二维数组:

　　创建：

var arr=[];
arr[0]=["1","2"];
arr[1]=["3","4"];

var data=[
    [1,2,3,4],
    [5,6,7,8],
]    

　　遍历：

for(r=0;r<arr.length;r++){
    for(n=0;n<arr[r].length;n++){
        ...
    }
}

10String

　字符串：多个字符组成的一个只读的集合

　凡是数组对象中，不修改原对象的API，字符串都能用，如：slice，indexof，length。

　转义字符：\可保留一些特殊符号  \n换行  \t缩进一个tab的宽度

　大小写转换：

　　转大写：str.toUpperCase();

　　转小写：str.toLowerCase();

　获取指定位置字符：

　　str[i];//i不能为负

　　str[str.length-2]

　　str.charAt(i);

　　str.charCodeAt(i);//返回字符的Unicode编号

　将任意数字转为字符串最快捷的方法：5000+""(加一个空字符)

　查找关键字的位置：var i=str.indexOf("keyword",start);//start可有可无，表示起始的查找位置。如果没找到就返回-1。

　API

　　str.slice(start,end+1);//end+1可要可不要，表示结束的位置

　　str.subStr(start,n);//n表示取几个

　　var arr=email.split("@");切割，按@切割字符串，返回一个数组

　　var i=str.search("keyword")//找第一个匹配的关键字

　　var arr=str.match(keyword);

　　var newStr=str.replace(模式,"替换内容");//替换

　正则：

　　\d：1位数字

　　\w：1位字母或是下划线

　　\s：1位空字符：空格，或是tab

　　.：除了换行外，其他所有的字符

　　\D：除了\d的意思

　　\W：除了\w的意思

　　\S：除了\s的意思

　　{min,max}：至少几位，至多几位

　　{min,}：至少几位

　　{min}：必须几位

　　？：可有可无，最多一次

　　*：可有可无，数量不限

　　+：至少一次，多了数量不限

　　创建：

　　　　var reg=/正则表达式/ig;    （i：忽略大小写，g：全部）

　　　　var reg=new RegExp("正则表达式","ig");

　　正则验证：var bool=reg.test(str);

　　需在正则表达式前加^，后加$

　　从正则表达式匹配的结果中获取子内容：

　　　　1正则表达式中，用（）包括要获取子内容的部分

　　　　2本次查找后：RegExp.$n;//n表示第几个圆括号，从1开始数

　string中的模式匹配API

　　2个查找：str.search(reg)   str.march(reg)

　　1个替换：str.replace("keyword");//keyword也可以为reg

　　去空格：str.trim();

　　

11Math

　取整：

　　Math.ceil(n);//上取整

　　Math.floor(n);//下取整

　　Math.round(n);//四舍五入取整

　取最大值/最小值

　　Math.max(a,b,c);

　　Math.min(a,b,c);

　　固定套路：Math.max.apply(Math,arr);   等于Math.max(arr[0],arr[1]...);   变向地使用数组

　　　　apply：应用某一对象的方法，用另一对象替换当前对象。   等于，应用了Math中的max方法，用数组对象来替换了当前做比较的对象。

12Date

　封装了一个时间点，提供了对时间和日期的操作API

　date中封装了从1970年1月1日0点0时0分0秒至今的毫秒数

　注：月和星期是从0开始算，其他都是从1开始。

13错误

　js中的错误类型：

　　SyntaxError：语法错误

　　ReferenceError：引用错误，找不到变量或对象

　　TpyeError：类型错误，错误地用了一个类型的方法

　　RangeError：范围错误，参数超范围

　　EvalError：调用eval函数时错误

　　URLError：URL错误

　错误处理：

　　

try{
    可能出错的代码段
}catch(err){//仅在发生错误时才执行，一旦发生错误，err中就会自动存入Error对象
    1记录、显示错误
    2继续向调用者抛出异常
}finally{
    无论对错，一定都会执行的代码段
    释放资源
    这最后这段代码可有可无
}

14function

　arguments对象：函数对象内，自动创建的专门接受所有参数值的类数组对象

　　arguments[i]：获得传入的下标为i的参数值

　　arguments.length：获得传入的参数的个数

　创建函数：

　　1声明方式：function 函数名(){};//名字和函数定义都会被提前，可提前使用它

　　2函数直接量：var 函数名=function(){};//仅声明提前函数定义留在原地

　匿名函数：

　　匿名函数自调，定义完，立即执行，执行完立即释放

　　

(function(参数){
    函数体
})(参数值);
//定义在哪里就在哪里执行，不提前

　闭包：

　　使一个变量即可共享，又可长久保存，又不会污染全局对象

　　三步：

　　　　1，外层定义函数，封装被保护的局部变量

　　　　2，定义内层函数，执行对外层函数局部变量的操作

　　　　3，外层函数返回内层函数的对象，并且外层函数被调用，结果被保存在全局变量中

fucntion outer(){
    var n=1;//外层保护变量
    function inner(){
        return n++;//内层操作变量
    }
    return inner;//外层返回内层对象
}
var getNum=outer();//全局变量来接住

　　何时使用：反复使用局部变量，又避免全局污染，就用闭包

　　判断闭包执行结果：

　　　　1外层函数被调用几次，就有几个受保护的局部变量副本

　　　　2反复调用来自一个闭包的函数，受保护的局部变量就变化几次

　　　　3外层函数调用几次，就有几个受保护的i，且互不干扰

15面向对象

　创建：

1
var obj={
    "属性名1":值1,
    "属性名2":值2,
}

2
var obj=new Object;
obj.name="david";

3
function obj(){
    this.name="david",
    this.age="20",
}
var obj1=new obj();

　访问属性：  obj.属性名    obj["属性名"]

　遍历当前对象中每个属性：for(var key in data[i]){};  data[{...},{...}];

　this:运行时，指代正在调用的方法对象。无主调用或赋值，默认this都指向window

var a=2;
function fun(){
    console.log(this.a);//指向全局：2
}
var o={
    a:3,
    fun:fun
}
var p={a:4}
o.fun;//指向o：3
(p.fun=o.fun)();//匿名函数字调，指向全局：2
p.fun();//指向p：4

　继承：

　　面向对象三大特点：封装，继承，多态

　　　　封装：将描述一个东西的属性和方法，定义在一个对象中

　　　　继承：父对象中属性和方法，子对象可直接调用

　　　　多态：同一对象在不同情况下会呈现出不同的状态

function student(sname,age){
    this.name=sname,
    this.age=age,
    this.intrself=function(){//应提入prototype中
        alert("I'm"+this.name+",I'm"+this.age);
    }
}
var lilei=new student("lilei",12);
//所有子对象的公共方法都应提入prototype中。如：
student.prototype.money=100;
console.log(lilei.money);//先看自己有没有money，没有就去父对象哪里要

　　继承：主要是为了避免重写定义方法对象，浪费内存。