理解 JavaScript 作用域和作用域链

JavaScript 开发进阶:理解 JavaScript 作用域和作用域链
原网址
  作用域是JavaScript最重要的概念之一,想要学好JavaScript就需要理解JavaScript作用域和作用域链的工作原理。今天这篇文章对JavaScript作用域和作用域链作简单的介绍,希望能帮助大家更好的学习JavaScript。

JavaScript作用域

  任何程序设计语言都有作用域的概念,简单的说,作用域就是变量与函数的可访问范围,即作用域控制着变量与函数的可见性和生命周期。在JavaScript中,变量的作用域有全局作用域和局部作用域两种。

  1. 全局作用域(Global Scope)
  在代码中任何地方都能访问到的对象拥有全局作用域,一般来说以下几种情形拥有全局作用域:

  (1)最外层函数和在最外层函数外面定义的变量拥有全局作用域,例如:

var authorName=”山边小溪”;
function doSomething(){
var blogName=”梦想天空”;
function innerSay(){
alert(blogName);
}
innerSay();
}
alert(authorName); //山边小溪
alert(blogName); //脚本错误
doSomething(); //梦想天空
innerSay() //脚本错误
  (2)所有末定义直接赋值的变量自动声明为拥有全局作用域,例如:

function doSomething(){
var authorName=”山边小溪”;
blogName=”梦想天空”;
alert(authorName);
}
doSomething(); //山边小溪
alert(blogName); //梦想天空
alert(authorName); //脚本错误
  变量blogName拥有全局作用域,而authorName在函数外部无法访问到。

  (3)所有window对象的属性拥有全局作用域

  一般情况下,window对象的内置属性都拥有全局作用域,例如window.name、window.location、window.top等等。

  1. 局部作用域(Local Scope)  
  和全局作用域相反,局部作用域一般只在固定的代码片段内可访问到,最常见的例如函数内部,所有在一些地方也会看到有人把这种作用域称为函数作用域,例如下列代码中的blogName和函数innerSay都只拥有局部作用域。

function doSomething(){
var blogName=”梦想天空”;
function innerSay(){
alert(blogName);
}
innerSay();
}
alert(blogName); //脚本错误
innerSay(); //脚本错误
作用域链(Scope Chain)

  在JavaScript中,函数也是对象,实际上,JavaScript里一切都是对象。函数对象和其它对象一样,拥有可以通过代码访问的属性和一系列仅供JavaScript引擎访问的内部属性。其中一个内部属性是[[Scope]],由ECMA-262标准第三版定义,该内部属性包含了函数被创建的作用域中对象的集合,这个集合被称为函数的作用域链,它决定了哪些数据能被函数访问。

  当一个函数创建后,它的作用域链会被创建此函数的作用域中可访问的数据对象填充。例如定义下面这样一个函数:

function add(num1,num2) {
var sum = num1 + num2;
return sum;
}
  在函数add创建时,它的作用域链中会填入一个全局对象,该全局对象包含了所有全局变量,如下图所示(注意:图片只例举了全部变量中的一部分):

 函数add的作用域将会在执行时用到。例如执行如下代码:

1
var total = add(5,10);
  执行此函数时会创建一个称为“运行期上下文(execution context)”的内部对象,运行期上下文定义了函数执行时的环境。每个运行期上下文都有自己的作用域链,用于标识符解析,当运行期上下文被创建时,而它的作用域链初始化为当前运行函数的[[Scope]]所包含的对象。

  这些值按照它们出现在函数中的顺序被复制到运行期上下文的作用域链中。它们共同组成了一个新的对象,叫“活动对象(activation object)”,该对象包含了函数的所有局部变量、命名参数、参数集合以及this,然后此对象会被推入作用域链的前端,当运行期上下文被销毁,活动对象也随之销毁。新的作用域链如下图所示:

在函数执行过程中,没遇到一个变量,都会经历一次标识符解析过程以决定从哪里获取和存储数据。该过程从作用域链头部,也就是从活动对象开始搜索,查找同名的标识符,如果找到了就使用这个标识符对应的变量,如果没找到继续搜索作用域链中的下一个对象,如果搜索完所有对象都未找到,则认为该标识符未定义。函数执行过程中,每个标识符都要经历这样的搜索过程。

作用域链和代码优化

  从作用域链的结构可以看出,在运行期上下文的作用域链中,标识符所在的位置越深,读写速度就会越慢。如上图所示,因为全局变量总是存在于运行期上下文作用域链的最末端,因此在标识符解析的时候,查找全局变量是最慢的。所以,在编写代码的时候应尽量少使用全局变量,尽可能使用局部变量。一个好的经验法则是:如果一个跨作用域的对象被引用了一次以上,则先把它存储到局部变量里再使用。例如下面的代码:

function changeColor(){
document.getElementById(“btnChange”).onclick=function(){
document.getElementById(“targetCanvas”).style.backgroundColor=”red”;
};
}
  这个函数引用了两次全局变量document,查找该变量必须遍历整个作用域链,直到最后在全局对象中才能找到。这段代码可以重写如下:

function changeColor(){
var doc=document;
doc.getElementById(“btnChange”).onclick=function(){
doc.getElementById(“targetCanvas”).style.backgroundColor=”red”;
};
}
  这段代码比较简单,重写后不会显示出巨大的性能提升,但是如果程序中有大量的全局变量被从反复访问,那么重写后的代码性能会有显著改善。

改变作用域链

  函数每次执行时对应的运行期上下文都是独一无二的,所以多次调用同一个函数就会导致创建多个运行期上下文,当函数执行完毕,执行上下文会被销毁。每一个运行期上下文都和一个作用域链关联。一般情况下,在运行期上下文运行的过程中,其作用域链只会被 with 语句和 catch 语句影响。

  with语句是对象的快捷应用方式,用来避免书写重复代码。例如:

function initUI(){
with(document){
var bd=body,
links=getElementsByTagName(“a”),
i=0,
len=links.length;
while(i < len){
update(links[i++]);
}
getElementById(“btnInit”).onclick=function(){
doSomething();
};
}
}
  这里使用width语句来避免多次书写document,看上去更高效,实际上产生了性能问题。

  当代码运行到with语句时,运行期上下文的作用域链临时被改变了。一个新的可变对象被创建,它包含了参数指定的对象的所有属性。这个对象将被推入作用域链的头部,这意味着函数的所有局部变量现在处于第二个作用域链对象中,因此访问代价更高了。如下图所示:

