首先，当然是要知道什么是PHP，然后废话不说，马上就是PHP的环境搭配。在网上可以说这样的教程多如牛毛，这里只是给一些需要的人看。并且是2012年出的，与时并进。（其实也是没有什么大不了的，代码还是那些代码。）

1、下载所需要的文件

以下是win7环境中的示例：

• php5.4(VC9 x86 Thread Safe)
• mysql(mysql-installer-5.5.24.0.msi)
• apache(httpd-2.2.22-win32-x86-openssl-0.9.8t.msi)

2、然后是安装这三个。

php安装

直接解压就可以了。

Apache安装

也是很简单的安装。安装完成后，可以在浏览器输入http://127.0.0.1测试。

mysql安装

3、配置httpd.conf

安装完php和apache之后，配置apache/conf/下的httpd.conf完成最基础的配置，让其可以运行.php。

别忘了，下面那个目录也要换成你的php根目录，不使用apache的htdocs。

接下来就是安装mysql，安装也十分地简单，等到要连接数据库的时候，我们再来讨论。我之前有一篇文章就是写mysql的配置的。另外，如果要安装phpMyadmin也是十分简单的，网上都有许多的资源。

总结

这只是一个开始，希望每天能写一个简单的php教程。前端教你学PHP，与你一起成长。有任务问题，请联系博主，谢谢。

安装完成后，我发现了原来没有自带phpMyadmin这个管理工具的，也是，那只是集成环境帮我们安装了。但是，我没有安装这个，我选择了一个客户端Navicat，平时可以用CMD嘛。

今天要连接数据库的时候，出现Fatal error:Call to undefined function mysql_connect。我就郁闷了，我有在php.ini打开mysql扩展的，怎么就不行了呢？上网搜索一番后，有了答案：

1. 首先在php.ini里面把 extension=php_mysql.dll 去掉了前面的 ;
2. mysql/lib/libmySQL.dll 拷贝到 php5.4下面，还有拷贝到 php5.4/ext 目录下
3. libmySQL.dll ，php5ts.dll 两个文件拷贝到 windows/system32

然后还是失败了，为什么呢？我又一番搜索。最后，答案终于出来了，打开extension_dir这个，并把值设成ext。

最后，别忘了重启apache。

官方的描述我没有看过，一般看文章的时候，博客也是只给出博主自己的理解。如果你问我什么是闭包，我可以一下子说不出来。这鬼东西我没有玩过……

我的理解：
1、闭包是一种作用域独立的环境？
2、闭包就是一种内存溢出的体现？
3、闭包就是内部保持引用外部的变量，使其没有被垃圾回收机制干掉？
4、忘记了，闭包跟作用域关系比较密切，要了解JS相关作用域知识。

你也许在想，怎么后面都有个问号呢？或者我还不能完全肯定吧。那闭包可以干什么呢？我没有实力展现，所以以下是我读的一篇文章，大家可以参考一下。

http://net.tutsplus.com/tutorials/javascript-ajax/closures-front-to-back/

首先来看这样的一个东西，老鸟表示小菜，这种写法太普通了。那我们新手要从中看中什么呢？答案就是隐藏myPrivateMultiplyFunction这个函数，仅为其提供一个接口multiply。

下面它还有一个例子，是关于检测键盘事件的。

其中是应用了闭包，生成了各自的isXXX方法。

最后也可以闭包来扩展方法。

chache的好处就是可以把运行过的结果保存下来，看下面的。

感兴趣可以去拜读一下原文。

当你在Javascript定义一个函数时，它会有一些预定义的属性；其一是让人迷惑的Prototype。在这篇文章中，我会简单地阐述它是什么，还有为什么你要在项目中使用它。

What is Prototype?(什么是原型?)

The prototype property is initially an empty object, and can have members added to it – as you would any other object.

原型是一个对象里面的空对象，可以在其中添加成员，像其他的对象一样。

In the snippet above, we’ve created a function, but if we call myObject(), it will simply return the window object, because it was defined within the global scope. this will therefore return the global object, as it has not yet been instantiated (more on this later).

在上面的代码片断，我们创建了一个函数，如果我们调用myObject()，它会简单地返回window这个对象，因为它是定义在全局变量里面，所以会返回全局变量，当前它还有没有实例化（后面更多介绍）。

