javascript基础笔记学习

/** * Created by Administrator on 2016/12/26. */

/* var box; alert( typeof box); box是Undefined类型，值是undefined,类型返回的字符串undefined var box=true; alert( typeof box); box是Boolean类型，值是true,类型返回的字符串boolean var box=''; alert( typeof box); //box是String类型，值是'',类型返回的字符串string var box=''; alert( typeof box); //box是String类型，值是'',类型返回的字符串string var box=21; alert( typeof box); //box是Number类型，值是21,类型返回的字符串number var box={}; alert( typeof box); //box是Object类型，值是{},类型返回的字符串object */// var box={};// alert( typeof box);//box是Object类型，值是{},类型返回的字符串object

var box=null;//表示已经还未创建对象，但先声明对象引用而必须初始化结果//还没有来的及创建对象，先声明一个对象的变量放在那边，默认初始化为nullvar box=[];//当创建一个变量时，一开始不知道使用什么时，就先使用这样的//undefined与null(它是父类)是相等的,但是数据类型是不同的//type undefined == type null;也可以进行比较

//isFinite()判断一个数值是否超过这个范围;如果未超过则true,否则false;//NaN不等于任何数（也不等于自身）,与任何数计算，返回NaN//isNaN()判断这个数字是否为nan,如果是返回true,否则返回false;//var b=++i,先将i累加到那个值时，然后在赋值给b//var b=i++,先将i赋值给b，然后在i累加到那个值//var a=100;+a 取正，返回的结果还是100for(var i=0;i<10;i++){    //先声明并幅值    //判断    //输出    //累加

}//创建对象var box=new Object();//创建一个对象,是可以省略的方式创建// alert(box);

//对象包含以下元素：属性和方法// box.name='名字';// box.age=30;// box.sex='男';// alert(box);// alert(box.age);// var box={};// box.age=20;// alert(box.age)//创建字面量var box={//通过这样的方式创建一个对象    name:'aa',    age:20,    run:function () {        return'123'    }}//调用// box.age//数组方式// alert(box["name"])// alert(box.run())// alert(box.run)//打印run中的代码段delete box.run()//删除想要的属性

function box2(r) {    if(r.name!=undefined){        // alert(r.name)    }    alert(r.box33())

}// box(r1);// var r1={//     name:'abc'// }// box2({//     name:'abc11',//     box33:function () {//         alert(20)//     },//// })

//数组var arr1=new Array();//声明一个空数组，属于object类型var arr2=new Array(1,2,3,4,'我们',[3,4,5,6]);//读取对应的下标值// alert(arr2[5])var arr3=new Array(10);//创建10个空对象值arr3[4]='第4个位置';// alert(arr3)// alert(arr);var arr4=['a','b','c'];//字面量//获取数组个数: .length//修改元素arr4[2]='func';//增加元素arr4[5]='hello';//对.length进行修改，如下arr4.length=34565;//不建议使用//添加到最后一位元素arr4[arr4.length]='abc';//数组转成其他方式//arr4.toLocaleString()本地格式化[针对Date()方式]//arr4.toString(),arr4.valueOf() 无论重写这2个方法，返回的结果是一样的//重构格式arr.join(obj),以字符串方式返回

//后进先出//arr.push()，可以向数组末尾中添加做任意数量的参数//.push(),返回的结果是一个数值和新的长度//arr.pop(),从数组末尾移除最后一个元素，并减少arr的长度值,然后返回数组//先进先出//arr.push()//arr.shift()移除数组中一个元素，并返回这个元素//arr.unshift()可以在数组中前端添加任意参数项，并返回新的长度   //注意:在ie浏览器下会，返回undefined的结果//arr.reverse()对数组中的元素反转 返回结果是object类型//arr.sort()从小到大进行排序

<script>    function def(a,b,c) {        return a(b,c)    }    function def1(a,b) {

        return a+b    }    var def2=def(def1,20,30)//    alert(def2)    //arguments.callee(object)调用自己

    //apply(),call冒充另外一个函数进行操作其他行为,重点是，在冒充作用域上面    function aa1(a,b) {        return a+b    }    function aa2(a,b) {        aa1.apply(this,[a,b])    }    function aa3(a,b) {        aa1.apply(this,arguments)    }    function aa4(a,b) {        aa1.call(this,a,b)    }//    alert(aa4(1,2))    //动态属性    var box={};//引用类型    box.name='leff';//添加一个属性    //复制变量值    //基础类型    var box='leff';    var box2=box;    //虽然box2复制box里面的数据，但不会修改box里面的数据，属于独立，不会影响其他变量    // 引用类型    var box1={};    var box2=box1;    box1.name='ss'    box2.name='cccc';//如果是引用类型时，当其实一个变量的信息被修改时，那么另一个变量的信息也跟着变化，因为它们的内存地址是相同的    alert(box2.name);    alert(box1.name);

    //按值传递    function s(a){        a+=10;//局部变量        return a;//60    }    var a=50;    alert(s(a));    alert(a);//50    //如果是按引用传递，那么局部变量中的值会影响全局变量中的值;    function abc1(obj) {        obj.name='111lef';        //js无传递参数功能        var obj=new Object();        obj.name='ssfdsfsd';    }    var obj=new Object();    abc1(obj);    alert(obj.name)    var a=1;    function b(){        return a+1;    }    window.a//全局变量    window.b();//全局方法    //获取几到几之间的随机整数:Math.floor(Math.random()*总数+第一个值)    var s=Math.floor(Math.random()*100+5)//总数+第一个数-1    console.log(s);    //随机5到10之间的数字    function select(a,b){        var c=b-a;        return Math.floor(Math.random()*c+a);

    }

