首页 > 代码库 > javascript基础的一些总结

javascript基础的一些总结

一 闭包

各种专业文献上的"闭包"(closure)定义非常抽象,很难看懂。我的理解是,闭包就是能够读取其他函数内部变量的函数。
由于在Javascript语言中,只有函数内部的子函数才能读取局部变量,因此可以把闭包简单理解成"定义在一个函数内部的函数"。
所以,在本质上,闭包就是将函数内部和函数外部连接起来的一座桥梁。
    function f1(){
var n=999;
function f2(){
alert(n);
}
return f2;
}
var result=f1();
result(); // 999
上一段代码中的f2函数,就是闭包。

闭包可以用在许多地方。它的最大用处有两个,一个是前面提到的可以读取函数内部的变量,另一个就是让这些变量的值始终保持在内存中:
function f1(){
var n=999;
nAdd=function(){n+=1}
function f2(){
alert(n);
}
return f2;
}
var result=f1();
result(); // 999
nAdd();
result(); // 1000

 

二 JS中函数声明与函数表达式的不同  

Js中的函数声明是指下面的形式:function functionName(){}
这样的方式来声明一个函数,而函数表达式则是类似表达式那样来声明一个函数,如:var functionName = function(){} 
看到这两一种写法时会产生疑惑,这两种写法差不多,在应用中貌似也都是可行的,那他们有什么差别呢?
事实上,js的解析器对函数声明与函数表达式并不是一视同仁地对待的。对于函数声明,js解析器会优先读取,
确保在所有代码执行之前声明已经被解析,而函数表达式,如同定义其它基本类型的变量一样,
只在执行到某一句时也会对其进行解析,所以在实际中,它们还是会有差异的,具体表现在,
当使用函数声明的形式来定义函数时,可将调用方式在函数声明之后,而后者,这样做会报错。

 

三 数值

NaN“非数值”,具有毒性,bug。typeof类型是number(这是typeof操作符最奇怪的行为之一)。

.1+.2 结果为0.30000000000000004。
利用Math.round()方法获得两位数的精度。
Math.round((.1+0.2)*100)/100 结果为0.3;

"sdxf".indexOf("x")在sdxf中出现的位置:3
"sdxf".charAt(4)在sdxf中的第4位字母是:f

类型比较:1=="1"返回true,1==="1"返回false。

变量:i=0,隐式声明,隐式声明的变量总是具有全局作用域的,即使该变量是在某个函数函数体中声明。(建议用var关键字声明,而且建议在作用域的顶部声明)
var i=0;显式声明。
var i;未初始化,包含特定的值undefined。

 

四 对象

对象:对象是属性的集合,每一个属性具有一个名称和一个值。属性可以包含除undefined外的任何类型,在创建对象之后可以对属性赋值。

实例化对象,第一种方法使用new关键字:
var myObject=new Object();
new 关键字将调用构造函数,或者更通用的说法是构造器。构造器将初始化新创建的对象。
构造函数:
function cName(name){
    alert(name);
}

var ccname=new cName("构造函数");

实例化对象,第二种方法使用字面量(这种方式创建对象更像其他语言中的散列【hash】或关联数组):
      var myObject={};
      var domArr={
             "name":"构造函数2",
             "age":myObject

         }
         var nm=domArr["name"];//可以用.,如下
         var ag=domArr.age;
         alert(nm);
         alert(ag);
        
因为属性也可以是对象,可以在任意层上嵌套对象:
var tem={ "name":{"bbo":{"uu":"h", "dd":"i"}}};
alert(tem.name.bbo.uu) 结果为 h。

javascript是一种动态语言,因此要更新一个属性,只需要重新对属性值赋值即可。要移除一个属性,只需使用delete操作符,删除不存在的属性不存在危险。

javascript使用原型继承,对象直接从其他对象继承,从而创建新的对象。简而言之,对象继承另外一个对象中的属性。因为javascript中没有类。

例如,人,javascript中是没有人这个类的,而是张三继承了李四这个人的特征【属性】(眼睛,鼻子,年龄等),形成了新的对象“张三”。

在创建新对象时,注意对象的初始化:
var object1=object2={}//引用的是同一个对象。
var object1={},object2={}//引用的不是同一个对象。

 

五 函数、闭包、变量

我们认为尽量避免使用全局变量,但有些情况是必须的,所以我们会采取一些办法避免扰乱全局名称空间。
一种办法是使用单个全局变量作为顶层对象,包含程序或框架中的所有方法和属性。安装惯例,命名空间都采用全部字母大写,但值得注意的是常量也用大写格式。
BBNN_PPO={};
BBNN_PPO.Clem={
    "name":"agele",
    "age":"5"
}
BBNN_PPO.Dem={
    "name":"Cdiny",
    "age":"4.5"
}

