2010.03.26——javascript 01

最新推荐文章于 2022-08-09 14:04:45 发布

cody123

最新推荐文章于 2022-08-09 14:04:45 发布

阅读量102

点赞数

文章标签： JavaScript C C++ C# prototype ViewUI

本文链接：https://blog.csdn.net/cody123/article/details/83610920

版权

2010.03.26——javascript 01
参考：http://www.iteye.com/topic/19506

1.变量的作用域

<SCRIPT LANGUAGE="JavaScript">   
var x='000';   
document.writeln(x);   
a();   
function a(){   
    var x='aaa';   
 function b(){   
     document.writeln(x);   
        var x='bbb';   
  document.writeln(x);   
 }   
 b();   
    document.writeln(x);   
}   
</SCRIPT>

答案： 000 undefined bbb aaa

为什么是undefined?
要理解这个看下面这三个例子

<SCRIPT LANGUAGE="JavaScript">   
document.writeln(a);   
var a=0;   
</SCRIPT> 

<SCRIPT LANGUAGE="JavaScript">   
document.writeln(a);   
a=0;   
</SCRIPT> 

<SCRIPT LANGUAGE="JavaScript">   
document.writeln(a);   
</SCRIPT>

第一个 undefined
第二个 第三个 报错 a未定义

为什么呢？
我确信var a=0;被javascript解释器“预编译过”，至少是记录下来了。甚至把它的值设置为 undefined。
而隐式声明的变量是在顺序解释的时候才把自己定义为全局变量的。

好了来解决第一个问题
a函数里面定义的局部变量x把全局变量x覆盖了，局部变量x将作用于整个a函数里面，不管是在x定义前或者定义后的语句，在变量定义前调用局部变量，所以就输出"undefined"

2.垃圾回收 delete

<SCRIPT LANGUAGE="JavaScript">   
var o=new Object();   
o.name="zkj";   
o.age=25;   
o.bir=new Date();   
for(var key in o){   
document.writeln(key+':'+o[key]+'</br>');   
}   
document.writeln('delete o.bir</br>');   
delete o.bir;  //删除了bir属性 
for(var key in o){   
document.writeln(key+':'+o[key]+'</br>');   
}   
</SCRIPT>

3.函数的定义

a、function add(x,y){return x+y;}   
b、var add = function(x,y){return x+y;}   
c、var add = new Function("x","y","return x+y");   
d、var add =function a(x,y){return x+y;}

4.函数的参数 arguments

<SCRIPT LANGUAGE = "JavaScript" >    
  function  add(x,y)  {   
document.writeln('x = ' + x);   
document.writeln('y = ' + y);   
document.writeln('arguments[ 0 ] = ' + arguments[ 0 ]);   
document.writeln('arguments[ 1 ] = ' + arguments[ 1 ]);  
arguments[ 0 ] = 11    
document.writeln('arguments[ 0 ] = ' + arguments[ 0 ]);   
 return  x + y;   
}    
document.writeln(add( 2 , 3 ));   
 </SCRIPT>

基本你可以把arguments当成个数组使用，但并不是真正的数组，
arguments也可以看成是函数对象add的一个属性

add.arguments[0] ======arguments[0]

arguments[index]可以在函数内改变，但建议你不要在函数内改变它们

arguments.length，表示参数的个数，改值是只读的不能改变

arguments还有个属性 callee 引用当前正在执行的函数

5.函数也是一种数据类型

var add=function(x,y){return x+y;};其实我们函数的定义都是把函数附值给变量。函数不但可以附值给变量，还可以当成参数传递。

<SCRIPT LANGUAGE = "JavaScript" >    
  var  add = function (x,y)  { return  x + y;} ;   
 var  fun = add;   
 function  opetate(fun,x,y)  {   
     return  fun(x,y);;   
}    
alert(opetate(fun, 2 , 3 ));   
 </SCRIPT >

其实javascript的高手不会在全局变量里定义函数，都会定义在全局变量的属性字段中。如

<SCRIPT LANGUAGE = "JavaScript" >    
   var  MyLib =  {} ;   
 MyLib.fun1 = function ()  {alert("fafa");} ;   
 MyLib.fun2 = function ()  {} ;   
 alert(MyLib);   
 alert(MyLib.fun1);   
</SCRIPT >

6.函数的生命周期

<SCRIPT LANGUAGE="JavaScript">   
fun1();   
 alert(fun1);   
