/** * 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)取消