因此在程序中应避免使用with语句,在这个例子中,只要简单的把document存储在一个局部变量中就可以提升性能。

  另外一个会改变作用域链的是try-catch语句中的catch语句。当try代码块中发生错误时,执行过程会跳转到catch语句,然后把异常对象推入一个可变对象并置于作用域的头部。在catch代码块内部,函数的所有局部变量将会被放在第二个作用域链对象中。示例代码:

try{
doSomething();
}catch(ex){
alert(ex.message); //作用域链在此处改变
}
  请注意,一旦catch语句执行完毕,作用域链机会返回到之前的状态。try-catch语句在代码调试和异常处理中非常有用,因此不建议完全避免。你可以通过优化代码来减少catch语句对性能的影响。一个很好的模式是将错误委托给一个函数处理,例如:

try{
doSomething();
}catch(ex){
handleError(ex); //委托给处理器方法
}
  优化后的代码,handleError方法是catch子句中唯一执行的代码。该函数接收异常对象作为参数,这样你可以更加灵活和统一的处理错误。由于只执行一条语句,且没有局部变量的访问,作用域链的临时改变就不会影响代码性能了。


参考资料

  1. High.Performance.JavaScript, Nicholas.C.Zakas

  2. Explaining JavaScript Scope And Closures, Robert Nyman

  3. ECMAScript Language Specification, bclary.com

instanceof 运算符深入剖析

JavaScript instanceof 运算符深入剖析-转载

随着 web 的发展,越来越多的产品功能都放在前端进行实现,增强用户体验。而前端开发的主要语言则是 JavaScript。学好 JavaScript 对开发前端应用已经越来越重要。在开发复杂产品中,需要使用面向对象的机制时,往往会用到复杂的 JavaScript 继承,而 instanceof 运算符是 JavaScript 语言中原生的用来判断实例继承关系的操作符。深入理解 instanceof 运算符的用法,对写好复杂的 JavaScript 程序,会有很大帮助。
2 评论
姜 俊杰, 软件工程师, IBM
2013 年 6 月 06 日
expand
内容

在 IBM Bluemix 云平台上开发并部署您的下一个应用。
开始您的试用
instanceof 运算符简介
在 JavaScript 中,判断一个变量的类型尝尝会用 typeof 运算符,在使用 typeof 运算符时采用引用类型存储值会出现一个问题,无论引用的是什么类型的对象,它都返回 “object”。ECMAScript 引入了另一个 Java 运算符 instanceof 来解决这个问题。instanceof 运算符与 typeof 运算符相似,用于识别正在处理的对象的类型。与 typeof 方法不同的是,instanceof 方法要求开发者明确地确认对象为某特定类型。例如:
清单 1. instanceof 示例
var oStringObject = new String(“hello world”);
console.log(oStringObject instanceof String); // 输出 “true”
这段代码问的是“变量 oStringObject 是否为 String 对象的实例?”oStringObject 的确是 String 对象的实例,因此结果是”true”。尽管不像 typeof 方法那样灵活,但是在 typeof 方法返回 “object” 的情况下,instanceof 方法还是很有用的。
instanceof 运算符的常规用法
通常来讲,使用 instanceof 就是判断一个实例是否属于某种类型。例如:
清单 2. instanceof 常规用法
// 判断 foo 是否是 Foo 类的实例
function Foo(){}
var foo = new Foo();
console.log(foo instanceof Foo)//true
另外,更重的一点是 instanceof 可以在继承关系中用来判断一个实例是否属于它的父类型。例如:
清单 3. instanceof 在继承中关系中的用法
// 判断 foo 是否是 Foo 类的实例 , 并且是否是其父类型的实例
function Aoo(){}
function Foo(){}
Foo.prototype = new Aoo();//JavaScript 原型继承

var foo = new Foo();
console.log(foo instanceof Foo)//true
console.log(foo instanceof Aoo)//true
上面的代码中是判断了一层继承关系中的父类,在多层继承关系中,instanceof 运算符同样适用。
你真的了解 instanceof 操作符吗?
看了上面的代码示例,是不是觉得 instanceof 操作符很简单,下面来看点复杂的用法。
清单 4. instanceof 复杂用法
console.log(Object instanceof Object);//true
console.log(Function instanceof Function);//true
console.log(Number instanceof Number);//false
console.log(String instanceof String);//false

console.log(Function instanceof Object);//true