另外一种是采用闭包:

函数:函数是一个代码块,他封装了一系列的javascript语句。函数可以接收参数,也可以返回值。
与c#和java不同,javascript中的函数是第一类(first-class)的对象。

返回值,接参数:
function calc(x){
    return x*10;
}
alert(calc(30));
结果300。


如果函数没有返回一个特定的值,则它将返回一个undefined的值:
var x=2;
function calc()
{
    x=x*10;
}
alert(x);//结果为20
alert(calc());//结果为 undefined

函数赋值给一个变量:
var calc=function(x)
{
    return x*2;
}
alert(calc(5));//结果为 10。
给函数名使用圆括号,将执行该函数并返回函数的值,而不是返回对该函数的引用。

将函数作为参数传递给其他函数:
function demo(fn){
    alert("这是接收来的:"+fn());
    }
    demo(function(){ return "大哥哥"});
    //结果为“这是接收来的:大哥哥”

二式:
function demo(fn)
{
    alert("这是接收来的:"+fn());
}
function calc()
{
    return 2*3;
}
demo(calc);
//结果为“这是接收来的:6”

匿名函数:一个特别重要的变体就是立即调用函数表达式,或称为自执行匿名函数。
这一模式的本质是将一个函数表达式包装在一对括号中,然后立即调用该函数。
这一技巧非常简单,将函数表达式包装在一对圆括号中,将迫使javascript引擎将function(){}块识别为一个函数表达式,而不是一个函数语句的开始。

(function(x,y){
    alert(x+y);
    })(5,6);//结果为 11,最后这圆括号(5,6),可以写在前面个圆括号内

由于这一的函数表达式将被立即调用,因此该模式用于确保代码块的“执行上下文”按照预的期效果执行,这是这种模式最重要的用途之一。
通过将参数传入函数,在执行时就可以捕获函数所创建的闭包中的变量。
闭包就是这样一个函数:它处在一个函数体中,并应用了函数体当前“执行上下文”中的变量。

闭包的应用,及函数中将另外一个函数作为返回值:

    var x=24;
    alert(x);结果为:24
    var message=(function(x){
        return function(){//函数中另外一个函数作为返回值
            alert("闭包中的x是:"+x);//结果是:闭包中的x是:24
        }
    })(x);
    message();//没结果
    x=12;
    alert(x);//结果为:12
    message();//结果是:"闭包中的x是:24",无论外部作用域x的值发生什么变化,闭包将记住函数执行时变量x的值。

“执行上下文”:它是一种对象,代码在“执行上下文”环境中执行。可以通过this关键字来访问“执行上下文”,this关键字是对当前“执行上下文”对象的引用。
若代码不存在于用户自定义对象或函数中,那么它将属于“全局上下文”。
在javascript中,没有定义具体“上下文”的函数,将把它们的this关键词的值绑定为undefined值。
alert(this);//[object DOMWindow]

eval函数setTimeout函数具有自己独立的“执行上下文”。

在开始执行一个函数或方法时,javascript创建了一个新的“执行上下文”并进入该函数的“执行上下文”,当函数执行完毕并返回时,控制权将交给原来的“执行上下文”。
在创建闭包时当前“上下文”将保留下来,否则当前“上下文”将被当着垃圾收集。

作用域和闭包:
讨论作用域时,考虑定义变量的位置和变量的生存期非常重要。作用域是指在什么地方可以使用该变量。
在javascript中,作用域维持在函数级别,而不是块级别。因此,参数以及使用var关键字定义的变量,仅在当前函数中可见。

嵌套函数:除了不能访问this关键字和参数之外,嵌套函数可以访问外部函数中定义的变量。这一机制是通过闭包来实现的,它指的是:即使在外部函数解释执行之后,内部嵌套函数继续保持它对外部函数的引用。闭包还有助于简绍名称空间的冲突。
每次调用一个包裹(enclosed)的函数时,虽然函数的代码并每月改变,但是javascript将为每一次调用创建一个新的作用域。
function getCom(value){
           return function(value){
            return value;
           }
        }
        var a=getCom(),b=getCom(),c=getCom();
        alert(a(0));//结果为 0 ,每一次调用都创建新的作用域
        alert(b(1));//结果为 1
        alert(c(2));//结果为 2
        alert(a===b);//false;
        });

