博客园_Rico In Code

用户界面草图设计工具-工具包和资源

2011-11-01T03:21:00Z

UI界面与设计使用的元素，软件，网站等。内容很丰富，适合网页设计师，用户体验设计师，界面设计师，产品设计师，JS前段开发，手机产品设计，ipad产品设计等使用

Lumzy

Lumzy是一个网站应用和原型界面制作工具。使用Lumzy，您可以轻松创建UI模型并即时发送到客户电脑中。 Lumzy还具有团队协作编辑工具。

Mockingbird

百舌鸟是一个在线工具，它使您轻松地创建UI界面模型，预览UI，并可以共享你的版面编排效果图。

The Pencil Project

为设计图表和用户界面图形原型开发的一个自由和开源工具。

Dojo

Dojo提供了强大的性能并节省您的时间。这是适合经验丰富前端开发者的JS开发工具包。

Mocklinkr

MockFlow

MockFlow是一个在线工具，用户界面设计和协作版面编排工具。

Serena Prototype Composer

Serena Prototype Composer是制作流程图，模拟程序流程和用户界面设计程序。

Cacoo

Cocoo是一个用户友好的在线绘图工具，允许你创建一个如网站地图，线框，UML和网络图图等。 Cacoo可以免费使用。

DENIM

一个早期非正式的网站和用户界面设计工具

Hot Gloo

网上应用线框

User Interface Design Framework

一个免费提供网页设计师使用的用户界面设计工具。

Pattern Tap

可以寻找一些设计资源与模式等。

User Interface Design Patterns

提供一些热门的用户UI界面设计模式参考图，分类很详细，如果设计网站或UI界面可以上去找一些资源，很不错。

Patternry

Patternry是用户界面设计模式库的目的是帮助解决常见的接口设计问题。

Mephobox

UI设计界面资源欣赏参考网站。

Android Asset Studio

可以在线生成图表，只需要输入参数即可

Mobility

移动用户界面设计使用，可以输入参数进行测试，很方便

Android UI Elements Set

可以自由设定Android操作系统的用户界面元素。

OSX Leopard GUI Set

该软件包含一些常用的Photoshop原文件和PNG文件，这些元素都是用来设计GUI界面的素材，通过该软件你可以快速制作出一些出色的界面

ALL In One Web Elements Kit

网页布局元素大集合,PSD文件。

iPad GUI Set

iPad平板电脑上设计布局用的元素集合。

本文链接

IIS URL Rewrite Model & ASP.NET Route Component ‘s Diff

2011-10-10T07:59:00Z

针对IIS 7.0的URL重写模块，以及在.NET框架3.5 SP1中包含了ASP.NET路由（Routing），许多ASP.NET开发人员开始质问这两种特性彼此间的关系，以及应该何时使用。

二者本质的区别在于：IIS URL重写的处理方式比ASP.NET路由在层次上更低，对于客户端是不可见的。

Ruslan给出了IIS 7 URL重写过程的可视化工作流。你可以看到URL重写模块是在请求被传递到请求处理器（Handler），例如ASP.NET管理的ASPX处理器之前被激活的。IIS URL重写并不知道具体的请求处理器。

他同时还给出了ASP.NET路由过程的可视化工作流。可以看到ASP.NET路由就是一个请求分发器，它必须明确地获知一个特定的请求究竟应途经哪个处理器。

