异步编程模型
① 怎样理解阻塞非阻塞与同步异步的区别
“阻塞”与"非阻塞"与"同步"与“异步"不能简单的从字面理解，提供一个从分布式系统角度的回答。
1.同步与异步
同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication)
所谓同步，就是在发出一个*调用*时，在没有得到结果之前，该*调用*就不返回。但是一旦调用返回，就得到返回值了。
换句话说，就是由*调用者*主动等待这个*调用*的结果。
而异步则是相反，*调用*在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在*调用*发出后，*被调用者*通过状态、通知来通知调用者，或通过回调函数处理这个调用。
典型的异步编程模型比如Node.js
举个通俗的例子：
你打电话问书店老板有没有《分布式系统》这本书，如果是同步通信机制，书店老板会说，你稍等，”我查一下"，然后开始查啊查，等查好了（可能是5秒，也可能是一天）告诉你结果（返回结果）。
而异步通信机制，书店老板直接告诉你我查一下啊，查好了打电话给你，然后直接挂电话了（不返回结果）。然后查好了，他会主动打电话给你。在这里老板通过“回电”这种方式来回调。
2. 阻塞与非阻塞
阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.
阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。
还是上面的例子，
你打电话问书店老板有没有《分布式系统》这本书，你如果是阻塞式调用，你会一直把自己“挂起”，直到得到这本书有没有的结果，如果是非阻塞式调用，你不管老板有没有告诉你，你自己先一边去玩了， 当然你也要偶尔过几分钟check一下老板有没有返回结果。
在这里阻塞与非阻塞与是否同步异步无关。跟老板通过什么方式回答你结果无关。
② 五体大字系统进阶课讲什么
大数据技术在如今应用非常广泛，许多想入行学习大数据培训的童鞋不知从何学起，从哪儿开始学首先要根据你的基本情况而定，如果你是零基础的也不需要担心，先从基础开始学起就好了，接下来学习基础java开始、数据结构、关系型数据库、linux系统操作，夯实基础之后，再进入大数据的学习，例如：hadoop离线分析、Storm实时计算、spark内存计算的学习，以道教育大数据课程体系可以如下：
第一阶段 WEB 开发基础
HTML基础
1、Html基本介绍
2、HTML语法规范
3、基本标签介绍
4、HTML编辑器/文本文档/WebStrom/elipse
5、HTML元素和属性
6、基本的HTML元素
6.1 标题
6.2 段落
6.3 样式和style属性
6.3 链接 a
6.4 图像 img
6.5 表格 table
6.6 列表 ul/ol/dl
7、 HTML注释
8、表单介绍
9、Table标签
10、DIV布局介绍
11、HTML列表详解
HTML布局和Bootstrap
1、 HTML块元素（block）和行内元素(inline)
2、使用div实现网页布局
3、响应式WEB设计（Responsive Web Design）
4、使用bootstrap实现响应式布局
HTML表单元素
1、HTML表单 form
2、HTML表单元素
3、 HTML input的类型 type
4、 Html input的属性
CSS基础
1、CSS简介及基本语法
2、在HTML文档中使用CSS
3、CSS样式
4、CSS选择器
5、盒子模型
6、布局及定位
CSS高级/CSS3
1、尺寸和对齐
2、分类（clear/cursor/display/float/position/visibility）
3、导航栏
4、图片库
5、图片透明
6、媒介类型 @media
7、CSS3
8、CSS3动画效果
JavaScript基础
1、JavaScript简介
2、基本语法规则
3、在HTML文档中使用JS
4、JS变量
5、JS数据类型
6、JS函数
7、JS运算符
8、流程控制
9、JS错误和调试
JavaScript对象和作用域
1、数字 Number
2、字符串String
3、日期 Date
4、数组
5、数学 Math
6、DOM对象和事件
7、BOM对象
8、Window对象
9、作用域和作用域链
10、JSON
Javascript库
1、Jquery
2、Prototype
3、Ext Js
Jquery
1、Jquery基本语法
2、Jquery选择器
3、Jquery事件
4、Jquery选择器
5、Jquery效果和动画
6、使用Jquery操作HTML和DOM
7、Jquery遍历
8、Jquery封装函数
9、Jquery案例
表单验证和Jquery Validate
1、用Js对HTML表单进行验证
2、Jquery Validata基本用法
3、默认校验规则和提示信息
4、debug和ignore
5、更改错误信息显示位置和样式
6、全部校验通过后的执行函数
7、修改验证触发方式
8、异步验证
9、自定义校验方法
10、radio 和 checkbox、select 的验证
Java基础
1、关于Java
2、Java运行机制
3、第一个Java程序，注释
4、Javac,Java,Javadoc等命令
5、标识符与关键字
6、变量的声明，初始化与应用
7、变量的作用域
8、变量重名
9、基本数据类型
10、类型转换与类型提升
11、各种数据类型使用细节
12、转义序列
13、各种运算符的使用
流程控制
1、选择控制语句if-else
2、选择控制语句switch-case
3、循环控制语句while
4、循环控制语句do-while
5、循环控制语句for与增强型for
6、break，continue，return
7、循环标签
8、数组的声明与初始化
9、数组内存空间分配
10、栈与堆内存
11、二维（多维）数组
12、Arrays类的相关方法
13、main方法命令行参数
面向对象
1、面向对象的基本思想
2、类与对象
3、成员变量与默认值
4、方法的声明，调用
5、参数传递和内存图
6、方法重载的概念
7、调用原则与重载的优势
8、构造器声明与默认构造器
9、构造器重载
10、this关键字的使用
11、this调用构造器原则
12、实例变量初始化方式
13、可变参数方法
访问权限控制
1、包 package和库
2、访问权限修饰符private/protected/public/包访问权限
3、类的访问权限
4、抽象类和抽象方法
5、接口和实现
6、解耦
7、Java的多重继承
8、通过继承来扩展接口
错误和异常处理
1、概念：错误和异常
2、基本异常
3、捕获异常 catch
4、创建自定义异常
5、捕获所有异常
6、Java标准异常
7、使用finally进行清理
8、异常的限制
9、构造器
10、异常匹配
11、异常使用指南
数据库基础（Mysql）
数据库基础（MySQL）
JDBC
1、Jdbc基本概念
2、使用Jdbc连接数据库
3、使用Jdbc进行crud操作
4、使用Jdbc进行多表操作
5、Jdbc驱动类型
6、Jdbc异常和批量处理
7、Jdbc储存过程
Servlet和JSP
1、Servlet简介
2、Request对象
3、Response对象
4、转发和重定向
5、使用Servlet完成Crud
6、Session和Coolie简介
7、ServletContext和Jsp
8、El和Jstl的使用
Ajax
1、什么是Ajax
2、XMLHttpRequest对象（XHR）
3、XHR请求
4、XHR响应
5、readystate/onreadystatechange
6、Jquery Ajax
7、JSON
8、案例：对用户名是否可用进行服务器端校验
综合案例
1、项目开发一般流程介绍
2、模块化和分层
3、DButils
4、QueryRunner
5、ResultSetHandle
6、案例：用户登录/注册，从前端到后端
第二阶段 Java SE
访问权限和继承
1、包的声明与使用
2、import与import static
3、访问权限修饰符
4、类的封装性
5、static（静态成员变量）
6、final（修饰变量，方法）
7、静态成员变量初始化方式
8、类的继承与成员继承
9、super的使用
10、调用父类构造器
11、方法的重写与变量隐藏
12、继承实现多态和类型转换
13、instanceof
抽象类与接口
1、抽象类
2、抽象方法
3、继承抽象类
4、抽象类与多态
5、接口的成员
6、静态方法与默认方法
7、静态成员类
8、实例成员类
9、局部类
10、匿名类
11、eclipse的使用与调试
12、内部类对外围类的访问关系
13、内部类的命名
Lambda表达式与常用类
1、函数式接口
2、Lambda表达式概念
3、Lambda表达式应用场合
4、使用案例
5、方法引用
6、枚举类型（编译器的处理）
7、包装类型（自动拆箱与封箱）
8、String方法
9、常量池机制
10、String讲解
11、StringBuilder讲解
12、Math，Date使用
13、Calendars使用
异常处理与泛型
1、异常分类
2、try-catch-finally
3、try-with-resources
4、多重捕获multi-catch
5、throw与throws
6、自定义异常和优势
7、泛型背景与优势
8、参数化类型与原生类型
9、类型推断
10、参数化类型与数组的差异
11、类型通配符
12、自定义泛型类和类型擦出
13、泛型方法重载与重写
集合
1 、常用数据结构
2 、Collection接口
3 、List与Set接口
4 、SortedSet与NavigableSet
5 、相关接口的实现类
6 、Comparable与Comparator
7、Queue接口
8 、Deque接口
9 、Map接口
10、NavigableMap
11、相关接口的实现类
12、流操作（聚合操作）
13、Collections类的使用
I/O流与反射
1 、File类的使用
2 、字节流
3 、字符流
4 、缓存流
5 、转换流
6 、数据流
7、对象流
8、类加载，链接与初始化
9 、ClassLoader的使用
10、Class类的使用
11、通过反射调用构造器
12、安全管理器
网络编程模型与多线程
1、进程与线程
2、创建线程的方式
3、线程的相关方法
4、线程同步
5、线程死锁
6、线程协作操作
7、计算机网络（IP与端口）
8、TCP协议与UDP协议
9、URL的相关方法
10、访问网络资源
11、TCP协议通讯
12、UDP协议通讯
13、广播
SSM-Spring
1.Spring/Spring MVC
2.创建Spring MVC项目
3.Spring MVC执行流程和参数
SSM-Spring.IOC
1.Spring/Spring MVC
2.创建Spring MVC项目
3.Spring MVC执行流程和参数
SSM-Spring.AOP
1.Spring/Spring MVC
2.创建Spring MVC项目
3.Spring MVC执行流程和参数
SSM-Spring.Mybatis
1.MyBatis简介
2.MyBatis配置文件
3.用MyBatis完成CRUD
4.ResultMap的使用
5.MyBatis关联查询
6.动态SQL
7.MyBatis缓冲
8.MyBatis-Generator
Socket编程
1.网络通信和协议
2.关于Socket
3.Java Socket
4.Socket类型
5.Socket函数
6.WebSocket
7.WebSocket/Spring MVC/WebSocket Ajax
IO/异步
window对象
全局作用域
窗口关系及框架
窗口位置和大小
打开窗口
间歇调用和超时调用（灵活运用）
系统对话框
location对象
navigator对象
screen对象
history对象
NIO/AIO
1.网络编程模型
2.BIO/NIO/AIO
3.同步阻塞
4.同步非阻塞
5.异步阻塞
6.异步非阻塞
7.NIO与AIO基本操作
8.高性能IO设计模式
第三阶段 Java 主流框架
MyBatis
1.mybatis框架原理分析
2.mybatis框架入门程序编写
3.mybatis和hibernate的本质区别和应用场景
4.mybatis开发方法
5.SqlMapConfig配置文件讲解
6.输入映射-pojo包装类型的定义与实现
7.输出映射-resultType、resultMap
8.动态sql
9.订单商品数据模型分析
10.高级映射的使用
11.查询缓存之一级缓存、二级缓存
12.mybatis与spring整合
13. mybatis逆向工程自动生成代码
Spring/Spring MVC
1. springmvc架构介绍
2. springmvc入门程序
3. spring与mybatis整合
4. springmvc注解开发—商品修改功能分析
5. springmvc注解开发—RequestMapping注解
6. springmvc注解开发—Controller方法返回值
7. springmvc注解开发—springmvc参数绑定过程分析
8. springmvc注解开发—springmvc参数绑定实例讲解
9. springmvc与struts2的区别
10. springmvc异常处理
11. springmvc上传图片
12. springmvc实现json交互
13. springmvc对RESTful支持
14. springmvc拦截器
第四阶段 关系型数据库/MySQL/NoSQL
SQL基础
1.SQL及主流产品
2.MySQL的下载与安装（sinux/windows）
3.MySql的基本配置/配置文件
4.基本的SQL操作 DDL
5.基本的SQL操作 DML
6.基本的SQL操作 DCL
7.MySQL客户端工具
8.MySQL帮助文档
MySQL数据类型和运算符
1 数值类型
2 日期时间类型
3 字符串类型
4 CHAR 和 VARCHAR 类型
5 BINARY 和 VARBINARY 类型
6 ENUM 类型
7 SET 类型
8 算术运算符
9 比较运算符
10 逻辑运算符
11 位运算
12 运算符的优先级
MySQL函数
1 字符串函数
2 数值函数
3 日期和时间函数
4 流程函数
5 其他常用函数
MySQL存储引擎
1.MySQL支持的存储引擎及其特性
2.MyISAM
3.InnoDB
4.选择合适的存储引擎
选择合适的数据类型
1 CHAR 与 VARCHAR
2 TEXT 与 BLOB
3 浮点数与定点数
4 日期类型选择
字符集
1 字符集概述
2 Unicode字符集
3 汉字及一些常见字符集
4 选择合适的字符集
5 MySQL 支持的字符集
6 MySQL 字符集的设置 .
索引的设计和使用
1.什么是索引
2.索引的类型
3.索引的数据结构 BTree B+Tree Hash
4.索引的存储
5.MySQL索引
6.查看索引的使用情况
7.索引设计原则
视图/存储过程/函数/触发器
1. 什么是视图
2. 视图操作
3. 什么是存储过程
4. 存储过程操作
5. 什么是函数
6. 函数的相关操作
7. 触发器
事务控制/锁
1. 什么是事务
2. 事务控制
3. 分布式事务
4. 锁/表锁/行锁
5. InnoDB 行锁争用
6. InnoDB 的行锁模式及加锁方法7
7 InnoDB 行锁实现方式7
8 间隙锁（Next-Key 锁）
9 恢复和复制的需要，对 InnoDB 锁机制的影响
10 InnoDB 在不同隔离级别下的一致性读及锁的差异
11 表锁
12 死锁
SQL Mode和安全问题
1. 关于SQL Mode
2. MySQL中的SQL Mode
3. SQL Mode和迁移
4. SQL 注入
5. 开发过程中如何避免SQL注入
SQL优化
1.通过 show status 命令了解各种 SQL 的执行频率
2. 定位执行效率较低的 SQL 语句
3. 通过 EXPLAIN 分析低效 SQL 的执行计划
4. 确定问题并采取相应的优化措施
5. 索引问题
6.定期分析表和检查表
7.定期优化表
8.常用 SQL 的优化
MySQL数据库对象优化
1. 优化表的数据类型
2 散列化
3 逆规范化
4 使用中间表提高统计查询速度
5. 影响MySQL性能的重要参数
6. 磁盘I/O对MySQL性能的影响
7. 使用连接池
8. 减少MySQL连接次数
9. MySQL负载均衡
MySQL集群
MySQL管理和维护
MemCache
Redis
在Java项目中使用MemCache和Redis
第五阶段：操作系统/Linux、云架构
Linux安装与配置
1、安装Linux至硬盘
2、获取信息和搜索应用程序
3、进阶：修复受损的Grub
4、关于超级用户root
5、依赖发行版本的系统管理工具
6、关于硬件驱动程序
7、进阶：配置Grub
系统管理与目录管理
1、Shell基本命令
2、使用命令行补全和通配符
3、find命令、locate命令
4、查找特定程序：whereis
5、Linux文件系统的架构
6、移动、复制和删除
7、文件和目录的权限
8、文件类型与输入输出
9、vmware介绍与安装使用
10、网络管理、分区挂载
用户与用户组管理
1、软件包管理
2、磁盘管理
3、高级硬盘管理RAID和LVM
4、进阶：备份你的工作和系统
5、用户与用户组基础
6、管理、查看、切换用户
7、/etc/...文件
8、进程管理
9、linux VI编辑器，awk，cut，grep，sed，find，unique等
Shell编程
1、 SHELL变量
2、传递参数
3、数组与运算符
4、SHELL的各类命令
5、SHELL流程控制
6、SHELL函数
7、SHELL输入/输出重定向
8、SHELL文件包含
服务器配置
1、系统引导
2、管理守护进程
3、通过xinetd启动SSH服务
4、配置inetd
5、Tomcat安装与配置
6、MySql安装与配置
7、部署项目到Linux
第六阶段：Hadoop生态系统
Hadoop基础
1、大数据概论
2、 Google与Hadoop模块
3、Hadoop生态系统
4、Hadoop常用项目介绍
5、Hadoop环境安装配置
6、Hadoop安装模式
7、Hadoop配置文件
HDFS分布式文件系统
1、认识HDFS及其HDFS架构
2、Hadoop的RPC机制
3、HDFS的HA机制
4、HDFS的Federation机制
5、 Hadoop文件系统的访问
6、JavaAPI接口与维护HDFS
7、HDFS权限管理
8、hadoop伪分布式
Hadoop文件I/O详解
1、Hadoop文件的数据结构
2、 HDFS数据完整性
3、文件序列化
4、Hadoop的Writable类型
5、Hadoop支持的压缩格式
6、Hadoop中编码器和解码器
7、 gzip、LZO和Snappy比较
8、HDFS使用shell+Java API
MapRece工作原理
1、MapRece函数式编程概念
2、 MapRece框架结构
3、MapRece运行原理
4、Shuffle阶段和Sort阶段
5、任务的执行与作业调度器
6、自定义Hadoop调度器
7、 异步编程模型
8、YARN架构及其工作流程
MapRece编程
1、WordCount案例分析
2、输入格式与输出格式
3、压缩格式与MapRece优化
4、辅助类与Streaming接口
5、MapRece二次排序
6、MapRece中的Join算法
7、从MySQL读写数据
8、Hadoop系统调优
Hive数据仓库工具
1、Hive工作原理、类型及特点
2、Hive架构及其文件格式
3、Hive操作及Hive复合类型
4、Hive的JOIN详解
5、Hive优化策略
6、Hive内置操作符与函数
7、Hive用户自定义函数接口
8、Hive的权限控制
Hive深入解读
1 、安装部署Sqoop
2、Sqoop数据迁移
3、Sqoop使用案例
4、深入了解数据库导入
5、导出与事务
6、导出与SequenceFile
7、Azkaban执行工作流
Sqoop与Oozie
1 、安装部署Sqoop
2、Sqoop数据迁移
3、Sqoop使用案例
4、深入了解数据库导入
5、导出与事务
6、导出与SequenceFile
7、Azkaban执行工作流
Zookeeper详解
1、Zookeeper简介
2、Zookeeper的下载和部署
3、Zookeeper的配置与运行
4、Zookeeper的本地模式实例
5、Zookeeper的数据模型
6、Zookeeper命令行操作范例
7、storm在Zookeeper目录结构
NoSQL、HBase
1、HBase的特点
2、HBase访问接口
3、HBase存储结构与格式
4、HBase设计
5、关键算法和流程
6、HBase安装
7、HBase的SHELL操作
8、HBase集群搭建
第七阶段：Spark生态系统
Spark
1.什么是Spark
2.Spark大数据处理框架
3.Spark的特点与应用场景
4.Spark SQL原理和实践
5.Spark Streaming原理和实践
6.GraphX SparkR入门
7.Spark的监控和调优
Spark部署和运行
1.WordCount准备开发环境
2.MapRece编程接口体系结构
3.MapRece通信协议
4.导入Hadoop的JAR文件
5.MapRece代码的实现
6.打包、部署和运行
7.打包成JAR文件
Spark程序开发
1、启动Spark Shell
2、加载text文件
3、RDD操作及其应用
4、RDD缓存
5、构建Eclipse开发环境
6、构建IntelliJ IDEA开发环境
7、创建SparkContext对象
8、编写编译并提交应用程序
Spark编程模型
1、RDD特征与依赖
2、集合（数组）创建RDD
3、存储创建RDD
4、RDD转换 执行 控制操作
5、广播变量
6、累加器
作业执行解析
1、Spark组件
2、RDD视图与DAG图
3、基于Standalone模式的Spark架构
4、基于YARN模式的Spark架构
5、作业事件流和调度分析
6、构建应用程序运行时环境
7、应用程序转换成DAG
Spark SQL与DataFrame
1、Spark SQL架构特性
2、DataFrame和RDD的区别
3、创建操作DataFrame
4、RDD转化为DataFrame
5、加载保存操作与Hive表
6、Parquet文件JSON数据集
7、分布式的SQL Engine
8、性能调优 数据类型
深入Spark Streaming
1、Spark Streaming工作原理
2、DStream编程模型
3、Input DStream
4、DStream转换 状态 输出
5、优化运行时间及内存使用
6、文件输入源
7、基于Receiver的输入源
8、输出操作
Spark MLlib与机器学习
1、机器学习分类级算法
2、Spark MLlib库
3、MLlib数据类型
4、MLlib的算法库与实例
5、ML库主要概念
6、算法库与实例
GraphX与SparkR
1、Spark GraphX架构
2、GraphX编程与常用图算法
3、GraphX应用场景
4、SparkR的工作原理
5、R语言与其他语言的通信
6、SparkR的运行与应用
7、R的DataFrame操作方法
8、SparkR的DataFrame
Scala编程开发
1、Scala语法基础
2、idea工具安装
3、maven工具配置
4、条件结构、循环、高级for循环
5、数组、映射、元组
6、类、样例类、对象、伴生对象
7、高阶函数与函数式编程
Scala进阶
1、 柯里化、闭包
2、模式匹配、偏函数
3、类型参数
4、协变与逆变
5、隐式转换、隐式参数、隐式值
6、Actor机制
7、高级项目案例
Python编程
1、Python编程介绍
2、Python的基本语法
3、Python开发环境搭建
4、Pyhton开发Spark应用程序
第八阶段：Storm生态系统
storm简介与基本知识
1、storm的诞生诞生与成长
2、storm的优势与应用
3、storm基本知识概念和配置
4、序列化与容错机制
5、可靠性机制—保证消息处理
6、storm开发环境与生产环境
7、storm拓扑的并行度
8、storm命令行客户端
Storm拓扑与组件详解
1、流分组和拓扑运行
2、拓扑的常见模式
3、本地模式与stormsub的对比
4、 使用非jvm语言操作storm
5、hook、组件基本接口
6、基本抽象类
7、事务接口
8、组件之间的相互关系
spout详解 与bolt详解
1、spout获取数据的方式
2、常用的spout
3、学习编写spout类
4、bolt概述
5、可靠的与不可靠的bolt
6、复合流与复合anchoring
7、 使用其他语言定义bolt
8、学习编写bolt类
storm安装与集群搭建
1、storm集群安装步骤与准备
2、本地模式storm配置命令
3、配置hosts文件、安装jdk
4、zookeeper集群的搭建
5、部署节点
6、storm集群的搭建
7、zookeeper应用案例
8、Hadoop高可用集群搭建
Kafka
1、Kafka介绍和安装
2、整合Flume
3、Kafka API
4、Kafka底层实现原理
5、Kafka的消息处理机制
6、数据传输的事务定义
7、Kafka的存储策略
Flume
1、Flume介绍和安装
2、Flume Source讲解
3、Flume Channel讲解
4、Flume Sink讲解
5、flume部署种类、流配置
6、单一代理、多代理说明
7、flume selector相关配置
Redis
1、Redis介绍和安装、配置
2、Redis数据类型
3、Redis键、字符串、哈希
4、Redis列表与集合
5、Redis事务和脚本
6、Redis数据备份与恢复
7、Redis的SHELL操作
③ jQuery链式操作如何实现以及为什么要用链式操作
链式操作
原理相信网络一下一大把，实际上链式操作仅仅是通过对象上的方法最后
return this
把对象再返回回来，对象当然可以继续调用方法啦，所以就可以链式操作了。那么，简单实现一个：
复制代码 代码如下:
//定义一个JS类
function Demo() {
}
//扩展它的prototype
Demo.prototype ={
setName:function (name) {
this.name = name;
return this;
},
getName:function () {
return this.name;
},
setAge:function (age) {
this.age = age;
return this;
}
};
////工厂函数
function D() {
return new Demo();
}
//去实现可链式的调用
D().setName("CJ").setAge(18).setName();
但……为什么要用呢？
一般的解释：
节省代码量，代码看起来更优雅。
例如如果没有链式，那么你可能需要这样写代码：
复制代码 代码如下:
document.getElementById("ele").dosomething();
document.getElementById("ele").dootherthing();
这个代码中调用了两次document.getElementById来获取DOM树的元素，这样消耗比较大，而且要写两行，而链式只要写一行，节省了代码……
但我们也可以用缓存元素啊。比如：
复制代码 代码如下:
var ele = document.getElementById("ele");
ele.dosomething();
ele.dootherthing();
而且两行并没有比一行多多少代码，甚至相应的封装反而使得代码更多了。
最糟糕的是所有对象的方法返回的都是对象本身，也就是说没有返回值，这不一定在任何环境下都适合。
举个例子，我们想弄一个超大整数BigInteger（意思是如果用Javascript的Number保存可能会溢出的整数），顺便扩展他的运算方法，会适合用链式操作么？
例如运算31415926535 * 4 - 271828182，如果设计成链式风格的方法可能会是这样的：
复制代码 代码如下:
var result = (new BigInteger("31415926535")).multiply(new BigInteger("4")).subtract(new BigInteger("271828182")).val();
console.log("result == " + result);
这看起来似乎也很优雅，但是如果我们想要中间的结果怎么办呢？或许会写成这样：
复制代码 代码如下:
var bigInteger = new BigInteger("31415926535");
var result1 = bigInteger.multiply(new BigInteger("4")).val();
var result2 = bigInteger.subtract(new BigInteger("271828182")).val();
console.log("result1 == " + result1 + ", result2 == " + result2);
这似乎一点也不优雅了，和不用链式操作没啥不同嘛！
那么如果要求是原来的BigInteger不能改变呢？好吧，链式操作似乎不能满足这个需求了。
那么到底为什么要用链式操作呢？
为了更好的异步体验
Javascript是无阻塞语言，所以他不是没阻塞，而是不能阻塞，所以他需要通过事件来驱动，异步来完成一些本需要阻塞进程的操作。
但是异步编程是一种令人疯狂的东西……运行时候是分离的倒不要紧，但是编写代码时候也是分离的就……
常见的异步编程模型有哪些呢？
•回调函数
所谓的回调函数，意指先在系统的某个地方对函数进行注册，让系统知道这个函数的存在，然后在以后，当某个事件发生时，再调用这个函数对事件进行响应。
复制代码 代码如下:
function f(num, callback){
if(num<0) {
alert("调用低层函数处理!");
alert("分数不能为负,输入错误!");
}else if(num==0){
alert("调用低层函数处理!");
alert("该学生可能未参加考试！");
}else{
alert("调用高层函数处理!");
setTimeout(function(){callback();}, 1000);
}
}
这里callback则是回调函数。可以发现只有当num为非负数时候callback才会调用。
但是问题，如果我们不看函数内部，我们并不知道callback会几时调用，在什么情况下调用，代码间产生了一定耦合，流程上也会产生一定的混乱。
虽然回调函数是一种简单而易于部署的实现异步的方法，但从编程体验来说它却不够好。
•事件监听
也就是采用事件驱动，执行顺序取决于事件顺序。
复制代码 代码如下:
function EventTarget(){
this.handlers = {};
}
EventTarget.prototype = {
constructor: EventTarget,
addHandler: function(type, handler){
this.handlers[type] = [];
},
fire: function(){
if(!event.target){
event.target = this;
}
if(this.handlers[event.type instanceof Array]){
var handlers = this.handlers[event.type];
for(var i = 0, len = handlers.length, i < len; i++){
handlers[i](event);
}
}
},
removeHandler: function(type, handler){
if(this.handlers[type] instanceof Array){
var handlers = this.handlers[type];
for(var i = 0, le = handlers.length; i < len; i++){
if(handlers[i] === handler){
break;
}
}
handlers.splice(i, 1);
}
}
};
上面是《JavaScript高级程序设计》中的自定义事件实现。于是我们就可以通过addHandler来绑定事件处理函数，用fire来触发事件，用removeHandler来删除事件处理函数。
虽然通过事件解耦了，但流程顺序更加混乱了。
•链式异步
个人觉得链式操作最值得称赞的还是其解决了异步编程模型的执行流程不清晰的问题。jQuery中$(document).ready就非常好的阐释了这一理念。DOMCotentLoaded是一个事件，在DOM并未加载前，jQuery的大部分操作都不会奏效，但jQuery的设计者并没有把他当成事件一样来处理，而是转成一种“选其对象，对其操作”的思路。$选择了document对象，ready是其方法进行操作。这样子流程问题就非常清晰了，在链条越后位置的方法就越后执行。
复制代码 代码如下:
(function(){
var isReady=false; //判断onDOMReady方法是否已经被执行过
var readyList= [];//把需要执行的方法先暂存在这个数组里
var timer;//定时器句柄
ready=function(fn) {
if (isReady )
fn.call( document);
else
readyList.push( function() { return fn.call(this);});
return this;
}
var onDOMReady=function(){
for(var i=0;i<readyList.length;i++){
readyList[i].apply(document);
}
readyList = null;
}
var bindReady = function(evt){
if(isReady) return;
isReady=true;
onDOMReady.call(window);
if(document.removeEventListener){
document.removeEventListener("DOMContentLoaded", bindReady, false);
}else if(document.attachEvent){
document.detachEvent("onreadystatechange", bindReady);
if(window == window.top){
clearInterval(timer);
timer = null;
}
}
};
if(document.addEventListener){
document.addEventListener("DOMContentLoaded", bindReady, false);
}else if(document.attachEvent){
document.attachEvent("onreadystatechange", function(){
if((/loaded|complete/).test(document.readyState))
bindReady();
});
if(window == window.top){
timer = setInterval(function(){
try{
isReady||document.documentElement.doScroll('left');//在IE下用能否执行doScroll判断dom是否加载完毕
}catch(e){
return;
}
bindReady();
},5);
}
}
})();
上面的代码不能用$(document).ready，而应该是window.ready。
•Promise
CommonJS中的异步编程模型也延续了这一想法，每一个异步任务返回一个Promise对象，该对象有一个then方法，允许指定回调函数。
所以我们可以这样写：
f1().then(f2).then(f3);
这种方法我们无需太过关注实现，也不太需要理解异步，只要懂得通过函数选对象，通过then进行操作，就能进行异步编程。
④ 浅谈Node.js异步编程中回调和异步调用的区别
异步编程模型是Node.js的主要特色,node.js的很多第三方模块都提供了异步的API。本文着重阐述了同步调用、异步调用及回调与异步调用的区别,通过案例说明回调函数的用法
⑤ javascript动画为什么是异步操作
JavaScript中的异步梳理（2）——使用Promises/A
Promises是一种异步编程模型，通过一组API来规范化异步操作，这样也能够让异步操作的流程控制更加容易。
这里谈的是Promises/A，算是Promises的一个分支吧，其实就是根据Promises模型定义了一组API。由于Promises对于新手而言理解曲线还是比较陡峭的，这里循序渐进的给大家介绍，同时实现一个最简单的Promises/A代码。
Promises/A有个别名叫做“thenable”，就是“可以then”的。这里一个promise有三种状态：[默认、完成、失败]，初始创建的时候是默认状态，状态只可以从默认变成完成，或者默认变成失败。一旦完成或者失败，状态就不能再变。为了简化文章，这里我们先只考虑完成，不考虑失败。
var Promise = function(ok){
this.state = 'unfulfilled';
this.ok = || function(obj) { return obj; };
};
Promise.prototype = {
resolve: function(obj){
if (this.state !== 'unfulfilled') throw '已完成，不能再次resolve';
this.state = 'fulfilled';
}
};
var promise = new Promise(function(obj){ return obj; });
构造函数中的ok是一个任务，promise.resolve(obj)表示将该promise的状态改为完成，此时ok会被执行，其返回值作为后续操作的参数以及resolve的返回值。
由于没有和任何异步操作关联在一起，这里的Promise还没有任何作用。
Promises/A之所以叫“thenable”是因为它的核心API叫做then，望文生义这个方法的作用是当一个promise完成或失败后继续干别的事情。
then传入一个函数作为参数nextOK①，当该promise被resolve时，resolve的返回值将会传递到nextOK中。
then返回一个promise，当上述后续操作完成时，返回的promise也会被resolve。
如果promise的状态是已完成，则nextOK会被立即调用。
但是这样并无法异步，因此这里有一个特殊情况，就是如果nextOK的返回值也是一个Promise，那么then返回的promise需要当这个promise被resolve时才会被resolve。
var Promise = function(ok){
this.state = 'unfulfilled';
this.ok = ok || function(obj) { return obj; };
this.thens = [];
};
Promise.prototype = {
resolve: function(obj){
if (this.state != 'unfulfilled') throw '已完成，不能再次resolve';
this.state = 'fulfilled';
this.result = this.ok(obj); // 执行ok
for (var i=0, len=this.thens.length; i<len; ++i){
// 依次调用该任务的后续任务
var then = this.thens[i];
this._fire(then.promise, then.ok);
}
return this;
},
_fire: function(nextPromise, nextOK){
var nextResult = nextOK(this.result); // 调用nextOK
if (nextResult instanceof Promise){
// 异步的情况，返回值是一个Promise，则当其resolve的时候，nextPromise才会被resolve
nextResult.then(function(obj){
nextPromise.resolve(obj);
});
}else{
// 同步的情况，返回值是普通结果，立即将nextPromise给resolve掉
nextPromise.resolve(nextResult);
}
return nextPromise;
},
_push: function(nextPromise, nextOK){
this.thens.push({
promise: nextPromise,
ok: nextOK
});
return nextPromise;
},
then: function(nextOK){
var promise = new Promise();
if (this.state == 'fulfilled'){
// 如果当前状态是已完成，则nextOK会被立即调用
return this._fire(promise, nextOK);
}else{
// 否则将会被加入队列中
return this._push(promise, nextOK);
}
}
};
到到了这里，我们的极简版Promise就完成了，那么如何使用呢？
这里举个例子，首先定义一些“任务”，例如：
function print(num){
console.log(num);
return num;
}
function addTwo(num){
return num + 2;
}
按需要组织这些任务
var promise = new Promise(print);
promise.then(addTwo)
.then(print)
.then(addTwo)
.then(print); // 这里的任务将会加入到队列中
promise.resolve(3); // 激活整个队列
可以看到控制台里依次打印出了3、5和7。
但这些任务都是同步的，无法体现出Promise的强大之处——异步控制。这里我们通过nextOK返回promise的方法来实现一个delay。
function delay(ms){
return function(obj){
var promise = new Promise();
setTimeout(function(){
promise.resolve(obj);
}, ms);
return promise;
};
}
利用它来改造上面的任务队列，让后两次打印之间延迟2秒：
var promise = new Promise(print);
promise.then(addTwo)
.then(print)
.then(delay(2000)) // 延迟2秒
.then(addTwo)
.then(print);
promise.resolve(3);
利用这个原理，可以做一些巧妙的代码：
function fibNext(pair){
print(pair[0]);
return [pair[1], pair[0]+pair[1]];
}
var promise = new Promise(fibNext);
promise.then(function(pair){
promise = promise.then(delay(1000))
.then(fibNext)
.then(arguments.callee);
return pair;
});
promise.resolve([1,1]);
上面没有使用循环，但是实现了一个无限每隔1秒自动打印的斐波那契数列。
Promises模型相当优雅，通过一些扩展可以实现诸如when, whenAll等API，对于封装异步操作非常有帮助。
事实上的库中不常直接用Promise这个名字，而常用Deferred，Defer的意思是“延迟”，因此Deferred常被成为“延迟队列”或者“异步队列”。在jQuery 1.5中引入了jQuery.Deferred，Dojo在这方面也是先行者，dojo 0.3就实现了Deferred。事实上在使用了Deferred之后，jQuery.ajax和dojo.ajax返回的结果都是Deferred，因此可以用then取代传统的传入回调函数的形式，非常方便，例如在dojo中可以：
dojo.xhrGet({
url: "users.json",
handleAs: "json"
}).then(function(userList){
dojo.forEach(userList, function(user){
appendUser(user);
});
});
使用这样的代码可以随时对ajax请求添加回调，而不一定是在定义之初设定回调，灵活性更强。
⑥ 全面解析C#中的异步编程
当我们处理一些长线的调用时，经常会导致界面停止响应或者IIS线程占用过多等问题，这个时候我们需要更多的是用异步编程来修正这些问题，但是通常都是说起来容易做起来难，诚然异步编程相对于同步编程来说，它是一种完全不同的编程思想，对于习惯了同步编程的开发者来说，在开发过程中难度更大，可控性不强是它的特点。
在.NET
Framework5.0种，微软为我们系统了新的语言特性，让我们使用异步编程就像使用同步编程一样相近和简单，本文中将会解释以前版本的Framework中基于回调道德异步编程模型的一些限制以及新型的API如果让我们简单的做到同样的开发任务。
为什么要异步
一直以来，使用远程资源的编程都是一个容易造成困惑的问题，不同于“本地资源”，远程资源的访问总会有很多意外的情况，网络环境的不稳定机器服务端的故障，会造成很多程序员完全不可控的问题，所以这也就要求程序员需要更多的去保护远程资源的调用，管理调用的取消、超市、线程的等待以及处理线程长时间没响应的情况等。而在.NET中我们通常忽略了这些挑战，事实上我们会有多种不用的模式来处理异步编程，比如在处理IO密集型操作或者高延迟的操作时候不组测线程，多数情况我们拥有同步和异步两个方法来做这件事。可是问题在于当前的这些模式非常容易引起混乱和代码错误，或者开发人员会放弃然后使用阻塞的方式去开发。
而在如今的.NET中，提供了非常接近于同步编程的编程体验，不需要开发人员再去处理只会在异步编程中出现的很多情况，异步调用将会是清晰的且不透明的，而且易于和同步的代码进行组合使用。
过去糟糕的体验
最好的理解这种问题的方式是我们最常见的一种情况：用户界面只拥有一个线程所有的工作都运行在这个线程上，客户端程序不能对用户的鼠标时间做出反应，这很可能是因为应用程序正在被一个耗时的操作所阻塞，这可能是因为线程在等待一个网络ID或者在做一个CPU密集型的计算，此时用户界面不能获得运行时间，程序一直处于繁忙的状态，这是一个非常差的用户体验。
很多年来，解决这种问题的方法都是做异步花的调用，不要等待响应，尽快的返回请求，让其他事件可以同时执行，只是当请求有了最终反馈的时候通知应用程序让客户代码可以执行指定的代码。
而问题在于：异步代码完全毁掉了代码流程，回调代理解释了之后如何工作，但是怎么在一个while循环里等待?一个if语句?一个try块或者一个using块?怎么去解释“接下来做什么”?
看下面的一个例子：
public
int
SumPageSizes(IList
uris)
{
int
total
=
0;
foreach
(var
uri
in
uris)
{
txtStatus.Text
=
string.Format("Found
{0}
bytes...",
total);
var
data
=
new
WebClient().DownloadData(uri);
total
+=
data.Length;
}
txtStatus.Text
=
string.Format("Found
{0}
bytes
total",
total);
return
total;
}
这个方法从一个uri列表里下载文件，统计他们的大小并且同时更新状态信息，很明显这个方法不属于UI线程因为它需要花费非常长的时间来完成，这样它会完全的挂起UI，但是我们又希望UI能被持续的更新，怎么做呢?
我们可以创建一个后台编程，让它持续的给UI线程发送数据来让UI来更新自身，这个看起来是很浪费的，因为这个线程把大多时间花在等下和下载上，但是有的时候，这正是我们需要做的。在这个例子中，WebClient提供了一个异步版本的DownloadData方法—DownloadDataAsync，它会立即返回，然后在DownloadDataCompleted后触发一个事件，这允许用户写一个异步版本的方法分割所要做的事，调用立即返回并完成接下来的UI线程上的调用，从而不再阻塞UI线程。下面是第一次尝试：
public
void
SumpageSizesAsync(IList
uris)
{
SumPageSizesAsyncHelper(uris.GetEnumerator(),
0);
}
public
void
SumPageSizesAsyncHelper(IEnumerator
enumerator,
int
total)
{
if
(enumerator.MoveNext())
{
txtStatus.Text
=
string.Format("Found
{0}
bytes...",
total);
var
client
=
new
WebClient();
client.DownloadDataCompleted
+=
(sender,e)=>{
SumPageSizesAsyncHelper(enumerator,
total
+
e.Result.Length);
};
client.DownloadDataAsync(enumerator.Current);
}
else
{
txtStatus.Text
=
string.Format("Found
{0}
bytes
total",
total);
}
}
然后这依然是糟糕的，我们破坏了一个整洁的foreach循环并且手动获得了一个enumerator，每一个调用都创建了一个事件回调。代码用递归取代了循环，这种代码你应该都不敢直视了吧。不要着急，还没有完
。
原始的代码返回了一个总数并且显示它，新的一步版本在统计还没有完成之前返回给调用者。我们怎么样才可以得到一个结果返回给调用者，答案是：调用者必须支持一个回掉，我们可以在统计完成之后调用它。
然而异常怎么办?原始的代码并没有关注异常，它会一直传递给调用者，在异步版本中，我们必须扩展回掉来让异常来传播，在异常发生时，我们不得不明确的让它传播。
⑦ C#几种异步编程
1、异步编程模型 (APM) 模式（也称为 IAsyncResult 模式），其中异步操作要求 Begin 和 End 方法（例如，异步写操作的 BeginWrite 和 EndWrite）。对于新的开发工作不再建议采用此模式。
2、基于事件的异步模式 (EAP) 需要一个具有 Async 后缀的方法，还需要一个或多个事件、事件处理程序、委托类型和 EventArg 派生的类型。EAP 是在 .NET Framework 2.0 版中引入的。对于新的开发工作不再建议采用此模式。
3、基于任务的异步模式 (TAP)，该模式使用一个方法表示异步操作的启动和完成。.NET Framework 4 中引入了 TAP，并且是 .NET Framework 中异步编程的建议方
⑧ C#中udp异步编程之烦恼
这个异步编程模型基本上就是掌握Begin函数和End函数就好了。
首先调用Begin，送一个委托（其实就是你自己写的一个函数）进去当参数，其他几个参数和同步的没什么太大区别。好了就没你什么事了……同步的时候此时是在等对吧，异步的就没得等了，函数直接返回。同步的时候函数返回就可以开始处理数据了对吧？异步的时候要等你送进去当参数的那个函数被调用的时候才能开始处理数据。
等到数据来了或者异常发生了，它会调用你那个函数，把IAsyncResult接口的某个对象当作参数送进来。此时你调用End那个函数，就可以拿到结果了（如果接收过程中有异常发生，End函数会抛出那个异常）
⑨ C#利用socekt做到http监听，怎么样才能做到高性能
用异步Socket编程去替代同步Socket编程是优化Socket的IO性能的一个途径，因为异步IO不会阻塞线程，在请求量大的时候体现出更佳的性能。
C#提供了3中不同的异步编程模式：
1、异步编程模型 (APM) 模式，其方法通常以Begin和End成对出现，已经不推荐使用。
2、基于事件的异步模式 (EAP) ，自.NET 2.0引入，现在也已经不推荐使用
3、基于任务的异步模式 (TAP)，自.NET 4.5引入，使用await/asnyc去完成异步IO操作，可以说是C#的一个特色，也是现在微软异步编程的最佳实践。
如果你还在使用System.Net.Sockets.Socket编程的话，建议你迁移到System.Net.Sockets.TcpListener和System.Net.Sockets.TcpClient上来，后者不仅对Socket进行了友好封装，也支持TAP异步编程。
⑩ 什么是异步编程
传统的同步编程是一种请求响应模型，调用一个方法，等待其响应返回.
异步编程就是要重新考虑是否需要响应的问题，也就是缩小需要响应的地方。因为越快获得响应，就是越同步化，顺序化，事务化，性能差化。
异步编程通常是通过fire and forget方式实现，发射事件后即忘记，做别的事情了，无需立即等待刚才发射的响应结果了。(发射事件的地方称为生产者，而将在另外一个地方响应事件的处理者称为消费者).异步编程是一种事件驱动编程，需要完全改变思路，将“请求响应”的思路转变到“事件驱动”思路上，是一种软件编程思维的转变.下面几种你看参考一下
1、异步编程模型 (APM) 模式（也称为 IAsyncResult 模式），其中异步操作要求 Begin 和 End 方法（例如，异步写操作的 BeginWrite 和 EndWrite）。对于新的开发工作不再建议采用此模式。
2、基于事件的异步模式 (EAP) 需要一个具有 Async 后缀的方法，还需要一个或多个事件、事件处理程序、委托类型和 EventArg 派生的类型。EAP 是在 .NET Framework 2.0 版中引入的。对于新的开发工作不再建议采用此模式。
3、基于任务的异步模式 (TAP)，该模式使用一个方法表示异步操作的启动和完成。.NET Framework 4 中引入了 TAP，并且是 .NET Framework 中异步编程的建议方法。