console.log(Foo instanceof Function);//true
console.log(Foo instanceof Foo);//false
看了上面的代码是不是又晕头转向了?为什么 Object 和 Function instanceof 自己等于 true,而其他类 instanceof 自己却又不等于 true 呢?如何解释?要想从根本上了解 instanceof 的奥秘,需要从两个方面着手:1,语言规范中是如何定义这个运算符的。2,JavaScript 原型继承机制。
回页首
详细剖析 ECMAScript-262 edition 3 中 instanceof 运算符的定义
语言规范对中 instanceof 运算符的定义如下:
清单 5. 规范中 instanceof 运算符定义
11.8.6 The instanceof operator
The production RelationalExpression:
RelationalExpression instanceof ShiftExpression is evaluated as follows:

  1. Evaluate RelationalExpression.
  2. Call GetValue(Result(1)).// 调用 GetValue 方法得到 Result(1) 的值,设为 Result(2)
  3. Evaluate ShiftExpression.
  4. Call GetValue(Result(3)).// 同理,这里设为 Result(4)
  5. If Result(4) is not an object, throw a TypeError exception.// 如果 Result(4) 不是 object,
    //抛出异常
    
    / 如果 Result(4) 没有 [[HasInstance]] 方法,抛出异常。规范中的所有 [[…]] 方法或者属性都是内部的,
    在 JavaScript 中不能直接使用。并且规范中说明,只有 Function 对象实现了 [[HasInstance]] 方法。
    所以这里可以简单的理解为:如果 Result(4) 不是 Function 对象,抛出异常
    /
  6. If Result(4) does not have a [[HasInstance]] method,
    throw a TypeError exception.
    // 相当于这样调用:Result(4).[HasInstance])
  7. Call the [[HasInstance]] method of Result(4) with parameter Result(2).
  8. Return Result(7).

    // 相关的 HasInstance 方法定义
    15.3.5.3 [[HasInstance]] (V)
    Assume F is a Function object.// 这里 F 就是上面的 Result(4),V 是 Result(2)
    When the [[HasInstance]] method of F is called with value V,
    the following steps are taken:

  9. If V is not an object, return false.// 如果 V 不是 object,直接返回 false
  10. Call the [[Get]] method of F with property name “prototype”.// 用 [[Get]] 方法取
    // F 的 prototype 属性
    
  11. Let O be Result(2).//O = F.[Get]
  12. If O is not an object, throw a TypeError exception.
  13. Let V be the value of the [[Prototype]] property of V.//V = V.[[Prototype]]
  14. If V is null, return false.
    // 这里是关键,如果 O 和 V 引用的是同一个对象,则返回 true;否则,到 Step 8 返回 Step 5 继续循环
  15. If O and V refer to the same object or if they refer to objects
    joined to each other (section 13.1.2), return true.
  16. Go to step 5.
    上面的规范定义很晦涩,而且看起来比较复杂,涉及到很多概念,但把这段规范翻译成 JavaScript 代码却很简单,如下:
    清单 6. JavaScript instanceof 运算符代码
    function instance_of(L, R) {//L 表示左表达式,R 表示右表达式
    var O = R.prototype;// 取 R 的显示原型
    L = L.proto;// 取 L 的隐式原型
    while (true) {
    if (L === null)
    return false;
    if (O === L)// 这里重点:当 O 严格等于 L 时,返回 true
    return true;
    L = L.proto;
    }
    }
    回页首
    JavaScript 原型继承机制
    由于本文主要集中在剖析 JavaScript instanceof 运算符,所以对于 JavaScript 的原型继承机制不再做详细的讲解,下面参考来自 http://www.mollypages.org/misc/js.mp 的一张图片,此图片详细的描述了 JavaScript 各种对象的显示和隐式原型链结构。
    由其本文涉及显示原型和隐式原型,所以下面对这两个概念作一下简单说明。在 JavaScript 原型继承结构里面,规范中用 [[Prototype]] 表示对象隐式的原型,在 JavaScript 中用 proto 表示,并且在 Firefox 和 Chrome 浏览器中是可以访问得到这个属性的,但是 IE 下不行。所有 JavaScript 对象都有 proto 属性,但只有 Object.prototype.proto 为 null,前提是没有在 Firefox 或者 Chrome 下修改过这个属性。这个属性指向它的原型对象。 至于显示的原型,在 JavaScript 里用 prototype 属性表示,这个是 JavaScript 原型继承的基础知识,在这里就不在叙述了。

    图 1. JavaScript 原型链
    JavaScript 原型链
    回页首
    讲解 instanceof 复杂用法
    有了上面 instanceof 运算符的 JavaScript 代码和原型继承图,再来理解 instanceof 运算符将易如反掌。下面将详细讲解 Object instanceof Object,Function instanceof Function 和 Foo instanceof Foo 三个示例,其它示例读者可自行推演。
    清单 7. Object instanceof Object
    // 为了方便表述,首先区分左侧表达式和右侧表达式
    ObjectL = Object, ObjectR = Object;
    // 下面根据规范逐步推演
    O = ObjectR.prototype = Object.prototype
    L = ObjectL.proto = Function.prototype
    // 第一次判断
    O != L
    // 循环查找 L 是否还有 proto
    L = Function.prototype.proto = Object.prototype
    // 第二次判断
    O == L
    // 返回 true
    清单 8. Function instanceof Function
    // 为了方便表述,首先区分左侧表达式和右侧表达式
    FunctionL = Function, FunctionR = Function;
    // 下面根据规范逐步推演
    O = FunctionR.prototype = Function.prototype
    L = FunctionL.proto = Function.prototype
    // 第一次判断
    O == L
    // 返回 true
    清单 9. Foo instanceof Foo
    // 为了方便表述,首先区分左侧表达式和右侧表达式
    FooL = Foo, FooR = Foo;
    // 下面根据规范逐步推演
    O = FooR.prototype = Foo.prototype
    L = FooL.proto = Function.prototype
    // 第一次判断
    O != L
    // 循环再次查找 L 是否还有 proto
    L = Function.prototype.proto = Object.prototype
    // 第二次判断
    O != L
    // 再次循环查找 L 是否还有 proto
    L = Object.prototype.proto = null
    // 第三次判断
    L == null
    // 返回 false
    回页首
    简析 instanceof 在 Dojo 继承机制中的应用
    在 JavaScript 中,是没有多重继承这个概念的,就像 Java 一样。但在 Dojo 中使用 declare 声明类时,是允许继承自多个类的。下面以 Dojo 1.6.1 为例。
    清单 10. Dojo 中多重继承
    dojo.declare(“Aoo”,null,{});
    dojo.declare(“Boo”,null,{});
    dojo.declare(“Foo”,[Aoo,Boo],{});

    var foo = new Foo();
    console.log(foo instanceof Aoo);//true
    console.log(foo instanceof Boo);//false

    console.log(foo.isInstanceOf(Aoo));//true
    console.log(foo.isInstanceOf(Boo));//true
    上面的示例中,Foo 同时继承自 Aoo 和 Boo,但当使用 instanceof 运算符来检查 foo 是否是 Boo 的实例时,返回的是 false。实际上,在 Dojo 的内部,Foo 仍然只继承自 Aoo,而通过 mixin 机制把 Boo 类中的方法和属性拷贝到 Foo 中,所以当用 instanceof 运算符来检查是否是 Boo 的实例时,会返回 false。所以 Dojo 为每个类的实例添加了一个新的方法叫 isInstanceOf,用这个方法来检查多重继承。
    结束语
    本文详细介绍了 JavaScript 语言中 instanceof 运算符,并且结合语言规范深入剖析了此操作符的算法。对读者使用 JavaScript 编写复杂的面向对象程序会有很大的帮助。本文所有代码在 Firefox 15 下通过测试。
    参考资料
    学习
    关于 Dojo,请参考 Dojo 官方网站
    developerWorks Web development 专区:通过专门关于 Web 技术的文章和教程,扩展您在网站开发方面的技能。
    developerWorks Ajax 资源中心:这是有关 Ajax 编程模型信息的一站式中心,包括很多文档、教程、论坛、blog、wiki 和新闻。任何 Ajax 的新信息都能在这里找到。
    developerWorks Web 2.0 资源中心,这是有关 Web 2.0 相关信息的一站式中心,包括大量 Web 2.0 技术文章、教程、下载和相关技术资源。

判断js函数是不是存在typeof