URL重写通常被用于在Web服务器处理请求之前操作URL路径。URL重写模块并不知道处理器实际处理URL重写的任何内容。此外，实际的请求处理器并不知道URL是否已被重写。
ASP.NET路由通常根据请求的URL路径将请求分发到处理器。与URL重写相反，路由组件知道处理器，并能够选择可以为请求的URL生成反应的处理器。你可以将ASP.NET路由看作是一个高级的处理器映射机制。
IIS URL重写模块能够用于任何类型的Web应用程序，包括ASP.NET，PHP，ASP和静态文件。ASP.NET路由只能用于基于.NET框架的Web应用程序。
在用于应用程序池方面，不管是集成的还是经典的IIS管道模式，IIS URL重写模块的工作方式都是相同的。而ASP.NET路由则会优先选择使用集成管道模式。ASP.NET路由也可以工作于经典模式，但是在这种情况下，应用程序的URL必须包含文件扩展名，或者应用程序必须在IIS中使用“*”配置处理器。
URL重写模块可以根据域名、HTTP标头和服务器变量进行重写判断。默认情况下，ASP.NET路由只能使用URL路径以及标头的形式。
除了重写功能，URL重写模块能够执行HTTP重定向，确定自定义状态码以及取消请求。ASP.NET路由则不具有这些功能。
URL重写模块在当前版本中是不能扩展的。ASP.NET路由完全能够扩展和定制。

左：IIS7 URL Rewrite

右：ASP.Net Route

本文链接

Entity Framework 4 & 4.1

2011-08-02T01:24:00Z

Entity Framework中的批量提交与事务处理

Entity Framework 4.1 Code First学习之路（二）

QA1:

布署EF 4.1时遇到此问题：

未能加载文件或程序集“Model, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”或它的某一个依赖项。拒绝访问。

1.检查一下Web.Config中是否缺少

<system.web>
    <compilation debug="true" targetFramework="4.0">
      <assemblies>
        <add assembly="System.Data.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
      </assemblies>
    </compilation>

2.这时问题应该解决了一半，还会报一个错“用户 'IIS APPPOOL\ASP.NET v4.0' 登录失败。 ”

在iis管理器中——》应用程序池——》ASP.NET V4.0————》高级设置——》标识——》改为localSystem或者NetworkService。

3.如果还有问题，请参照“IIS APPPOOL\RwindRhine登录失败的解决方案”

QA2:

EF4.1 报错：Unable to load the specified metadata resource

是因为以下数据配置有问题

4.“Unable to update the EntitySet XXXXXX because it has a DefiningQuery and no element exists in the element to support the current operation.” is one of the errors you will eventually run into with the ADO.NET Entity Framework 1.0.

A Probable Cause

If a table doesn’t have a primary key defined, this error will occur when you’re trying to delete an object. The generated EDMX file should also generate a warning:

Warning 6002: The table/view ‘TABLENAME’ does not have a primary key defined. The key has been inferred and the definition was created as a read-only table/view.

A solution to this problem is simply adding a primary key to the table and update your EDMX model.

本文链接

[转] LINQ Method cannot be translated into a store expression.

2011-07-13T03:19:00Z

LINQ to Entities does not recognize the method 'Int32 ToInt32(System.String)' method, and this method cannot be translated into a store expression.

This is a shortcomming of LINQ to Entities, and indeed the ADO.NET Entity Framework at the current release! The reason for a similar exception message is that in queries on the Entity Framework, custom methods and extensions methods cannot be translated into store expressions.

There are workarounds to still enjoy LINQ to Entities and as an example please read the following:

My example uses the AdventureWorksDB database which can be downloaded from http://www.codeplex.com. I’ve generated the Entity Data Model from the database (in case you wish to replicate this behavior). The scenario is the following: I have a TextBox and a Button on a form and I want to print the name of the Contact by entering the ContactID into the TextBox.

<div>
    <asp:Label ID="lblContactID" runat="server"
               AssociatedControlID="txtContactID">ContactID:</asp:Label>
    <asp:TextBox ID="txtContactID" runat="server"></asp:TextBox>
    <asp:Button ID="btn" runat="server" Text="Search" OnClick="btn_Click" />
     
    <asp:Label ID="lblContactName" runat="server"></asp:Label>
</div>

The obvious thing to do is to apply a Where clause on an EntityCollection and filtering everything on the ContactID given in the txtContactID TextBox. If you use Convert.ToInt32(“ID”) in the Where clause the upper Exception is thrown.

