⑴ 怎么把html页面中的JS函数，提取封装到一个JS中，直接在页面调用JS文件就可以了
需要准备的材料分别有：电脑、html编辑器、浏览器。
1、首先，打开html编辑器，新建html文件，例如：index.html，填充问题基础代码。
⑵ C#定义的函数在asp.NET 的前端文件中如何调用
楼上两位说的都不算错，但是会造成前后台代码混编的问题，代码多了以后，维护很困难。
我建议楼主的方法是：用javascript给一个变量赋值，比如flag=1， 然后提交一个post。
在cs文件的page_load中，判断flag是否为1，如果是1，则调用Method
⑶ 请问: 在编程中, 对函数进行封装的目的和好处是什么
一，安全性
二，面向对象
三，代码的复用
四，程序的简洁性和可读性
五，其他
⑷ 零基础怎么系统学Web前端
网站开发开发大致分为前端和后端，前端主要负责实现视觉和交互效果，以及与服务器通信，完成业务逻辑。其核心价值在于对用户体验的追求。可以按如下思路学习系统学习：
基础知识：
1.html + css 这部分建议在 w3school 在线教程 上学习，边学边练，每章后还有小测试。 之后可以模仿一些网站做些页面。
2. javascript 要学的内容实在很多，如果没有其他编程语言的基础的话，学起来可能要费些力，还是建议先在 w3school上学习。之后建议马上看《javascript语言精粹》，js是一门很混乱的语言，这本书能够帮助你区分哪些是语言的精华，哪些是糟粕，对于语言精华，应该深入学习。糟粕部分能看懂别人写的代码就行，自己就不用尝试了。
对于习惯看视频学习的同学，以上内容也可以在优就业网站上学习。
进阶：
有了以上基础，就可以进行一般的静态网页设计，不过对于复杂的页面还需要进一步学习。
1.css。截至今日（2015.12.08），天猫、淘宝、支付宝都已停止对ie6,7的支持，未来相信大多数网站都会停止对ie6，7的支持，ie8的市场份额也不像两年前那么高了（天猫即将停止对IE8的支持，2016.12.13），webkit内核已成为市场主流。对于css的学习，我推荐分三块：“基础概念”，“css2.1规范”，“css3规范”。必看 精通CSS（第2版） (豆瓣)，看完这本书你应该对：盒子模型，流动，block，inline，层叠，样式优先级，等概念非常了解了。这本确实有些年头了，但基础概念部分讲述非常清晰，可以称之为经典。ie6，7相关的内容可以不看。css3的部分可以参考：CSS3实用指南 (豆瓣)。这本书同样有些老，只是最新出版的书中没发现有特别好的。
2. javascript。上面提到内容还不足以让你胜任js编程。在有了基础之后，进一步学习内容包括：
a) 框架。推荐 zepto，简单易用，在w3school简单学习js后，直接上手 zepto 即可完成一些简单的项目。zepto 源码简单清晰，也适合新手阅读。补充： 可以使用 codecademy 学习 javascript，zepto，用户体验真的很好（感谢 TonyOuyang ）。最近比较热门的框架是React, VUE, Angular这些, 根据需要稍作了解即可。随着ie浏览器市场份额的下降，以及移动端的发展，标准原生js已经可以在实际项目中使用（目前还需要借助es5shim、babel等），重点还是ES5, ES6, ES7。
b) javascript 语言范式 。这个名字可能并不恰当，只是我找不到可以描述“面向对象”，“函数式”这个两个概念的概念。javascript不完全是一个面向对象的语言，它的很多设计理念都有函数编程语言的影子，甚至说如果你不用面向对象，完全可以把它理解成一门函数式编程语言。javascript的很多语言特性，都是因为他具有函数式语言的特点才存在的。这部分推荐先学习面向对象的基本理论，对封装，继承，多态等概念要理解，维基网络，网络会是你的帮手，另外推荐《object oriented javascript》，应该有中文版。对与函数式编程可以参考这篇文章：JavaScript 中的函数式编程实践
c) javascript 语言内部机制。必须弄清如下概念：js中变量的作用域，变量传递方式，函数的定义环境与执行环境，闭包，函数的四种调用方式（一般函数，对象的方法，apply，call），以及四种调用方式下，‘this'指向的是谁。这部分内容你会在《javascript语言精粹》中详细了解。
d) dom编程，这个web前端工程师的核心技能之一。必读《dom编程艺术》，另外《高性能javascript》这本书中关于dom编程的部分讲的也很好。
e) ajax编程，这是另一核心技术。ajax建议在网上查些资料，了解这个概念的来龙去脉，网络，维基网络上的内容就足够了。真正编程是很容易的，如今几乎所有框架都对ajax有良好的封装，编程并不复杂。另外，ajax未来几年会被 Fetch Standard 取代，也需要了解。另外关于xhr2，cors（跨站资源共享），formData文件上传，也需要了解。
f) es5, es6。现在开发js大部分基于es5的，ie8以下通过es5-shim。但利用一些工具，现在已经可以直接写es6代码了，尤其在reactjs，nodejs类型的项目中。对于从es5，es6每个阶段js发生了哪些变化都需要系统学习，学习顺序建议是 JavaScript基础 -> es5 -> es6，越靠前的越重要。一些参考链接：ECMAScript 5 compatibility tableECMAScript 6入门ES5 « 张鑫旭
3. html5。需要了解html都提供了哪些api，然后项目中用起来。这部分没有什么难理解的，关键在于能用html5解决业务问题，以及不支持html5的浏览器的降级方案。这部分体现了前端的一个思想：面向未来编程，尽早将新技术引入业务中来，而不是过分考虑兼容性问题，进而导致面向过去编程。
再进一阶 · 代码层面：
有了以上知识，对于大多数小型网站，你应该已经可以写出能够工作的代码了。但要想成为更专业的前端，你还需继续努力。更高的要求大概还有四方面：1易维护，2可测试，3高性能，4低流量（移动端）。
1.易维护。对于页面你该理解‘样式’，‘数据’，‘行为’三者分离，对应的当然就是css,html,js。对于js代码，你最好了解设计模式，重构，MVC等内容。
2. 可测性。就是保证你的代码能沟通单元测试100%覆盖到所有分支
3. 高性能。必读《高性能javascript》
4. 低流量。移动端关注比较多，PC端现在可以不用太关注了
再进一阶 · 工程层面：
前端项目同样面临软件生命周期的各个环节，首先是代码管理，你必须学会使用svn和git。其次是代码的构建，如今前端代码构建已经不是简单的压缩一下了，需要进行依赖管理、模块合并、各种编译，必须要学会使用grunt、gulp、webpack、rollup等前端构建工具，以及前端模块管理的方式，amd，cmd，es6 mole 等等。
然后呢？以上内容只是简单说了前端学习的顺序。前端工程师应该有的知识结构请参考这里：JacksonTian/fks · GitHub
补充：
对于前段开发，基本内容就这些了，可以根据自己的兴趣爱好选择性学习以下内容。
1. 交互设计。大公司依然有专业人士搞这些，不过不懂交互的前端一定不是好前端。推荐《简约至上》。
2. 后端。应该说前段工程师必须至少了解一门后端语言，不过如果爱好也可深入学习，入手难度比较低的应该是php了。这部分由可分为基于页面，基于框架两种。大型项目都是基于框架开发的，建议至少了解一个MVC框架，比如php的ci, yii, yaf 等，好还框架的设计思想都大同小异。如今NodeJs在大公司已经得到普遍的使用，推荐大家使用在Node上使用Koa框架做一些后端服务的开发。
3. Android和ios开发。时至今日，前端的工作领域已经非常广泛，native的界面开发本质上也是前端开发，个大公司都面临着Native环境和web环境页面同时维护的问题，如果能够在技术上得到统一，将会有巨大的价值。对于学有余力的同学，应该了解Native开发的基本流程，至少了解到界面构建的技术。
4. 如果你能够认真看到这里，说明你对前端有真爱，最后说一个编程习惯的问题，绝对是保你工作平安，少出故障。代码提交前必须做的三个事情：A. git diff（svn diff）,检查所有变更；B. 跑一边单元测试；C. 手动运行一遍所有demo.
⑸ 做前端的应该如何从头学习 JavaScript
之后
a) 框架。推荐jQuery，简单易用，我的第一web项目就是在w3school简单学习后，直接上手jQuery完成的，真的很难简单，很好用。jQuery适用环境有限，对于那些对性能要求很高的页面无法胜任。推荐了解一下 YUI 或网络的 tangram ，都很好用，学习方法也很简单，照着产品文档做几个页面就行了，不用面面俱到，以后遇到问题查文档就行了。框架可以帮你屏蔽浏览器的差异性，让你能更专注与web开发学习的精髓部分。
b) javascript 语言范式。这个名字可能并不恰当，只是我找不到可以描述“面向对象”，“函数式”这个两个概念的概念。javascript不完全是一个面向对象的语言，它的很多设计理念都有函数编程语言的影子，甚至说如果你不用面向对象，完全可以把它理解成一门函数式编程语言。javascript的很多语言特性，都是因为他具有函数是语言的特点才存在的。这部分推荐先学习面向对象的基本理论，对封装，继承，多态等概念要理解，维基网络，网络会是你的帮手，另外推荐《object oriented javascript》，应该有中文版。对与函数式编程我了解的也不系统，不好多说，可以自己网络一下。
c) javascript 语言内部机制。必须弄清如下概念：js中变量的作用域，变量传递方式，函数的定义环境与执行环境，闭包，函数的四种调用方式（一般函数，对象的方法，apply，call），以及四种调用方式下，‘this'指向的是谁。这部分内容你会在《javascript语言精粹》中详细了解。另外，你必须理解json。
d) dom编程，这个web前端工程师的核心技能之一。必读《dom编程艺术》，另外《高性能javascript》这本书中关于dom编程的部分讲的也很好。
e) ajax编程，这是另一核心技术。ajax建议在网上查些资料，了解这个概念的来龙去脉，网络，维基网络上的内容就足够了。真正编程是很容易的，如今几乎所有框架都对ajax有良好的封装，编程并不复杂。
f) 了解浏览器差异性。这部分包括css和js两部分，浏览器差异内容很多，建议在实践中多多积累。
⑹ 如何理解JavaScript中的caller，callee，call，apply 前端设计
在提到上述的概念之前，首先想说说javascript中函数的隐含参数：arguments
Arguments —— 该对象代表正在执行的函数和调用它的函数的参数。
[function.]arguments[n]
参数
function ：选项。当前正在执行的 Function 对象的名字。
n ：选项。要传递给 Function 对象的从0开始的参数值索引。
说明
Arguments是进行函数调用时，除了指定的参数外，还另外创建的一个隐藏对象。Arguments是一个类似数组但不是数组的对象，说它类似数组是因为其具有数组一样的访问性质及方式，可以由arguments[n]来访问对应的单个参数的值，并拥有数组长度属性length。
还有就是arguments对象存储的是实际传递给函数的参数，而不局限于函数声明所定义的参数列表，而且不能显式创建 arguments 对象。
arguments 对象只有函数开始时才可用。
下边例子详细说明了这些性质:
//arguments 对象的用法。
function ArgTest(a, b){
var i, s = "The ArgTest function expected ";
var numargs = arguments.length; // 获取被传递参数的数值。
var expargs = ArgTest.length; // 获取期望参数的数值。
if (expargs < 2)
s += expargs + " argument. ";
else
s += expargs + " arguments. ";
if (numargs < 2)
s += numargs + " was passed.";
else
s += numargs + " were passed.";
s += "\n\n"
for (i =0 ; i < numargs; i++){ // 获取参数内容。
s += " Arg " + i + " = " + arguments[i] + "\n";
}
return(s); // 返回参数列表。
}
在此添加了一个说明arguments不是数组(Array类)的代码:
Array.prototype.selfvalue = 1;
alert(new Array().selfvalue);
function testAguments(){
alert(arguments.selfvalue);
}
运行代码你会发现第一个alert显示1，这表示数组对象拥有selfvalue属性，值为1，而当你调用函数testAguments时，你会发现显示的是“undefined”，说明了不是arguments的属性，即arguments并不是一个数组对象。
现在开始caller，callee，call，apply：
caller：返回一个对函数的引用，该函数调用了当前函数。
functionName.caller functionName 对象是所执行函数的名称。
说明
对于函数来说，caller属性只有在函数执行时才有定义。如果函数是由顶层调用的，那么 caller 包含的就是 null 。
如果在字符串上下文中使用 caller 属性，那么结果和functionName.toString 一样，也就是说，显示的是函数的反编译文本。
下面的例子说明了 caller 属性的用法：
// caller demo {
function callerDemo() {
if (callerDemo.caller) {
var a= callerDemo.caller.toString();
alert(a);
} else {
alert("this is a top function");
}
}
function handleCaller() {
callerDemo();
}
//输出结果：
function handleCaller() {
callerDemo();
}
callee —— 返回正被执行的 Function 对象，也就是所指定的 Function 对象的正文。
[function.]arguments.callee
可选项 function 参数是当前正在执行的 Function对象的名称。
说明
callee属性的初始值就是正被执行的 Function 对象。
callee属性是 arguments 对象的一个成员，它表示对函数对象本身的引用，这有利于匿名
函数的递归或者保证函数的封装性，例如下边示例的递归计算1到n的自然数之和。而该属性
仅当相关函数正在执行时才可用。还有需要注意的是callee拥有length属性，这个属性有时候
用于验证还是比较好的。arguments.length是实参长度，arguments.callee.length是
形参长度，由此可以判断调用时形参长度是否和实参长度一致。
示例
//callee可以打印其本身
function calleeDemo() {
alert(arguments.callee);
}
//用于验证参数
function calleeLengthDemo(arg1, arg2) {
if (arguments.length==arguments.callee.length) {
window.alert("验证形参和实参长度正确！");
return;
} else {
alert("实参长度：" +arguments.length);
alert("形参长度： " +arguments.callee.length);
}
}
//递归计算
var sum = function(n){
if (n <= 0)
return 1;
else
return n ＋arguments.callee(n - 1)
}
比较一般的递归函数：
var sum = function(n){
if (1==n) return 1;
elsereturn n + sum (n-1);
调用时：alert(sum(100));
其中函数内部包含了对sum自身的引用，函数名仅仅是一个变量名，在函数内部调用sum即相当于调用一个全局变量，不能很好的体现出是调用自身，这时使用callee会是一个比较好的方法。
apply and call：它们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数方式有所区别：
apply(thisArg,argArray);
call(thisArg[,arg1,arg2…] ]);
即所有函数内部的this指针都会被赋值为thisArg，这可实现将函数作为另外一个对象的方法运行的目的
apply的说明：
如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。
如果没有提供 argArray 和 thisArg任何一个参数，那么 Global 对象将被用作 thisArg，
并且无法被传递任何参数。
call的说明：
call方法可将一个函数的对象上下文从初始的上下文改变为由 thisArg指定的新对象。
如果没有提供 thisArg参数，那么 Global 对象被用作 thisArg
相关技巧：
应用call和apply还有一个技巧在里面，就是用call和apply应用另一个函数（类）以后，当前的函数（类）就具备了另一个函数（类）的方法或者是属性，这也可以称之为“继承”。
看下面示例:
// 继承的演示
function base() {
this.member = " dnnsun_Member";
this.method = function() {
window.alert(this.member);
}
}
function extend() {
base.call(this);
window.alert(member);
window.alert(this.method);
}
上面的例子可以看出，通过call之后，extend可以继承到base的方法和属性。
顺便提一下，在javascript框架prototype里就使用apply来创建一个定义类的模式，
其实现代码如下：
var Class = {
create: function() {
returnfunction() {
this.initialize.apply(this, arguments);
}
}
}
解析：从代码看,该对象仅包含一个方法：Create，其返回一个函数，即类。但这也同时是类的
构造函数，其中调用initialize，而这个方法是在类创建时定义的初始化函数。通过如此途径，
就可以实现prototype中的类创建模式
示例：
var vehicle=Class.create();
vehicle.prototype.initialize= function(type)
{
this.type=type;
}
vehicle.prototype.showSelf= function()
{
alert("this vehicle is "+ this.type);
}
var moto=new vehicle("Moto");
moto.showSelf();
你自己看看吧，此文章转自：http://www.cnblogs.com/ghost-draw-sign/articles/1530108.html
⑺ 如何封装Node.js和前端通用的模块
在Node.js中对模块载入和执行进行了包装，使得模块文件中的变量在一个闭包中，不会污染全局变量，和他人冲突。
前端模块通常是我们开发人员为了避免和他人冲突才把模块代码放置在一个闭包中。
如何封装Node.js和前端通用的模块，我们可以参考Underscore.js 实现，他就是一个Node.js和前端通用的功能函数模块，查看代码：
// Create a safe reference to the Underscore object for use below.
var _ = function(obj) {
if (obj instanceof _) return obj;
if (!(this instanceof _)) return new _(obj);
this._wrapped = obj;
};
// Export the Underscore object for **Node.js**, with
// backwards-compatibility for the old `require()` API. If we're in
// the browser, add `_` as a global object via a string identifier,
// for Closure Compiler "advanced" mode.
if (typeof exports !== 'undefined') {
if (typeof mole !== 'undefined' && mole.exports) {
exports = mole.exports = _;
}
exports._ = _;
} else {
root._ = _;
}
通过判断exports是否存在来决定将局部变量 _ 赋值给exports，向后兼容旧的require() API，如果在浏览器中，通过一个字符串标识符“_”作为一个全局对象；完整的闭包如下：
(function() {
// Baseline setup
// --------------
// Establish the root object, `window` in the browser, or `exports` on the server.
var root = this;
// Create a safe reference to the Underscore object for use below.
var _ = function(obj) {
if (obj instanceof _) return obj;
if (!(this instanceof _)) return new _(obj);
this._wrapped = obj;
};
// Export the Underscore object for **Node.js**, with
// backwards-compatibility for the old `require()` API. If we're in
// the browser, add `_` as a global object via a string identifier,
// for Closure Compiler "advanced" mode.
if (typeof exports !== 'undefined') {
if (typeof mole !== 'undefined' && mole.exports) {
exports = mole.exports = _;
}
exports._ = _;
} else {
root._ = _;
}
}).call(this);
通过function定义构建了一个闭包，call(this)是将function在this对象下调用，以避免内部变量污染到全局作用域。浏览器中，this指向的是全局对象（window对象），将“_”变量赋在全局对象上“root._”，以供外部调用。
和Underscore.js 类似的Lo-Dash，也是使用了类似的方案，只是兼容了AMD模块载入的兼容：
;(function() {
/** Used as a safe reference for `undefined` in pre ES5 environments */
var undefined;
/** Used to determine if values are of the language type Object */
var objectTypes = {
'boolean': false,
'function': true,
'object': true,
'number': false,
'string': false,
'undefined': false
};
/** Used as a reference to the global object */
var root = (objectTypes[typeof window] && window) || this;
/** Detect free variable `exports` */
var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
/** Detect free variable `mole` */
var freeMole = objectTypes[typeof mole] && mole && !mole.nodeType && mole;
/** Detect the popular CommonJS extension `mole.exports` */
var moleExports = freeMole && freeMole.exports === freeExports && freeExports;
/*--------------------------------------------------------------------------*/
// expose Lo-Dash
var _ = runInContext();
// some AMD build optimizers, like r.js, check for condition patterns like the following:
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
// Expose Lo-Dash to the global object even when an AMD loader is present in
// case Lo-Dash was injected by a third-party script and not intended to be
// loaded as a mole. The global assignment can be reverted in the Lo-Dash
// mole by its `noConflict()` method.
root._ = _;
// define as an anonymous mole so, through path mapping, it can be
// referenced as the "underscore" mole
define(function() {
return _;
});
}
// check for `exports` after `define` in case a build optimizer adds an `exports` object
else if (freeExports && freeMole) {
// in Node.js or RingoJS
if (moleExports) {
(freeMole.exports = _)._ = _;
}
// in Narwhal or Rhino -require
else {
freeExports._ = _;
}
}
else {
// in a browser or Rhino
root._ = _;
}
}.call(this));
再来看看Moment.js的封装闭包主要代码：
(function (undefined) {
var moment；
// check for nodeJS
var hasMole = (typeof mole !== 'undefined' && mole.exports)；
/************************************
Exposing Moment
************************************/
function makeGlobal(deprecate) {
var warned = false, local_moment = moment;
/*global ender:false */
if (typeof ender !== 'undefined') {
return;
}
// here, `this` means `window` in the browser, or `global` on the server
// add `moment` as a global object via a string identifier,
// for Closure Compiler "advanced" mode
if (deprecate) {
this.moment = function () {
if (!warned && console && console.warn) {
warned = true;
console.warn(
"Accessing Moment through the global scope is " +
"deprecated, and will be removed in an upcoming " +
"release.");
}
return local_moment.apply(null, arguments);
};
} else {
this['moment'] = moment;
}
}
// CommonJS mole is defined
if (hasMole) {
mole.exports = moment;
makeGlobal(true);
} else if (typeof define === "function" && define.amd) {
define("moment", function (require, exports, mole) {
if (mole.config().noGlobal !== true) {
// If user provided noGlobal, he is aware of global
makeGlobal(mole.config().noGlobal === undefined);
}
return moment;
});
} else {
makeGlobal();
}
}).call(this);
从上面的几个例子可以看出，在封装Node.js和前端通用的模块时，可以使用以下逻辑：
if (typeof exports !== "undefined") {
exports.** = **;
} else {
this.** = **;
}
即，如果exports对象存在，则将局部变量装载在exports对象上，如果不存在，则装载在全局对象上。如果加上ADM规范的兼容性，那么多加一句判断：
if (typeof define === "function" && define.amd){}
⑻ asp.net 后台调用前端函数 方法
你这段后台调用前台的代码没问题。
推荐你先在前台方法中alert(123)，然后运行后台，看是否成功调用方法。我觉得应该是成功调用了前台方法。
⑼ 如何系统地学习前端
目前入门前端的人群分类
1、计算机相关专业出身系统走过计算机的理论基础，比如计算机组成原理、操作系统原理、计算机网络、算法数据结构、设计模式，至少用过两门以上编程语言（强类型+弱类型）。
优点：理论、架构方面扎实，有整体计算机思维，内功不错，外功学起来比较快。
缺点：部分人，前端相关细节技术不扎实，不过花时间能很快搞定。
2、非计算机出身自学（也包括计算机专业没好好学的）理论基础薄弱，后来因个人兴趣或者职业需求，自学前端开发技能。
优点：自学能力比较强，能够根据自己的兴趣规划学习内容。
缺点：部分人对前端没有整体的学习框架 ，属于东一片，西一片，不成体系，部分人计算机没有整体思维，建议系统梳理下前端知识体系结构，该补的还是要补起来。
门前端时的一些困境
1、因一些基础算法、数据结构理论不扎实导致一些编程思维难于理解。比如 原型链，如果清楚 数据结构中链表结构，那么这个东西不难理解，再比如 哈希值，懂得数据结构中哈希表，哈希值也就迎刃而解。
2、计算机体系结构、操作系统理论、网络理论不扎实导致到后期一些东西难于理解。比如有同学从前端学习入手，后来学习node开发 ，在 I/O ,进程、线程、IPC 、线程锁方面有些概念就比较难于理解，而导致不能很好得使用node 的api 。
3、前端整体体系架构没有做过深入思考。
导致用会用，但不知道为什么用，用另外一个有什么区别。
4、学习环境中无高手。
没有高手能够指导自己进入下一个层次。
5、有意识但是没有行动我的网盘收集了一堆资料或者一堆视频，然后就没有然后了 。
如何系统学习前端
网站开发开发大致分为前端和后端，前端主要负责实现视觉和交互效果，以及与服务器通信，完成业务逻辑。其核心价值在于对用户体验的追求。如果你现在是零基础学员，大致可以按如下思路学习系统学习：
基础部分
1、HTML + CSS 这部分学习，可以模仿一些网站做些页面。在实践中积累了一些经验后，可以系统的读一两本书，推荐《Head First HTML 与 CSS 中文版》，这本书讲的太细了，我没能拿出耐心细读。你可以根据情况斟酌。
2、Java 要学的内容实在很多，如果没有其他编程语言的基础的话，学起来可能要费些力，建议马上看《Java语言精粹》，JS是一门很混乱的语言，这本书能够帮助你区分哪些是语言的精华，哪些是糟粕，对于语言精华，应该深入学习。糟粕部分能看懂别人写的代码就行，自己就不用尝试了。
进阶部分
有了以上基础，就可以进行一般的静态网页设计，不过对于复杂的页面还需要进一步学习。
1、CSS。必看《精通CSS》，看完这本书你应该对：盒子模型，流动，Block，inline，层叠，样式优先级，等概念非常了解了。作为练习可以看下《CSS艺门之匠》这本书，它对标题，背景，圆角，导航条，table，表单等主题都有详细的介绍。
2、Java。上面提到内容还不足以让你胜任JS编程。在有了基础之后，进一步学习内容包括：
a） 框架。
推荐jQuery，简单易用，学习方法也很简单，照着产品文档做几个页面就行了，不用面面俱到，以后遇到问题查文档就行了。框架可以帮你屏蔽浏览器的差异性，让你能更专注与Web开发学习的精髓部分。补充：可以使用 Codecademy 学习 Java，jQuery，用户体验真的很好（感谢 TonyOuyang ）。
b） Java 语言范式 。这个名字可能并不恰当，只是我找不到可以描述“面向对象”，“函数式”这个两个概念的概念。Java不完全是一个面向对象的语言，它的很多设计理念都有函数编程语言的影子，甚至说如果你不用面向对象，完全可以把它理解成一门函数式编程语言。
Java的很多语言特性，都是因为他具有函数式语言的特点才存在的。这部分推荐先学习面向对象的基本理论，对封装，继承，多态等概念要理解，维基网络，网络会是你的帮手，另外推荐《Object Oriented Java》，应该有中文版。对与函数式编程我了解的也不系统，不好多说，可以自己网络一下。
c） Java 语言内部机制。必须弄清如下概念：JS 中变量的作用域，变量传递方式，函数的定义环境与执行环境，闭包，函数的四种调用方式（一般函数，对象的方法，apply，call），以及四种调用方式下，‘this’指向的是谁。这部分内容你会在《Java语言精粹》中详细了解。另外，你必须理解 json。
d） dom编程，这个Web前端工程师的核心技能之一。必读《Dom编程艺术》，另外《高性能 Java》这本书中关于dom编程的部分讲的也很好。
e） Ajax编程，这是另一核心技术。Ajax建议在网上查些资料，了解这个概念的来龙去脉，网络，维基网络上的内容就足够了。真正编程是很容易的，如今几乎所有框架都对Ajax有良好的封装，编程并不复杂。
f） 了解浏览器差异性。这部分包括CSS和js两部分，浏览器差异内容很多，建议在实践中多多积累。另外对于浏览器的渲染模式，DOCTYPE等内容应该系统学习。
3、HTML5和CSS3 。HTML5规范已经于2014年10月28日发布了，移动端HTML5和CSS3已经得到了非常广泛的使用，必知必会呀。
升级部分
有了以上知识，对于大多数小型网站，你应该已经可以写出能够工作的代码了。但要想成为更专业的前端，你还需继续努力。更高的要求大概还有四方面：1）易维护，2）可测试，3）高性能，4）低流量（移动端）。
易维护。对于页面你该理解‘样式’，‘数据’，‘行为’三者分离，对应的当然就是CSS,HTML,js。对于js代码，你最好了解设计模式，重构，MVC等内容。
可测性。
高性能。必读《高性能Java》
低流量。移动端关注比较多。
额外补充部分
前端项目同样面临软件生命周期的各个环节，首先是代码管理，你必须学会使用Svn和Git。其次是代码的构建，如今前端代码构建已经不是简单的压缩一下了，需要进行依赖管理、模块合并、各种编译，比需要学会使用Grunt、Gulp等前端构建工具。
以上内容只是简单说了前端学习的顺序。对于前端开发，基本内容就这些了，可以根据自己的兴趣爱好选择性学习以下内容。
1、交互设计。大公司依然有专业人士搞这些，不过不懂交互的前端一定不是好前端。推荐《简约至上》。
2、后端。
应该说前端工程师必须至少了解一门后端语言，不过如果爱好也可深入学习，入手难度比较低的应该是PHP了。这部分由可分为基于页面，基于框架两种。大型项目都是基于框架开发的，建议至少了解一个MVC框架，比如PHP的Ci、Yii、Yaf 等，好还框架的设计思想都大同小异。如今NodeJs在大公司已经得到普遍的使用，推荐大家使用在Node上使用Express框架做一些后端服务的开发。
3、Android和IOS开发。
时至今日，前端的工作领域已经非常广泛，native的界面开发本质上也是前端开发，个大公司都面临着Native环境和web环境页面同时维护的问题，如果能够在技术上得到统一，将会有巨大的价值。
如何才能快速入门前端
1、学习东西，自学是一种途径，然而在自学的过程中，很多人处于不知道自己不知道的状态。
2、另一种是跟着高手，开阔视野，达到知道自己不知道的境界，从而有方向，在短时期内进入到一个新的境界，节约时间成本。
⑽ 如何封装ajax函数
用ajax的局部刷新来给网站提升用户体验我们已经用过很多了，ajax已然成为了前端开发最重要的“工具”之一。
但是，我想应该会有不少人在使用ajax的时候都在依赖于jQuery或者prototype或者其他js库。但现实是，假设某一天一个项目不能引入任何一个js库，只能用原生js写代码，那你怎么办？又或者是一个非常简单的页面，但是要用到ajax，难道就为了下这么一个ajax请求要引用一个jq这么大的js库？我想这是不值得的，所以我们应该学会用原生的js来写ajax，并且把它封装好以便于以后使用。
由于之前使用过jq的ajax而且觉得他使用起来挺舒服的，所以我在封装ajax的时候一方面舍去了很多不常用的参数只留下了最常用的几个功能，另一方面尽量保持它原有的使用风格。
我一共只留了五个参数，他们分别是发送方式（type）、发请求的url（url）、是否为异步请求（async）、发送的参数（data）、传输成功的回调函数（success），函数代码如下:
/* 封装ajax函数
* @param {string}opt.type http连接的方式，包括POST和GET两种方式，默认使用GET
* @param {string}opt.url 发送请求的url
* @param {boolean}opt.async 是否为异步请求，true为异步的，false为同步的
* @param {object}opt.data 发送的参数，格式为对象类型
* @param {function}opt.success ajax发送并接收成功调用的回调函数 */
function ajax(opt) {
opt = opt || {};
var type = opt.type || 'GET';
type = type.toUpperCase() || 'GET';
var url = opt.url || '';
var async = opt.async || true;
var data = opt.data || null;
var success = opt.success || function () {};
var xmlHttp = null;
if (XMLHttpRequest) {
xmlHttp = new XMLHttpRequest();
}
else {
xmlHttp = new ActiveXObject('Microsoft.XMLHTTP');
}
var params = [];
for (var key in data){
params.push(key + '=' + data[key]);
}
var dataStr = params.join('&');
if (type === 'POST') {
xmlHttp.open(type, url, async);
xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded;charset=utf-8');
xmlHttp.send(dataStr);
}
else {
xmlHttp.open(type, url + '?' + dataStr, async);
xmlHttp.send(null);
}
xmlHttp.onreadystatechange = function () {
if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {
success(xmlHttp.responseText);
}
};
}
以对象的形式做函数的参数还是比较灵活的，不用拘泥于参数个数的问题。但这容易出现一个问题，就是使用参数的时候很有可能参数没给却在函数内部使用了，比如在调用函数时忘了写success回调函数，而定义的时候却用到了他，这就会报错了，因为success是undefined了。所以为了避免这种情况我觉得最好在封装函数的时候尽量给每一个参数一个默认值，如果调用的时候未给出某个参数那么他就使用默认值代替，这样就不会出现上述情况了。
接下来下面是创建XMLHttpRequest对象，写了两种创建方式是为了兼容IE才有的写法，旧版本的IE浏览器不支持XMLHttpRequest构造函数，IE有他自己独特的构造函数来支持ajax那就是ActiveXObject构造函数。
创建好了XMLHttpRequest对象，接下来写的是对发送参数data的转换，在使用ajax函数的时候data也用json的数据格式会有一种亲切感，因为大部分ajax传输的时候返回数据都使用json格式，所以发送的时候也使用json格式显得很友好。这里需要将{a: b, c: d}的格式转换为a=b&c=d的格式。
然后是对"POST"和"GET"两种不同的发送方式做处理。GET方法比较简单，直接把整理好的数据接在open方法的url参数的后面就行了（要记得在url后面加上"?"），send方法也不用带参数了，因为参数已经在url后面带着发过去了，所以send方法的参数直接给个null；POST方法这里有个坑，如果不注意可能会很烦恼为什么会得不到想要的结果，那就是需要设定Content-Type头信息，模拟HTTP的POST方法发送一个表单，这样服务器才会知道如何处理上传的内容。send方法中参数的提交格式和GET方法中url的写法一样，也是a=b&c=d格式。注意open方法必须放在设定头信息的前面，否则也会报错。async参数可以是true也可以是false，true代表使用异步方式调用，false代表使用同步方式调用，理所当然使用ajax是一定用异步的，这里只是提供一个选择，而且他的默认值也是true。
最后需要注册一个onreadystatechange事件，当XMLHttpRequest对象的readyState属性等于4了（代表收到完整的服务器响应了），同时status属性等于200（代表服务器响应的状态值为OK，状态正常）就可以判定这次ajax从发送过程到响应过程全程传输成功了，我们可以对返回的数据做一些处理，把要处理的代码写在success函数中，ajax成功就会调用之。
// 使用示例
ajax({
method: 'POST',
url: 'test.php',
data: {
name1: 'value1',
name2: 'value2'
},
success: function (response) {
// codes here
}
});
这个ajax函数很简单代码量也很少，已经基本满足我的日常使用需求了，以后使用也不用依赖js库或者每次写一遍了。如果以后还有更多其他功能要使用，再往里面加。