Once loaded, the editor registers a global object called FCKeditorAPI. This object offers the entry point to interact with any editor instance placed in a page.

NOTE: The FCKeditorAPI object will not be available during the page load. You need to wait for the editor to be loaded to use it.

Often, I see that people complain about a JavaScript error, “FCKeditorAPI is not defined”, when they try to use FCKeditorAPI.

For example

The following code will throw a JavaScript error when you try to use the FCKeditorAPI -

You can resolve the JavaScript error by adding a line of code (Line # 4) as shown below -

Hope this helps!

1. IE中不能在运行时重命名元素。

The NAME attribute cannot be set at run time on elements dynamically created with the createElement method. To create an element with a name attribute, include the attribute and value when using the createElement method.

后来找到国外的一篇帖子，找到一个解决方法，那就是使用mergeAttributes 方法，模拟新建一个只有name不同的元素，并和之前的元素合并，这样就能达到重命名的效果了。代码如下：

var setElementName = function(el, newName) {

el = (typeof el === "string") ? document.getElementById(el) : el;

el.name = newName;

if(/MSIE (\d+\.\d+);/.test(navigator.userAgent)) { // Internet Explorer test 

el.mergeAttributes(document.createElement("<INPUT name='" + newName + "'/>"), false);

}

};

This topic contains the following sections.

• Introduction
• Parsing the User-Agent String
• Using Conditional Comments
• Detecting Features
• Using the ASP.NET HttpBrowserCapabilities Object
• Alternatives to Browser Detection
• Summary

Introduction

Many Web designers use browser detection techniques to ensure that their sites display properly when viewed with specific browsers. Some browser detection techniques encounter problems when viewed with later versions of the browser they're tailored for. For example, many Web designers used Cascading Style Sheets (CSS) rules that relied on the implementation of CSS in Microsoft Internet Explorer 6 to detect that version of the browser. When Internet Explorer 7 provided additional support for the CSS, Level 2 (CSS2) standard, many of these rules (also known as "CSS hacks") failed to detect the new version of the browser. As a result, sites that relied on these rules no longer displayed as intended. When using browser detection techniques, use techniques that support current and future versions of the browser you're targeting.

This topic examines four different ways to detect Internet Explorer and also provides a brief look at alternatives to browser detection. Advantages of each technique are reviewed and suggestions are offered for effective use. In addition, examples demonstrate techniques that support current and future versions of Internet Explorer.

Parsing the User-Agent String

The most common way to detect Internet Explorer is to use client-side scripting to parse the user-agent string and extract the version number from the version token. The following example shows the preferred way to do this with JavaScript.

function getInternetExplorerVersion()



// Returns the version of Internet Explorer or a -1



// (indicating the use of another browser).



{



var rv = -1; // Return value assumes failure.



if (navigator.appName == 'Microsoft Internet Explorer')



{



var ua = navigator.userAgent;



var re  = new RegExp("MSIE ([0-9]{1,}[".0-9]{0,})");



if (re.exec(ua) != null)



rv = parseFloat( RegExp.$1 );



}



return rv;



}



function checkVersion()



{



var msg = "You're not using Internet Explorer.";



var ver = getInternetExplorerVersion();







if ( ver > -1 )



{



if ( ver >= 8.0 ) 



msg = "You're using a recent copy of Internet Explorer."



else



msg = "You should upgrade your copy of Internet Explorer.";



}



alert( msg );



}

As you review this example, please note the following:

• A regular expression extracts the version number from the user-agent version token. Regular expressions let you specify optional conditions to match, so that you can match a larger number of version tokens, not just those that match a strict set of conditions.

• The version number extracted from the version token is formally converted to a numeric value. Care must be taken because pre-release versions of Internet Explorer typically add letters to the version token. For example, the version token for pre-release versions of Internet Explorer 7 was "MSIE 7.0b."

• The checkVersion() function verifies that the browser is version 8.0 or later. This ensures that the welcome message is displayed for those using newer versions of the browser.

This example properly detects most versions of Internet Explorer, but only if scripting is enabled. However, the user-agent string is dynamic; it can be changed by the end user, by browser extensions, and by operating system updates. As a result, there's no guarantee that the user-agent string accurately reflects the browser being used. The next sections show techniques that may be more effective alternatives.

For more information about the user-agent string and Internet Explorer's user-agent tokens, see Understanding User-Agent Strings.

Using Conditional Comments

If you are specifically interested in Internet Explorer, conditional comments might be a more appropriate choice. The following example shows an effective way to use conditional comments to display custom content.

