JS学习笔记_基础篇_2

var add = function(num, num2, num3) {
				alert(num + num2 + num3);
			}
			
			//add   指向函数对象的引用.  add.lenth:期望接收的参数个数.  arguments.length:实际接收的参数个数
			alert(add.length);
			add(1, 2, 3);
			
			
			//此时希望接收参数个数为0
			var add2 = function() {
			
			}
			
			alert(add2.length);

//逻辑表达式不返回null,Undefined  就为真,if(4) if(aaa) 都为真
  var s = false;

  alert(s);

  var s = "hello"; // s是原始类型(String),也可以使用单引号定义

  alert(typeof s);//typeof:一元运算符以,用于获取变量的数据类型
  //其返回值有5个：undefined、boolean、number、string以及object(全部小写)

  var s = new String("hello"); //s是对象类型(Object),js所有的对象都是Object继承下来的

  alert(typeof s);

  var s = false;

  alert(typeof s);

  var s = 3;

  alert(typeof s);

  
  function add()
  {
	return 3;
	//return;
  }
 
  alert(add());//如果没有显式返回值(或就一个return) 则返回undefined

  alert(typeof ss);//未定义的变量  此时 打印:undefined

  alert(undefined == null);//为ture,undefined从null派生出来的

  var s = Number(3);

  alert(s);//打印数字3

  var s = Boolean("hello");

  alert(s);//打印为ture,非null,Undefined就为ture

  var s = new String("hello");

  alert(typeof s);//为Object
  
   var s = String("hello");

  alert(typeof s);//为String : 表示强转

  
  var s = new Boolean("hello");

  alert(s);//true;
  alert(typeof s);//为object
  
 // var object = new Object();//所有的类都是从Object继承的,生成Object实例的方法


  var object = new Object();

  for(var v in object)
  {
	alert(v);//in  遍历类中的属性,但是对于Object类 这种方法打印不出来(无法枚举出来
	//  能枚举出来的 就可以打印出来                                             
  }

  //alert(object.propertyIsEnumerable("prototype"));//判断某个属性是否可以枚举出来  不可枚举  打印结果为false



  //for  in  枚举 window 对象的属性, window 是个内置对象,不用new 直接用就可以了
  //window 对象 可枚举属性
  for(var v in window)
  {
	//alert(v);
  }


	alert("window");

  var object = new Object();
  
  //alert(object.username);
  object.username = "guojie";//添加属性的两种方式, 动态语言:对象生成后还可以添加属性
  object["username"] = "shengsiyuan";
  alert(object.username);
  delete object.username; // username属性已经从object对象中删除
  alert(object.username);//undefined


  // 在JavaScript中定义对象的最常见的方式
  //多对属性之间用逗号隔开
  var object = {username: "zhangsan", password: 123};
  alert(object.username);
  alert(object.password);

// array 指向 new 出来的 那个对象的引用
//  可扩容(与Java不同)
var array = new Array();

array.push(1);
array.push(2);
array.push(3);

alert(array.length);

//定义数组的第二种方式,常用
var array = [1, 3, 25];
//对原数组排序.
array.sort();//升序  1 , 25 , 3  并不是按照大小排序的, 调用toString 然后比较

alert(array);

//编写自己的排序方法
function compare(num1, num2)
{
	var temp1 = parseInt(num1);
	var temp2 = parseInt(num2);

	if(temp1 < temp2)
	{
		return -1;//无需交换
	}
	else if(temp1 == temp2)
	{
		return 0;
	}
	else
	{
		return 1;//交换顺序
	}
}

var array = [1, 3, 25];

array.sort(compare); 

alert(array);

var array = [1, 3, 25];