</script>

<script>    //创建一个构造函数    function createObject(name,age) {        this.name=name;//创建一个变量        this.age=age;        this.run=function () {//创建一个方法

        }

    }    var c=new createObject('a',1);//创建一个构造方法    c.run()//调用对应的构造函数中的方法    //原型:prototype,共享属性和方法,需要通过构造函数创建出来    createObject.prototype.run1=function (sex) {       self.sex=sex;       return self.sex    }    var c=new createObject('a',1);    alert(c.run1('女'));    alert(c.__proto__);//指针指向原型对象    alert(c.constructor);//指向构造属性，获取它本身 ，也就实例对象对应原型对象    alert(createObject.prototype.isPrototypeOf(c));    //判断实例化对象是否是它的原型,如果是，返回true;    //原型模式执行流程(就近原则)    //先查找构造函数实例里面属性或者，如果有，立即返回    //如果构造函数实例中未找到，就去它对应的原型对象中查找，如果有，就返回    //判断属性是否在构造函数的实例化中    alert(c.hasOwnProperty('age'));//如果有，就返回true;    alert('age11' in c);//不管实例属性或者原型属性是否存在，如果有，就返回true    //判断只有原型中有的属性    function isProty(object,pro) {        return !object.hasOwnProperty(pro)&&(pro in object)    }    //对象实例无法访问到prototype    //通过字面量创建原型:封装    function Box() {

    }    Box.prototype={        name:'Leff',        age:200,        run:function () {            return this.name+this.age        }    }    //字面量创建的原型，它的constructor，返回的是object对象,它不会指向实例对象    //如果想让字面量方式的constructor指向实例对象的话，可以使用如下方式    Box.prototype={        constructor:Box,//强制指向实例对象

    }    //重写原型对象    Box.prototype={        age:300,//它不会保留之前所有相关的信息行为，也就是覆盖之前的所有行为    }    //内置使用了prototype    var box=[4,1,2,5,6,7,8];    //查看对应内置方法中相关的方法或者属性    alert(Array.prototype.sort)    //扩展原型方法    String.prototype.addString=function () {        //编写自己的语句体    };    var box='hello';    box.addString();

    //原型缺点    function Box() {

    }    Box.prototype={        constructor:Box,        name1:'2',        age:30,        f1:[1,2,3],        run:function () {            return        }

    }    //为了解决构造函数共享资源问题，可以使用构造函数+原型模式来处理    function Box(a,b) {//它是独立的构造函数        this.name=a;        this.age=b;        this.run=function () {            //语句体        }    }    Box.prototype={//这边是共享的原型        constructor:Box,        name1:'2',        age:30,        f1:[1,2,3],        run:function () {            return        }

    }    //动态原型模式:不可以再使用字面量方式重写原型，因为会切断实例和新原型间的联系    //封装到一起了    function Box(a,b) {        this.name=a;        this.age=b;        this.f1=[1,2,3,4];        if(typeof  this.run!='function'){//只会初始化一次,原型            Box.prototype.run=function () {                //原型会被调用2次                //语句体            }        }    }//原型的初始化，只要第一次初始化，就行了，不用每次 都初始化    //寄生构造函数:工厂模式+构造函数    function Box(a,b) {        var obj=new Object();        obj.name=a;        obj.age=b;        obj.run=function () {            //语句体        };        return obj;

    }//安全模式下的，禁止使用如this,new关键字的方法，如下    function Box(a,b) {        var obj=new Object();        obj.run=function () {           return a+b;        };        return obj;

    }    var box=Box(2,3);//直接调用    box.run()//与寄生类似

