JQuery的extend扩展方法:
Jquery的扩展方法extend是我们在写插件的过程中常用的方法,该方法有一些重载原型,在此,我们一起去了解了解。
 一、Jquery的扩展方法原型是:

 extend(dest,src1,src2,src3...);

它的含义是将src1,src2,src3…合并到dest中,返回值为合并后的dest,由此可以看出该方法合并后,是修改了dest的结构的。如果想要得到合并的结果却又不想修改dest的结构,可以如下使用:

  var newSrc=$.extend({},src1,src2,src3...)//也就是将"{}"作为dest参数。

这样就可以将src1,src2,src3…进行合并,然后将合并结果返回给newSrc了。如下例:

var result=$.extend({},{name:"Tom",age:21},{name:"Jerry",sex:"Boy"})

 

那么合并后的结果

  result={name:"Jerry",age:21,sex:"Boy"}

也就是说后面的参数如果和前面的参数存在相同的名称,那么后面的会覆盖前面的参数值。

二、省略dest参数
上述的extend方法原型中的dest参数是可以省略的,如果省略了,则该方法就只能有一个src参数,而且是将该src合并到调用extend方法的对象中去,如:
1、$.extend(src)
   该方法就是将src合并到jquery的全局对象中去,如:

 $.extend({
  hello:function(){alert('hello');}
  });

就是将hello方法合并到jquery的全局对象中。
2、$.fn.extend(src)
该方法将src合并到jquery的实例对象中去,如:

 $.fn.extend({
  hello:function(){alert('hello');}
 });

 

就是将hello方法合并到jquery的实例对象中。

下面例举几个常用的扩展实例:

$.extend({net:{}});

 

这是在jquery全局对象中扩展一个net命名空间。

  $.extend($.net,{
   hello:function(){alert('hello');}
  })

这是将hello方法扩展到之前扩展的Jquery的net命名空间中去。

三、Jquery的extend方法还有一个重载原型:

extend(boolean,dest,src1,src2,src3...)

第一个参数boolean代表是否进行深度拷贝,其余参数和前面介绍的一致,什么叫深层拷贝,我们看一个例子:

var result=$.extend( true,  {},
    { name: "John", location: {city: "Boston",county:"USA"} },
    { last: "Resig", location: {state: "MA",county:"China"} } );

我们可以看出src1中嵌套子对象location:{city:”Boston”},src2中也嵌套子对象location:{state:”MA”},第一个深度拷贝参数为true,那么合并后的结果就是:

result={name:"John",last:"Resig",
        location:{city:"Boston",state:"MA",county:"China"}}

 

也就是说它会将src中的嵌套子对象也进行合并,而如果第一个参数boolean为false,我们看看合并的结果是什么,如下:

var result=$.extend( false, {},
{ name: "John", location:{city: "Boston",county:"USA"} },
{ last: "Resig", location: {state: "MA",county:"China"} }
                    );

那么合并后的结果就是:

  result={name:"John",last:"Resig",location:{state:"MA",county:"China"}}

 

以上就是$.extend()在项目中经常会使用到的一些细节。

转自:http://www.cnblogs.com/RascallySnake/archive/2010/05/07/1729563.html

 

很多时候,在填写完资料、帐号、密码等之后,用户习惯性地会按Enter(回车键)表示完成。

为了做好用户体验,我们必须在此监听这一动作。

具体逻辑是,在前面的input标签里监听onkeydown事件,当用户输入完之后,按回车键,立马跳到下一个输入框,到最后一个输入框输入完成时,就按回车,focus到提交标签那里。

第一种是:在input标签里面添加onkeydown事件。

<input onkeydown=”jump(下一个input的id)” type=”text” id=”name” />
<input onkeydown=”jump(下一个input的id)” type=”text” id=”pwd” />
<input onkeydown=”jump(下一个input的id)” type=”text” id=”code” />
<input  type=”submit” id=”submit” value=”登录”/>

<script type=”text/javascript”>
function jump(next){
var nextInp = document.getElementById(next);
var event = arguments.callee.caller.arguments[0] || window.event;
if(event.keyCode == 13){//判断是否按了回车,enter的keycode代码是13,想看其他代码请猛戳这里
nextInp.focus();
}
}
</script>

第二种是:在js里面添加onkeydown监听事件(监听方法比较多,这里只列举一种)。

这里只列举一个标签的事件,其他代码自己再组织吧。