The Secret Link(背后的秘密链)

Before we continue, I’d like to discuss the “secret” link that makes prototype work the way it does.

在我们继续之前，我想讨论一下它的“秘密”链是怎么工作的。

Every object within JavaScript has a “secret” property added to it when it is defined or instantiated, named __proto__; this is how the prototype chain is accessed. However, it is not a good idea to access __proto__ within your application, as it is not available in all browsers.

在Javascript中，每一个对象当它被定义时或实例化都会添加一个“秘密”的属性，名字叫__proto__；这就是为什么原型链可以访问的原因。然而，你却不可以通过__proto__来访问你的程序，因为不是所有浏览器都支持。

The __proto__ property shouldn’t be confused with an object’s prototype, as they are two separate properties; that said, they do go hand in hand. It’s important to make this distinction, as it can be quite confusing at first! What does this mean exactly? Let me explain. When we created the myObject function, we were defining an object of type Function.

我们不应该为对象原型中的prototype和__proto__属性感到迷惑，它们的2个分开的属性；换句话说，它们是联合行动的，一定要注意区分它们，在刚开始的时候都会比较让人疑惑！这是到底什么意思呢？让我来解释一下。当我们创建 myObject 函数，我们是在定义一个对象的类型为Function。

For those unaware, Function is a predefined object in JavaScript, and, as a result, has its own properties (e.g. length and arguments) and methods (e.g. call and apply). And yes, it, too, has its own prototype object, as well as the secret __proto__ link. This means that, somewhere within the JavaScript engine, there is a bit of code that could be similar to the following:

对于那些没有意识到的，Function在Javascript里面是一个预定义对象，但是，它作为Function对象，它有它自己的属性(例如，length和arguments)和方法(例如，call和apply)。是的， 它也有它自己的原型对象，还有秘密链接“__proto__”。这意味着，在JavaScript引擎的某处，有一些与下面相似的代码：

In truth, it probably wouldn’t be quite so simplistic; this is merely to illustrate how the prototype chain works.

事实上，它并没有像上面的代码那样过于简单；这是用来阐明原型链是怎么工作的而已。

So we have defined myObject as a function and given it one argument, name; but we never set any properties, such as length or methods, such as call. So why does the following work?

上面，我们已经定义了 myObject 这个函数，给了它一个唯一的参数，name；但是我们还没有设置任何的属性，例如，长度或方法，再如call。那么接下来怎么做呢？

This is because, when we defined myObject, it created a __proto__ property and set its value to Function.prototype (illustrated in the code above). So, when we access myObject.length, it looks for a property of myObject called length and doesn’t find one; it then travels up the chain, via the __proto__ link, finds the property and returns it.

这是因为，当我们定义了 myObject ，它创建了一个 __proto__ 属性跟设置了它的值为Function.prototype(像上面说的代码那样)。所以，当我们访问 myObject.length，它会查找 myObject里面的属性 length，然后没有找到；然后它就递归到上一层链，通过__proto__链，找到属性并返回它。

You might be wondering why length is set to 1 and not 0 – or any other number for that fact. This is because myObject is in fact an instance of Function.

你也许会觉得奇怪，为什么长度会是1而不是0 – 或者不是其他的值。这是因为 myObject是Function的一个实例。

When an instance of an object is created, the __proto__ property is updated to point to the constructor’s prototype, which, in this case, is Function.

当一个对象被实例化，__proto__属性就会更新指向构造器的prototype属性，在这里，指向Function。

Additionally, when you create a new Function object, the native code inside the Function constructor will count the number of arguments and update this.length accordingly, which, in this case, is 1.

另外，当你创建了一个新的Function对象，内部代码中，Function构造器会计算参数的长度和更新到相应的this.length，在这里，是1。

If, however, we create a new instance of myObject using the new keyword, __proto__ will point to myObject.prototype as myObject is the constructor of our new instance.

如果我们使用new关键字来实例化 myObject，__proto__会指向myObject.prototype，因为 myObject是新实例的构造器。

In addition to having access to the native methods within the Function.prototype, such as call and apply, we now have access to myObject’s method, getName.