<!--[if gte IE 8]>



<p>You're using a recent version of Internet Explorer.</p>



<![endif]-->







<!--[if lt IE 7]>



<p>Hm. You should upgrade your copy of Internet Explorer.</p>



<![endif]-->







<![if !IE]>



<p>You're not using Internet Explorer.</p>



<![endif]>

Like the earlier JavaScript example, this example makes sure the current version is greater than or equal to a specified version number. This ensures that the content designed for the current version of the browser is properly displayed in a future version.

This example carefully combines downlevel-revealed and downlevel-hidden conditional comments to ensure that each message appears only for the intended browsers.

Because conditional comments do not rely on JavaScript, they are effective even if the user has disabled scripting. Unlike the user-agent string, conditional comments are typically updated when the browser is upgraded. This makes them more reliable than user-agent strings. However, because no other browser currently supports conditional comments, they are limited to Internet Explorer. Depending on your needs, this may be an advantage or a disadvantage.

For more information about conditional comments, see About Conditional Comments.

Detecting Features

For many Web sites, detecting a browser's features is the preferred form of browser detection because it allow the Web developer to focus on the general capabilities of a browser, rather than the specific details of each browser release. The following example demonstrates a simple form of feature detection.

if (XMLHttpRequest)



{



// This browser implements this feature. 



}

Feature detection tends to support a broader range of browsers. In addition, should a browser implement the feature you're interested in, your content will be delivered without requiring changes to your browser detection technique. As a result, techniques that focus on features tend to require less maintenance than techniques that rely on environmental factors, such as the user-agent string. In addition, they tend to work across a wider variety of browser devices, including screen readers, mobile devices, and so on.

Use care when creating or using browser detection techniques that attempt to detect a browser based on unsupported functionality. If a future version of the browser implements the missing feature, it's entirely possible your site may not display as intended.

Using the ASP.NET HttpBrowserCapabilities Object

ASP.NET developers can use the HttpBrowserCapabilities object to detect and respond to almost any browser. In addition, alternate content is not sent to the end-user's browser. The following example shows how to detect Internet Explorer from an ASP.NET application using C#.

private float getInternetExplorerVersion()



{



// Returns the version of Internet Explorer or a -1



// (indicating the use of another browser).



float rv = -1;



System.Web.HttpBrowserCapabilities browser = Request.Browser;



if (browser.Browser == "IE")



rv = (float)(browser.MajorVersion + browser.MinorVersion);



return rv;



}







private void Page_Load(object sender, System.EventArgs e)



{



string msg;



double ver = getInternetExplorerVersion();



if (ver > 0.0)



{



if (ver >= 7.0) 



msg = "You're using a recent version of Internet Explorer.";



else



msg = "You should upgrade your copy of Internet Explorer.";



} 



else



msg = "You're not using Internet Explorer.";







Label1.Text = msg;



}

Because the HttpBrowserCapabilities object parses the user-agent string for you, you can use the MajorVersion and MinorVersion properties to determine the current version of the browser. Unlike the JavaScript examples, these properties are numeric; MajorVersion returns an integer value, and MinorVersion returns a double value. Depending on the language used to implement your ASP.NET application, however, you might still have to typecast these property values to the data type you're using. To illustrate, the C# example converts MajorValue to the floating point value returned by the function.

For more information about the HttpBrowserCapabilities object, see HOW TO: Determine the Browser Version in ASP.NET or Browser Sniffing in ASP.NET .

Alternatives to Browser Detection

If you use browser detection because Internet Explorer doesn't appear to support a particular feature, an alternate approach may be more effective. Before implementing new (or revising existing) browser detection, it may be worthwhile to consider one of the following approaches to solve the underlying problem.

• Internet Explorer allows Web developers to choose between various document compatibility modes that affect the way the browser interprets and displays content. If you are not seeing the results you expect, a different document compatibility mode may provide the results you seek. For more information, see Defining Document Compatibility.

  You may want to consider using the Developer Tools to preview your pages in different document compatibility modes or to experiment with different ways to achieve various visual and layout effects. It's entirely possible there's another way to accomplish the same result.

• If the Document Object Model (DOM) doesn't support a feature that you need, you may be able to add the feature using DOM mutable prototypes.

• If none of the previous suggestions apply, it may be worthwhile to consider using an alternate approach.

Summary

If you must detect the browsers that view your Web sites, follow effective practices: plan for future browser releases, convert values appropriately, and design techniques to fail gracefully. Doing so will reduce the long-term maintenance of your site and help ensure that your site functions properly when viewed with newer versions of Internet Explorer and other browsers.