</script>

   //继承    function A() {//被继承函数，叫父类        this.a='abcde111';        this.run=function () {            return '原型链'        }    }    A.prototype.a='abcde';//如果此处覆盖掉了原型中的信息的话，实例属性中有，不会去执行它，而是返回abcde111,否则返回 abcde    function B() {//继承的函数叫子类或者派生类        this.age=123;    }    //通过原型链方式,父类实例化后对象实例，赋值给子类的原型属性;     B.prototype=new A();//A内部的相关信息交给B    var b=new B();    alert(b.a);

    //对象冒充:只能继承构造函数中的信息，无法继承原型中的信息    function  A1(a) {        this.name=[1,2,3];        this.age=a;    }    function A2(age) {        A1.call(this,age);//冒充对象，给子类对象中传递参数    }    //构造函数中的方法，放在构造里面，每次实例化后，都会分配一个内存地址，浪费空间,最好放在原型里面    A1.prototype.run=function () {        //语句体    };    //组合继承    A2.prototype=new A1();//原型链继承

    //解决多次被调用 的方式    //原型式继承

    function obj(o) {    //o将要传递的对象        function F() {//临时新建的对象,存储传递过来的对象

        }        F.prototype=o;        return new F();    }    //字面声明方式    var box={        name:'aa',        age:100

    };    var b1=obj(box);    alert(b1.name);    //寄生函数    function create(o) {        var f=obj(o);        f.run=function () {            //语句体        }

    }    var a1=create(box);

    function create(a,b) {//寄生组合继承,        var f=obj(a.prototype)        f.constructor=b;//调整原型构造执行         b.prototype=f;    }    create(A1,A2);//这个方法来替代A2.prototype=new A1()方法

    //闭包    //创建表达式方式来执行自己    (function () {        return 'abc'    })()    function box1() {        return function () {            return 1        }

    }    alert(box1()());    var b=box1();    b();    //重点:闭包    function s1() {        var age=100;        return function () {            age++;            return age;        }    }    //闭包累加    var b=s1();    b();    b();    b();    b=null;//垃圾回收    function box(){        var arr=[];        for(var i=0;i<5;i++){            arr[i]=(function (num) {//自我执行                return num            })(i);

        }        //当循环已经执行完毕后，i最终的结果永远是最后一个值        return arr;

    }    var b=box();    for(var i=0;i<5;i++){        alert(b[i])    }

    function box(){        var arr=[];        for(var i=0;i<5;i++){            arr[i]=(function (num) {//自我执行                return function () {                    return nun                }            })(i);//闭包可以驻留在内存中,与上面的累加原理是一样的        }        //当循环已经执行完毕后，i最终的结果永远是最后一个值        return arr;

    }    var b=box();    for(var i=0;i<5;i++){        alert(b[i]())    }    //自我执行var b=function(){        return 1}();    //闭包中的this(也是指向window)var box={    getTihs:function () {        return function () {            return this        }    }};box.getTihs()();

//想让闭包中的this指向当前对象    //1:对象冒充    box.getTihs().call(box)    //作用域链    var box={        getTihs:function () {            //预留this            var self=this;            return function () {                return self;            }        }    };    //内存泄漏    //ie浏览器下面的    //调用完之后，将null赋值给对应的变量    //私有化:模仿块级作用域    function box(){        (function () {            for(var i=0;i<5;i++){                alert(i)//执行完之后 ，这个i在外面 调用 会报错            }        })();        alert(i)//i is not defined(…)    }    box()

    //私有方法和属性    function Box() {        var age=100;//私有变量        function abc() {;//私有函数

        }        this.run=function () {            return //对外公开        }    }

    //bom    //window    //新建窗口:open();    //窗口位置大小    //ie:screenLeft,screenTop;    // firefox:screenX,screenY;    //chrome:innerWidth=outerWidth,innerHeight=outerHeight 宽度和高度    //ie,firefox,safari,opera,chrome:    //document.documentElement.clientWidth,document.documentElement.clientHeight保存窗口信息;(ie6)    //怪异模式:document.body.clientWidth;    //很少 用到的ie下面的    //moveTo(x,y),moveBy(x,y)  移动。向下和向右    //resizeTo(x,y),resizeBy(x,y)调整，扩展    //var a=setTimeout(a,1000)a:表示代码块:函数体,1000是毫秒数    //clearTimeout(a,1000)取消