未完待续

周日还在写邮件询问Google Storage的事，它现在只针对美国开发者开放。周一还是意外收到邮件拿到了邀请，免不得晚上熬夜把玩了一番。现在收到邀请的开发者配额有100GB的数据存储空间和300GB的月流量，超过使用可以向他们开发团队申请增加。

Google Storage for Developers（简称GS）目前提供三种形式的管理工具，基于网页界面的Google Storage Manager，开源的命令行管理工具GSUtil Tool和Python Library（改进过的boto，原为Amazon S3的）。

Google Storage Manager

Google Storage Manager的界面比较简单，只能新建Bucket(存储库)，新建文件夹，批量上传，批量删除和共享文件，虽然GS有严格的访问控制权限（ACLs），但在Google Storage Manager里面还无法管理权限分配。同时还提供了一个类似书签的地方保存经常使用的存储库和文件夹用于快捷访问。
Google Storage Manager 不能单独使用IE访问，可以使用下面版本的浏览器访问：

Google Chrome 4.1+
Chrome Frame for IE
Firefox 3.6+
Safari 4.0+

这主要原因可能是IE原生不支持多文件的选取与上传。

GSUtil Tool

GSUtil Tool是更强大的命令行管理工具，可以安装在Linux和Mac OS上，也可以通过Cygwin安装在Windows上。第一次运行GSUtil Tool时候需要进行简单的配置，如果还没有手工配置直接输入命令就会出现提示，输入授权ID和访问KEY重新执行刚才的命令就可以了。

通过GSUtil Tool可以直接像操作本地文件一样操作远程文件，它提供一些类似本地shell的命令：
创建存储库

gsutil mb gs://cats gs://dogs

1	gsutil mb gs://cats gs://dogs

上传文件

gsutil cp *.jpg gs://dogs

1	gsutil cp *.jpg gs://dogs

列出存储库或文件

gsutil ls
gsutil ls gs://dogs

1 2	gsutil ls gsutil ls gs://dogs

移动或改名

gsutil mv gs://dogs/*.jpg gs://cats/
gsutil mv gs://cats/poodle.jpg gs://cats/siamese.jpg

1 2	gsutil mv gs://dogs/*.jpg gs://cats/ gsutil mv gs://cats/poodle.jpg gs://cats/siamese.jpg

下载

gsutil cp gs://cats/*.jpg file://pets/

1	gsutil cp gs://cats/*.jpg file://pets/

改变授权

gsutil setacl acls.txt gs://cats/siamese.jpg
gsutil setacl bucket-owner-full-control gs://cats/siamese.jpg

1 2	gsutil setacl acls.txt gs://cats/siamese.jpg gsutil setacl bucket-owner-full-control gs://cats/siamese.jpg

删除文件或者存储库

gsutil rm gs://cats/collie.jpg
gsutil rb gs://dogs

1 2	gsutil rm gs://cats/collie.jpg gsutil rb gs://dogs

Python Library
Python Library是提供的一组Python API用于访问Google Storage，它源自boto（AS3的访问接口）。使用Python Library访问Google Storage仍然需要依赖GSUtil。目前Google App Engine已经支持使用Python Library访问Google Storage。

此外Google Storage API提供了非常RESTful的接口用于访问Google Storage，除了使用上面的工具，你还可以自己动手通过API访问Google Storage。
我在GAE上放了一个DEMO用于遍历存储库中文件及提供下载链接，欢迎测试速度。

Demo源码下载 [download id=”37″]

题外话：
Google Storage的出现弥补了Google App Engine文件存储的缺陷，但是GAE文件执行时间的问题导致还是无法利用GAE来传送大文件到GS。虽然网站上已经对资源的标了价格，但目前Google还没有提供查询资源使用情况及付费的入口。另一方面GS比S3吸引力更大的地方是有免费配额，无疑为在项目初期选择它又多了一道砝码。
-EOF

JavaScript陷阱太多，因此我们得步步为营，下面是一些常见的影响性能的陷阱。
1.避免使用eval或者Function构造函数
使用eval或者Function构造函数的代价是非常昂贵的，每次都需要脚本引擎转换源代码到可执行代码。
此外，使用eval处理字符串必须在运行时解释。

运行缓慢的代码：

function addMethod(object, property, code) {
	object[property] = new Function(code);
}
addMethod(myObj, 'methodName', 'this.localVar=foo');

function addMethod(object, property, code) {

object[property] = new Function(code);

}

addMethod(myObj, 'methodName', 'this.localVar=foo');

运行更快的代码：

function addMethod(object, property, func) {
	object[property] = func;
}
addMethod(myObj, 'methodName', function () { 'this.localVar=foo'; });

function addMethod(object, property, func) {

object[property] = func;

}

addMethod(myObj, 'methodName', function () { 'this.localVar=foo'; });