<input type=”text” id=”code” />
<input type=”submit” id=”btnS” value=”登录”/>
<script type=”text/javascript”>
var code= document.getElementById(“code”);
var btnS= document.getElementById(“btnS”);
function jump(event){
var event = event || window.event;//这里的event兼容跟上面不同,关于event的兼容,请猛戳这里
if(event.keyCode == 13){
btnS.focus();
}
}
code.onkeydown=jump;
</script>

 

网上搜了很多回来,跟大家分享一下。有些是IE特有的,有些是FF特有的。

如:alert(event.altKey)

Abstract.
altKey 设置或获取 Alt 键的状态。
altLeft 设置或获取左 Alt 键的状态。
attrName.
attrChange.
Banner 使用 event 对象获取高级流重定向器(ASX)文件中项目的 Banner 内容。
bubbles 返回布尔值,指示事件是否是起泡事件类型。
button 设置或获取用户所按的鼠标按钮。
cancelable 返回布尔值,指示事件是否可拥可取消的默认动作。
cancelBubble 设置或获取当前事件是否要在事件句柄中向上冒泡。
clientX 设置或获取鼠标指针位置相对于窗口客户区域的 x 坐标,其中客户区域不包括窗口自身的控件和滚动条。
clientY 设置或获取鼠标指针位置相对于窗口客户区域的 y 坐标,其中客户区域不包括窗口自身的控件和滚动条。
contentOverflow 获取表明文档处理当前 LayoutRect 对象后是否包含附加的内容。
ctrlKey 设置或获取 Ctrl 键的状态。
ctrlLeft 设置或获取左 Ctrl 键的状态。
currentTarget 返回其事件监听器触发该事件的元素。
dataFld 设置或获取 oncellchange 事件影响的数据列。
detail.
eval.eval.
eventPhase 返回事件传播的当前阶段。
fromElement 设置或获取事件发生时激活或鼠标将要离开的对象。
hasOwnProperty.
initEvent.
initMutationEvent.
initUIEvent.
isPrototypeOf.
keyCode 设置或获取与导致事件的按键关联的 Unicode 按键代码(下面附有详细代码)。
layerX.
layerY.
MoreInfo 通过 event 对象获取高级流重定向器(ASX)文件中项目横幅的 MoreInfo 内容。
newValue.
nextPage 获取打印模板中下页的位置。
offsetX 设置或获取鼠标指针位置相对于触发事件的对象的 x 坐标。
offsetY 设置或获取鼠标指针位置相对于触发事件的对象的 y 坐标。
pageX.
pageY.
preventDefault.
prevValue.
prototype.
propertyIsEnumerable.
propertyName 设置或获取对象上发生更改的属性名称。
qualifier 设置或获取由数据源对象提供的数据成员的名称。
reason 设置或获取数据源对象的数据传输结果。
recordset 从数据源对象设置或获取对默认数据集的引用。
repeat 获取 onkeydown 事件是否正在重复。
relatedNode.
relatedTarget 返回与事件的目标节点相关的节点。
returnValue 设置或获取事件的返回值。
saveType 当 oncontentsave 触发时获取剪贴板类型。
screenX 设置或获取获取鼠标指针位置相对于用户屏幕的 x 坐标。
screenY 设置或获取鼠标指针位置相对于用户屏幕的 y 坐标。
shiftKey 设置或获取 Shift 键的状态。
shiftLeft 设置或获取左 Shift 键的状态。
srcElement 设置或获取触发事件的对象。
srcFilter 设置或获取触发 onfilterchange 事件的滤镜对象。
srcUrn 获取触发事件的行为的统一资源名称(URN)。
stopPropagation.
target 返回触发此事件的元素(事件的目标节点)。
timeStamp 返回事件生成的日期和时间。
toElement 设置或获取用户要将鼠标指针移动指向的对象的引用。
toLocaleString.
type 从 event 对象中获取事件名称。
unwatch.
userName.
valueOf.
view.
watch
wheelDelta 设置或获取滚轮按钮滚动的距离和方向。
x 设置或获取鼠标指针位置相对于父文档的 x 像素坐标。
y 设置或获取鼠标指针位置相对于父文档的 y 像素坐标。