除了有访问Function.prototype的内部的方法之外，还可以访问call和apply，现在我们来访问 myObject’s的方法，getName。

As you can imagine, this is quite handy, as it can be used to blueprint an object, and create as many instances as needed – which leads me onto the next topic!

就像你想象那样，这是非常便利的，它可以很好地计划一个对象，可以创建许多的实例 – 接着带领我进去下一个话题！

Why is Using Prototype Better?(为什么使用原型会更好?)

Say, for instance, that we are developing a canvas game and need several (possibly hundreds of) objects on the screen at once. Each object requires its own properties, such as x and y coordinates, width,height, and many others.

例如我们在开发一个canvas做的游戏，需要几个对象（或几百个）同时出现在屏幕上。每个对象都有自己的属性，例如x和y坐标，宽，高，还有其他。

We might do it as follows:

What this will do is create all these objects within memory – all with separate definitions for methods, such as draw and whatever other methods may be required. This is certainly not ideal, as the game will bloat the browsers allocated JavaScript memory, and make it run very slowly… or even stop responding.

当在内存中创建如此多对象会发生什么事 – 所有定义的方法都会占一定的内存，例如draw还有其他的依赖的方法。这不是理想中的效果，这个程序 会使浏览器变得缓慢，占用更多内存，甚至会便程序失去响应。

While this probably wouldn’t happen with only 100 objects, it still can serve to be quite a performance hit, as it will need to look up one hundred different objects, rather than just the single prototype object.

虽然不会可能只有100个对象，它仍然表现得不是很好，它要查找100个不同的对象，而不是单单一个原型属性。

How to Use Prototype

To make the application run faster (and follow best practices), we can (re)define the prototype property of the GameObject; every instance of GameObject will then reference the methods within GameObject.prototype as if they were their own methods.

为了让它跑得更快(更好的体验)，我们可以重新定义这个 GameObject的原型；每个 GameObject的实例会引用 GameObject.prototype就像使用自己的方法一样。

We can then instantiate the GameObject 100 times.

然后我们创建100个 GameObject对象。

Now we have an array of 100 GameObjects, which all share the same prototype and definition of the draw method, which drastically saves memory within the application.

现在我们有一个含100个 GameObject对象的数组，共享了相同的属性和定义了draw方法，彻底地解决了问题，节省许多内存。

When we call the draw method, it will reference the exact same function.

当我们访问draw方法，它会引用相同的函数。

Prototype is a Live Object(prototype是一个动态的对象)

An object’s prototype is a live object, so to speak. This simply means that, if, after we create all our GameObject instances, we decide that, instead of drawing a rectangle, we want to draw a circle, we can update our GameObject.prototype.draw method accordingly.

prototype是一个动态的对象，这就是说，当我们创建了全部的 GameObject实例后，如果我们想要画一个矩形，我们想画一个圆，我们可能更新相应的 GameObject.prototype.draw方法。

And now, all the previous instances of GameObject and any future instances will draw a circle.

现在，所有之前的实例和后面的都可以画圆了。

Updating Native Objects Prototypes

Yes, this is possible. You may be familiar with JavaScript libraries, such as Prototype, which take advantage of this method.

是的，这成为了可能。你可能熟悉JavaScript的库，例如Prototype，扩展了许多高级的方法。

Let’s use a simple example:

让我们做个简单的例子：

We can now access this as a method of any string:

这样我们的任何字符串就可以访问这个方法了。

There is a minor downside to this, however. For example, you may use this in your application; but a year or two down the road, a browser may implement an updated version of JavaScript that includes a native trim method within the String‘s prototype. This means that your definition of trim will override the native version! Yikes! To overcome this, we can add a simple check before defining the function.

这里有一个小小的不足，例如，当你在你的应用中使用这个方法；但是一年或两年之后，浏览器内部就已经更新了版本，集成了这个方法。这意味着你的方法trim会覆盖了本地的方法！呀！为了实现和谐，我们可以做一个判断。

Now, if it exists, it will use the native version of the trim method.

现在，如果当这个方法存在，会使用本地的这个trim方法。

As a rule of thumb, it’s generally considered a best practice to avoid extending native objects. But, as with anything, rules can be broken, if needed.

