1.定义理解

目录：

1.基本类型
2.Function函数
3.this
4.call与apply
5.块
6.闭包
7.对象
8.类
9.原型对象
10.单体模式

1.基本类型

number、string、boolean、object、function、undefined

Number

    var num1 = 10 ;
    var num2 = 10.5 ;
    var num3 = .6 ;        // 0.6
    var num4 = 070 ;    // 八进制 56
    var num5 = 1/0 ;    // 正无穷
    var num6 = window.parseInt("dasdsdsadsad");        //NaN not a number

 

String

   单双引号表示的字符串

 

Boolean

   true、false

 

Object

    var date = new Date();
    var arr  = new Array();
    var obj  = {name:'bjsxt' , age:10};//json

 

Undefined

    //Undefined 变量声明了 但是并没有被赋值  其实也等同于Null
    var a ;
    alert(a);
    alert(undefined == null); //true  三个等号即判断类型又判断数据
    alert(typeof null);    //表示的就是一个空对象的引用 object

 

function

    function fun(){
        console.info('fun...');
    }
　　fun表示引用；fun();表示调用
　　alert(typeof fun);//function

 

 

2.Function函数

1: function语句形式

fun1();//javascript解释器 直接回去找 , 其他的代码就从上到下顺序执行,因此可以在定义之前进行调用

function fun1(){  
    alert('fun1...');
};

 

2: 函数直接量的形式

var fun2 = function(){//fun2();必须放在声明之后
    alert('fun2...');
};

 

3: 构造函数形式

var fun3 = new Function('x','y','return x+y;');  //具有顶级作用域
alert(fun3(10,20));//30

 

var k = 1 ;
function test(){
    var k = 2 ;
    //创建三种方式的函数:
    //function f(){return k;};//2
    //var f = function(){return k;};//2
    var f = new Function('return k;');//1  ,无论在哪里new都相当于在最顶层进行new，去全局变量
    alert(f());
};
test();

 

arguments对象

第一个作用:接受函数的实际参数

arguments对象:每一个函数内部都有一个arguments对象
function test(x,y){
    alert(arguments.length);        // len = 3
    alert(arguments[2]);            // val = 3
};
test(1,2,3);

 

第二个作用: 通常用于递归操作 

// arguments.callee 表示引用当前函数本身
function fact(number){
    if(number <= 1){
        return 1 ;
    } else {
        return number*arguments.callee(number-1);
    }
};
//alert(fact(5));
var fact2 = fact ;//引用赋值给变量
fact = null ;
alert(fact2(5));

 

3.this

This 关键字 在javascript里的使用
this关键字总是指向调用者，谁调用函数，this就指向谁
直接调用函数，则this是window

var x = 5; // window.x = 5 ;
function test() {
alert(this.x);
};
alert(test.x);
window.test();

4.call与apply

call apply 主要作用是绑定作用域

var color = 'red';
var obj = {
color : 'yellow'
};
function showColor(x, y, z) {
alert(x + y + z);
alert(this.color);
};
// call、apply 绑定一个函数 ，到你指定的作用域内执行，区别apply的参数是数组
showColor.call(obj, 10, 20, 30);//color = 'yellow'赋值
showColor.call(window, 10, 20, 30);// color = 'red'赋值
showColor.apply(obj, [2, 3, 4]);

 

5.块

js中的块是指一个函数整体，因为变量回收是按照函数执行完以后进行回收

如想在函数中实现块的划分可以使用匿名函数(function(){})(); 

不使用匿名函数

function test(){
for(var i = 1 ;i <=5 ; i++){
alert(i);
}    
alert(i);//会显示i=6
};

 使用匿名函数

function test(){
(function(){
for(var i = 1 ;i <=5 ; i++){
　　alert(i);
}    
})();
　　alert(i);//提示错误未定义
};
test();

 

6.闭包

闭包 ：执行环境、作用域链、js垃圾回收
函数碰到return直接返回、没有renturn 返回结果undefined
在javascript语言里: 更不提倡使用全局变量 (1：不安全、2：做变量搜索查找的时候效率比较低)

function test(){
return function(){
alert('我是闭包体代码...');
};
};
var f = test(); // 获取对象，使用对象调用函数，由于函数没有名称则f()进行调用
alert(typeof f);//function
f();//可以直接调用

function test(){
var temp = 10 ;
return function(){
alert(temp);
};
};
test()();//保留了test()的局部变量temp因为内部function中调用；避免使用全局变量 

闭包使用

var inp = (function(){
    var i = 0;
    return {
        getCount:function(){
            alert(++i);
        }
    };
})();

inp.getCount();
inp.getCount();
inp.getCount();
inp.getCount();

 7.对象

    //var obj = new Object();等同于 var obj={};
    var obj = {name:'z3' ,sex:'女', age:20};    //json对象
    obj.sex = '男';        //新增属性
    obj.age = 25 ;        //修改属性的值
    delete obj.name ;    //删除对象的属性或方法，无法删除对象可使用obj={}
    
    //枚举对象内置属性的循环
    for( var attr in obj){
        alert(attr + " : " + obj[attr]);
    }}

 

 8.类

Ext.onReady(function(){
//定义了一个js的类
    var Person = function(name , age){
        this.name = name ; 
        this.age  = age ;
        // private 
        var _sex = '男';    //js的私有属性
        this.getSex = function(){
            return _sex ;            
        };
        this.setSex = function(sex){
            _sex = sex ;
        };
    };
    //扩展类
    Person.prototype.id = 10 ;   //添加属性id
    Person.prototype.method = function(){ //添加方法method
        alert(this.age);
    };
    //实例化对象
    var p=new Person();
    
});

 

 9.原型对象

原型对象的构造器 总是指向当前对象的模板，可以灵活扩展类对象

Ext.onReady(function(){
//定义了一个js的类
    var Person = function(name , age){
        this.name = name ; 
        this.age  = age ;
        // private 
        var _sex = '男';    //js的私有属性
        this.getSex = function(){
            return _sex ;            
        };
        this.setSex = function(sex){
            _sex = sex ;
        };
    };
    //原型对象的构造器 总是指向当前对象的模板
    Person.prototype = {
        constructor:Person ,
        id:10 , 
        method : function(){
            alert('method....');
        } 
    };    
    //实例化对象
    var p=new Person();
});

 

 10.单体模式

简单单体

Ext.onReady(function(){
    var SXT = {}; //从无到有
    SXT.Array = {
        each:function(){
            alert('each....');
        },
        filter:function(){
            alert('filter...');
        }
    };
    SXT.staticMethod = function(){ //静态方法添加
        alert('我是单体下的静态方法！');
    };
    
    SXT.Array.each();
    SXT.staticMethod();
});

 

 闭包单体

    var SXT = (function(){
        var Array = {
            each:function(){
                alert('each...');
            }
        };
        return {
            arrayEach:function(){
                Array.each();
            }
        };
    })();
    SXT.arrayEach();