判断js函数是不是存在typeof 【转载】

判断js函数是否存在typeof

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
//*==============================================================================*/
//* Ajax加载 */
//* 语法:var objLoad=new AjaxLoad() */
//* objLoad.Loading(doAction,dataNode[,dataType[,callback[,fullShow]]]); */
//* */
//* 参 数: */
//* -doAction[必需的] 执行 URL */
//* -dataNode[必需的] 显示获取内容的容器 ID */
//* -dataType[可选的] 数据类别[text|xml|body],缺省值 text */
//* -callback[可选的] 输出函数[函数对 像] */
//* -fullShow[可选的] 显示模式: 缺省值false-单块模式,true-全屏模式 */
//* */
//* */
//* 输出函数 [callback]: */
//* 可自定义输出函数来格式化所获取的数据,其格式请参加页尾objPrint()函数 */
//* */
//*==============================================================================*/
/*此处调用Charset.vbs来解决当dataType='body'时,xmlHttp.responseBody产生的乱码问题 */
/*请保证Charset.vbs文件与本文件存放在同一路径当中 */
var charsetPath=document.getElementsByTagName("script")[document.getElementsByTagName("script").length-1].src.split("?")[0];
charsetPath=charsetPath.replace("Ajax_Load.js","Charset.vbs");
document.write("<script type=\"text/vbscript\" src=\""+charsetPath+"\"></scr"+"ipt>");
//*==============================================================================*/
//* AjaxLoad begin */
//*==============================================================================*/
function AjaxLoad(){
/*初始化Ajax */
function InitAjax(){
var Ajax=false;
/*Microsoft*/
try {
Ajax = new ActiveXObject("Msxml2.XMLHTTP");
} catch (e) {
try {
Ajax = new ActiveXObject("Microsoft.XMLHTTP");
} catch (E) {
Ajax = false;
}
}/*Mozilla*/
if (!Ajax && typeof Ajax!='undefined') {
Ajax = new XMLHttpRequest();
}
return Ajax;
}
/*---------------------------------------*/
/* 判断函数或对像是否存在 一定要添加try catch块,否则不起作用 */
/*---------------------------------------*/
function objExists(objName){
try{
if(typeof eval(objName)=="undefined"){return false;}
if(typeof eval(objName)=="object"){return true;}
}catch(e){
return false;
}
}
function funExists(funName){
try{
if(typeof eval(funName)=="undefined"){return false;}
if(typeof eval(funName)=="function"){return true;}
}catch(e){
return false;
}
}
/*-----------------------------------*/
var fullShow=false;
var doAction="";
var dataType="text";
var callback=null;
var dataNode=null;
var objAjax = new InitAjax();
this.Loading=function(_doAction,_dataNode,_dataType,_callback,_fullShow){
try{
doAction=_doAction;
dataType=_dataType;
callback=_callback;
dataNode=document.getElementById(_dataNode);
/**/
if(!dataNode){alert("参数错误,请输入正确的ID");return false;}
if(!_fullShow){fullShow=false;}else{fullShow=true; }
objAjax.open("GET",doAction, true);
objAjax.onreadystatechange = function(){handleStateChange();};
objAjax.setRequestHeader("Accept-charset","gb2312");
objAjax.setRequestHeader("If-Modified-Since","0"); //禁止缓存
objAjax.send(null);
}catch(e){
}
}
function handleStateChange(){
if (objAjax.readyState == 4 && objAjax.status == 200) {
try{
var data=getData(dataType,objAjax);
if(objExists(callback)){
data=eval(callback+"("+data+");");
}
dataNode.innerHTML = data;
}catch(e){
alert(e)
}
}else{
var outString="";
if(!fullShow){
/*Loading, please wait……|在此处设置显示样式*/
outString+="<div style='color: #FF0000;font-size: 10pt;'>正在加载,请稍候……</div>";
dataNode.innerHTML = outString;
}else{
outString+="<!-- load start -->";
outString+="<div id='load' style='position:absolute;z-index:10;top:expression(body.clientHeight/2-60);left:expression(body.clientWidth/2-110); height:120px;width:220px;margin-right: auto;margin-left: auto;text-align: center;color: #FF0000;font-size: 10pt;padding: 5px;line-height: 20px;background-color: #FFFFFF;border-top-width: 1px;border-right-width: 2px;border-bottom-width: 2px;border-left-width: 1px;border-top-style: inset;border-right-style: outset; border-bottom-style: outset;border-left-style: inset;border-top-color: #ECE9D8; border-right-color: #ECE9D8;border-bottom-color: #ECE9D8;border-left-color: #ECE9D8;'>";
outString+=" <div id='loadLogo' style='margin-top: 30px;margin-right: auto;margin-bottom: 20px;margin-left: auto;'><img src='Images/Wait.gif' width='32' height='32' /></div>";
outString+=" <div id='loadTitle' style=''>Loading, please wait……</div> ";
outString+="</div>";
outString+="<div id='loadMask' style='position:absolute;z-index:1; top:0;left:0; width:expression(body.clientWidth); height:expression(body.clientHeight);background:#999999;filter:Alpha(opacity=60);'></div>";
outString+="<!-- load end -->";
dataNode.innerHTML = outString;
}
}
}
function getData(dataType,xmlHttp){
if(dataType=="xml"){
return xmlHttp.responseXML;
}else if(dataType=="body"){
/*Bytes2Bstr在Charset.vbs中*/
return Bytes2Bstr(xmlHttp.responseBody);
}else if(dataType=="stream"){
return xmlHttp.responseStream;
}else{
return xmlHttp.responseText;
}
}
/*-----------------------------------*/
}
/*===========================================================================*/
/* AjaxLoad end */
/*===========================================================================*/
/*Charset.vbs文件内容:
'编码处理函数:解决XMLHTTP返回的中文乱码处理
Function Bytes2Bstr(bodyStr)
strReturn = ""
For i = 1 To LenB(bodyStr)
ThisCharCode = AscB(MidB(bodyStr,i,1))
If ThisCharCode < &H80 Then
strReturn = strReturn & Chr(ThisCharCode)
Else
NextCharCode = AscB(MidB(bodyStr,i+1,1))
strReturn = strReturn & Chr(CLng(ThisCharCode) * &H100 + CInt(NextCharCode))
i = i + 1
End If
Next
Bytes2Bstr = strReturn
End Function
*/
/*---------------------------------------*/
/* 输出函数格式如下 */
/*---------------------------------------*/
function objPrint(){
/*在此处格式化数据后,再返回格式化了的数据*/
//alert("执行了格式化哟")
return data;
}


