面向对象

构造函数

function person(name,sex,age){
	this.name = name;  //this.name属性     name参数 习惯上 属性名称==参数
	this.sex  = sex;
	this.age  = age;
	this.show = function(){
		alert(this.name+"---"+this.sex+"---"+this.age);
	}
}
var obj1 = new person("zhangsan","nan",18);
//alert(obj1.sex);
obj1.show();
var obj2 = new person("lisi","nv",20);
obj2.show();
//注意： this 代表当前对象，obj1和obj2两者之间是独立的，函数内部只能用this访问属性和方法

工厂模式

function createObject(name,age){
	var obj = new Object();
	obj.name = name;// obj.name 属性  name参数
	obj.age  = age;
	obj.run = function(){ //在obj对象中 调用obj对象的属性 this 代表的当前对象***
		return this.name +"----" + this.age +"运行中....";  
	}
	obj.say = function(){
		return "今天天气不错";
	}
	return obj;
}
var box1 = createObject("张三",18);
//alert(box1.name); //调用属性成功
//alert(box1.run()); //调用方法成功
var box2 = createObject("李四",20);
//alert(box2.name);
alert(box2.run());
//box1 和 box2 有关系？？？
// 构造和 工厂模式 不同：
//1 构造方式不会显示创建对象 将属性赋值给 this ，不需要return 对象
//2 工厂 在方法内部创建 object对象  返回object对象 ，属性和方法都是赋给object对象

原型模式

function test(){
}
//alert(test.prototype instanceof Object); //自带该对象 prototype是Object子对象
test.prototype.color 	= "red";
test.prototype.heights 	= "1.7";
test.prototype.widths 	= "1.2";	
test.prototype.showInfo = function(){
	alert(this.color+"---"+this.heights+"---"+this.widths);
}
test.prototype.getinfo  = function(){
	alert("aaaaa");
}
var car1 = new test();
car1.getinfo();


function test(){
}
//json数据定义属性和方法
test.prototype={
	color:"red",
	heights:"1.7",
	widths:"1.2",
	showinfo:function(){
		alert(this.color+"---"+this.heights+"---"+this.widths);
	},
	getinfo:function(str){
		alert(str);
	}
}
var car1 = new test();
car1.getinfo("abc");

混合模式

//混合模式：构造+原型
function blog(name,url,friend){
	this.name 	= name;
	this.url	= url;
	this.friend	= friend;
}
blog.prototype={
	test:"awt",
	showinfo:function(){
		alert(this.name+"---"+this.url);
	},
	gets:function(){
		alert(this.friend);
	}
}
var peo = new blog("张三","http://www.baidu.com","李四");
peo.showinfo();

封装

function demo() {
  var n = 1; //局部变量，在方法外部不能直接访问
  function test() { //外部调用的出口
    n++;
  }
  test(); //n++ =2 
  return n;
}
alert(demo());

function A(){
	var t = 3;
	function _xx(){ alert(11+"****") ;}
	this.xx = function(){
		return _xx;
	}
}
A.prototype = {
	oth:function(){
		alert("普通方法");
	}
}
var a = new A();
var b = a.xx(); // a.xx()  ---> function _xx()
//b();
a.oth();
// 缺陷： 1 占用内存  2 不利于继承

继承

var person = function(){}
person.prototype.say = function(){
	alert("天气挺好");
}
var p = new person();
p.say(); // p 没有say方法的
// p.__proto__ = person.prototype  ---》 有say方法

var person = function(){};
person.prototype.say = function(){
	alert("天气挺好");
}
person.prototype.gongzi = 500;

var programmer = function(){};
programmer.prototype = new person();
programmer.prototype.wcd = function(){
	alert("明天天气也不错");
}
programmer.prototype.gongzi=1000;

var p = new programmer();
//p.say(); //可以调用
//p.wcd();
alert(p.gongzi);
// var p = new programmer();  p.__proto__ = programmer.prototype   = new person();
//var p1 = new person();   programmer.prototype = p1
// p.say(); p.__proto__ --> programmer.prototype ==p1 --->p1.__proto__  ==person.prototype.say();

function person(name,age){//父
	this.name= name;
	this.age = age;
}
person.prototype.sayhello = function(){
	alert("属性name值"+this.name);
}
/*
var per = new person("zhangsan",20);
per.sayhello();
*/
function student(){} ;//子
student.prototype = new person("李四",18);// 原型继承
student.prototype.grade = 3;
student.prototype.test = function(){
	alert(this.grade);
}
var  s = new student();
s.sayhello();
alert(s.grade);
//过程分析：
// s.__proto__ = student.prototype = p1    p1.__proto__ = person.protype.sayhello();

function parents(name){
	this.name = name;
	this.say = function(){
		alert("父亲的名字:"+this.name);
	}
}
function child(name,age){ //继承parents
	this.pObj = parents;//用父对象来创建子对象
	this.pObj(name);
	this.age = age;
	this.sayC = function(){
		alert("child:"+this.name+"---"+"age:"+this.age);
	}
}

var p = new parents("zhangsan");
p.say();
var c = new child("李四",20);
c.sayC();
//  李四---》 this.pObj(name); ---》 parents（name） ---> this.name=name="李四"
// this.sayC --->this.name--->parents-->this.name
//父对象 被子对象继承   所有的属性和方法，都将传递到子对象中*****

function person(name,age,len){
	this.name = name;
	this.age = age;
	this.len = len;
	this.say = function(){
		alert(this.name+":"+this.age+":"+this.len);
	}
}
//call继承
function student(name,age){
	person.call(this,name,age);
}
//apply继承
function teacher(name,age,len){
	person.apply(this,[name,age,len])
}

var per = new person("张三",25,"170");
per.say();
var stu = new student("李四",18);
stu.say(); // 李四 18 undefined
var tea = new teacher("王武",20,"180");
tea.say();

call apply

function add(a,b){
  alert(a+b);
}
function subs(a,b){
  alert(a-b);
}
add.call(subs,5,3); // subs-->add  ===>add(5,3)  subs只能引用一个存在的对象
add.apply(subs,[5,3]);

function animal() {
  this.name = "ani";
  this.showName = function () {
    alert(this.name);
  }
}

function cat() {
  this.name = "cat1";
}
var an = new animal();
var c = new cat();
an.showName.call(c, ","); // 通过call方法，将showName--》cat使用了
an.showName.apply(c, []);

arguments.callee

正在执行的function对象

var sum = function (n) {
  if (n <= 1) {
    return 1;
  } else {
    return n + arguments.callee(n - 1); //在函数内部调用本函数
  }
}
alert(sum(5));

arguments

function test(a, b, c) {
  alert(arguments.length);
  alert(arguments[1]); //arguments如果是表示参数，可以遍历的
}
test(1, 2, 3);