Community Content

function isMSIE() {



return '"v' == 'v';



}

The navigator object

The navigator object was conceived back in the days when Netscape Navigator reined supreme. These days it serves as much as an irony of NS's diminished market share as way of probing browser information.

The navigator object of JavaScript contains the following core properties:

Let's see exactly what these properties reveal of the browser you're currently using:

appCodeName: Mozilla
appName: Netscape
appVersion: 5.0 (Windows; zh-CN)
userAgent: Mozilla/5.0 (Windows; U; Windows NT 6.1; zh-CN; rv:1.9.2.3) Gecko/20100401 Firefox/3.6.3
platform: Win32

At a glance

At a glance at the above table, you may be swayed towards turning to the following two properties to do your browser detection bidding:

navigator.appName
navigator.appVersion

After all, you are trying to detect a browser's name and version right? However, they both will most likely mislead you. In browsers such as various versions of Netscape and Firefox, these two properties return simply "Netscape" for appName, and 5.0 for appVersion without any further distinction for Firefox and its version, and hence are pretty much useless in the real world. For example, in both Firefox 1.x and Firefox 2.x, these two properties return:

appName: Netscape



appVersion: 5.0 (Windows; en-US)

We need to turn to a property that's more thorough in its investigative work if we want more consistency and accuracy, and that turns out to be navigator.userAgent.

Detecting Firefox x.x

In Firefox 2.0.0.13 for example, the userAgent property reads:

UserAgent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.13) Gecko/20080311 Firefox/2.0.0.13

The detail we're interested in apparently lies at the very end, or Firefox/2.0.0.13. Different versions of Firefox will contain a different version number, but the pattern is consistent enough. The part we're interested in occurs after the string "Firefox/", or the exact version number. There are many ways to get to it using either standard String or RegExp methods- I'm opting for the later here:

Output: You're using FF 3.x or above

Basically, I'm capturing just the versonMajor.versionMinor portion of the full version number of Firefox (ie: 2.0.0.13 becomes simply 2.0), and using that as basis to detect the various versions of Firefox. Delving any deeper, and the returned version may no longer be a number but a string (ie: 2.0.0), which makes numeric comparisons cumbersome.

Detecting IE x.x

In IE 7.0 for example, the userAgent property reads:

UserAgent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; .NET CLR 2.0.50727)

So the part we're interested in lies in the middle, or MSIE 7.0;. If you try a shortcut and use parseFloat on the entire string to get to the 7.0 portion, it won't work. This is due to the way parseFloat works- by returning the first number it encounters, which in this case is 4.0. Once again we need to use either standard String or RegExp methods again to get to the actual version number; below I'm using RegExp as well:

<script type="text/javascript">