keycode代码

 

  • keycode     8 = BackSpace BackSpace
  • keycode     9 = Tab Tab
  • keycode    12 = Clear
  • keycode    13 = Enter
  • keycode    16 = Shift_L
  • keycode    17 = Control_L
  • keycode    18 = Alt_L
  • keycode    19 = Pause
  • keycode    20 = Caps_Lock
  • keycode    27 = Escape Escape
  • keycode    32 = space space
  • keycode    33 = Prior
  • keycode    34 = Next
  • keycode    35 = End
  • keycode    36 = Home
  • keycode    37 = Left
  • keycode    38 = Up
  • keycode    39 = Right
  • keycode    40 = Down
  • keycode    41 = Select
  • keycode    42 = Print
  • keycode    43 = Execute
  • keycode    45 = Insert
  • keycode    46 = Delete
  • keycode    47 = Help
  • keycode    48 = 0 equal braceright
  • keycode    49 = 1 exclam onesuperior
  • keycode    50 = 2 quotedbl twosuperior
  • keycode    51 = 3 section threesuperior
  • keycode    52 = 4 dollar
  • keycode    553 = 5 percent
  • keycode    54 = 6 ampersand
  • keycode    55 = 7 slash braceleft
  • keycode    56 = 8 parenleft bracketleft
  • keycode    57 = 9 parenright bracketright
  • keycode    65 = a A
  • keycode    66 = b B
  • keycode    67 = c C
  • keycode    68 = d D
  • keycode    69 = e E EuroSign
  • keycode    70 = f F
  • keycode    71 = g G
  • keycode    72 = h H
  • keycode    73 = i I
  • keycode    74 = j J
  • keycode    75 = k K
  • keycode    76 = l L
  • keycode    77 = m M mu
  • keycode    78 = n N
  • keycode    79 = o O
  • keycode    80 = p P
  • keycode    81 = q Q at
  • keycode    82 = r R
  • keycode    83 = s S
  • keycode    84 = t T
  • keycode    85 = u U
  • keycode    86 = v V
  • keycode    87 = w W
  • keycode    88 = x X
  • keycode    89 = y Y
  • keycode    90 = z Z
  • keycode    96 = KP_0 KP_0
  • keycode    97 = KP_1 KP_1
  • keycode    98 = KP_2 KP_2
  • keycode    99 = KP_3 KP_3
  • keycode 100 = KP_4 KP_4
  • keycode 101 = KP_5 KP_5
  • keycode 102 = KP_6 KP_6
  • keycode 103 = KP_7 KP_7
  • keycode 104 = KP_8 KP_8
  • keycode 105 = KP_9 KP_9
  • keycode 106 = KP_Multiply KP_Multiply
  • keycode 107 = KP_Add KP_Add
  • keycode 108 = KP_Separator KP_Separator
  • keycode 109 = KP_Subtract KP_Subtract
  • keycode 110 = KP_Decimal KP_Decimal
  • keycode 111 = KP_Divide KP_Divide
  • keycode 112 = F1
  • keycode 113 = F2
  • keycode 114 = F3
  • keycode 115 = F4
  • keycode 116 = F5
  • keycode 117 = F6
  • keycode 118 = F7
  • keycode 119 = F8
  • keycode 120 = F9
  • keycode 121 = F10
  • keycode 122 = F11
  • keycode 123 = F12
  • keycode 124 = F13
  • keycode 125 = F14
  • keycode 126 = F15
  • keycode 127 = F16
  • keycode 128 = F17
  • keycode 129 = F18
  • keycode 130 = F19
  • keycode 131 = F20
  • keycode 132 = F21
  • keycode 133 = F22
  • keycode 134 = F23
  • keycode 135 = F24
  • keycode 136 = Num_Lock
  • keycode 137 = Scroll_Lock
  • keycode 187 = acute grave
  • keycode 188 = comma semicolon
  • keycode 189 = minus underscore
  • keycode 190 = period colon
  • keycode 192 = numbersign apostrophe
  • keycode 210 = plusminus hyphen macron
  • keycode 211 =
  • keycode 212 = copyright registered
  • keycode 213 = guillemotleft guillemotright
  • keycode 214 = masculine ordfeminine
  • keycode 215 = ae AE
  • keycode 216 = cent yen
  • keycode 217 = questiondown exclamdown
  • keycode 218 = onequarter onehalf threequarters
  • keycode 220 = less greater bar
  • keycode 221 = plus asterisk asciitilde
  • keycode 227 = multiply division
  • keycode 228 = acircumflex Acircumflex
  • keycode 229 = ecircumflex Ecircumflex
  • keycode 230 = icircumflex Icircumflex
  • keycode 231 = ocircumflex Ocircumflex
  • keycode 232 = ucircumflex Ucircumflex
  • keycode 233 = ntilde Ntilde
  • keycode 234 = yacute Yacute
  • keycode 235 = oslash Ooblique
  • keycode 236 = aring Aring
  • keycode 237 = ccedilla Ccedilla
  • keycode 238 = thorn THORN
  • keycode 239 = eth ETH
  • keycode 240 = diaeresis cedilla currency
  • keycode 241 = agrave Agrave atilde Atilde
  • keycode 242 = egrave Egrave
  • keycode 243 = igrave Igrave
  • keycode 244 = ograve Ograve otilde Otilde
  • keycode 245 = ugrave Ugrave
  • keycode 246 = adiaeresis Adiaeresis
  • keycode 247 = ediaeresis Ediaeresis
  • keycode 248 = idiaeresis Idiaeresis
  • keycode 249 = odiaeresis Odiaeresis
  • keycode 250 = udiaeresis Udiaeresis
  • keycode 251 = ssharp question backslash
  • keycode 252 = asciicircum degree
  • keycode 253 = 3 sterling
  • keycode 254 = Mode_switch
 