2.避免使用with
尽管很方便，with需要附加的查找引用时间，因为它在编译的时候并不知道作用域的上下没。

运行缓慢的代码：

with (test.object) {
	foo = 'Value of foo property of object';
	bar = 'Value of bar property of object';
}

with (test.object) {

foo = 'Value of foo property of object';

bar = 'Value of bar property of object';

}

运行更快的代码：

var myObj = test.object;
myObj.foo = 'Value of foo property of object';
myObj.bar = 'Value of bar property of object';

var myObj = test.object;

myObj.foo = 'Value of foo property of object';

myObj.bar = 'Value of bar property of object';

3.不要在性能要求关键的函数中使用try-catch-finally
try-catch-finally在运行时每次都会在当前作用域创建一个新的变量，用于分配语句执行的异常。
异常处理应该在脚本的高层完成，在异常不是很频繁发生的地方，比如一个循环体的外面。
如果可能，尽量完全避免使用try-catch-finally。

运行缓慢的代码：

var object = ['foo', 'bar'], i;
for (i = 0; i < object.length; i++) {
	try {
		// do something that throws an exception
	} catch (e) {
		// handle exception
	}
}

var object = ['foo', 'bar'], i;

for (i = 0; i < object.length; i++) {

try {

// do something that throws an exception

} catch (e) {

// handle exception

}

运行更快的代码：

var object = ['foo', 'bar'], i;
try {
	for (i = 0; i < object.length; i++) {
		// do something
	}
} catch (e) {
	// handle exception
}

var object = ['foo', 'bar'], i;

try {

for (i = 0; i < object.length; i++) {

// do something

}

} catch (e) {

// handle exception

}

4.避免使用全局变量
如果你在一个函数或者其它作用域中使用全局变量，脚本引擎需要遍历整个作用域去查找他们。
全局作用域中的变量在脚本的生命周期里都存在，然后局部范围的会在局部范围失去的时候被销毁。

运行缓慢的代码：

var i,
str = '';
function globalScope() {
	for (i=0; i < 100; i++) {
		str += i; // here we reference i and str in global scope which is slow
	}
}
globalScope();

var i,

str = '';

function globalScope() {

for (i=0; i < 100; i++) {

str += i; // here we reference i and str in global scope which is slow

}

globalScope();

运行更快的代码：

function localScope() {
	var i,
	str = '';
	for (i=0; i < 100; i++) {
		str += i; // i and str in local scope which is faster
	}
}
localScope();

function localScope() {

var i,

str = '';

for (i=0; i < 100; i++) {

str += i; // i and str in local scope which is faster

}

localScope();

5.避免在性能要求关键的函数中使用for-in
for-in循环需要脚本引擎建立一张所有可枚举属性的列表，并检查是否与先前的重复。
如果你的for循环作用域中的代码没有修改数组，可以预先计算好数组的长度用于在for循环中迭代数组。

运行缓慢的代码：

var sum = 0;
for (var i in arr) {
	sum += arr[i];
}

var sum = 0;

for (var i in arr) {

sum += arr[i];

}

运行更快的代码：

var sum = 0;
for (var i = 0, len = arr.length; i < len; i++) {
	sum += arr[i];
}

var sum = 0;

for (var i = 0, len = arr.length; i < len; i++) {

sum += arr[i];

}

6.使用字符串累加计算风格
使用+运算会在内存中创建一个新的字符串并把连接的值赋给它。仅仅是将这个结果赋值给一个变量。
为了避免连接结果的中间变量，可以使用+=来直接赋值结果。

运行缓慢的代码：

a += 'x' + 'y';

1	a += 'x' + 'y';

运行更快的代码：

a += 'x'; a += 'y';

1	a += 'x'; a += 'y';

7.原操作会比函数调用快
可以考虑在性能要求关键的循环和函数中使用可以替代的原操作。
运行缓慢的代码：

var min = Math.min(a, b);
arr.push(val);

1 2	var min = Math.min(a, b); arr.push(val);

运行更快的代码：

var min = a < b ? a : b;
arr[arr.length] = val;

1 2	var min = a < b ? a : b; arr[arr.length] = val;

8.设置setTimeout() 和 setInterval() 时传递函数名而不是字符串
如果你传递一个字符串到setTimeout() 或者 setInterval()中，字符串将会被eval计算而导致缓慢。
使用一个匿名函数包装来代替，这样在编译的时候就可以被解释和优化。

运行缓慢的代码：

setInterval('doSomethingPeriodically()', 1000);
setTimeOut('doSomethingAfterFiveSeconds()', 5000);

1 2	setInterval('doSomethingPeriodically()', 1000); setTimeOut('doSomethingAfterFiveSeconds()', 5000);

运行更快的代码：

setInterval(doSomethingPeriodically, 1000);
setTimeOut(doSomethingAfterFiveSeconds, 5000);

1 2	setInterval(doSomethingPeriodically, 1000); setTimeOut(doSomethingAfterFiveSeconds, 5000);

9.避免在对象中使用不需要的DOM引用

不要这么做：

var car = new Object();
car.color = "red";
car.type = "sedan"

var car = new Object();

car.color = "red";

car.type = "sedan"

更好的一种形式：

var car = {
	color : "red";
	type : "sedan"
}

var car = {

color : "red";

type : "sedan"

}

10.最清晰的目标速度，最小化作用域链

低效率方法：

var url = location.href;

1	var url = location.href;

一种高效形式：

var url = window.location.href;

1	var url = window.location.href;

11.试着在脚本中少使用注释，避免使用长变量名
尽可能的保证注释少或者避免使用注释，特别是在函数，循环以及数组中。
注释不必要的减缓脚本执行并且增加了文件大小。比如：

不建议的形式：

function someFunction()
{
	var person_full_name="somename"; /* stores the full name*/
}

function someFunction()

{

var person_full_name="somename"; /* stores the full name*/

}

更好的写法：

function someFunction()
{
	var name="somename";
}

function someFunction()

{

var name="somename";

}

12.在当前作用域存储应用的外部变量
当一个函数被执行的运行上下问被穿件，一个活动的对象会包含所有局部变量会被推到上下文链的前面。
在作用域链中，最慢的是清楚的识别标识符，意味着局部变量是最快的。存储频繁使用的外部变量读和写都会明显的加快。这对于全局变量和其他深层次的标识符查找特别明显。
同样，在当前作用域中的变量(var myVar)比对象像属性的访问速度快(this.myVar)。

运行缓慢的代码：

function doSomething(text) {
	var divs = document.getElementsByTagName('div'),
		text = ['foo', /* ... n ... */, 'bar'];
	for (var i = 0, l = divs.length; i < l; i++) {
		divs[i].innerHTML = text[i];
	}
}

function doSomething(text) {

var divs = document.getElementsByTagName('div'),

text = ['foo', /* ... n ... */, 'bar'];

for (var i = 0, l = divs.length; i < l; i++) {

divs[i].innerHTML = text[i];

}

运行更快的代码：

function doSomethingFaster(text) {
	var doc = document,
		divs = doc.getElementsByTagName('div'),
		text = ['foo', /* ... n ... */, 'bar'];
	for (var i = 0, l = divs.length; i < l; i++) {
		divs[i].innerHTML = text[i];
	}
}

function doSomethingFaster(text) {

var doc = document,

divs = doc.getElementsByTagName('div'),

text = ['foo', /* ... n ... */, 'bar'];

for (var i = 0, l = divs.length; i < l; i++) {

divs[i].innerHTML = text[i];

}

如果你需要访问一个元素（如 head）在一个大的循环中，使用一个本地的DOM访问(如例子中的get)会更快。
运行更快的代码：

function doSomethingElseFaster() {
	var get = document.getElementsByTagName;
	for (var i = 0, i < 100000; i++) {
		get('head');
	}
}

function doSomethingElseFaster() {

var get = document.getElementsByTagName;

for (var i = 0, i < 100000; i++) {

get('head');

}

13.使用变量缓存值
在做重复工作的地方使用局部变量缓存值。
下面的一组例子表明了存储值到局部变量的广泛意义。

例子1.计算执行前在循环体内使用变量存储数学函数
错误的方法：

var d=35;
for (var i=0; i<1000; i++) {
	y += Math.sin(d)*10;
}

var d=35;

for (var i=0; i<1000; i++) {

y += Math.sin(d)*10;

}

更好的处理：

var d = 55;
var math_sind = Math.sin(d)*10;
for (var i=0; i<1000; i++) {
	y += math_sind;
}

var d = 55;

var math_sind = Math.sin(d)*10;

for (var i=0; i<1000; i++) {

y += math_sind;

}

例子2.保存数组的长度在循环中使用
糟糕的处理:
数组的长度每次都会被重复计算

for (var i = 0; i < arr.length; i++) {
	// do something
}

for (var i = 0; i < arr.length; i++) {

// do something

}

更好的改进：
更好的方法是保存数组的长度

for (var i = 0, len = arr.length; i < len; i++) {
	// do something
}

for (var i = 0, len = arr.length; i < len; i++) {

// do something

}

总的来说，如果已经做了一次，我们就不需要重复的做不必要的工作。例如，作用域或者函数中多次使用到计算的一个表达式的值，保存到变量可以使它多次被使用，否则我们会过头的声明一个变量并赋值然后只适用一次。所以请记住这些。

via JavaScript Performance Best Practices
-EOF-

To Be Continued

简历加分点

App Engine SDK 1.35发布

Google Storage for Developers初体验

Godaddy $0.99域名优惠码(2010/06/25)

JavaScript性能陷阱