判断父页面函数是否存在
if(typeof(opener.showLicenceList)=='object'){

}

instanceof与typeof

JS中typeof与instanceof的区别 查看原网页转载▼

JavaScript 中 typeof 和 instanceof 常用来判断一个变量是否为空,或者是什么类型的。但它们之间还是有区别的:
typeof
typeof 是一个一元运算,放在一个运算数之前,运算数可以是任意类型。
它返回值是一个字符串,该字符串说明运算数的类型。typeof 一般只能返回如下几个结果:
number,boolean,string,function,object,undefined。我们可以使用 typeof 来获取一个变量是否存在,如 if(typeof a!=”undefined”){alert(“ok”)},而不要去使用 if(a) 因为如果 a 不存在(未声明)则会出错,对于 Array,Null 等特殊对象使用 typeof 一律返回 object,这正是 typeof 的局限性。
网上的一个小例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<script language="javascript" type="text/javascript">
document.write ("typeof(1): "+typeof(1)+"<br>");
document.write ("typeof(NaN): "+typeof(NaN)+"<br>");
document.write ("typeof(Number.MIN_VALUE): "+typeof(Number.MIN_VALUE)+"<br>");
document.write ("typeof(Infinity): "+typeof(Infinity)+"<br>");
document.write ("typeof(\"123\"): "+typeof("123")+"<br>");
document.write ("typeof(true): "+typeof(true)+"<br>");
document.write ("typeof(window): "+typeof(window)+"<br>");
document.write ("typeof(Array()): "+typeof(new Array())+"<br>");
document.write ("typeof(function(){}): "+typeof(function(){})+"<br>");
document.write ("typeof(document): "+typeof(document)+"<br>");
document.write ("typeof(null): "+typeof(null)+"<br>");
document.write ("typeof(eval): "+typeof(eval)+"<br>");
document.write ("typeof(Date): "+typeof(Date)+"<br>");
document.write ("typeof(sss): "+typeof(sss)+"<br>");
document.write ("typeof(undefined): "+typeof(undefined)+"<br>")
</script>
<title>javascript类型测试</title>
</head>

<body>
</body>
</html>

查看效果

instanceof
instance:实例,例子
a instanceof b?alert(“true”):alert(“false”); //a是b的实例?真:假
instanceof 用于判断一个变量是否某个对象的实例,如 var a=new Array();alert(a instanceof Array); 会返回 true,同时 alert(a instanceof Object) 也会返回 true;这是因为 Array 是 object 的子类。再如:function test(){};var a=new test();alert(a instanceof test) 会返回
谈到 instanceof 我们要多插入一个问题,就是 function 的 arguments,我们大家也许都认为 arguments 是一个 Array,但如果使用 instaceof 去测试会发现 arguments 不是一个 Array 对象,尽管看起来很像。
另外:
测试 var a=new Array();if (a instanceof Object) alert(‘Y’);else alert(‘N’);
得’Y’
但 if (window instanceof Object) alert(‘Y’);else alert(‘N’);
得’N’
所以,这里的 instanceof 测试的 object 是指 js 语法中的 object,不是指 dom 模型对象。
使用 typeof 会有些区别
alert(typeof(window)) 会得 object

instanceof和typeof的区别

javascript instanceof,typeof的区别