第一种:在html元素中直接加入on事件

function demo1(){//在元素中直接加入on事件,不能直接取得event,应此必须用arguments.callee.caller.arguments[0]才能够取得FF里面的event对象;
var event=arguments.callee.caller.arguments[0]||window.event;//消除浏览器差异
var e=event.srcElement||event.target;//IE支持srcElement,FF支持target 获取当前触发事件的元素
     alert(“我是”+e.tagName+”标签”);
 
}

第二种:在js里用事件监听,可以加入参数以直接获取事件

function demo2(event){
var event=event||window.event;
var e=event.srcElement||event.target;
  alert(“我是”+e.tagName+”标签”);
}
function load(){
document.getElementByIdx(“demo2″).onclick=demo2;
}

 

今天在网上看到一条关于面向对象的很形象的题目,决定转过来分享一下。

小贤是一条可爱的小狗(Dog),它的叫声很好听(wow),每次看到主人的时候就会乖乖叫一声(yelp)。

小芒和小贤一样,原来也是一条可爱的小狗,可是突然有一天疯了(MadDog),一看到人就会每隔半秒叫一声(wow)地不停叫唤(yelp)。

请根据描述,按示例的形式用代码来实现(提示关键字: 继承,原型,setInterval)。

正确答案:

<script language=”JavaScript” type=”text/javascript”>
    window.onload = function(){
        function Dog(name){this.name = name;}
        Dog.prototype = {
            constructor : Dog,
            wow: function(){
                alert(‘wow’);
            },
            yelp: function(){
                return this.wow();
            }
        }
        function CrazyDog(name){this.name = name;}
        CrazyDog.prototype = new Dog();
        CrazyDog.prototype.madYelp = function(){
            var _self = this;
            setInterval(function(){
                return _self.yelp();
            }, 2000);
        }
        var xiaoXian = new Dog(“xiaoXian”);
        var xiaoXianBtn = document.getElementById(“xiaoXianBtn”);
        xiaoXianBtn.onclick = function(){xiaoXian.yelp();}
        var xiaoMang = new CrazyDog(“xiaoMang”);
        var xiaoMangBtn = document.getElementById(“xiaoMangBtn”);
        xiaoMangBtn.onclick = function(){xiaoMang.madYelp();}
    }
</script>
 

this是Javascript语言的一个关键字。

它代表函数运行时,自动生成的一个内部对象,只能在函数内部使用。比如,

  function test(){

this.x = 1;

}

随着函数使用场合的不同,this的值会发生变化。但是有一个总的原则,那就是this指的是,调用函数的那个对象。

下面分四种情况,详细讨论this的用法。

情况一:纯粹的函数调用

这是函数的最通常用法,属于全局性调用,因此this就代表全局对象Global。

请看下面这段代码,它的运行结果是1。

  function test(){

this.x = 1;

alert(this.x);

}

test(); // 1

为了证明this就是全局对象,我对代码做一些改变:

  var x = 1;

function test(){

alert(this.x);

}

test(); // 1

运行结果还是1。再变一下:

  var x = 1;

function test(){

this.x = 0;

}

test();

alert(x); //0

情况二:作为对象方法的调用

函数还可以作为某个对象的方法调用,这时this就指这个上级对象。

  function test(){

alert(this.x);

}

var o = {};

o.x = 1;

o.m = test;

o.m(); // 1

情况三 作为构造函数调用

所谓构造函数,就是通过这个函数生成一个新对象(object)。这时,this就指这个新对象。

  function test(){

this.x = 1;

}

var o = new test();

alert(o.x); // 1

运行结果为1。为了表明这时this不是全局对象,我对代码做一些改变:

  var x = 2;

function test(){

this.x = 1;

}

var o = new test();

alert(x); //2

运行结果为2,表明全局变量x的值根本没变。

情况四 apply或call调用

apply()是函数对象的一个方法,它的作用是改变函数的调用对象,它的第一个参数就表示改变后的调用这个函数的对象。因此,this指的就是这第一个参数。

  var x = 0;