// ///把以下代码放到定义最后面可以执行。    
  fun2();  //报错 
 alert(fun2);   
 fun3();   //报错
 alert(fun3);   
  // /    
    function  fun1()  {document.writeln('fun1 run ! ');}    
   var  fun2  = function ()  {document.writeln('fun2 run ! ');} ;   
  var  fun3  = new  Function( " document.writeln('fun3 run!'); ");  
</SCRIPT>

a、javascript预编译过程（在html中， </head>前后,<body>内外有特殊情况，这指纯.js文件中）
javascript的预编译我认为是个很简单的过程，对于解释执行语言，肯定不会编译成什么中间语言。（我认为）过程如下：
首先，为执行环境（一个html也，框架环境下有几个执行环境）建立建立一个全局对象，一般客户端脚本为 window或global对象。（在这我觉得global好理解，因为浏览器会放入window总其他的属性）
然后，检查某环境中根代码块中（非函数或{}中）var关键字，把这些变量设置成global对象的属性，并附初值undefined.
如果过程中遇到直接定义的函数（fun1的定义），那么把fun1设置成global对象的属性，并附初值函数的定义（你可以把函数当成undefined,true,1,'1'等数据类型）。
b、解释执行过程
代码按照顺序执行，
一般我们把全局变量的俯值放到代码最前面，如var s="hello"; 那么把s的值用 'hello'替换预编译过程的undefined。
如果遇到变量的应用，如代码 document.writeln(a)，如果我们在global找到属性a,看a是否在前面代码俯值过，如果没有，a的值为预编译的undefined。如果是隐式变量声明，在这把它添加到global的属性中去。
如果遇到类似var fun=function(){}; 把函数当成数据赋值给变量fun.
c、函数的调用过程
你运行一下以下代码，为什么结果是 test undefined local

<SCRIPT LANGUAGE="JavaScript">   
var  s = " golbe " ;   
 function  fun(s) {   
    document.writeln(s);   
    document.writeln(a);   
     var  s = " local " ;   
     var  a = "" ;   
     return  s;   
}    
document.writeln(fun( " test " ));  
</SCRIPT>

首先：预编译代码，把s、fun设置为golbe的属性，并赋值s=undefined,fun=函数定义（可以直接调用）。

然后：按照顺序解释执行代码。赋值s="golbe"; 函数已经可以直接调用了。
执行函数：当运行到fun("test")时，开始函数调用。
(1)先为本次调用建立一个调用对象（fun-global）。
(2)预编译函数体内代码，把参数设置为fun-global的属性，值为为传值"test",即var s="test",参数就相当于局部变量，查找var，把a设置成fun-global的属性，值为undefined.(如果var s与参数名称相同，则不重复设置例如函数体内var s="local";)
(3)按照顺序执行函数内代码，当代码中遇到变量，先从调用对象属性中查找，如果找到直接使用。遇到var s="local";时，代码会覆盖调用对象中属性值（和参数名称相同）

调用对象（fun-global）是个暂时对象，生命周期很短，只有在调用过程中存在，递归可能会建立多个独立的调用对象。
javascript的函数应该和java中一样是线程安全的吧。

7.函数的属性和方法
A: length
函数的length代表函数实际需要的参数个数。

<SCRIPT LANGUAGE="JavaScript">   
function  add(x,y) {   
     var  actual = arguments.length;   
     var  expected = arguments.callee.length;  
     document.writeln("arguments.length:"+actual+"===arguments.callee.length:"+expected); 
     if (actual != expected)  {   
         throw   new  Error('函数需要' + expected + '个参数，您输入了' + actual + '个');   
    }    
     return  x + y;   
}    
alert(add( 3 , 2 ));   
alert(add( 3 , 2 , 3 ));  
</SCRIPT>

结果：arguments.length:2===arguments.callee.length:2 arguments.length:3===arguments.callee.length:2

B:prototype
这个属性引用的是预定义的原型对象，只有在new 函数名才有效。讲解对象时介绍。
C:定义自己的函数属性

<SCRIPT LANGUAGE="JavaScript">   
add.count = 0 ;  //定义add函数的静态属性 
 function  add(x,y)  {   
    add.count ++ ;   
     return  x + y;   
}    
add( 3 , 2 );   
add( 3 , 2 );   
add( 3 , 2 );   
add( 3 , 2 );   
document.writeln('共调用函数几次：' + add.count);   
</SCRIPT>

D:apply() call()方法