一般来说，最好不要去扩展本地对象的方法，但是如果需要的时候，那就把规则打破。

Conclusion(总结)

Hopefully, this article has shed some light on the backbone of JavaScript that is prototype. You should now be on your way to creating more efficient applications.

If you have any questions regarding prototype, let me know in the comments, and I’ll do my best to answer them.

上一次使用ZeroClipboard是在配置好之后，我便没有测试它。我当前总结了2个要注意的地方，在大家配置它的时候，可以有个参考的地方。

首先贴一个参考吧：

下面说说注意事项：

1. 复制按钮接受的是一个DOM元素id
2. 注意z-index。

第2点有必要说一下，是什么意思呢？我也是在刚才看了说明才发现的。这与它的实现方式有关，大概的原理是通过生成一个跟复制按钮一样大小的flash来完成复制的。而它是通过absolute来定位，而页面如果是resize后，它的位置又会变化等，当然，它也有一个方法reposition()是用来反馈重新定位的。但是下面官方又推荐了一种实现的方式，可以比较完美地解决问题的。

相应的Javscript这样写：

更多的信息请参与官网

http://code.google.com/p/zeroclipboard/wiki/Instructions

今天在cnblogs上看到一篇博文，关于JavaScript构造函数返回值的。

一般在Javascript中，返回是关键字return，即遇到return则返回。在上面的程序中，实例化后，this值将会丢失。如果要返回这个this.child，是不是加个回调的函数使用它返回就可以了呢？答应是肯定的，但是觉得还是没有解决为什么会丢失的问题。通常，我们可以用下面这种形式返回this的值。

下面，我们就知道了。与其说是丢失，还不如说this指向了window。

所以，这些都是this的指向问题，在JavaScript中，匿名函数的this会指向window对象，因为window的掌管着所有的对象，不知道描述正确否。总之当你发现变量是undefined，你可以试着看是不是this已经不再是指向当前的对象了。

这时，不得不让人想到，JavaScript中还有2个函数可以改变this的指向的，分别是call()和apple()。

不知不觉文章也变长了，本来只是小小的讨论。无所谓，反正是知识的整合。我的目标是，一名合格的前端。

在学习Php.5.4的新特性时，我发现了与javascript有许多相似的地方。比如：

1、转换类型

2、注释

PHP中有三种常见的注释，但是2种最常用的跟javascript是一样的。

php5.4中，语法变化多，语法更加的严谨。在后面的学习中，所有文章都可能会随时更新。文章也是有生命的，并不是一写就写死在这里了。

for循环大家都会用，可是里面多少涉及一些优化的问题。在信息时代，各种优化很快被我们知道，我就不不说了。国内写这方面的博文也不少，贴上一个网址吧。
http://bbs.blueidea.com/thread-3023913-1-1.html

而我的问题是什么呢?

今天在写for的时候，写成了这样：

这样的错误的写法，让程序运行起来又卡又怪，于是我找了一个原来的文章，那个写法有误，我又改成了下面这个正确的。

这个问题应该是我对它的语法还不够了解深刻，就像我之前不记得Math.ceil()和Math.floor()一样，用得少就不熟悉，不熟就容易搞混，后来我根据英文单词把它们记得了，ceil为有天花板的意思，而floor是地板。一个意为向上取整，一个意为向下取整。经过这次的遭遇，我已经对这个for有深刻的了解了。

从一开始的Editplus到今天用了vim，可以说经历差不多10款了(甚至现在都可以用浏览器来做编辑器)。到现在为止记忆比较深的就是vim，sublimeText 2这2个，当然如果你在Mac下还有TextMate和Coda，这两个我都用过，那时候的我用起来也觉得不怎么好用。现在开发还在用Notepad++，因为vim还没有太熟练。这几天也就在学学命令跟找几个好用插件。

其实，编辑器强大的地方在于用的人。也就是说任何一款编辑器在适合的人手中，都可以发挥它的作用。像我们一开始用的Editplus，虽然我们没有在用了，但是还有许多人在使用它们。而想要使用号称神级编辑器的菜鸟，如果使用不好，反而会被别人笑话。找一个好的编辑器，适合自己的，Just use it。