function test(){

alert(this.x);

}

var o={};

o.x = 1;

o.m = test;

o.m.apply(); //0

apply()的参数为空时,默认调用全局对象。因此,这时的运行结果为0,证明this指的是全局对象。

如果把最后一行代码修改为

  o.m.apply(o); //1

运行结果就变成了1,证明了这时this代表的是对象o。

call的用法跟apply差不多,只是后面第二个参数不同,第一个参数是一样的用法。

参考:http://www.ruanyifeng.com/blog/2010/04/using_this_keyword_in_javascript.html

 

第一种 prototype 引用型原型继承
语言支持:js原生支持的继承方式 构造器的的prototype属性作为类的原型 每个该类的对象都持有一个到原型的引用 当对象中的属性不存在时 可以访问原型的属性

代码示例:

<script>
function parent(){
this.x=10;
}
function child(){
}
child.prototype=new parent();
var childObj=new child();
alert(childObj.x);
</script>

第二种 复制型原型继承
语言支持:js new运算符的性质 当构造函数return值为非空对象时 new表达式返回return的对象
代码示例:
<script>
function parent(){
this.x=10;
}
function child(){
var ret=new parent();
ret.y=20;
return ret;
}
var childObj=new child();
alert(childObj.x);</script>

第三种 类继承 属性抄写
语言支持:for in枚举对象所有属性
<script>
function parent(){
this.x=10;
}
function child(){
var parentObj=new parent();
for(var p in parentObj)this[p]=parentObj[p];
}
var childObj=new child();
alert(childObj.x);
</script>

第四种 类继承 对象冒充
语言支持: 1.动态添加和删除方法 2.函数的call和apply
代码:
用语言支持1实现的类继承
<script>
function parent(){
this.x=10;
}
function child(){
this.parent=parent;
this.parent();
delete this.parent;
}
var childObj=new child();
alert(childObj.x);</script>

用语言支持2实现的类继承
<script>
function parent(){
this.x=10;
}
function child(){
parent.call(this);
}
var childObj=new child();
alert(childObj.x);</script>

第五种 原型抄写
语言支持:通过修改类的原型对象 可以为一类对象添加属性和方法
代码
<script>
function parent(){}
parent.prototype.me=function(){alert(“parent”)};
function child(){}
for(var p in parent.prototype)child.prototype[p]=parent.prototype[p];
var childObj=new child();
childObj.me();</script>

第六种 元类
语言支持: js函数都是对象 且js函数可被构造
<script>function parent(string){
var child=new Function(“this.x=10;”+string);
return child;
}
var child=new parent(“this.y=20;”);
var childObj=new child();
alert(childObj.y);
</script>

对js对象来说 它的属性来自两部分:prototype属性和自身属性 call/apply只能继承自身属性 原型抄写只能继承prototype属性
将它们混用互相没有任何干扰 而且实现了所有属性的继承。但是我觉得,如果按规范编码的话,似乎只用其一就足够了,对一个类来说,同时给prototype和构造函数添加属性的情况很少见吧?

转自:http://hi.baidu.com/tangdecai/blog/item/6c7e6306698b837d020881ff.html

 

//构造函数 myObject
//使自己的对象多次复制,同时实例根据设置的访问等级可以访问其内部的属性和方法
//当对象被实例化后,构造函数会立即执行它所包含的任何代码
function myObject(msg){
//特权属性(公有属性)
this.myMsg = msg; //只在被实例化后的实例中可调用
this.address = ‘上海’;

//私有属性
var name = ‘豪情’;
var age = 29;
var that = this;

//私有方法
function sayName(){
alert(that.name);
}
//特权方法(公有方法)
//能被外部公开访问
//这个方法每次实例化都要重新构造而prototype是原型共享,所有实例化后,都共同引用同一个
this.sayAge = function(){
alert(name); //在公有方法中可以访问私有成员
}
//私有和特权成员在函数的内部,在构造函数创建的每个实例中都会包含同样的私有和特权成员的副本,
//因而实例越多占用的内存越多
}
//公有方法
//适用于通过new关键字实例化的该对象的每个实例
//向prototype中添加成员将会把新方法添加到构造函数的底层中去
myObject.prototype.sayHello = function(){
alert(‘hello everyone!’);
}
//静态属性
//适用于对象的特殊实例,就是作为Function对象实例的构造函数本身
myObject.name = ‘china’;
//静态方法
myObject.alertname = function(){
alert(this.name);
}
//实例化
var m1 = new myObject(’111′);
//—- 测试属性 —-//
console.log(myObject.name); //china
console.log(m1.name); //undefined, 静态属性不适用于一般实例
console.log(m1.constructor.name); //china, 想访问类的静态属性,先访问该实例的构造函数,然后再访问该类静态属性
console.log(myObject.address); //undefined, myObject中的this指的不是函数本身,而是调用address的对象,而且只能是对象
console.log(m1.address); //上海 此时this指的是实例化后的m1

