0、在Javascript中没有函数（重载）的概念
1、在js中为某个对象（控件）绑定事件通常可以采取两种手段：
1》<input type=”input” onclick=”clickHandler()”>
2> <input type=”button” id=”button1”>
<script type=”text/javascript”
Var v = document.getElementById(“button1”);
v.onclick = clickHandler;
</script>
2、有两种类型的Cookie
1>持久性Cookie，会被存储到客户端的硬盘上。
2>会话Cookie，不会存储到客户端的硬盘上，而是放在浏览器进程所处的内存当中，当浏览器关闭则该会话Cookie就销毁了。
3、在JavaScript中，函数（function）就是对象。
4、在JavaScript中有一个Function对象，所有自定义的函数都是Function对象类型的。
Function对象接收的所有参数都是字符串类型的，其中最后的一个参数就是要执行的函数体，而前面的参数则是函数真正需要接收的参数。
var add=new Function(“number”,”number1”,”alert(number + nubmer1)”);
add本身是Function函数对象的引用。
var add = new Function("m","n","var o = new Person('qqqqq','wwww');o.sayHello();");
add("qweqwe","123123");
function Person(username,password){
this.username = username;
this.password = password;
Person.prototype.sayHello = function(){
alert(this.username + " " + this.password);
}
}
5、在JavaScript中，每个函数都有一个隐含的对象arguments，表示给函数实际传递的参数。
arguments.length，length属性表示实际给函数传递的参数个数。
function add（）{
if（1 == arguments.length）{
alert（arguments[0]）；
}else if (2 == arguments.length){
alert(agruments[0] + agruments[1]);
}
}
6、 每个函数对象都有一个length属性，表示该函数期望接收的参数个数。他与函数的arguments不同，arguments表示函数实际接收的参数个数，函数名.length期望接收参数的个数。
7、JavaScript中有五种原始数据类型：Undefined，Null，Boolean，Number以及String
8、Undefined数据类型的值只有一个：undefined。
9、Null数据类型的值只有一个：null。
10、Boolean数据类型的值有两个：true和false
11、JavaScript中没有char字符数据类型，所以单引号和双引号都表示字符串数据类型
12、typeof是一元运算符，后跟变量的名称，用于获取变量的数据类型，其返回值有5个：undefined、boolean、number、string以及object。
验证变量是否为原始数据类型
var s = “hello”;//s是原始数据类型
alert(typeof s);
var s1 = new String（“123”）；//对象数据类型
alert（typeof s1）；
13、在JavaScript中，如果函数没有声明返回值，那么会返回undefined。
14、null与undefined的关系：undefined实际上是从null派生出来的。
15、强制类型转换：在JavaScript中有3中强制类型转换，Boolean（value）、Number（value）、String（value）。
var s = String(“hello”);
alert(typeof s);//string
16、在JavaScript中，对于函数中定义的变量来说，加var表示局部变量，不加var表示的是全局变量。
17、在JavaScript中，所有的对象都是从Object对象继承来的。Object中的属性是不可枚举的，因此无法通过for……in语句得到其中的属性。
var object = new Object();
for(var I in object){
alert(i);
}
alert(object.propertyIsEnumerable(“prototype”));//判断对象是否有枚举的属性。
JavaScript中最顶层的对象是window对象，浏览器窗口对象。
for(var v in window){
alert(v);//打印window的所有属性。
}
18、在Javascript中，可以动态添加对象属性，也可以动态删除对象属性。
var object = new Object();
alert(object.username);//undefined
//如果给对象添加属性并赋值共有两种方式(. 和[“”])。注意下：：：：
object.username = “shengsiyuan”;
object[“username”]=”shengsiyuan”;//有点像EL表达式。
alert(object.username);
//如果想要从对象中删除执行的属性，如下
delete object.username;//username属性从object对象中被删除。
alert(object.username);
在JavaScript中定义对象的最常见的方式，也是开发中常用的。
var object = {username : “zhangsan”,password : ”123”};
alert(object.username + object.password);
小例子：
Jquery.ajax({
url:elem.a,
aysnc:false
});
19、在JavaScript中,数组中的sort方法来说，他会将待排序的内容转换为字符串（调用toString（）方法），按照字符串的先后顺序进行排序。
var array = new Array();
array.push(1);
array.push(2);
alert(array.length);
最常用如下：
var array = [1,3,25];
array.sort();//如上说明，内部是转换为字符串排序的。
alert(array);
function compare(num,num1){
var temp = parentInt(num);
var temp1 = parentInt(num1);
if(temp < temp1){
return -1;
}else if(temp == temp1){
Return 0;
}else if(temp > temp1){
Return 2;
}
}
array.sort(compare);//排序函数对象的引用。
alert(array);
//匿名函数
function(){}
20、JavaScript中定义对象的几种方式（JavaScript中没有类得概念，只有对象）
1》基于已有对象扩充其属性和方法
var object = new Object();
object.name = "zhangsan";
object.sayName = function(name){
this.name = name;
alert(this.name);
}
object.sayName('lisi');
object.sayName(“lisi”);
2>工厂方式
}//工厂方式创建对象
function createObject(){
var object = new Object();
object.username = “zhangsan”
object.password = “123”;
object.get = function(){
alert(this.username + “,” + this.password);
}
return object;
var object1 = new Object();
var object2 = new Object();
object1.get();
让一个函数对象被多个对象所共享，而不是每个对象拥有一个函数对象
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;
}
var object = createObject("z","123");
var object2 = createObject("x","123");
object.get();
object2.get();
3》构造函数
无参数 或者 带参数
function Person(username,password){
//在执行第一行代码之前，js引擎会为我们生成一个对象
this.username=username;
this.password=password;
this.getInfo = function(){
alert(this.username + “,” + this.password);
}
//此处会有一个隐藏的return语句，用于将之前生成的对象返回。
}
4》使用Prototype(原型定义)创建对象
function Person(){
}
Person.prototype.username = “zhangsan”;
Person.prototype.password = “123”;
Person.prototype.getInfo = function(){
Alert(this.username + “,” + this.password);
}
var person = new Person();
var person1 = new Person();
person.username = “lisi”;
prson.getInfo();
prson1.getInfo();
单纯使用原型方式定义类无法在构造函数中为属性赋初值，只能在对象那个生成后再去改变属性值。
如果使用原型方式对象，那么生成的所有对象共享原型中的属性，这样一个对象改变了该属性也会反映到其他对象中。Array例子
P1 Person() username=new Array(); 共享同一个引用的值。
P2 Person() password
不错的解决方案如下：
//使用原型方式 + 构造函数方式来定义对象，每个对象之间的属性互不干扰，两个对象之间共享同一个方法。
function Person(){
this.username = new Array();
this.password = “123”;
}
Person.prototype.getInfo = function(){
alert(this.username + “,” + this.password);
}
var person = new Person();
var person1 = new Person();
person.username.push(“zhangsan”);
person.username.push(“lisi”);
person.getInfo();
person1.getInfo();
5》动态原型方式定义对象
在构造函数总通过标志量让所以对象共享一个方法，而每个对象拥有自己的属性。
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;
}
}
Var p = new Person();
Var p2 = new Person();
p.getInfo();
p2.getInfo();
21、JavaScript中的继承
1》对象冒充
function Parent(username){
this.username = username;
this.sayHello = function(){
alert(this.username);
}
}
function Child(username,password){
//下面三行代码是最关键的代码
this.method = Parent; //定义method属性，将Parent函数指定给method
this.method(username);//Parent函数中的this指的是该Child对象
delete this.method;
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();
2》call调用方式
Call方法是Function对象中的方法，因此我们定义的每个函数都拥有该方法。可以通过函数名来调用call方法，call方法的第一个参数会被传递给函数中的this，从第2个参数开始，逐一赋值给函数中的参数。
//继承的第二种方式，call方法方式，Function对象中的方法。
function test(str){
alertI(this.username + str);
}
Var o = new Object();
o.username = “zhangsan”;
test.call(o,”xxx”);
3》使用apply方式实现对象继承。
第一个参数是传入的对象，接着第二个参数传递的是数组，数组中传入参数。
4、使用原型链方式(prototype chain) 实现对象继承
无法给构造函数传递参数
function Parent(){
}
Parent.prototype.hello = “hello”
Parent.prototype.sayHello=function(){
alert(this.hello);
}
function Child(){
}
Child.prototype.world = “world”;
Child.prototype.sayWorld = function(){
alert(this.world);
}
Child.prototype = new Parent();
var child = new Child();
child.sayHello();
child.sayWorld();
5、使用混合方式实现对象继承（推荐）
function Parent(hello){
this.hello = hello;
}
Parent.prototype.sayHello = function(){
alert(this.hello);
}
function Child(hello,world){
Parent.apply(this,[hello]);
this.world = world;
}
Child.prototype = new Parent();
Child.prototype.sayWorld = function(){
alert(this.world);
}
var child = new Child("Hello","World");
child.sayHello();
child.sayWorld();