js知识点总结，代码加注释, 纯手打全运行通过，很长慎入

js特点就是特灵活

我是分阶段敲得，可能会有注释的不合理问题，不过每一块代码去掉注释都可以运行

var tg=document.getElementById("ta");
tg.innerHTML="还行吧";
tg.style.backgroundColor="#aab";

var a="3.145";
var b=a-2;//自动转数值
var c=a+2;//字符串拼接
alert(b+"\n"+c)
c=parseInt(a)+2   3.999+2=5
c=parseFloat(a)+2 3.145+2=5.145
a=345t44   b=w222
parseInt(a) 345,//开头可以读，到非数停
parseInt(b) NaN,//开头就裂开

//全局范围，无论有无var都是全局变量，函数内局部，没用var,也是全局的；
//局部变量，函数里还要var,
var b="全局变量";
function myFun(){
   age=4
    var isMale=20;
}
myFun();//必须要调用才能拿
alert(b+"\n"+age);
alert(isMale);
var b="全局变量";
function myFun(){
 
    var b="局部变量";//局部覆盖全局便梁，
     b="局部变量"//给全局变量赋值，函数外也改变
    alert(b);
}
myFun();//必须要调用才能拿

alert(b);

function test(o){
    var i=0;
    //typeof//判断类型是不是object
    if(typeof o=="object"){
        var j=5;
        for(var k=0;k<10;k++){
            //js没有代码块概念，作用范围是整个的函数内，不限于当前内函数
            //只认函数体的{}
            document.write(k);
        }
       alert(k+"\n"+j);
    }
}
test(document);

var scope="全局变量";
function test(){
    //变量提升，局部变量会在函数开始定义，所以西面undifine
if(0){var scope="局部遍历"; }
return ;
        //变量提升定义，剋运行也会提升，不用赋值
        
document.write(scope);
var scope="局部遍历";
document.write(scope);
}
test();

var scope1="全局变量1";
var scope2="全局变量2";
var scope3="全局变量3";

alert(window.scope)//默认在window对象的属性；
//alert(window["scope"])//可点出属性，可以数组
for(var i=1;i<4;i++){
    alert("scope"+1);//这只能输出变量名scope1，想输出值
    alert(window["scope"+i]);
}

// let有块的范围。
function test(){
    console.log(sc);
    let sc="jibu";//报错你在le前不让你用
    var sc="ww";//顶都是上面undifine
}
/*
ox 十六进制
0 开头八进制
 0/0 = NaN
 3/0 = Infinity,
-3/0 = -Infinity
undifined是创建的，没有赋值，null是有值，是为空
null==undifined; true值
null===undifined ;  false类型不同;
var x,y=null
x==y  true
x===y  false

不存在的属性是undifiend，报错的话，大多是变量名不对应
const常量，final
NaN!=NaN;要用isNaN(a)
parseInt(a);得到的不是NaN就是数，所以再isNaN(a)
float 精度丢失；要用差值比较
字符和字符串一样var a="a"

charAt(1);获取索引处字符
a.length;
toUpperCase();大写
String.fromCharCode(93，94，95);找到unicode码对应的abc
indexOf("a",3);返回第一次出现位置,从3开始找
*/
var a="abc中国";
var b=a.length;
var c=String.fromCharCode(97,98,99);
alert(b+"-------"+a.charAt(4)+"-----"+a.charCodeAt(4)+"-----"+c)

var a="hellojavascript";
var b=a.indexOf("llo");
//从第几个开始找经常indexOf("llo",indexOf("a"));
//没找到返回-1；
var c=a.indexOf("llo",3);
var d=a.lastIndexOf("a");
alert(b+"\n"+c+"\n"+d+"\n")

subString()不可以负数
slice可以，slice(0,4)就是1234，
var s="abcdefg";
a=s.slice(0,4);
b=s.slice(2,4);
c=s.slice(4);
d=s.slice(3,-1);
e=s.slice(3,-2);
f=s.slice(-3,-1);
alert("a:"+a+"\nb :"
+b+"\nc :"
+c+"\nd :"
+d+"\ne :"
+e+"\nf :"
+f
)
match();