//—- 测试方法 —-//
myObject.alertname(); //china,直接调用函数的类方法
m1.alertname(); //FF: m1.alertname is not a function, alertname 是myObject类的方法,和实例对象没有直接关系
m1.constructor.alertname(); //china, 调用该对象的构造函数(类函数)的方法(函数)
m1.sayHello(); //hello everyone, myObject类的prototype原型下的方法将会被实例继承
myObject.sayHello(); //myObject.sayHello is not a function,sayHello是原型方法,不是类的方法

//—- 测试prototype —-//
console.log(m1.prototype); //undefined, 实例对象没有prototype
console.log(myObject.prototype); //Object
alert(myObject.prototype.constructor); //console.log返回myObject(msg),此时alert()更清楚,相当于myObject
console.log(myObject.prototype.constructor.name); //china, 相当于myObject.name;

转自:http://www.cnblogs.com/jikey/archive/2011/05/13/2045005.html

 

第二篇  

<script type=”text/javascript”>

//构造函数  Person     //其中一种类方法定义的方法
  function Person(name){
     //类变量
     this.name = name;
     this.age  = 0;

      this.gender = 0;

     this.pets = new Array();
  }

  //类setName(name)的函数
  Person.prototype.setName=function(name){
     this.name=name;
  }

  //类getName(name)的函数
  Person.prototype.getName=function(){
     return this.name;
  }

  //类pushPetsArr(item)的函数
  Person.prototype.pushPetsArr=function(item){
     this.pets[this.pets.length] = item;
  }

//构造函数 Person    //另一种类方法定义的方法
  function Person(name){
     //类变量
     this.name = name;
     this.age  = 0;
     this.gender = 0;
     this.pets = new Array();
  }

  //类setName(name)的函数
  Person.prototype = {
      setName: function(name){
          this.name=name;
      },

      //类getName(name)的函数

      getName: function(){
          return this.name;
      },

      //类pushPetsArr(item)的函数
      pushPetsArr: function(item){
          this.pets[this.pets.length] = item;
      }
  }
</script>

<script type=”text/javascript”>

 var myNameSpace = new Object(); //构造一个命名 空间myClass

 //类的属性
 myNameSpace.names=”cnscn”;
 myNameSpace.age=”30″;

 myNameSpace.ClassPersons=function(argName,argAge){ //构造类名,即构造函数
    this.names=argName;
    this.age=argAge;
 }

 myNameSpace.ClassPersons.prototype={//类方法的定义
    //方法getName()
    getName:function(){
      alert(this.names);
    }//注意这里是”逗号
     //方法setName(argName)
    setName:function(argName){
       this.names=argName;
    }
 }

 var obj=new myNameSpace.ClassPersons(“yao”, 23);
 obj.getName();
 obj.setName(“hhhh”);
 obj.getName();
alert(myNameSpace.name);

</script>

转自:http://blog.sina.com.cn/s/blog_675879000100ijui.html

 

NaN:保留字(表明数据类型不是数字)
undefined:对象属性或方法不存在,或声明了变量但从未赋值。
即当你使用了对象未定的属性或者未定义的方法时或当你声明一个变量,但你确从未对其进行赋值,便对其进行操作(当然赋值除外),会有”undefined”提示。
null :指出一个变量中没有包含有效的数据。
产生 null 的原因是:对一个变量显式地赋值为 null。 包含 null 的表达式之间的任何操作。

Boolean 表达式
一个值为 true 或者 false 的表达式。
如果需要,非 Boolean 表达式也可以被转换为 Boolean 值,但是要遵循下列规则:所有的对象都被当作 true。 当且仅当字符串为空时,该字符串被当作 false。
null 和 undefined 被当作 false。
当且仅当数字为零时,该数字被当作 false。

字符串比较
两个字符序列之间的比较。
除非在进行比较操作的函数中指出,所有的字符串比较操作都是二进制的。
在英语中,二进制比较区分大小写;而文本比较则不区分。

数值表达式
数值表达式指的是任何值为数字的表达式。这种表达式的元素可以包括关键字、变量、文字和运算符的任意组合,只要此组合能够生成一个数字。在特定的情况下,如果可以的话,字符串也可以被转换为数字。