protected void btn_Click(object sender, EventArgs e)
{
    AdventureWorksEntities entities = new AdventureWorksEntities();        
    Contact contact = entities.Contact
            .Where(c => c.ContactID == Convert.ToInt32(txtContactID.Text)).FirstOrDefault();
    if (contact != null)
        lblContactName.Text = contact.FirstName + " " + contact.LastName;
    else lblContactName.Text = "Contact not found!";
}

The workaround to this is to declare a variable of type int, which contains the converted value from the TextBox and use this variable in the Where query.

protected void btn_Click(object sender, EventArgs e)
{
    AdventureWorksEntities entities = new AdventureWorksEntities();
    int ContactID = Convert.ToInt32(txtContactID.Text);
    Contact contact = entities.Contact
                     .Where(c => c.ContactID == ContactID).FirstOrDefault();
    if (contact != null)
        lblContactName.Text = contact.FirstName + " " + contact.LastName;
    else lblContactName.Text = "Contact not found!";
}

Because this feature is available in normal LINQ to SQL I hope the ADO.NET team will do some improvement on this in the next major release of the Entity Framework.

本文链接

Script#

2011-04-28T15:52:00Z

At MIX11 last week, I presented the Script#: Compiling C# to JavaScript using Visual Studio.

As full-fledged script-based development becomes widespread with the HTML5 wave, a couple set of interesting questions emerge - what are the development tools you and your team uses to productively author and manage a code base? Shouldn’t you write code in a model that is optimized for development and productivity and let a compiler do its magic and produce code that is optimized for deployment and runtime?

Script# allows you to write your code in C# and compile it down to deployable JavaScript, it also unlocks the power of C#, Visual Studio and existing .NET tools for scripting scenarios.

The Script# Project

Productivity and better tooling are primary motivators behind Script#. At the same time, a fundamental design tenet and driving philosophy behind the design of Script# is to produce script that resembles hand-written script that is aware and faithful to the script runtime environment found in browsers. Specifically the compiler does not introduce unnecessary layers of abstraction or indirection. The idea is you’re simply writing script in a better and pragmatic way, rather than trying to port a .NET application to the browser, which is more likely to produce impractical results.

Script# allows programming against the DHTML DOM APIs and JavaScript APIs, as well as Silverlight 1.0 script API. The compiler itself isn’t coupled to any one particular framework. You can use Script# to program against Microsoft ASP.NET Ajax as well as other 3rd party frameworks such as ExtJS (via Ext#). At the same time, the compiler is complemented by an optional ScriptFX framework, which is a small framework built using Script# itself. Finally, if you have existing scripts, they can be imported and then used from new C# code so you don’t have to rewrite everything from scratch to start using Script#.

Scripts generated using Script# are honest-to-goodness plain old JavaScript files, that you can freely deploy into your applications, and there is no runtime dependency on the Script# compiler. This is further explained in the Understanding Script# page. You will need .NET 2.0+ and/or Visual Studio on your development machine. You can also use Visual C# Express which is available for free.

Script# is an evolving project, but is quite mature and ready for use in real-world projects such as those listed in the showcase. Script# is being used both internally within Microsoft as well as external applications. It was first released in May 2006 (introductory blog post). Over the course of the last two+ years, it has been regularly updated with new features and bug fixed based on actual usage and feedback from developers like you. You can read about the latest release on the release history page. Please do continue sending any feedback on Script# that you might have.

The content on this site will be updated periodically to include additional concepts and tutorials. Please subscribe to the Script# feed to stay up-to-date or check this page often.

What you can build with Script# Project

Ajax Applications – Script# allows you to implement the Ajax code for your pages and mashups using a choice of frameworks. (see tutorial)
Ajax Frameworks and Components – Script# allows you to create reusable script libraries and components that can be consumed during further application development using either Script# or via direct JavaScript as well.
ASP.NET Ajax Server Controls – Script# can be used to develop script libraries containing components such as controls and behaviors that can then be embedded into server controls and control extenders. (see tutorial)
Sidebar Gadgets – Script# can be used to program gadgets for Windows Vista by referencing the Gadget APIs, RSS Feed APIs and File System APIs in addition to the default DHTML DOM APIs. (see tutorial)