当定义一个独立函数(没有绑定任何对象)时,this关键字绑定与全局名称空间。
作为一个最直接的结果,当在一个方法内创建一个函数时,内部函数的关键字this将绑定与全局名称空间,而不是绑定该方法。
为了解决这个问题,可以将包裹方法的this关键字简单地赋值给一个名为that的中间变量。
var     obj={};
        obj.mathod=function(){
            var that=this;
            this.counter=0;
            var count=function(){
                that.counter+=1;
                alert(that.counter);//上层函数定义的值传不进来
            }
            count();//结果为 1;
            count();//结果为 2;
            alert(this.counter);//当没有调用到内部函数时,值为0;现在值为2
        }
        obj.mathod();
(个人理解:一个小偷,一个叫花子,都想吃到食物(内心世界=内部函数),小偷进入主人家(家=外部函数),但却找不到食物(食物=外部函数变量),叫花子侧在家门口(外部函数之外)乞讨,却得到了食物(函数变量),所以小偷想获得食物必须迂回到外部方能求得食物)

在javascript中并没有官方的访问级别语法,javascript没有类似于java语言中的private或protected这样的访问级别关键字。默认情况下,对象中的成员都是共有和可访问的。但在javascript中可以实现与私有或公有属性类似的访问级别效果。要实现私有方法或属性,请使用闭包:
function reTun(){
            var chaer="狠狠不如意";//私有

            this.oo=function(){//闭包
                return chaer;//公有
            }
        }
        var dem=new reTun();
        alert(dem.chaer);//undefined
        alert(dem.oo());//狠狠不如意

        this.oo()是函数reTun的专有方法,它可以访问reTun中的私有成员。另外chaer变量是“私有”的,他的值只能通过专有方法进行访问


使用模块:与私有和专有访问级别类似,在javascript中没有内置的包语法。模块模式是一种常用的编码模式

TTMMOON={};// 创建名称空间
TTMMOON.teme=(function(){//函数表达式
    var destion="",molde="",fulle="";//私有成员
    //公有访问方法
    return{
        //设置器
        setDestion:function(dest){
            this.destion=dest;
        },
        setModl:function(mold){
            this.molde=mold;
        },
        setFulle:function(full){
            this.fulle=full;
        },
        //访问器
        getDestion:function(){
           return this.destion;
        },
        getModl:function(){
           return this.molde;
        },
        getFulle:function(){
           return this.fulle;
        },
        //其他成员
        toString:function(){
            alert(this.getModl()+"-嗨,中国"+this.getFulle()+"-谢谢您们!"+this.getDestion());
        }
        //在这里执行初始化过程
    }
}());
var myTimeus=TTMMOON.teme;
myTimeus.setModl("我叫joy,");
myTimeus.setFulle(",我很开心");
myTimeus.setDestion("我会回来的。");
myTimeus.toString();

});

 

六、数据类型、javascript实践

 

扩展类型:
javascript支持将方法和其他属性绑定到内置类型,比如字符串、数值和数组类型。与其他任何对象类似,String对象也具有prototype属性。开发人员可以为String对象扩充一些便利的方法。例如,String没有将字符串false或true转换为布尔值的方法。
可以用下面的代码为String对象添加该功能:
String.ptrototype.boolean=function()
        {
            return "true"==this;
        };
        var t=‘true‘.boolean();
        var f=‘false‘.boolean();
        alert(t);//ture
        alert(f);//false

简化二:
Function.prototype.mathod=function(name,func)
{
    this.prototype[name]=func;
    return false;
}
String.mathod("boolean",function(){
    return "true"==this;
})
"true".boolean();//true

javascript的最佳实践:

1、使用parseInt()函数将字符串转换为整数,但确保总是指定基数。更好的办法是使用一元操作符(+)将字符串转化为数值:
Good:parseInt("010",10);//转化为十进制
Better:+"010";//高效

2、是用等同(===)操作符来比较两个值,避免意料之外的类型转换。
类型比较:1=="1"返回true,1==="1"返回false。

3、在定义对象字面量时,在最后一个值的结尾不要使用逗号:
var obj={
            name : "any",
            age : "20"
        }

4、不要使用with语句。
5、在循环中创建函数应该谨慎小心,这种方式非常低效。
6、eval()函数可以接受一个字符串,并将其视为javascript代码执行。应该限制eval()函数的使用,它很容易在代码中引入各种各样严重的安全问题。
7、使用分号作为语句的结尾,当精简代码时特别有用。
8、应该避免使用全局变量。应该总是使用var关键字来声明变量。将代码包裹在匿名函数中,避免命名冲突,请使用模块来组织代码。
9、对函数名使用首字母大写表示该函数将作为new操作符的构造函数,但请不要对其他任何函数的函数名使用首字母大写。

javascript基础的一些总结