构造函数
一种 JScript 函数,具有两个特殊的性质:由 new 运算符来调用此函数。 通过 this 关键字将新创建对象的地址传递到此函数。 强列建议使用构造函数来初始化新的对象。

ASCII 字符集
美国标准信息交换编码 (ASCII) 的 7 位字符集,它被广泛地用来表示标准的美国键盘上的字母和符号。
ASCII 字符集与 ANSI 字符集中的头 128 个字符 (0–127) 完全相同。Automation 对象通过Automation 接口可以被其他应用程序或编程工具使用的对象。

全球标准时间 (UTC)
全球标准时间指的是由世界时间标准设定的时间。原先也被称为格林威治标准时间或者 GMT。

Jscript 有三种主要数据类型、两种复合数据类型和两种特殊数据类型。
主要(基本)数据类型是:字符串 数值 布尔
复合(引用)数据类型是:对象 数组
特殊数据类型是:Null Undefined
null = = undefined
true

“NaN” = = NaN
false

5 = = NaN
false

NaN = = NaN
false

NaN != NaN
true

false = =0
true

true = =1
true

true = = 2
false

undefined = = 0
false

null = = 0
false

“5″ = = 5
true

1.类型分析:
js中的数据类型有undefined,boolean,number,string,object等5种,前4种为原始类型,第5种为引用类型。
var a1;
var a2 = true;
var a3 = 1;
var a4 = “Hello”;
var a5 = new Object();
var a6 = null;
var a7 = NaN;
var a8 = undefined;
alert(typeof a); //显示”undefined”
alert(typeof a1); //显示”undefined”
alert(typeof a2); //显示”boolean”
alert(typeof a3); //显示”number”
alert(typeof a4); //显示”string”
alert(typeof a5); //显示”object”
alert(typeof a6); //显示”object”
alert(typeof a7); //显示”number”
alert(typeof a8); //显示”undefined”
从上面的代码中可以看出未定义的值和定义未赋值的为undefined,null是一种特殊的object,NaN是一种特殊的number。

2.比较运算
var a1; //a1的值为undefined
var a2 = null;
var a3 = NaN;
alert(a1 == a2); //显示”true”
alert(a1 != a2); //显示”false”
alert(a1 == a3); //显示”false”
alert(a1 != a3); //显示”true”
alert(a2 == a3); //显示”false”
alert(a2 != a3); //显示”true”
alert(a3 == a3); //显示”false”
alert(a3 != a3); //显示”true”
从上面的代码可以得出结论:(1)undefined与null是相等;(2)NaN与任何值都不相等,与自己也不相等。

Null 数据类型
在 Jscript 中数据类型 null 只有一个值:null。关键字 null 不能用作函数或变量的名称。
包含 null 的变量包含“无值”或“无对象”。换句话说,该变量没有保存有效的数、字符串、boolean、数组或对象。可以通过给一个变量赋 null 值来清除变量的内容。
请注意,在 Jscript 中,null 与 0 不相等(与在 C 和 C++ 中不同)。同时应该指出的是,Jscript中 typeof 运算符将报告 null 值为 Object 类型,而非类型 null。这点潜在的混淆是为了向下兼容。

Undefined 数据类型
如下情况是返回 undefined 值:
对象属性不存在,
声明了变量但从未赋值。
注意不能通过与 undefined 做比较来测试一个变量是否存在,虽然可以检查它的类型是否为“undefined”。在以下的代码范例中,假设程序员想测试是否已经声明变量 x :

// 这种方法不起作用
if (x == undefined)
// 作某些操作

// 这个方法同样不起作用- 必须检查
// 字符串 “undefined”
if (typeof(x) == undefined)
// 作某些操作

// 这个方法有效
if (typeof(x) == “undefined”)
// 作某些操作

考虑将 undefined 值与null做比较。
针对上面的判断,如果变量 x 没有定义的话 if (x == undefined) {…}会抛出exception:变量x未定义,这句判断不会执行,可用try{…}catch(ex){…} 捕获。
不管x是否已经定义,使用 if (typeof(x) == undefined) 都会判断为 false。
someObject.prop == null;

如下情况时,比较的结果为 true,
如果属性 someObject.prop 包含 null 值,
如果属性 someObject.prop 不存在。

要检查一个对象属性是否存在,可以使用新的 in 运算符:
if (“prop” in someObject)
// someObject 有属性 ‘prop’

在JavaScript中,null与undefined一度使人迷惑。下面的分析,有利于你更清晰的认知它(或者让你更迷惑):
- null是关键字;undefined是Global对象的一个属性
- null是对象(空对象, 没有任何属性和方法);undefined是undefined类型的值。