A set of samples available with the Script# install demonstrate some of these uses of Script# further. Read the topic on What's in Script# to understand more about what is currently available.

An in-depth list of how C# constructs are mapped to JavaScript is described on the topic From C# to Script. On the flip side, an in-depth list of how script constructs are modeled in C# is described on the topic Achieving Script’isms in C#.

Script# Roadmap

The Script# project has been an on-going piece of work. The following are on the list for a v1 release during 2009 beyond what is available in the current and latest build:

Unit testing support
jQuery support
High priority bug fixes and improved Visual Studio integration

Longer term, there are a number of additional features on the roadmap such as:

Support for generics
Support for static linking and other script optimizations
Support for additional script APIs and scenarios

本文链接

C# + Html5 =C3

2011-04-27T11:41:00Z

There are some rumors lately about a new Microsoft project called C3 (cloud computing client, or a synonym to C# [the # key is the same as '3' in a QWERTY keyboard]) which is designed to bring better development experience to web, using Html5, JavaScript and CSS in combination with some Microsoft based technologies (.Net, C#, etc.).

In very high level, what Microsoft is trying to do with this project is to ease the development experience of building a web application using Html5 by providing better coding tools that will provide things that do not exist today such as:

type-safe variables
modular architecture
managed languages such as C#

Microsoft is constantly trying to keep developers from leaving Visual Studio in favor of other IDE's and a new set of tools for Html5 can definitely bring value to web developers aiming to build features rich applications that will work both online and offline.

I've recently predicted that by 2013, Html5 based applications will rule the enterprise, because of all the advantages this technology brings together with being the only true device agnostic technology to date.

Since I've recently participated in a project which involved Html5, mobile apps, offline mode, and an extremely powerful design, I would like to give an example of how web development (for mobile) can change with the introduction of Html5:

In most web applications, every time you a submit a request, save a change, or goes to another page – you actually send a request to the server. This is probably the oldest pattern in web, but it also means you need a valid connection to the server 100% of the time.

The request is sent to the server, the server builds the response, generates the page and content, and sends it back to the client.

This is perfect for desktop applications , but what about a smartphone or tablet which is sometimes offline? no connection then, which means the application is stuck.

This is where Html5 can come to the rescue; with a local database, caching of the pages, and some extensive JavaScript code – you can practically process the requests in the client side, without having to call the server. The requests to the server can be stored in the database as well and can be synced whenever connectivity is back. (In the past, developers tried to minimize the use of JavaScript in the client side due to performance issues – but as we progress, browsers are now completely capable of doing massive JS work without any issue).

Such kind of pattern (offline storage, message queues, client side processing) was typical for native mobile applications years ago, and now Html5 enables such patterns for mobile web apps as well. The only problem with it is that as a developer you have to build your product infrastructure to make it work. That's a lot of work, and I'm talking from my own experience. Unless… unless Microsoft comes up with a new technology that will make most of it ready, and thus simplify the entire thing. It will be similar to building a new improved version of Silverlight which is based on Html5, JavaScript and CSS and does not require any ActiveX installation whatsoever. Think how efficient that could be!

Now, if Microsoft can also add to it some C# wrappers so that developers can use C# when they code instead of JavaScript – that can be even better! Faster coding, type-safe, database, client side processing, a perfect world.

Amazing stuff.

What's even more amazing is that such a product already exists.

Thousands are already using it. It's called: Script# (Script Sharp).

Oh, and it's free too…

And you can read all about it in here: Script#.

---

本文链接

[转]qUIpt：JavaScript Cache Library

2011-04-15T02:11:00Z

qUIpt 是一个很小很小的 JavaScript Library，所有原始码也才只有 115 行而已（包括批注），我觉得作者 Mario Heiderich 真是太有创意了，他的原理十分简单，使用的 Cache 方法是将数据储存在 window 对象的 name 属性中 ( window.name )，在这里他是将透过 XHR ( XML Http Request ) 取回的 JavaScript 档案内容储存在 window.name 属性里。

通常 window.name 是用在 window.open() 的时候指定的第二的参数，还有当我们在窗体(form)中设定 target 属性的时候，这个 target 指定的就是 window.name 的值，但预设来说 window.name 大部分来讲都是空的，所以 qUIpt 就拿这个属性来做额外的快取(Cache)用途。

qUIpt 基本的运作流程如下：

首先，他先检查你的 window.name 是否有资料。
如果 window.name 是空的，就透过 XHR 动态下载 JavaScript 档案，并将档案内容储存在 window.name 属性中。
如果使用者第一次造访你的网页，或从其他网站进来的，就会先将 window.name 给清空，并重新下载 JS 档回来。
等使用者下次造访你的网页（例如连到下一页），就直接用 eval() 函示将 window.name 的 JS 读出执行，这样所有对象都重新被加载回来了，完全不需要重新下载 JavaScript 檔。

底下这段 code 说明了这个运作流程：

/**
* some security checks to avoid arbitrary off-site
* self.name poisoning
*/

if(document.referrer == '' ||
document.referrer.match(/\w+:\/\/[^\/]+/)[0]
!== location.href.match(/\w+:\/\/[^\/]+/)[0]) {
self.name = '';
}

/**
* let's start
*/
if(!self.name.length) {
quipt_load();
} else {
quipt_eval();
}

原理就是这么简单，你可以下载看原始码回来看，才几行而已，也许可以激发你一些更有创意的想法。

由于此项目十分的阳春，毕竟是第一版嘛，经我个人测试之后发现只有 Firefox 能用，IE 目前是无法执行的，所以我小修了一下程序把一些仅支持 Firefox 的语法给修正了，底下的 code 应该可以运作于 Firefox 与 IE 7 ( 其他版本的 IE 我没测试过 )。

/**
* quipt - caching in the name of performance
*
* @author Mario Heiderich <mario.heiderich@gmail.com> , Will 保哥 <doggy.huang@gmail.com>
* @license LGPL
*/
(function quipt_init() {

/**
* the config object
*/
var quipt_config = {

/**
* the method to call when loading is done
*
* hint: just set it to false if not needed
*/
'starter' : 'my_init_function',

/**
* add files to load to this array
*
* hint: you can add as many files as you wish - as long as they
* come from the same domain. quipt also supports proxied
* off-domain scripts.
*/
'files' : [
'jquery-1.2.6.min.js',
'dummy-js-file-01.js',
'dummy-js-file-02.js'
],

/**
* don't touch this - private stuff! else!
*/
'status' : 0
}

var quipt_code = [];

/**
* the loader method - it monitors the status of the ressource
* fetching and kick-starts the XHR method
*
*/
var quipt_load = function() {
quipt_request();
}

/**
* this method just fires XHR requests against the files given in the
* config literal until all ressources are fetched
*
*/
var quipt_request = function() {
try {
console.log('loading ressources from filesystem');
} catch(e) {}

var x = new XMLHttpRequest();
x.open('GET', quipt_config.files[quipt_config.status], true);
x.send(null);
x.onreadystatechange = function() {
if(x.readyState == 4 && x.status == 200) {
quipt_code.push(x.responseText);
quipt_config.status++;
self.name += x.responseText + ';\n';
if(quipt_config.status < quipt_config.files.length) {
quipt_request();
} else {
quipt_eval();
}
}
}
}

/**
* the eval method - which is called if window.name contains
* the right data
*/
var quipt_eval = function() {
self.eval(self.name);
if(quipt_config.starter) {
self[quipt_config.starter]();
}
}

/**
* some security checks to avoid arbitrary off-site
* self.name poisoning
*/
if(document.referrer == '' || document.referrer.match(/\w+:\/\/[^\/]+/)[0]
!== location.href.match(/\w+:\/\/[^\/]+/)[0]) {
self.name = '';
}

/**
* let's start
*/
if(!self.name.length) {
quipt_load();
} else {
quipt_eval();
}
})();

本文链接

Project Calculation Rules

2011-03-02T14:38:00Z

2011-03-02T14:38:00Z2011-03-02T14:38:00ZRicoRuihttp://www.cnblogs.com/RuiLei/

本文链接

Proposal for Delayed Script Execution

2011-03-02T12:01:00Z

Presently, HTML5 documents are limited in the number of ways a script can be loaded:

By default, a <script> tag immediately begins to download an external JavaScript file and executes when the download is complete. Multiple <script> tags placed in order will always execute in order, blocking further execution and resource downloads until each script is executed. User agents may download the external files in parallel but always execute the scripts in order.
When a <script> tag is marked with defer, the download of the external file begins immediately but execution is deferred until after the DOMContentLoaded event and before the load the event. Deferred scripts do not block but do preserve the order of execution.
When a <script> tag is marked with async, the download of the external file begins immediately and execution occurs as soon as the file is completely downloaded. An async script does not block other resources from being downloaded. Multiple async scripts do not preserve the order in which they are specified, instead each executes as soon as it is completely downloaded. This occurs before the load event.

Each approach solves a very specific problem but no approach solves them all. For instance, there is no way to download a JavaScript file and delay it’s execution until a later point in time that can be defined by the developer (deferred scripts are the closest, but the execution point is predetermined and unchangeable).

Goal

This proposal is intended to describe a mechanism whereby JavaScript can be included in an HTML page, either via inline script or external file, and the parsing and execution is delayed until a time determined by the developer.

Rationale

Currently, there are various script loaders such as LAB.js and ControlJS that seek to alter the way that scripts are loaded onto a page. Each script loader operates on their own theory of how best to load script files, whether to optimize for parallel downloads or delay execution until a later point in time. After some consideration, it seems that developer-controlled execution time of JavaScript is a minimal feature that would enable parallel downloads as well as other execution paradigms.

Requirements

The functionality must be exposed to feature detection techniques.
Avoid double downloads of a single file.
Don’t inhibit the ability to download files in parallel and execute in any arbitrary order.

Proposal Summary

Allow scripts to be marked as “preload”, indicating that the script should be downloaded (in the case of external scripts) but not executed immediately. Since the script isn’t being executed, it must not block other page resources from being downloaded (which would allow parallel downloading). Developers may instruct the script to execute at a later point in time.
This proposal is based largely on the Internet Explorer implementation for dynamic script nodes. In that implementation, the external script file begins to download as soon as src is assigned but the script is not executed until the node is added to the document. This is a nice feature but suffers from several drawbacks:

No way to feature detect that this behavior happens (as opposed to other browsers that only begin to download when the script node is added to the document).
No way to determine when the script is downloaded but not ready for execution.

This proposal seeks to build upon this behavior to fix these shortcomings.

Proposal Details

HTML Usage

There is no HTML usage for the preload attribute. If an attribute named preload is included in an HTML <script> tag, it must be treated as an unknown attribute.

JavaScript Usage

Scripts may be dynamically loaded from JavaScript by creating a <script> element and setting its preload property to true (default value is false). Example:
var script = document.createElement(“script”);
script.preload = true;
script.src = “foo.js”;
When the src attribute is assigned, the JavaScript file should be downloaded per user agent default and stored in the appropriate user agent cache(s) but not executed. User agents may background parse or compile the script in preparation for execution but must not execute the code until instructed to do so.
In order to execute the code, the script node must be added to the document:
document.body.appendChild(script);
Upon adding into the document, the contents of the external file referenced by the <script> element must be executed synchronously in the global scope per usual user agent behavior.

Additional HTMLScriptElement Members

In order to accurately detect and react to changes in script state due to this proposal, several changes and additions are necessary to the HTMLScriptElement.
interface HTMLScriptElement : HTMLElement {
attribute DOMString src;
attribute boolean async;
attribute boolean defer;
attribute DOMString type;
attribute DOMString charset;
attribute DOMString text;
attribute boolean preload;
};
The only change is the introduction of a preload property. As discussed earlier, setting this to true prior to the src being set puts the script into preload mode, where code may be downloaded but not executed.
The default value for preload is false. When preload is false, the user agent may download and execute the external script according to its normal behavior.
For feature detection, a developer may determine if this proposal has been implemented by detecting the preload property:

var preloadSupported = (typeof
document.createElement(“script”).preload == “boolean”); Changes to HTMLScriptElement Events

HTML5 defines two events: load and error. The load event fires on preload scripts only after the script has been downloaded and executed; the error event functions exactly the same for preload scripts.
Additionally, In order to fulfill the requirements of this proposal, it’s necessary to introduce a new event for HTMLScriptElement. The preload event fires with a preload script has been completely loaded and is ready for execution. You can therefore determine when a script has been preloaded using the following:
var script = document.createElement(“script”);
script.preload = true;
script.src = “foo.js”;
script.onpreload = function(event){
document.head.appendChild(script);
}; To ensure a script has been preloaded properly, you should also listen for the error event.

Additional Behaviors

Since preloaded scripts alter the behavior of dynamic scripts slightly, there are a few edge cases to consider.

Any attempt to set the text property on a dynamic script element already marked with preload is ignored. If the preload property is set to true after the text property is set to a value, then the preload property is ignored and remains false.
If cloneNode() is called on a script marked as preload, then the cloned script node cannot be executed.

Possible Augmentation

One possible augmentation of this proposal is that preload automatically be set to true for script elements created using JavaScript, thus allowing developers to opt-out of this functionality by setting to false rather than opt-in. This likely would work since this is the default behavior in Internet Explorer already.

Examples

Mimic deferred scripts

The following is an example of using this proposal’s functionality to simulate deferred scripts in JavaScript. Note that real deferred scripts fire before DOMContentLoaded, while this will fire during.

The following is an example of a script loader that allows scripts to download in parallel but execute in the order in which they are specified. This is done by creating preload scripts for each external JavaScript file and waiting until they are all loaded. Once all are loaded, a loop is used to execute each in order.
var ScriptLoader = (function(){
var batches = [];
function handlePreload(batchId, scriptId){
var batch = batches[batchId],
script = batch.scripts[scriptId];
batch.loaded++;
//all scripts are now loaded
if (batch.loaded == batch.scripts.length){
for (var i=0, len=batch.scripts.length; i<len; i++){
document.body.appendChild(batch.scripts[i].scriptNode);
}
batch.success();
}
}
function handleError(batchId, scriptId){
var batch = batches[batchId];
batch.error()
}
return {
loadScripts: function(urls, successCallback,
errorCallback){
var batch = {
scripts: [],
success: successCallback,
error: errorCallback,
id: batches.length,
loaded: 0
},
i=0,
len = urls.length,
script;
batches.push(batch);
while(i < len){
script = document.createElement("script");
script.type = "text/javascript";
script.preload = true;
script.onpreload = (function(scriptId){
return function(){
handlePreload(batch.id, scriptId);
};
})(i);
script.onerror = (function(scriptId){
return function(){
handleError(batch.id, scriptId);
};
})(i);
batch.scripts.push({scriptNode: script, id: i});
script.src = urls[i];
document.head.appendChild(script);
i++;
}
}
};
})();
//usage
ScriptLoader.loadScripts([“foo.js”, “bar.js”],
function(){
foo.init();
},
function(){
alert(“On no!”);
}
);

本文链接

10个有用的网站访问分析工具

2011-01-10T14:54:00Z

几乎所有的网站,不论是门户网站还是个人博客,都少不了一些网站访问分析,最简单的就是一个计数器!这对于分析网站的访问人群等等指数具有十分重要的意义,对于广告的投放也十分重要!

下面是10个常用的网站分析工具!

goingup!

Clicky

Google Analytics

W3Counter

Woopra

W3Perl

Piwik

TraceWatch

Snoop

本文链接