区分string 与 String的[区别

为什么结果会是false呢?
代码如下:

1
2
3
4
5
<script type="text/javascript"> 
var aColors = ["red", "green", "blue"];
alert(typeof aColors[0]); //output "string"
alert(aColors[0] instanceof String); //output "false";
</script>

你要区分string 与 String的区别
aColors[0] 是 string值类型, 当然不是String的实例啦。参考下面代码

1
2
3
4
var aColors = ["red", "green", "blue"]; 
aColors[0]= new String("1")
alert(typeof aColors[0]); //output "Object"
alert(aColors[0] instanceof String); //output "true";

更多可以参考下面的文章:

instanceof 运算符
返回一个 Boolean 值,指出对象是否是特定类的一个实例。

result = object instanceof class

参数
result
必选项。任意变量。
object
必选项。任意对象表达式。
class
必选项。任意已定义的对象类。

  • 说明:
    如果 object 是 class 的一个实例,则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例,或者 object 是 null,则返回 false。
    示例
    下面的例子举例说明了 instanceof 运算符的用法。
    代码如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    function objTest(obj){ 
    var i, t, s = ""; // 创建变量。
    t = new Array(); // 创建一个数组。
    t["Date"] = Date; // 填充数组。
    t["Object"] = Object;
    t["Array"] = Array;
    for (i in t)
    {
    if (obj instanceof t[i]) // 检查 obj 的类。
    {
    s += "obj is an instance of " + i + "\n";
    }
    else
    {
    s += "obj is not an instance of " + i + "\n";
    }
    }
    return(s); // 返回字符串。
    }
    var obj = new Date();
    document.write(objTest(obj));
  • instanceof和typeof都能用来判断一个变量是否为空或是什么类型的变量。

  • typeof用以获取一个变量的类型,typeof一般只能返回如下几个结果:number,boolean,string,function,object,undefined。我们可以使用typeof来获取一个变量是否存在,如if(typeof a!=”undefined”){},而不要去使用if(a)因为如果a不存在(未声明)则会出错,对于Array,Null等特殊对象使用typeof 一律返回object,这正是typeof的局限性。

  • 如果我们希望获取一个对象是否是数组,或判断某个变量是否是某个对象的实例则要选择使用instanceof。instanceof用于判断一个变量是否某个对象的实例,如var a=new Array();alert(a instanceof Array);会返回true,同时alert(a instanceof Object)也会返回true;这是因为Array是object的子类。再如:function test(){};var a=new test();alert(a instanceof test)会返回true。

  • 谈到instanceof我们要多插入一个问题,就是function的arguments,我们大家也许都认为arguments是一个Array,但如果使用instaceof去测试会发现arguments不是一个Array对象,尽管看起来很像。

另外:
测试 var a=new Array();if (a instanceof Object) alert(‘Y’);else alert(‘N’);
得’Y’
但 if (window instanceof Object) alert(‘Y’);else alert(‘N’);
得’N’

所以,这里的instanceof测试的object是指js语法中的object,不是指dom模型对象。
使用typeof会有些区别
alert(typeof(window) 会得 object

年轻的时候,先少废话,多做事。

回调函数的概念及其使用

回调函数的概念及其使用,出处
1 什么是回调
软件模块之间总是存在着一定的接口,从调用方式上,可以把他们分为三类:同步调用、回调和异步调用。同步调用是一种阻塞式调用,调用方要等待对方执行完毕才返回,它是一种单向调用;回调是一种双向调用模式,也就是说,被调用方在接口被调用时也会调用对方的接口;异步调用是一种类似消息或事件的机制,不过它的调用方向刚好相反,接口的服务在收到某种讯息或发生某种事件时,会主动通知客户方(即调用客户方的接口)。回调和异步调用的关系非常紧密,通常我们使用回调来实现异步消息的注册,通过异步调用来实现消息的通知。同步调用是三者当中最简单的,而回调又常常是异步调用的基础,因此,下面我们着重讨论回调机制在不同软件架构中的实现。

对于不同类型的语言(如结构化语言和对象语言)、平台(Win32、JDK)或构架(CORBA、DCOM、WebService),客户和服务的交互除了同步方式以外,都需要具备一定的异步通知机制,让服务方(或接口提供方)在某些情况下能够主动通知客户,而回调是实现异步的一个最简捷的途径。

对于一般的结构化语言,可以通过回调函数来实现回调。回调函数也是一个函数或过程,不过它是一个由调用方自己实现,供被调用方使用的特殊函数。

在面向对象的语言中,回调则是通过接口或抽象类来实现的,我们把实现这种接口的类成为回调类,回调类的对象成为回调对象。对于象C++或Object Pascal这些兼容了过程特性的对象语言,不仅提供了回调对象、回调方法等特性,也能兼容过程语言的回调函数机制。

Windows平台的消息机制也可以看作是回调的一种应用,我们通过系统提供的接口注册消息处理函数(即回调函数),从而实现接收、处理消息的目的。由于Windows平台的API是用C语言来构建的,我们可以认为它也是回调函数的一个特例。

对于分布式组件代理体系CORBA,异步处理有多种方式,如回调、事件服务、通知服务等。事件服务和通知服务是CORBA用来处理异步消息的标准服务,他们主要负责消息的处理、派发、维护等工作。对一些简单的异步处理过程,我们可以通过回调机制来实现。

下面我们集中比较具有代表性的语言(C、Object Pascal)和架构(CORBA)来分析回调的实现方式、具体作用等。

2 过程语言中的回调(C)

2.1 函数指针

回调在C语言中是通过函数指针来实现的,通过将回调函数的地址传给被调函数从而实现回调。因此,要实现回调,必须首先定义函数指针,请看下面的例子:

void Func(char s);// 函数原型
void (
pFunc) (char *);//函数指针

可以看出,函数的定义和函数指针的定义非常类似。

一般的化,为了简化函数指针类型的变量定义,提高程序的可读性,我们需要把函数指针类型自定义一下。

typedef void(pcb)(char );

回调函数可以象普通函数一样被程序调用,但是只有它被当作参数传递给被调函数时才能称作回调函数。

被调函数的例子:

void GetCallBack(pcb callback)
{
/do something/
}
用户在调用上面的函数时,需要自己实现一个pcb类型的回调函数:
void fCallback(char s)
{
/
do something */
}
然后,就可以直接把fCallback当作一个变量传递给GetCallBack,
GetCallBack(fCallback);

如果赋了不同的值给该参数,那么调用者将调用不同地址的函数。赋值可以发生在运行时,这样使你能实现动态绑定。

回页首

2.2 参数传递规则

到目前为止,我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中,可以在函数类型前加_cdecl,_stdcall或者_pascal来表示其调用规范(默认为_cdecl)。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名,参数传递的顺序(从右到左或从左到右),堆栈清理责任(调用者或者被调用者)以及参数传递机制(堆栈,CPU寄存器等)。

将调用规范看成是函数类型的一部分是很重要的;不能用不兼容的调用规范将地址赋值给函数指针。例如:

// 被调用函数是以int为参数,以int为返回值
__stdcall int callee(int);

// 调用函数以函数指针为参数
void caller( __cdecl int(*ptr)(int));

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错

指针p和callee()的类型不兼容,因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p,尽管两者有相同的返回值和参数列

2.3 应用举例

C语言的标准库函数中很多地方就采用了回调函数来让用户定制处理过程。如常用的快速排序函数、二分搜索函数等。

快速排序函数原型:

void qsort(void base, size_t nelem, size_t width, int (_USERENTRY fcmp)(const void , const void ));
二分搜索函数原型:
void bsearch(const void key, const void base, size_t nelem,
size_t width, int (_USERENTRY
fcmp)(const void , const void ));

其中fcmp就是一个回调函数的变量。

下面给出一个具体的例子:

#include

#include

int sort_function( const void a, const void b);
int list[5] = { 54, 21, 11, 67, 22 };

int main(void)
{
int x;

qsort((void *)list, 5, sizeof(list[0]), sort_function);
for (x = 0; x < 5; x++)
printf(“%i\n”, list[x]);
return 0;
}

int sort_function( const void a, const void b)
{
return (int)a-(int)b;
}

2.4 面向对象语言中的回调(Delphi)

Dephi与C++一样,为了保持与过程语言Pascal的兼容性,它在引入面向对象机制的同时,保留了以前的结构化特性。因此,对回调的实现,也有两种截然不同的模式,一种是结构化的函数回调模式,一种是面向对象的接口模式。

2.4.1 回调函数

回调函数类型定义:

type
TCalcFunc=function (a:integer;b:integer):integer;

按照回调函数的格式自定义函数的实现,如

function Add(a:integer;b:integer):integer
begin
result:=a+b;
end;
function Sub(a:integer;b:integer):integer
begin
result:=a-b;
end;

回调的使用

function Calc(calc:TcalcFunc;a:integer;b:integer):integer

下面,我们就可以在我们的程序里按照需要调用这两个函数了

c:=calc(add,a,b);//c=a+b
c:=calc(sub,a,b);//c=a-b

2.4.2 回调对象

什么叫回调对象呢,它具体用在哪些场合?首先,让我们把它与回调函数对比一下,回调函数是一个定义了函数的原型,函数体则交由第三方来实现的一种动态应用模式。要实现一个回调函数,我们必须明确知道几点:该函数需要那些参数,返回什么类型的值。同样,一个回调对象也是一个定义了对象接口,但是没有具体实现的抽象类(即接口)。要实现一个回调对象,我们必须知道:它需要实现哪些方法,每个方法中有哪些参数,该方法需要放回什么值。

因此,在回调对象这种应用模式中,我们会用到接口。接口可以理解成一个定义好了但是没有实现的类,它只能通过继承的方式被别的类实现。Delphi中的接口和COM接口类似,所有的接口都继承与IInterface(等同于IUnknow),并且要实现三个基本的方法QueryInterface, _AddRef, 和_Release。

定义一个接口

type IShape=interface(IInterface)
procedure Draw;
end

实现回调类

type TRect=class(TObject,IShape)
protected
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
public
procedure Draw;
end;

type TRound=class(TObject,IShape)
protected
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
public
procedure Draw;
end;

使用回调对象

procedure MyDraw(shape:IShape);
var
shape:IShape;
begin
shape.Draw;
end;

如果传入的对象为TRect,那么画矩形;如果为TRound,那么就为圆形。用户也可以按照自己的意图来实现IShape接口,画出自己的图形:

MyDraw(Trect.Create);
MyDraw(Tround.Create);

2.4.3 回调方法

回调方法(Callback Method)可以看作是回调对象的一部分,Delphi对windows消息的封装就采用了回调方法这个概念。在有些场合,我们不需要按照给定的要求实现整个对象,而只要实现其中的一个方法就可以了,这是我们就会用到回调方法。

回调方法的定义如下:

TNotifyEvent = procedure(Sender: TObject) of object;
TMyEvent=procedure(Sender:Tobject;EventId:Integer) of object;

TNotifyEvent 是Delphi中最常用的回调方法,窗体、控件的很多事件,如单击事件、关闭事件等都是采用了TnotifyEvent。回调方法的变量一般通过事件属性的方式来定义,如TCustomForm的创建事件的定义:

property OnCreate: TNotifyEvent read FOnCreate write FOnCreate stored IsForm;

我们通过给事件属性变量赋值就可以定制事件处理器。

用户定义对象(包含回调方法的对象):

type TCallback=Class
procedure ClickFunc(sender:TObject);
end;
procedure Tcallback.ClickFunc(sender:TObject);
begin
showmessage(‘the caller is clicked!’);
end;

窗体对象:

type TCustomFrm=class(TForm)
public
procedure RegisterClickFunc(cb:procedure(sender:Tobject) of object);
end;

procedure TcustomFrm..RegisterClickFunc(cb:TNotifyEvent);
begin
self.OnClick=cb;
end;

使用方法:

var
frm:TcustomFrm;
begin
frm:=TcustomFrm.Create(Application);
frm.RegisterClickFunc(Tcallback.Create().ClickFunc);
end;

3 回调在分布式计算中的应用(CORBA)

3.1 回调接口模型

CORBA的消息传递机制有很多种,比如回调接口、事件服务和通知服务等。回调接口的原理很简单,CORBA客户和服务器都具有双重角色,即充当服务器也是客户客户。

回调接口的反向调用与正向调用往往是同时进行的,如果服务端多次调用该回调接口,那么这个回调接口就变成异步接口了。因此,回调接口在CORBA中常常充当事件注册的用途,客户端调用该注册函数时,客户函数就是回调函数,在此后的调用中,由于不需要客户端的主动参与,该函数就是实现了一种异步机制。

从CORBA规范我们知道,一个CORBA接口在服务端和客户端有不同的表现形式,在客户端一般使用桩(Stub)文件,服务端则用到框架(Skeleton)文件,接口的规格采用IDL来定义。而回调函数的引入,使得服务端和客户端都需要实现一定的桩和框架。下面是回调接口的实现模型:

3.1.1 范例

下面给出了一个使用回调的接口文件,服务端需要实现Server接口的框架,客户端需要实现CallBack的框架:

module cb
{
interface CallBack;
interface Server;

interface CallBack
{
void OnEvent(in long Source,in long msg);
};
interface Server
{
long RegisterCB(in CallBack cb);
void UnRegisterCB(in long hCb);
};
};

客户端首先通过同步方式调用服务端的接口RegistCB,用来注册回调接口CallBack。服务端收到该请求以后,就会保留该接口引用,如果发生某种事件需要向客户端通知的时候就通过该引用调用客户方的OnEvent函数,以便对方及时处理。

分类: 程序设计

js中typeof介绍

转载

  • 经常会在js里用到数组,比如 多个名字相同的input, 若是动态生成的, 提交时就需要判断其是否是数组.

if(document.mylist.length != “undefined” ) {} 这个用法有误.

正确的是 if( typeof(document.mylist.length) != “undefined” ) {}

或 if( !isNaN(document.mylist.length) ) {}

typeof的运算数未定义,返回的就是 “undefined”.

运算数为数字 typeof(x) = “number”

字符串 typeof(x) = “string”

布尔值 typeof(x) = “boolean”

对象,数组和null typeof(x) = “object”

函数 typeof(x) = “function”

typeof 运算符返回一个用来表示表达式的数据类型的字符串。
可能的字符串有:”number”、”string”、”boolean”、”object”、”function” 和 “undefined”。
如:
alert(typeof (123));//typeof(123)返回”number”
alert(typeof (“123”));//typeof(“123”)返回”string”

  • typeof 运算符
    返回一个用来表示表达式的数据类型的字符串。

typeof[()expression[]] ;

expression 参数是需要查找类型信息的任意表达式。

说明
typeof 运算符把类型信息当作字符串返回。typeof 返回值有六种可能: “number,” “string,” “boolean,” “object,” “function,” 和 “undefined.”

typeof 语法中的圆括号是可选项。

js产生undefined的情况

js 产生undefined的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
<script type="text/javascript">
var outObj = {
type :"java"
}
function innerM(){
var p;
alert(p);//undefined
alert("k:"+k);//error--innerObj未定义
alert(outObj.jack);//undefined
alert(innerObj.jack);//error--innerObj未定义
}

innerM();

</script>

<script type="text/javascript">
alert(typeof(false) === 'boolean'); //true
alert(typeof(0) === 'number'); //true
alert(typeof("") === 'string'); //true
alert(typeof(null) === 'object'); //true
alert(typeof undefined === 'undefined'); //true
</script>

<script type="text/javascript">
alert(false == undefined); //false
alert(false == null); //false
alert(false == 0); //true
alert(false == ""); //true
alert(null == undefined); //true
</script>

<script type="text/javascript">
alert(false.toString()); // "false"
alert("".charAt(0)); // ""
alert((0).toExponential(10)); // 0.0000000e+0
alert(undefined.toString()); // throw exception "undefined has no properties"
alert(null.toString()); // "null has no properties"
</script>


<script type="text/javascript">
alert(String(false)); // "false"
alert(String("")); // ""
alert(String(0)); // 0.0000000e+0
alert(String(undefined)); // "undefined"
alert(String(null)); // "null"

alert(decodeURI(undefined));// "undefined"
alert(decodeURI(null));// "null"
</script>


<script type="text/javascript">
//假值和空值作为if条件分支
//假值和空值有一个共性,那就是在 作为if的条件分支时,均被视为false ;应用"!"操作之后得到的均为true。
//这是因为,这几个对象均被视为各自类型中的无效值或空值。因此if分支中这些对象均被视为false对待。如下示例代码:
var ar = [undefined,false,0,"",null];
for(var i = 0,len = ar.length; i < len; i++){
if(ar[i]){
alert("你不应该看到此对话框!");
}
}
</script>


<script type="text/javascript">
//undefined和null对象无非是两个特殊对象,undefined表示无效对象,null表示空对象。
//如果变量显式或者隐式(由Javascript引擎进行赋值)地被赋予了undefined,
//那么代表了此变量未被定义,如果被赋予null值,则代表此变量被初始化为空值。
//在Javascript中,变量是通过var声明,=赋值符进行定义(初始化变量所指向的对象)。
//当然,如果声明一个全局变量(作为window属性)可以不使用var关键字。变量可以在声明的同时进行定义。
//变量如果声明了但是没有初始化,那么Javascript引擎会将此变量自动指向undefined对象。
//这里需要注意,我们在上面引用window.abcd时,弹出的是undefined;而直接引用abcd变量时,却抛出了一个异常。
//这是由于Javascript引擎对于没有显式指定对象链的变量,会尝试从最近的作用域开始查找变量,
//查找失败,则退到父级作用链进行查找。如果均查找失败,则抛出"变量未定义"的异常。

var undefinedVariable,nullVariable = null;
alert(undefinedVariable); // "undefined"
alert(window.undefinedVariable); // "undefined"
alert(window.abcd); // "undefined"
alert(nullVariable); // "null"
alert(abcd); // throw exception "abcd is not defined"
</script>

<script type="text/javascript">
//这两个值在进行数字运算的时候也有不同。
alert(1+undefined); // "NaN"
alert(1+null); // "1"
</script>

<script type="text/javascript">
alert("!undefined......" + (!undefined));
alert("undefined==false......" + (undefined==false));
</script>

alert与console.log区别

简单的说alert 是弹出提示而console.log是在调试工具里打日志,下面具体给大家列出alert()与console.log()的不同点,
[1]alert()

[1.1]有阻塞作用,不点击确定,后续代码无法继续执行
[1.2]alert()只能输出string,如果alert输出的是对象会自动调用toString()方法
e.g. alert([1,2,3]);//‘1,2,3’
[1.3]alert不支持多个参数的写法,只能输出第一个值
e.g. alert(1,2,3);//1

[2]console.log()

[2.1]在打印台输出
[2.2]可以打印任何类型的数据
e.g. console.log([1,2,3]);//[1,2,3]
[2.3]支持多个参数的写法
e.g. console.log(1,2,3)// 1 2 3

原型链中toString()方法输出alert()和console.log()得到不同的结果

1
2
3
4
5
6
7
8
<script type="text/javascript">
var a = [1,2,3];
alert(a); //1,2,3
Array.prototype.toString = function(){
return 'str';
}
alert(a); //str
</script>


1
2
3
4
5
6
7
8
<script type="text/javascript">
var a = [1,2,3];
console.log(a); //[1,2,3]
Array.prototype.toString = function(){
return 'str';
}
console.log(a); //[1,2,3]
</script>

上面的代码输出的结果不一样的原因如下:
console.log() 可以打印任何类型的数据。而 alert() 只能输出string,如果alert输出是对象会自动调用 toString() 方法。如果想 console.log() 输出的与alert相同,需要调用 toString() :

console.log(obj. toString() );

和自己写不写toString()完全没有关系,你自己写的那个toStrong() 只是重写了对象默认的toString()方法。
如果你没有重写toString()方法时,alert() 也会调用默认的。
还是那句话: console.log() 可以打印任何类型的数据,并会因为你自己重写了toString(),而调用。如果log() 也只能打印string的话,那么console 的这个log 方法就没有存在的必要了。
主要是俩个函数所期望的数据类型不一样。alert()期望的数据类型是string型的。这就是相当于要把对象用在string语境中,自然就会做出相应的转换。console.log()显然是可以接受任何类型的数据。那他就不用转换。也就是说不用放在string语境中。那OBJ自然是他一开始的数据类型。

使用border图形效果的综合运用

记录一个使用border图形效果的综合运用

记录一个小应用,我在开发中也经常碰到的,很多的小细节。先上一个效果图。

看起来就是常见的网页菜单运用。这里要说明的是,两边的小红色三角形,也是用css来写的。

原理也简单,只是以前没用过,设置一个宽高都为0像素的标签,但是有border,如果将各个边的border设置成不同的颜色,可能会出现如下的现象。

比如上图就是一个上下border为黑色,左右border为红色的标签,样式为:width:0; height:0;border:20px solid black; border-left-color:red; border-right-color:red;

理解了这个,左边的小红三角就好做了,整个border为白色,左边的border为红色就可以了。这是第一个技巧,具体样式为:

1
2
3
4
5
6
7
8
9
10
11
12
13
.bor{
width:0;
height:0;
border:8px solid #fff;
display: block;
position: absolute;
top:7px;
overflow: hidden;
}
.wrap a:hover .bor-left{
border-left-color:red;
left:5px;
}

对于两个三角,采用了绝对定位。

这里记录下另外一个小技巧,也是开发中常常遇到的。

在给一个标签加hover样式的时候,如果hover时加了边框,会出现轻微的抖动的现象,这是因为加了边框后,原有标签所占的空间增大,挤到了相邻的标签。


为了预防这种抖动,可以对hover前的标签加白色边框,这样在hover的时候,只需要改变边框的颜色,而不会改变边框的大小,这样就不会产生抖动的现象了。

转载的地址

,