试试下面的代码:
document.writeln(typeof null); //return object
document.writeln(typeof undefined); //return undefined

- 对象模型中,所有的对象都是Object或其子类的实例,但null对象例外:
document.writeln(null instanceof Object); //return false

- null“等值(==)”于undefined,但不“全等值(===)”于undefined:
document.writeln(null == undefined); //return true
document.writeln(null === undefined); //return false

- 运算时null与undefined都可以被类型转换为false,但不等值于false:
document.writeln(!null, !undefined); //return true,true
document.writeln(null==false); //return false
document.writeln(undefined==false); //return false

 

字面上理解下来就是,回调就是一个函数的调用过程。那么就从理解这个调用过程开始吧。函数a有一个参数,这个参数是个函数b,当函数a执行完以后执行函数b。那么这个过程就叫回调。

其实中文也很好理解:回调,回调,就是回头调用的意思。函数a的事先干完,回头再调用函数b。

这里必须清楚一点:函数b是你以参数形式传给函数a的,那么函数b就叫回调函数。

也许有人有疑问了:一定要以参数形式传过去吗,我不可以直接在函数a里面调用函数b吗?确实可以。求解中。

<解惑:如果你直接在函数a里调用的话,那么这个回调函数就被限制死了。但是使用函数做参数就有下面的好处:当你a(b)的时候函数b就成了回调函数,而你还可以a(c)这个时候,函数c就成了回调函数。如果你写成了function a(){…;b();}就失去了变量的灵活性。>

下面用代码来证实我的理解。

  • <html>
  • <head>
  • <title>回调函数(callback)</title>
  • <script language=”javascript” type=”text/javascript”>
  • function a(callback)
  • {
  •     alert(“我是parent函数a!”);
  •     alert(“调用回调函数”);
  •     callback();
  • }
  • function b(){
  • alert(“我是回调函数b”);
  • }
  • function c(){
  • alert(“我是回调函数c”);
  • }
  • function test()
  • {
  •     a(b);
  •    a(c);
  • }
  • </script>
  • </head>
  • <body>
  • <h1>学习js回调函数</h1>
  • <button onClick=test()>click me</button>
  • <p>应该能看到调用了两个回调函数</p>
  • </body>
  • </html>

转自:http://www.cnblogs.com/yhql/archive/2011/08/08/2131420.html

以上的例子简单易懂,但是对比下面的,我就有点糊涂了,可能是我这水平还看不懂吧,是不是那个option啊

今天想用js调取一个接口,可总不知道如何获取返回值,只能怪自己思维打盹了,其实返回值中是个函数回调,在调用页定义这个函数就可以了,例子如下:

<script     src=”http://blogpagin.sinajs.cn/article?1315019920&0&requestId=scriptId_0.37” ></script>

趁热打铁,看了下公司牛人写的js代码,温习下他们是如何这类问题的

<SCRIPT LANGUAGE=”JavaScript”>

window.$ScriptLoader = {

requestTable : {},

request : function (url, option){
option = option || {};
option.charset = option.charset || “utf-8″;

var id = “scriptId_” + Math.random();
url = url + “&id=” + id ;

this.requestTable[id] = {
id : id,
url : url,
option : option
};
var sTag = document.createElement(“script”);
sTag.id = id;
sTag.src = url;
sTag.charset = option.charset;

document.body.appendChild(sTag);
},
response : function (id, txt){

var entity = this.requestTable[id];
if (entity){
try {
entity.option.onComplete(txt );
} catch (err) {
var oe = entity.option.onException;
try {
if(oe)
oe(txt,    err);
else {
alert(“error occurs while calling onComplete to url : ” + this.requestTable[id].url + ” Error : ” + err);
}
} catch (err) {}
} finally {

}
}
}
}

</SCRIPT>

<body>

<SCRIPT LANGUAGE=”JavaScript”>
function fun( str)
{
alert(str);
}

function errfun()
{
alert(“error”);
}

var url = “http://www.test.com/cms/test.php?quest=” ;
var option = {onComplete:fun,onException:errfun};
window.$ScriptLoader.request(url,option);

</SCRIPT>

</body>

 

原理就是动态加载一个js文件,注意js文件的编码,然后预设一个回调函数,回调函数的触发点就是onComplete时间,这也是ajax的原型

看看test.php服务器端的代码:

<?php
echo “window.\$ScriptLoader.response(‘” . $_GET[id] . “‘,’ttt’);”;
?>

 

转自:http://hi.baidu.com/ywdblog/item/d95878eb6ec891e3fa42bae4

© 2012 Hedgehog Suffusion theme by Sayontan Sinha