对象是由 new 运算符加上要实例化的对象的名字创建的。例如，下面的代码创建 Object 对象的实例：
var obj = new Object();
alert(typeof obj); //object
alert(typeof Object); //function
对创建对象的函数的引用（指针）。对于 Object 对象，该指针指向原始的 Object() 函数。
对该对象的对象原型的引用。对于所有的对象，它默认返回 Object 对象的一个实例。 Object 对象还具有几个方法：
判断对象是否有某个特定的属性。必须用字符串指定该属性。（例如，o.hasOwnProperty("name")）
判断该对象是否为另一个对象的原型。
判断给定的属性是否可以用 for...in 语句进行枚举。
返回对象的原始字符串表示。对于 Object 对象，ECMA-262 没有定义这个值，所以不同的 ECMAScript 实现具有不同的值。
返回最适合该对象的原始值。对于许多对象，该方法返回的值都与 ToString() 的返回值相同。
Object 对象中的所有属性和方法都会出现在其他对象中，所以理解了 Object 对象，就可以更好地理解其他对象。
>javascript 中所有对象已经自动被做了引用
所有的全局函数都是 Global 对象中的方法，
// Global.isNaN(); // 不用明确指定 isNan();
在javascript中函数就是类
//第一种方式
function fn1()
{
alert('test1');
}
//第二种方式 匿名函数，一个表达式
var n = function() {};
a=function(b){};
a(b);
//等同于
(function(b){})(b) //匿名函数立即执行
直到函数真正运行后才能调用
function fun2()
{
//arguments对象，是一个数组，可以解析出参数
alert(arguments[1]);
for (var i = 0; i<arguments.length; i++) {
alert(arguments[i]);
}
}
fun2(1,2,3);
//算出n的阶乘
function digui(n) {
return n ? n*digui(n-1) : 1;
}
//另一种写法
//arguments.callee 调用自身
function digui(n) {
return n ? n*arguments.callee(n-1) : 1;
}
digui(2);
function fun4(a, b, c) {
}
//length 属性
fun4.length
//caller属性 必须在函数内部调用，读取谁调用了我
function func5() {
alert(arguments.callee.caller);
}
function fun6() {
func5();
}
fun6(); //输出 函数fun6,因为 fun6调用了它
不被计算的变量函数，也就是说，函数可以使用函数之外使用的变量
//一个简单的闭包
var ms = '我是全局变量';
function msg()
{
alert(ms);
}
msg();
function test1() {
function test2() {
alert('外面访问不到我');
}
}
test2(); 报错；可以理解为局部变量
//复杂的闭包调用
function each() {
var i = 0;
for (; i < 10; i++) {}
function inner() {alert(i);}
return inner;
}
var fn = each();
fn(); //10
//闭包内存泄露写法
function each() {
var i = 0, inner, a = [];
for (; i < 10 ; i++) {
//注意这里调用10次cache()
cache(i);
}
function cache(abc) {
a.push(function(){
alert(abc);
});
}
return a;
}
//比较好的写法
function each() {
var i = 0;a=[];
for(;i<10;i++) {
a.push(function() {alert(i);});
}
return a;
}
//一大好处，暂存之后再处理,见一下代码实例
function fntest(num1, num2) {
return function() {
//复杂的计算
alert("num1+num2结果为" + (num1+num2));
}
}
//这里保存下来
var result = fnTest(23, 24);
var a = false;
//经过很多处理来更改a的值。。。。。。。
//我用它的时候再进行调用，不用的时候不调用
if (a) {
result();
}
var fun = function fun1() {
}
alert(fun); //function
//可以理解为构造函数
alert(new fun()); //object 变成了对象
//构造函数特点
//不要使用 return
所有全局变量都是window对象的属性
function demo(name, age) {
this.name = name;
this.age=age;
alert(this);
}
demo(); //this指向window
new demo() //自动创建一个对象，this指向本对象
var obj = {};
obj.name = "mtao";
obj.method = demo;
obj.method(); //this执行obj对象
构造函数A的prototype属性是一个对象 这个对象具有的所有属性，A的实例也具有
function Demo() {};
var d = new Demo();
// Demo.prototype={
// name: 'mtao'
// };
// alert(d.name); //undefined
Demo.prototype.name = 'mtao';
alert(d.name); //mtao
简单继承
function fun1()
{
this.name = 'mtao';
}
function fun2()
{
}
fun2.prototype = new fun1();
var fun = new fun2();
alert(fun.name); //mtao
改变this指针
function fun1()
{
this.name = 'mtao';
}
var o = {};
o.fun = fun1;
o.fun();
alert(o.name);
等同于
//这里用call 方法写
function fun1(a, b) {
this.name = 'mtao';
}
var o = {};
fun1.call(o, '1', '2');
//call(this指向的对象，...函数的参数)
fun1.apply(o, [1,2]);
//apply(this指向的对象，...数组参数)
alert(o.name);
//object 是所有类的根，是最基本的对象
alert(Demo instanceof Object);
// Array
// String
// Number
// Boolean
//RegExp
//它们都是Object对象的子类
Object.prototype.name = "mtao";
alert([].name);
alert('sdf'.name);
alert(/a/.name);
//它们都自动具有了name属性
//给String对象加了一个trim方法
String.prototype.trim = function()
{
return this.replace(/^\s+/, '').replace(/\s+$/, '');
}
var x = ' sd dfg ';
alert('|'+x.trim()+'|');
//arguments 继承数组join方法
function msg() {
//用call来调用
alert([].join.call(arguments, '\n'));
}
msg('adf', 12, 32, 14);
函数方法覆盖
var fn = new Object();
Object.prototype.toString = function() {
alert('ddd');
};
alert("" + fn);
var str = new String();
alert(str instanceof String);
var a = [];
alert(a instanceof Array); //判断是不是数组构造函数的
//isPrototypeOf 判断prototype是不是某个对象的
alert
>相关的信息存储在对象的能力
//闭包模拟私有
function demo(name, age)
{
this.name = name;
this.age = age;
this.getName = function()
{
return name;
};
this.getAge = function()
{
return age;
};
this.setName = function(n)
{
name=n;
};
this.setAge = function(a)
{
age=a;
};
}
把一个对象存储在另一个对象的能力
>由另一个类得来类的属性和方法的能力
>编写能以多种方法运行的函数或方法的能力
//arguments 运用
...................................