var s="abfd--abc@d.comcdefg";
search找到匹配到的位置
a=s.search(/[a-z]+@d.[a-zA-z]{2}m/);
var str="1dfd2dfs3df5";
match找到匹配到的东西，
var b=str.match(/\d/g);//g是全局找
alert(a+"\n"+b);
replace
结果：4    1,2,3,4


. /d /s /w ^ $
{2，5} 出现2-5次
？ 0-1次
+  1次以上
*  0到所有次
((k)|(l)) |是或者选择
trim()去掉开头结尾空格
test() /^[0-6]{2}$/.test("34")

alert(/^<a href=(\'|\")[a-zA-Z0-9\/:\.]*(\'|\")>.*<\/a>$/
.test("<a href='http://www.crezyit.org'>疯狂Java联盟</a>"));
function trim(s){
    return s.replace(/(^\s*)|(\s*$)/g,"")
}
alert (trim('    hallo,J  avaScript   '));

var a=/^[0-6]{2}$/;//直面量
var a=new RegExp("[0-6]{2}");//面向对象
alert(a.test("34"))

数组赋值跳过不写 c[0]=1,c[4]=3,中间123赋值为空，c[5]undifined
长度可变，不会越界，没赋值的是undifined不会报错。
push();尾部
pop()
unshift();前端
shift();

var stack=[];
stack.push("悟空");
stack.push("八戒");
stack.push("白骨精");

console.log(stack.pop());
console.log(stack.pop());
var queue=[];
queue.unshift("疯狂讲义");
queue.unshift("疯狂讲义应用实战");
queue.unshift("疯狂讲义开发讲义");;
console.log(queue.shift());
console.log(queue.shift());

concat 新的数组，执行后就没了
var a=["html",2,"yeeku"];
console.log(a.concat(4,5));
console.log(a.concat([4,5]));
console.log(a.concat([4,5],[6,7]));

//join数组连起来join（）里元素之间加的东西
var b=["html",20,"is",99,"good"];
console.log(b.join());
console.log(b.join("+"));

//reverse反转
var c=["html","css","jquary","bootstrap"];
c.reverse();
console.log(c);

//slice(),一个到最后，取字符；原数组不变,和下面splice反着
var d=["yeetu","leegeng","crazy","fkit","chaarlie"];
console.log(d.slice(3));
console.log(d.slice(2,4));
console.log(d.slice(1,-2));
console.log(d.slice(-3,-2));

//splice截取完后会导致原数组改变
var e=["yeetu","leegeng","crazy","fkit","chaarlie"];
console.log(e.splice(3));
console.log(e.splice(1,1));
console.log(e.splice(0,1,20,30,40));
console.log(e);

函数没重载，js只认函数名
函数常用if(typeof age==="number")
Math.pow(3,5);3^5次方
Math.sqrt(2);开根号

5=="5" true;"5"字符串转换int
5==="5" false 三等是类型等
！==要类型，值，全不等才可以

逗号运算符,只要最后的选择
a=(b=1,c=,
in2,d=3)
a=d=3;

void强制没返回值
a=void(b=1,c=2,d=3)
a=undifined;




null 类型是object
typeof 只知道类型  instanceof 判断是那个指定类，更深入
typeof dog=object//typeof是运算符
typeof (man)=object//typeof是函数
 dog instanceof Dog
try{
        for(var i=0;i<10;i++){
                document.writeln(i+'<br />');
                if(i<4)throw new Error("用户自定义错误");
                //throw "我是错"，下面console.log(e);
        }
        
}catch(e){
        console.log(e.massage);//接的是new的Error;
        console.log(e);//接的是直接的;
        document.writeln(e.massage);
}finally{
        console.log("woquanyun");
}
js的异常只有一个Error定义函数时不用跑出，所以没有throws关键字
js是弱类型语言，不用声明类型；
try只有一个catch块，e.massage java用的是getMassage（）

with(){

}
var s='C';
switch(s){
case 'A' : document.writeln("优秀.");
                break;
 case 'B' : document.writeln("良好.");
                break;  
case 'C':document.writeln("中");
                break;
                case 'D':document.writeln("几个");
                break;   
                case 'E':document.writeln("不及格");
                break;  
                default:document.writeln("裂开");                               
}
document.getElementById要让外部js defer,h后续执行
可是document.write就不行了；，htlml执行完，document就是固定了；

var a=["hallo","javascript","world"];
for(str in a){
        document.writeln('索引'+str+'的值是'+a[str]+"<br/>");
}
for(var i=0;i<a.length;i++){
        document.writeln('索引'+i+'的值是'+a[i]+"<br/>");
}

for( int a in b)
记得下面用b[a]操作，b.a大概率没这属性
document.writeln("<h1>navigator对象的全部属性：</h1>");
for(pro in navigator){
        document.write('属性'+pro+'的值是'+navigator[pro]);
        document.write("<br/>")
}
for(pro in navigator){
        //a.b和
        document.write('属性'+pro+'的值是'+navigator.pro);
        document.write("<br/>")
}

break,结束整个for函数体
continue ,结束当前循环，当前for循环继续
正常名字加: ,就可以做标签，相当于坐标，在那结束就加哪
outer:
for(var i=0;i<5;i++){
        for(var j=0;j<5;j++){
                document.write('j的值是'+i);
                //outer标签，结束外层，也就是全没了
                if(j>=2) break outer;
                document.writeln("i的值是："+i);
                document.writeln("<br/>")
        }
}
ou:
for(var i=0;i<5;i++){
        for(var j=0;j<5;j++){
                document.write('j的值是'+i);
                if(j>=2) continue ou;
                document.writeln("i的值是："+i);
                document.writeln("<br/>")
        }
}

函数提升，只能是在一个script标签里，就是先使用，在定义
匿名函数，若是后方有名字，如下面的test,test失效
var f=function test(name){
        document.writeln('匿名<br/>');
        document.writeln('你好，'+name)
};
f('yeeku');
由于函数就是类，并且是这个类的唯一构造器；

函数：
1. 函数可以被调用；
2. 定义一个函数，会创建一个对象，Function的实例；
3. 函数常赋给一个对象，匿名函数，
4. 定义时得到同名类，变量
这个同名变量很坑，如下
     function test(name){
                document.writeln('匿名<br/>');
                document.writeln('你好，'+name)
        }
        test="ha";
        test("en");
        同名赋值给伴生的变量，test函数已经没了，成了普通变量

阶乘必须找对边界，逻辑规律
var fa=function(n){
        if(typeof (n)=="number"){
                if(n==1){
                        return 1;
                }else{
                        return n*fa(n-1);
                }
        }else{
                alert("类型不对");
        }
}
alert(fa(5));
alert(fa(99));

function outer(){
        function inner1(){
                document.write("局部函数111<br/>");
        }
        function inner2(){
                document.write("局部函数222<br/>");
        }
        document.write("开始测试局部函数。。。<br/>")
        inner1();
        inner2();
        document.write("结束测试局部函数。。。<br/>")
}
document.write("调用outer之前。。。<br/>");
        outer();
inner1（）；//不能运行，局部函数只存话在外部函数中
        document.write("调用outer之后。。。<br/>");

var hallo=function(name){
        return name+"您好";
}
alert("hello是否为Function的实例："+(hallo instanceof Function)
+"\nhello是否为Object的实例："+(hallo instanceof Object));
alert(hallo);//把函数作为字符串输出
alert(hallo("世界"));//把函数处理后的东西输出

function Person (name,age){
        this.name=name;
        this.age=age;
        this.info=function(){
                document.writeln("我的名字是："+this.name+"<br/>");
                document.writeln("我的年龄是："+this.age);
        }
}
可以直接调用，也可以new个新的
var p=new Person("meng",20);
p.info();

类里只有
function Person (na,age){
        this.age=age;
        Person.na=na;
        var bb=0;
bb只能在类利用
}

函数三属性：局部，实例，类属性，都不可混用，混了，就是undifined
var p1=new Person("中国",29);
document.write("创建一个person对象<br/>");
document.write("p1的age属性："+p1.age+"<br>");
document.write("p1的national属性："+p1.na+"<br>");
document.write("通过Person类方式访问national的属性："+Person.na+"<br>");
document.write("p1的bb属性："+p1.bb+"<br>");
var p2=new Person("美国",32);
document.write("创建两个个person对象<br/>");
document.write("p2的age属性："+p1.age+"<br>");
document.write("p2的national属性："+p1.na+"<br>");
document.write("通过Person类方式访问national的属性："+Person.na+"<br>");
document.write("p2的bb属性："+p2.bb+"<br>");

var each=fuhnction(array,fn){
        for(var index in array){
                // fn.call(null,index,array[index]);
                // fn.call(window,index,array[index]);
                //fn(index,array[index])
                //window.fn(index,array[index])不行，会认为是window的函数
        }
}
each([4,20,3],fuhnction(index,ele){
        document.write("第"+index+"个元素是："+ele+"<br/>")
})

//独立体，谁吊我，this就是谁
function Person (name){
                this.name=name;
               
                this.info=function(){

                        alert("我的名字是："+this.name);          
                }
        }
        var p=new Person ("yeeku");
        p.info();
        var name="测四名字";
        //
        p.info.call(window);

function Dog(name,age,bark){
        this.name=name;
        this.age=age;
        this.bark=bark;
        this.info=function(){
                return this.name+"年龄："+this.age+"它的叫声："+this.bark;
        }
}
var dog=new Dog("旺财",3,"汪汪汪。。。");
function Cat(name,age){
        this.name=name;
        this.age=age;
}
var cat=new Cat("kitty",2);
alert(dog.info.call(cat));
输出kitty年龄：2它的叫声：undefined
。call(cat),info是独立的，但是要先拿到dag.info虽然在Dog里

map,用数组接返回值，
forEach
var arr=["tee","fruit","lee","crazy"];
var newArr1 =arr.map(function(ele){
        return ele.length;
});
var newArr2 =arr.map((ele)=>{
        return ele.length;
});
var newArr3 =arr.map(ele =>ele.length);
console.log(newArr3);
arr.forEach(function(ele){
        console.log(ele);
});
arr.forEach((ele)=>{
        console.log(ele);
});
arr.forEach((ele)=>console.log(ele));

function Person(){
        this.age=0;
        setInterval(function growUp(){
                console.log(this===window);
                this.age++;
        },1000);
}
var p=new Person();
setInterval(function(){
        console.log(p.age);
},1000);

function Person(){
        this.age=0;
        setInterval(()=>{
                console.log(this===window);
                this.age++;
        },1000);
}
var p=new Person();
setInterval(function(){
        console.log(p.age);
},1000);

function fo(){
        var f=function(i){return 'hallo,'+argument[i];
        return f(2,7,9,97,0);
}
}
fo("a","b","c")//无用，没人接abc的值，argument隔着太远
也就是function(2)    return f(2,7,9,97,0);的第一个值进去
argument[i]要的f(2,7,9,97,0);得植9

function fo(){
        var f=(i)=>{return 'hallo,'+argument[i];
        return f(2,7,9,97,0);
}
}
fo("a","b","c")
 => 没有this,和富函数通着，可以拿到 fo("a","b","c")
也就是function(2)    
argument[i] 要的 fo("a","b","c")  输出 c

function changeAge(person){
        person.age=10;
        document.write("函数执行中person的age值："+person.age+"<br/>");
        person=null;
}
var person={age:5};
document.write("函数调用前person的age值："+person.age+"<br/>");
changeAge(person);
document.write("函数调用后person的age值："+person.age+"<br/>");
document.write("person对象："+person);

functionPerson(){
        var lo='crazy';
        this.in=function(){
                this.document.write("local:"+lo);
                return lo;
        }
        var p=new personalbar();
        var val =p.in();
        alert(val);
}

function Person (name,age){
        this.name=name;
        this.age=age;
        this.info=function(){
document.write("name:"+this.name+"<br>");
document.write("age:"+this.age+"<br>");
        }
}
var p1=new Person('yee',29);
p1.info();

Person.prototype.walk=function(){
        document.write(this.name+'溜达<br/>')
}
document.write('<hr/>');
var p2=new Person('lee',30);
p2.info();
document.write('<hr/>');
p1.walk();
p2.walk();

Array.prototype.indexOf=function(obj){
        var result=-1;
        for(var i=1;i<this.length;++i){
                if(this[i]==obj){
                        result=i;
                        break;
                }
        }
        return result;

}
var arr=[4,5,6,7];
alert ("数组[4,5,6,7]<br/>"+"找7<br>"+"位置："+arr.indexOf(7));

去掉break

function Person (name,age){
this.name=name;
this.age=age;
}
Person.prototype.say=function(){
        console.log(this.name+"打着招呼");
}
var per=new Person("牛魔王",22);
per.say();
function Stu(grade){
        this.grade=grade;
}
Stu.prototype=new Person();
先继承在写自己的类
Stu.prototype.in=function(){
        console.log("%s是个学生，读%d年纪",this.name,this.grade);
}
var stu=new Stu(5);
stu.name="悟空";
console.log(stu instanceof Stu);
console.log(stu instanceof Person);
stu.say();
stu.in();

function Person (name,age){
        this.name=name;
        this.age=age;
        this.say=function(){
                console.log(this.name+"打着招呼");
        }
        }
        
        var per=new Person("牛魔王",22);
        per.say();
        function Stu(name,age,grade,){
                Person.apply(this,[name,age]);
                this.grade=grade;
        }
        //Stu.prototype=new Person();
        
        Stu.prototype.in=function(){
                console.log("%s是个学生，读%d年纪",this.name,this.grade);
        }
        var stu=new Stu("悟空",34,5);
      
        console.log(stu instanceof Stu);
        console.log(stu instanceof Person);
        stu.say();
        stu.in();

把函数拿出来Animal.protype.a=
原型链最强
先继承再写自己的，先写自己的会导致继承bie
Dog.prototype=new Animal();
Dog.prototype.say=function(){
        console.log(this.type+"嗷嗷叫");

}
对象冒充，类内写的话函数在外面就没法获取了
function Stu(name,age,grade,){
        Person.apply(this,[name,age]);
        this.grade=grade;
}

function Animal(sex,age){
this.sex=sex;
this.age=age;

}
Animal.prototype.info=function(){
        console.log("name:"+this.sex+"age:"+this.age);
}
function Dog(sex,age,type){
        this.type=type;
        animal.apply(this,[sex,age]);
       
}
//先继承再写自己的，先写自己的会导致继承bie
Dog.prototype=new Animal();
Dog.prototype.say=function(){
        console.log(this.type+"嗷嗷叫");

}
var dog=new Dog("erha  ",21,"哈士奇");
dog.info();
dog.say();
function Cat(sex,age,type){
        this.type=type;
        animal.apply(this,[sex,age]);
        
}
Cat.prototype=new Animal();
Cat.prototype.say=function(){
        console.log(this.type+"喵喵叫");

}
var cat=new Cat("tom  ",21,"波斯猫");
cat.info();
cat.say();

        function Animal(sex,age){
        this.sex=sex;
        this.age=age;
        
        }
        Animal.prototype.info=function(){
                console.log("name:"+this.sex+"age:"+this.age);
                return this.age;
        }
        var cat=new Animal("tom  ",21);
       alert( cat.info());

function funA(){
        var a = 10;  // funA的活动对象之中;
        return function(){   //匿名函数的活动对象;
              alert(a);
        }
      }
      var b = funA();
      b();  //10

下面两个例子是区别全局，局部变量，在闭包作用下区别
        function outerFn(){
                var i = 0; //局部
                function innerFn(){
                i++;
                console.log(i);
                }
                return innerFn;
        }
        var inner = outerFn();  //每次外部函数执行的时候,都会开辟一块内存空间,外部函数的地址不同，都会重新创建一个新的地址
        inner();
        inner();
        inner();
        var inner2 = outerFn();
        inner2();
        inner2();
        inner2();   //1 2 3 1 2 3

        var i = 0;、、全局
        function outerFn(){
        function innnerFn(){
        i++;
        console.log(i);
        }
        return innnerFn;
        }
        var inner1 = outerFn();
        var inner2 = outerFn();
        inner1();
        inner2();
        inner1();
        inner2();     //1 2 3 4