if (/MSIE ("d+"."d+);/.test(navigator.userAgent)){ //test for MSIE x.x;



 var ieversion=new Number(RegExp.$1) // capture x.x portion and store as a number



 if (ieversion>=8)



  document.write("You're using IE8 or above")



 else if (ieversion>=7)



  document.write("You're using IE7.x")



 else if (ieversion>=6)



  document.write("You're using IE6.x")



 else if (ieversion>=5)



  document.write("You're using IE5.x")



}



else



 document.write("n/a")



</script>

Output: n/a

Detecting Opera x.x

Detecting Opera using the navigator object at first appears to be tricky business due to the browser's identity crisis. You see, Opera 8 and below by default identifies itself as IE6 (or lower) in the navigator object. Users can override this setting under "Edit Site Settings" in the toolbar to identify as Opera or even another browser instead. Starting in Opera 9, the browser regains its confidence and identifies by default as itself, Opera, though users can still modify this setting manually in the toolbar. The bottom line is, Opera can appear as either Opera, Internet Explorer, or another browser within a designated list in the navigator object.

Lets take a look at what navigator.userAgent in Opera 8.5 returns depending on what it has chosen to identify itself as (whether automatically or manually):

As IE6: Mozilla/4.0 (compatible; MSIE 6.0; Windows XP) Opera 8.5 [en]
As Moz5: Mozilla/5.0 (Windows XP; U) Opera 8.5 [en]
As Opera: Opera/8.5 (Windows XP; U) [en]

Notice how if it's set to identify as IE, MSIE 6.0 appears within the string, while if set to identify as Mozilla, Mozilla/5.0 appears instead. As Opera itself, Opera/8.5 appears. In all three cases, the one commonality that we can exploit to actually detect Opera and its true version regardless of which identify it's decided to take on is the string "Opera x.x" or "Opera/x.x" within navigator.userAgent. In other words, there are two versions of the target string we need to be aware of. With that said, here's how you might go about testing for a specific version of Opera, which turns out to be no different than the technique used for detecting, say, Firefox:

<script type="text/javascript">
//Note: userAgent in Opera9.24 WinXP returns: Opera/9.24 (Windows NT 5.1; U; en)
//         userAgent in Opera 8.5 (identified as IE) returns: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1) Opera 8.50 [en]
//         userAgent in Opera 8.5 (identified as Opera) returns: Opera/8.50 (Windows NT 5.1; U) [en]

if (/Opera["/"s]("d+"."d+)/.test(navigator.userAgent)){ //test for Opera/x.x or Opera x.x (ignoring remaining decimal places);
 var oprversion=new Number(RegExp.$1) // capture x.x portion and store as a number
 if (oprversion>=10)
  document.write("You're using Opera 10.x or above")
 else if (oprversion>=9)
  document.write("You're using Opera 9.x")
 else if (oprversion>=8)
  document.write("You're using Opera 8.x")
 else if (oprversion>=7)
  document.write("You're using Opera 7.x")
 else
  document.write("n/a")
}
else
 document.write("n/a")
</script>

Output: n/a

Conclusion

We've seen how to use navigator to detect the browser type of your visitors. If the potential pitfalls and complexity of usage of it is a little too much for you, an alternative is to use Object Detection. Whichever method you choose, just be sure to choose one!

var setName = function(el, newName) {



el = (typeof el === "string") ? document.getElementById(el) : el;



el.name = newName;



if (/*@cc_on!@*/0) { // Internet Explorer test (needs to be modified for IE8)



el.mergeAttributes(document.createElement("<INPUT name='" + newName + "'/>"), false);



}



};

In Mootools 1.2.1:

var setName = function(elementId, newName) {



var el = (!!elementId) ? $(elementId) : null;



if (!elementId || !newName || !el) return;







el.set({ "name" : newName });



if (Browser.Engine.trident4 || Browser.Engine.trident5) {



el.mergeAttributes(document.createElement("<INPUT name='" + newName + "'/>"), false);



}



};

Demo:

Before OUTERHTML:



<INPUT id=renameTarget value="Set Random Name" type=submit>

I discovered a real JavaScript gem in PHPMyAdmin this morning. They have code that inserts content into a <textarea> at the cursor position instead of just at the beginning/end of the content. This is something I thought wasn’t possible – I’m quite pleased I was wrong.

I’ll be glad to see this code spread quickly to web forms that use buttons to aid in styling text and inserting image and link tags. WordPress and other blog and web forum packages would really benefit from this. (PHPMyAdmin is GPL, so any other GPL app should be able to use their code directly with attribution).

Here is a quick look at a generic version of the technique:

15个优秀的jQuery图片幻灯片/画廊效果，基本都已经包含了原插件的发布地址、使用方法和源代码下载。

1，Gallerific

Galleriffic 是使用 Mike Alsup 的 jQuery Cycle plugin 创建的图片展示效果，包括缩略图、图片标题和描述等详细功能，是一个非常不错的高质量画廊相册展示工具。

2，ZoomImage

zoomimage ，以一种独具魅力的方式展示图片效果。缩略图链接在本页弹出大图，并且可以可以随意拖拽该悬浮图片。

3，EasySlider

Easy Slider 可以实现图片或其他任意内容，在水平或垂直方向上的滑动效果，你还可以通过 CSS 自定义设置样式。

4，The Slider from Barack Obama’s website

一个源自美国总统 Barack Obama 网站的垂下滑动菜单控制的图片幻灯效果。

5，CodaSlider

CodaSlider， 又一个不错的滑动控制效果。

6，jQuery Slider II

jQuery Slider II 的布局非常符合操作习惯，在底部列出带滚动条的缩略图控制列表，然后在上面显示对应图片的大图浏览，非常适合做高级相册。

7，Beautiful Slider

Beautiful Slider， 光看这个效果图你就知道这个插件有多棒了吧，是的，这个插件实现的效果已经不逊色于Flash完成的效果，整体表现流畅，文字显示效果更是创意独特。

８，LoopedSlider

loopedSlider是又一个任意内容滚动 切换的幻灯片插件，使用操作简单。

9，SpaceGallery

SpaceGallery是一个全新的jQuery插件，点击当 前图片，会自动放大消失，同时后面的图片向前展示，有一种时光机器的感觉。

10，jQuery Popeye

11，Noobslide

12，Accessible News Slider

13，SmoothGallery

SmoothGallery是一个最好的 Javascript 幻灯片效果之一，可以实现各种不同的幻灯片转换效果。

14，jQuery Multimedia Portfolio

jQuery Multimedia Portfolio是一个基于jQuery 的滑动效果插件,除了可以展示图片之外，还可以加入各种不同类型的多媒体文件。

15，s3Slider

s3Slider是一个非常简单实用的流畅幻灯片效果，这个 插件被应用在无数的WordPress专业主题模板中。

javascript 字符串处理

文章来源：http://lmgq.vip.sina.com/tech/jsadvancedlesson/c2p1.htm

一、声明字符串:
var normal_monkey = "I am a monkey!<br>";
document.writeln("Normal monkey " + normal_monkey);

var bold_monkey = normal_monkey.bold();
document.writeln("Bold monkey " + bold_monkey);

这里的声明： var bold_monkey = normal_monkey.bold();
和下面对声明是等同的： 
var bold_monkey = "<b>" + normal_monkey + "</b>";

第1个版本的声明看起来要简明得多。这里用到了字符串对象中
的bold对象，其他的字符串对象还有indexOf, charAt, 
substring, 以及split, 这些方法可以深入字符串的组成结构。
首先我们研究一下indexOf。

2、indexOf
indexOf用于发现一系列的字符在一个字符串中等位置并告诉你子字符串的起始位置。如

果一个字符串中部包含该子字符串则indexOf返回returns "-1."
例子：
var the_word = "monkey"; 
 //让我们从单词 "monkey"开始。 
var location_of_m = the_word.indexOf("m"); 
 //location_of_m(字母m的位置)将为0，因为字母m位于该字符串的起始位置。
var location_of_o = the_word.indexOf("o"); 
 //location_of_o(字母o的位置)将为1。
var location_of_key = the_word.indexOf("key"); 
 //location_of_key(key的位置)将为3因为子字符串“key”以字母k开始，而k

在单词monkey中的位置是3。
var location_of_y = the_word.indexOf("y"); 
 //location_of_y)字母y的位置)是5。 
var cheeky = the_word.indexOf("q"); 
 //cheeky值是-1，因为在单词“monkey”中没有字母q。

indexOf更实用之处:
var the_email = prompt("What’s your email address?", "");
var the_at_is_at = the_email.indexOf("@");
if (the_at_is_at == -1)
{
    alert("You loser, email addresses must 
    have @ signs in them.");
}

这段代码询问用户的电子邮件地址，如果用户输入的电子邮件地址中不包含字符 则 提

示用户＂＠你输入的电子邮件地址无效，电子邮件的地址必须包含字符@。＂

3、charAt 
chatAt方法用于发现一个字符串中某个特定位置的字符。
这里是一个例子：
var the_word = "monkey";
var the_first_letter = the_word.charAt(0);
var the_second_letter = the_word.charAt(1);
var the_last_letter = the_word.charAt(the_word.length-1);

the_first_letter(第1个字符)是"m"
the_second_letter(第2个字符)是"o"
the_last_letter(最后一个字符)是 "y"

注意利用字符串的length(长度)属性你可以发现在包含多少个字符。在本例中，

the_word是"monkey"，所以the_word.length是6。不要忘记在一个字符串中第1个字符的

位置是0，所以最后一个字符的位置就是length-1。所以在最后一行中用了

the_word.length-1。>>

4、子字符串（substring）
子字符串（substring）和charAt有些象，不同之处在于它能够从一个单词中抓取整个的

子字符串，而不只是字母，这里是其格式：

var the_substring = the_string.substring(from, to);

"From"指的是子字符串中第１个字母的位置，"to"有点奇特，它是该子字符串中比最后

一个位置大１的位置．使用这种神奇的方法你可以标记子字符串的起始和结束位置，用

"to"的位置减去"from"的位置就会得出该子字符串的长度：

var the_string = "monkey";
var clergy = the_string.substring(0,4);
var tool = the_string.substring(3,6);

运行该段代码后变量clergy的值为"monk"; 变量tool的值为"key"。

子字符串常和indexOf一起使用，将字符串分成若干块．例如，
你可以从一个给定的URL中抽取出其域名：

var the_url = prompt("What’s the URL?","");
var lead_slashes = the_url.indexOf("//");
var domain_start = lead_slashes + 2;
var without_resource = the_url.substring(domain_start, the_url.length);
var next_slash = without_resource.indexOf("/");
var domain = without_resource.substring(0, next_slash);

这段代码的意思是：如果你输入
"http://www.webmonkey.com/javascript/index.html";，则域名 就是

"www.webmonkey.com" ．如果这个方法对你来说有些麻烦，我将向你介绍如何使用split

方法简化其执行过程．但是首先我们作一些分析．

基本的技巧是将第１个斜杠和第２个斜杠之间的内容分离出来：
var the_url = prompt("What’s the URL?",""); 
//这行代码向用户询问一个URL．假设用户输入了
"http://www.webmonkey.com/javascript/index.html."; 
var lead_slashes = the_url.indexOf("//"); 
这行代码确定第一个双斜杠的位置．在本例中lead_slashes的值是５，因为双斜杠的位

置从５开始．

你可能会想，通常的URL都是以http://开始，所以双斜杠的位置肯定是在５开始，为什

么还要加入indexOf这一段多余的代码呢？但是问题的关键在于你不知道用户在填入URL

时是否一定填入http:，他们也许会不小心多键入了一个空格，也许他们所键入的URL在

一个加密服务器上，其URL是"https://www.whatever.com/"; ． 在编程你必须预料到种种

可能发生的问题．所以我们必须用indexOf方法确定双斜杠的确切的起始位置．

var domain_start = lead_slashes + 2; 

这行代码用于计算该域名的第１个字母的起始位置．由于这里有一个双斜杠，所以域名

第１个字母的起始位置应该在双斜杠所在位置加２的位置．

var without_resource = the_url.substring(domain_start, the_string.length); 

这段代码将域名起始位置往后的所有字符都提取出来．所以执行完这行代码后

without_resource是"www.webmonkey.com/javascript/index.html." 

var next_slash = without_resource.indexOf("/"); 

这行代码计算出该字符串中下一个斜杠的位置，而从该字符串起始位置到这个斜杠之间

的内容就是域名．在本例中下一个斜杠的位置是17。

var domain = without_resource.substring(0, next_slash); 

最后一步是提取出该字符串起始位置到下一个斜杠之间的所有内容．在本例中使得域名

等同于"www.webmonkey.com"。

这样做确实很麻烦，利用split方法则可以使该过程容易很多．>>

5、分割方法(splitting method) 
你可以使用split方法用限位器来分割一系列的名称，然后将其
放在一个数组中．例如：

var my_friends ="trixie,moxie,sven,guido,hermes";

var friend_array =my_friends.split(",");

for (loop=0; loop < friend_array.length;loop++)
{    document.writeln(friend_array[loop] + " is myfriend.<br>");}

这段代码将字符串my_friends分割成包含５个元素的数组．JavaScript可以为你自动建

立一个数组，所以你无需使用new Array()．

将字符串分割成数组之后，我们使用了循环语句写出每一个名称．我们可以利用split方

法简化前面所讲到的域名提取：

var the_url = prompt("What’s the URL?","");
var first_split = the_url.split("//");
var without_resource = first_split[1];
var second_split = without_resource.split("/");
var domain = second_split[0];

这段代码简化了很多而且也更容易理解．我们来分析一些这段代码：

var the_url = prompt("What’s the URL?",""); 

提示用户输入一个URL，假设用户输入
"http://www.webmonkey.com/javascript/index.html"; ．
var first_split = the_url.split("//"); 
将用户输入的字符串分割成两块：first_split[0]是"http:"，first_split[1]是

"www.webmonkey.com/javascript/index.html." 
var without_resource = first_split[1]; 
//提取出数组中的第２个元素，所以现在without_resource是

"www.webmonkey.com/javascript/index.html." 
var second_split = without_resource.split("/"); 
将without_resource分割成３块：www.webmonkey.com,javascript, 和index.html．现

在你可以看到split的用途了吧？

var domain = second_split[0]; 

现在我们提取出新数组中的第１个元素就可得出域名．

Evaluates an expression after a specified number of milliseconds has elapsed.

(在指定时间过后执行指定的表达式)

Syntax:

Parameters

vCode	Required. Variant that specifies the function pointer or string that indicates the code to be executed when the specified interval has elapsed.
iMilliSeconds	Required. Integer that specifies the number of milliseconds.
sLanguage	Optional. String that specifies one of the following values: JScript Language is JScript. VBScript Language is VBScript. JavaScript Language is JavaScript.

Return Value

Integer. Returns an identifier that cancels the evaluation with the clearTimeout method.

==============================================================

以上内容摘自某本JScript教程(CHM格式,出处不详,跟原作者说声Sorry)

以下内容没抄任何人的,如果有雷同,估计不是你抄偶的就是巧合,嘿嘿.

-------------------------------------------------------------------
setTimeout( alert("3秒种过去了"), 3000);//调用一个函数,允许带常量参数
-------------------------------------------------------------------
<script language="Javascript">
//by zuoyang

var x = 1;
var y = 2;
var z = 3;

var sum;

function Plus(a, b)
{
          var z = 0;
          var i = 0;
          for (i = 0; i < arguments.length; i++)
          {
                   z += arguments[i];
          }
          setTimeout( function() {alert(z);}, 6000); //可以带变量参数的setTimeout调用形式
          return z;
}

setTimeout( function(){ sum = Plus(x, y, z); }, 3000);/*除了可以带变量参数还可以获取返回值的setTimeout调用形式*/

</script>

setInterval()的用法和setTimeout()是一样的:

iTimerID = window.setInterval(vCode, iMilliSeconds [, sLanguage])

不同的是setTimeout()是一次性作用,而setInterval()是每隔iMilliSeconds就执行一次vCode.(Evaluates an expression each time a specified number of milliseconds has elapsed)

假如文本中包含了大量的 "<" 和 "&" 字符 - 就像编程代码中经常出现的情况一样 - 那么这个 XML 元素就可以被定义为一个 CDATA 部分。

CDATA 区段开始于 "<![CDATA["，结束于 "]]>"：

<script type="text/javascript">
<![CDATA[
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
]]>
</script>

在上面的例子中，在 CDATA 区段中的所有东西都会被解析器忽略。

关于 CDATA 区段的注释:

CDATA 区段不能包含字符串 "]]>"，所以，CDATA 区段的嵌套是不被允许的。

同时也需要确保在 "]]>" 字符串中没有空格或折行。

为什么要使用CDATA:

       XHTML的第二个改变是使用CDATA段。XML中的CDATA段用于声明不应被解析为标签的文本（XHTML也是如此），这样就可以使用特殊字符，如 小于（<）、大于（>）、和号（&）和双引号（"），而不必使用它们的字符实体。考虑下面的代码：

<script type="text/javascript">
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
</script>

这个函数相当简单，它比较数字a和b，然后显示消息说明它们的关系。但是，在XHTML中，这段代码是无效的，因为它使用了三个特殊符号，即小于、 大于和双引号。要修正这个问题，必须分别用这三个字符的XML实体&lt;、&gt;和&quot;替换它们：

<script type="text/javascript">
function compare(a,b)
{
if (a &lt;b)
   {alert(&quot;a小于b&quot;);}  
else if (a&gt;b)
   {alert(&quot;a大于b&quot;);}
else
   {alert(&quot;a等于b&quot;);}
}
</script>

这段代码存在两个问题。首先，开发者不习惯用XML实体编写代码。这使代码很难读懂。其次，在JavaScript中，这种代码实际上将视为有语法 错，因为解释程序不知道XML实体的意思。用CDATA段即可以以常规形式（即易读的语法）编写JavaScript代码。正式加入CDATA段的方法如 下：

<script type="text/javascript">
<![CDATA[
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
]]>
</script>

虽然这是正式方式，但还要记住，大多数浏览器都不完全支持XHTML，这就带来主要问题，即这在JavaScript中是个语法错误，因为大多数浏览器还不认识CDATA段。

<script type="text/javascript">
//<![CDATA[                                            
function compare(a,b)
{
if (a < b)
   {alert("a小于b");}
else if (a>b)
   {alert("a大于b");}
else
   {alert("a等于b");}
}
//]]>                                      
</script>

当前使用的解决方案模仿了“对旧浏览器隐藏”代码的方法。使用单行的JavaScript注释"//"，可在不影响代码语法的情况下嵌入CDATA段：

现在，这段代码在不支持XHTML的浏览器中也可运行。

但是，为避免CDATA的问题，最好还是用外部文件引入JavaScript代码。

XHTML is subject to the same syntactical rules as XML. Because of this, an XHTML processor treats the characters < and & as markup, even if they reside inside a <script> block. Since the < and & characters are also used by the JavaScript language, this creates a conflict. When an XHTML processor sees these characters within the JavaScript code of a <script> block, it attempts to parse the JavaScript code as if it were markup, which causes the XHTML parser to fail.

You can get around this conflict and make all JavaScript code compatible with XHTML by placing the JavaScript code within a CDATA section. A CDATA section in XML/XHTML starts with the characters <![CDATA[ and ends with the characters ]]>.

Any characters within the starting and ending element of a CDATA section are not treated by the XML/XHTML processor as markup, thus preventing a conflict.

Here is an example of how to declare JavaScript code within a CDATA section so that it is compatible with XHTML:

Note that JavaScript source code must be placed within the opening and closing elements of the CDATA section. The CDATA section itself should be commented out with a JavaScript single-line comment // as in the example above. This is so that the JavaScript interrupter does not interpret the CDATA markup as JavaScript, which would cause a JavaScript error.

JavaScript code that is imported into an XHTML document from an external source file is always compatible with XHTML. So, for example, any code you place into the external file external.js and import into an XHTML file via the src attribute of the <script> tag will be valid. Here is an example of how to import the file external.js:

XHTML™ 1.0 The Extensible HyperText Markup Language (Second Edition) 定义XHTML是为了把HTML 4扩展成像XML 1.0一样的应用程序。

在许多站点中XHTML正在迅速的替代HTML 4；然而，主流浏览器对完全支持XHTML方面表现得不足，和网页设计师对HTML 4与XHTML的基本差异缺乏理解，产生了当今网络上的一个不断扩大的问题。

<script type="text/javascript">



var i = 0;







while (++i < 10)



{



// ...



}



</script>

<style type="text/css">



<!--



body {background-color: blue; color: yellow;}



-->



</style>



<script type="text/javascript">



<!--



var i = 0;



var sum = 0;







for (i = 0; i < 10; ++i)



{



sum += i;



}



alert('sum = ' + sum);



// -->



</script>

<script type="text/javascript">



<!--



var i;



var sum = 0;







for (i = 10; i > 0; --i)



{



sum += i;



}



// -->



</script>

<script type="text/javascript">



//<![CDATA[



var i = 0;







while  (++i < 10)



{



// ...



}



//]]>



</script>

建议

理解XHTML 1.0的HTML兼容指导

这个XHTML 1.0 HTML Compatibility Guidelines帮助创建XHTML文档向后兼容性在那些不能理解XML的老浏览器。

请注意那是纯粹的XHTML文档，你不需要使用xml-stylesheet处理指导，但应该使用link涉及的外部文件包含CSS。

本文转自：http://info.codepub.com/2008/09/info-22582.html

原文如下：

MarkitUp - jQuery

Official Website | Demo

功能不是很多，但很轻量，很灵活。打包后只有6.5K大小。

jWYSIWYG - jQuery

Official Website | Demo

非常基本的编辑器，简单为本。打包后只有7K。

Lightweight RTE- jQuery

Official Website | Demo

简单到不能再简单，很容易自己修改。

HTMLBox - jQuery

Official Website | Demo

跨浏览器，开源，基于 jQuery。可以很容易同各种 CMS，论坛，留言本，博客等系统集成。

D Small Rich Text Editor - jQuery

Official Website | Demo

基于 iframe 对象。

WYMEditor - jQuery

Official Website | Demo

TinyMCE - non-jQuery

Official Website | Demo

最经典的基于 JavaScript 的编辑器，COMSHARP CMS 默认的编辑器就是这个。

fckeditor - Non-jQuery

Official Website | Demo

功能非常强大。

Yahoo YUI Rich Text Editor - Non-jQuery

Official Website | Demo

基于 Yahoo YUI，简单，但很可靠。

Xinha - Non-jQuery

Official Website | Demo

自由的基于  BSD 许可编辑器，功能完善，很适合同各种系统集成。

本文原文来源：http://www.queness.com/post/212/10-jquery-and-non-jquery-javascript-rich-text-editors

Pop-Up Blocking

window.open

window.showHelp

window.showModalDialog

window.showModelessDialog

window.external

window.NavigateAndFind

在web编程过程中，经常会遇到一些页面需要弹出窗口，但是在服务器端用window.open弹出的窗口会被IE阻止掉，showModalDialog弹出的窗口有时并不能满足我们需要，我们需要弹出新的浏览器窗口。

 为什么我们编写的弹出窗口会被IE阻止呢，原来IE会自动判断弹出窗口的状态，它会阻止自动弹出的窗口，而通过我们用鼠标点击弹出的窗口，它是不会阻止的。这里就有一个问题，有人说：我的程序是写在服务器按钮里的，也是通过鼠标点击弹出的呀！其实只有在加载页面后，我们点击到弹出这段时间页面没有被重新加载的情况下，弹出的窗口才不会被阻止！这也就是说，写在服务器控件的回传事件里的window.open都会被阻止。

继续Google解决办法，在分析了几种解决方法并进行对比之后，发现最简单有效的方法如下：
在window.open()函数中增加一个参数，将target设置为‘self’，
即改为使用： window.open(link,'_self');
问题解决。