// 匿名函数  相当于Java中的匿名类
array.sort(function(num1, num2)
{
	var temp1 = parseInt(num1);
	var temp2 = parseInt(num2);

	if(temp1 < temp2)
	{
		return -1;
	}
	else if(temp1 == temp2)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
);

alert(array);

//此种方式弊端:再要一个对象 则 属性都要写一遍
				var object = new Object();
				//添加属性 name
				object.name = "zhangsan";
				//添加一个方法. 动态语言,可以先生成对象  再 生成属性
				object.sayName = function(name) {
					this.name = name;
					alert(this.name);
				}
				
				object.sayName("lisi");

//工厂方式创建对象
//工厂方法. 调用此工厂方法 就能创建对象
function createObject()
{
	var object = new Object();

	object.username = "zhangsan";
	object.password = "123";

	object.get = function()
	{
		alert(this.username + ", " + this.password);
	}

	return object;
}

var object1 = createObject();
var object2 = createObject();

object1.get();//会被下面的覆盖掉,打印出来为未定义


//调用的时候可以传参
function createObject(username, password)
{
	var object = new Object();

	object.username = username;
	object.password = password;

	object.get = function()
	{
		alert(this.username + ", " + this.password);
	}

	return object;
}

var object1 = createObject("zhangsan", "123");
object1.get();


/**
 * 方法一份,方法定义在外面
 * 属性 每个对象独享爱
 * @memberOf {TypeName} 
 */
function get()
{
	alert(this.username + ", " + this.password);
}

function createObject(username, password)
{
	var object = new Object();

	object.username = username;
	object.password = password;

	object.get = get;//不能加括号

	return object;
}
//没有new动作,需要显示return
var object = createObject("zhangsan", "123");
var object2 = createObject("lisi", "456");

object.get();
object2.get();

function Person()
{
    //使用new的方式生成对象 :在执行第一行代码前，js引擎会为我们生成一个对象
	this.username = "zhangsan";
	this.password = "123";

	this.getInfo = function()
	{
		alert(this.username + ", " + this.password);
	}
	//不需显示return
	//此处有一个隐藏的return语句，用于将之前生成的对象返回
}

var person = new Person();//使用new的方式
person.getInfo();//会被下面的覆盖掉


function Person(username, password)
{
	this.username = username;
	this.password = password;

	this.getInfo = function()
	{
		alert(this.username + ", " + this.password);
	}
}

var person = new Person("zhangsan", "123");
person.getInfo();

//使用原型（prototype）方式创建对象

//prototype  属性 是 Object 对象里拥有的  所以 每个对象都有这个属性
function Person()
{

}
//在函数的外面进行扩充
//prototype的特性
Person.prototype.username = "zhangsan";//给 Person对象的prototype赋上username属性,就宣称:Person对象 拥有username属性
Person.prototype.password = "123";

Person.prototype.getInfo = function()
{
	alert(this.username + ", " + this.password);
}

var person = new Person();//生成对象 与 构造函数方法一样
var person2 = new Person();

person.username = "lisi";

person.getInfo();
person2.getInfo();


/**
 * 单纯使用prototype生成对象  1: 无法传参  2: 导致程序错误:属性所有对象共享
 */
function Person()
{

}

Person.prototype.username = new Array();
Person.prototype.password = "123";

Person.prototype.getInfo = function()
{
	alert(this.username + ", " + this.password);
}

var person = new Person();
var person2 = new Person();

person.getInfo();
person2.getInfo();

// 只对person修改  person2也影响,通过原型方式生成对象:属性所有对象共用  对于字符串类型的不影响(password)
person.username.push("zhangsan");
person.username.push("lisi");
person.password = "456";

person.getInfo();
person2.getInfo();

//使用原型+构造函数方式来定义对象
function Person()
{
	this.username = new Array();
	this.password = "123";
}

/**
 * 方法放原型里面,属性放构造函数中
 * 这样:属性每个对象独享,方法共享
 * @memberOf {TypeName} 
 */
Person.prototype.getInfo = function()
{
	alert(this.username + ", " + this.password);
}

var p = new Person();
var p2 = new Person();

// 这样 两个username属性互不影响了
p.username.push("zhangsan");
p2.username.push("lisi");

p.getInfo();
p2.getInfo();

function Person()
{
	this.username = "zhangsan";
	this.password = "123";

	//只有创建第一个对象的时候创建方法,否则就不创建了
	if(typeof Person.flag == "undefined")
	{
		alert("invoked");
		
		Person.prototype.getInfo = function()
		{
			alert(this.username + ", " + this.password);
		}

		Person.flag = true;//方法生成一份后  就 置为true 或者 其他 非 undefined的. 修改的Peson类的flag 所以第二个对象会影响.
	}
}

var p = new Person();
var p2 = new Person();

p.getInfo();
p2.getInfo();

//继承第一种方式：对象冒充
//可以继承属性和方法
function Parent(username)
{
	this.username = username;

	this.sayHello = function()
	{
		alert(this.username);
	}
}

//username继承父类,password 子类特有
function Child(username, password)
{
	//下面三行代码是最关键的代码  把子类的属性 和方法 继承下来,这种方式可以实现多继承,
	//但是会把 后面父类的方法 替换掉前面父类的同名方法.
	this.method = Parent;//定义一个method属性,指向Parent函数的引用
	this.method(username);//给username赋值,把子类的this传递给父类的this,父类的this.username = username;变成子类的this.username = username;
	//同理 方法名也变成子类的
	delete this.method;//删除掉属性,也可以不删除

	this.password = password;//子类特有的

	this.sayWorld = function()//子类特有的
	{
		alert(this.password);
	}
}

var parent = new Parent("zhangsan");
var child = new Child("lisi", "1234");

parent.sayHello();//父类只有一个方法

child.sayHello();//子类就有两个方法
child.sayWorld();

//继承的第二种实现方式，call方法,Function对象中的方法
function test(str, str2)
{
	//this.name : 某一对象的name属性
	alert(this.name + ", " + str + ", " + str2);
}

var object = new Object();
object.name = "zhangsan";

//call是Function中的方法,因此每一个自定义函数都有call方法
//call函数: 第一个参数给this  第二个开始 逐个给参数赋值
//test.call相当于调用了test函数
test.call(object, "你好", "郭杰"); //将object赋给了this

//使用call方式实现对象的继承
function Parent(username)
{
	this.username = username;

	this.sayHello = function()
	{
		alert(username);
	}
}

function Child(username, password)
{
	Parent.call(this, username);//tihs:child对象.  这一行等于对象冒充里的3行

	this.password = password;

	this.sayWorld = function()
	{
		alert(this.password);
	}
}

var parent = new Parent("zhangsan");

var child = new Child("lisi", "123");//字符串单引号双引号都可以

parent.sayHello();

child.sayHello();
child.sayWorld();

//使用apply方法实现对象继承
function Parent(username)
{
	this.username = username;

	this.sayHello = function()
	{
		alert(this.username);
	}
}

function Child(username, password)
{
	Parent.apply(this, new Array(username));//apply和call一样定义在Function里面的,
	//child的this传给Parent 的this,则 Parent 的this就是子类的this了
	//第二个参数:以数组的形式传递过去
	//将多个参数放到数组里传递
	this.password = password;

	this.sayWorld = function()
	{
		alert(this.password);
	}
}


var parent = new Parent("zhangsan");
var child = new Child("lisi", "123");

parent.sayHello();

child.sayHello();
child.sayWorld();

//使用原型链（prototype chain）方式实现对象继承,无法传参数
//空的父对象
function Parent()
{

}
//对父对象进行扩展
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function()
{
	alert(this.hello);
}

function Child()
{

}
//继承父对象,子类的prototype指向父类对象.
//子类的prototype属性具有父类的prototype属性了
Child.prototype = new Parent();

Child.prototype.world = "world";
Child.prototype.sayWorld = function()
{
	alert(this.world);
}

var child = new Child();

child.sayHello();
child.sayWorld();

//使用混合方式实现对象继承(推荐)

function Parent(hello)
{
	this.hello = hello;
}

Parent.prototype.sayHello = function()
{
	alert(this.hello);
}

function Child(hello, world)
{
	Parent.call(this, hello);//call实现属性的继承.第一个当前对象,后面传参数,可以多个

	this.world = world;
}

Child.prototype = new Parent();//prototype实现方法的继承

Child.prototype.sayWorld = function()
{
	alert(this.world);
}

var child = new Child("hello", "world");

child.sayHello();
child.sayWorld();

//父类edge  表示有多少条边
function Shape(edge)
{
	this.edge = edge;
	this.sayEdge = function()
	{
		return this.edge;
	}
}
//附加一个方法:定义返回面积.
//高级语言中做成接口,这里返回-1,没有意义
Shape.prototype.getArea = function()
{
	return -1;
}
//附加第二个方法,拿到边数
Shape.prototype.getEdge = function()
{
	return this.edge;
}

//三角形边数固定  3
function Triangle(bottom, height)
{
	//边数变为3
	Shape.call(this, 3);

	//声明两个成员变量
	this.bottom = bottom;
	this.height = height;
}

//定义获得面积的方法.
//new Shape:继承里面所有的方法.

//重写里面获得面积的方法,不用重写拿到边数的方法
Triangle.prototype.getArea = function()
{
	return 0.5 * this.bottom * this.height;
}


//三角形的底和高
var triangle = new Triangle(10, 4);
alert(triangle.sayEdge());//没有用父类prototype附件的方法,可以不用new父类了.sayEdge  非 getEdge
alert(triangle.getArea());


//四边形
function Rectangle(bottom, height)
{
	//四边形
	Shape.call(this, 4);

	this.bottom = bottom;
	this.height = height;
}

Rectangle.prototype = new Shape();//要是父类的prototype附件的方法继承下来,必须还这么new一下.

//重写getArea方法
Rectangle.prototype.getArea = function()
{
	return this.bottom * this.height;
}
var rectangle = new Rectangle(20, 40);
alert(rectangle.getEdge());
alert(rectangle.getArea());

 function showLog(message)
 {
	 //albert 调试弊端:会跳出模态的对话框
	 //此种调试IE不支持
	 // fire bug  特有 调试用  console
	console.log(message);
	console.info(message);
	console.warn(message);
	console.error(message);
	console.debug(message);
 }

//生成对象第一种方式:生成对象 附加属性:适合临时生成对象
//prototype方法:适合对已有对象扩充方法,不适合扩展属性!!

//对象继承原理:使父对象中的this 变成子类的this
 function test(name)
 {
	showLog(name);
 }

 test("hello");