mergeTableCells(List
8.**命名只是一个表示符，只要告诉你变量在哪定义不需要吧所有的信息都塞到命名里面**
recentlyUpdatedAnnualSalesBid 存在不是最近更新的全年销售投标么？ 存在没有被更新的最近的全年销售投标么？ 存在最近更新的非全年的销售投标么？ 存在最近更新的全年非销售的投标么？ 存在最近更新的全年销售非投标的东东吗？ 上面的任何一个问题回答是不存在，那就意味着命名中引入了无用的单词 finalBattleMostDangerousBossMonster 请写成 boss weaklingFirstEncounterMonster 请写成firstMonster 如果有一些你觉得过了，太短了，容易引起歧义，但是你可以大胆的这样做，如果在之后的开发中你觉得命名会造成冲突和不明确 你可以填一些修饰词来完善它，反之如果一开始就是一个很长的名字，你不可能再改回来 9.**省略命名中可以从上下文获取的单词**
// Bad: class AnnualHolidaySale { int _annualSaleRebate; void promoteHolidaySale() { ... } } // Better: class AnnualHolidaySale { int _rebate; void promote() { ... } } 实际上一个命名嵌套的层次越多，他就有更多的相关的上下文，也就更简短，换句话说一个变量的作用域越小，命名就越短 10.**省略命名中无任何意义的单词**
例如：data、state、amount、value、manager、engine、object、entity 和 instance一类的 不需要这类严肃的词语 11.**是否可以描述出一幅画（我在装逼）**
一个好的命名能够在阅读者的脑海里面描绘出一幅图画，而降变量命名为manager 并不能象读者传达出任何有关该变量做什么的信息 在命名时可以问一下自己，把这个单词去掉含义是不是不变？如果是，那就果断把它剔除吧 12.**终极一例**
例子:好吃的华夫饼 // 好吃的比利时华夫饼 class DeliciousBelgianWaffleObject { void garnishDeliciousBelgianWaffleWithStrawberryList( List
14.**请勿抛异常直接返回**
类似如下规范 Result result=Result.build(); boolean isChecking = redisServiceUtil.getIsCheckingOfAutomatedLoanService(); result.setValue(isChecking); if (isChecking) { logger.info("--- isSystemChecking ---系统清算中-----"); result.withError(ResultMsgStatus.SYSTEM_CHECKING.getMessage()); } return result; ================================================ FILE: docs/code-rpc.md ================================================ ### 分布式事务的讲解与实现 基础的ACID等等就不一一介绍了 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ ##简介： 基础的ACID等等就不一一介绍了，柔性事务一类的大家在网上一搜都是，可以先看看基础的！ 我的github都是实际操作加讲解，我觉得写文章大篇大论浪费时间，不如实际操作来的深刻 感谢大家支持！ 1.tcc事务演进与场景 2.tcc事务源码解析与实际操作 3.分布式事务的实操与演进 2. **TCC事务的简介** 两段式事务  三段式事务  TCC的优点： 1.解决了扩应用的业务操作的原子性问题 2.数据库的二阶段提交提到了应用层实现 使用场景: 组合支付，账务一类的 比较要求强一致性高的场景使用 Tcc项目地址: [](https://github.com/changmingxie/tcc-transaction/tree/master-1.2.x) 如果你想 用dubbo的他的还不行有点错误请下载： (使用请先参考TCC文档) [](https://github.com/qiurunze123/tcc-dubbo) 效果图：  |_tcc-transaction-dubbo| |_1 字节码代理 -> 创建接口的代理对象 |_2 DubboTransactionContextEditor -> TRANSACTION_CONTEXT[标识事务状态]利用Dubbo的隐式参数来传递关键的非业务数据 |_tcc-transaction-spring| |_封装了一些关键的Spring组件 |_questions| |_1、什么时候生成的TRANSACTION_CONTEXT隐式参数 |_2、如何判断一个大的事务下，都有哪些小的事务 |_3、为什么要有@Compensable注解 |_4、两个拦截器都没有处理Confirm和Cancel |_基础概念 | |_主事务和分支事务【事务参与者】 |_事务拦截器作用：[Spring AOP的基本概念要熟练掌握]|_1 CompensableTransactionInterceptor |_ 将事务区分为Root事务和分支事务 |_不断的修改数据库内的状态【初始化事务，修改事务状态】 |_注册和清除事务管理器中队列内容 |_ResourceCoordinatorInterceptor |_主要处理try阶段的事情 |_在try阶段，就将所有的"资源"封装完成并交给事务管理器 |_资源 -- 事务资源 事务的参与者 |_1.Confirm上下文 |_2.Cancel上下文 |_3.分支事务信息 |_4.事务管理器修改数据库状态 |_ 调用目标对象 -- order red cap |_小结 |_ 1.事务的相关信息【全局事务编号，乐观锁版本等要持久化存储】 |_ 2.资源：* TCC 【try-confirm-cancel】 try核心点： 预留业务资源 把事务数据资源存入库中 |_ 3 流程： |_注册和初始化事务 |_组织事务参与者 |_执行目标try方法 |_执行confirm和cancel方法 ================================================ FILE: docs/code-solve.md ================================================ ### 秒杀常见问题 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ > 秒杀注意事项以及整体简略设计 #### [1.如何解决卖超问题]() --在sql加上判断防止数据变为负数 --数据库加唯一索引防止用户重复购买 --redis预减库存减少数据库访问 内存标记减少redis访问 请求先入队列缓冲，异步下单，增强用户体验 #### [注册功能 -- 如果有前端的牛人加入修改几个页面那是再好不过了哈哈哈]() #### [全局异常处理拦截]() 1.定义全局的异常拦截器 2.定义了全局异常类型 3.只返回和业务有关的 4.详情请看GlobleException #### [页面级缓存thymeleafViewResolver]() 1.详细请看basecontroller 缓存渲染页面 #### [对象级缓存redis🙋🐓]() redis永久缓存对象减少压力 redis预减库存减少数据库访 内存标记方法减少redis访问 #### [订单处理队列rabbitmq]() 请求先入队缓冲，异步下单，增强用户体验 请求出队，生成订单，减少库存 客户端定时轮询检查是否秒杀成功 #### [解决分布式session]() --生成随机的uuid作为cookie返回并redis内存写入 --拦截器每次拦截方法，来重新获根据cookie获取对象 --下一个页面拿到key重新获取对象 --HandlerMethodArgumentResolver 方法 supportsParameter 如果为true 执行 resolveArgument 方法获取miaoshauser对象 --如果有缓存的话 这个功能实现起来就和简单，在一个用户访问接口的时候我们把访问次数写到缓存中，在加上一个有效期。 通过拦截器. 做一个注解 @AccessLimit 然后封装这个注解，可以有效的设置每次访问多少次，有效时间是否需要登录！ #### [秒杀安全 -- 安全性设计]() 秒杀接口隐藏 数字公式验证码 接口防刷限流(通用 注解，拦截器方式) #### [通用缓存key的封装采用什么设计模式]() 模板模式的优点 -具体细节步骤实现定义在子类中，子类定义详细处理算法是不会改变算法整体结构 -代码复用的基本技术，在数据库设计中尤为重要 -存在一种反向的控制结构，通过一个父类调用其子类的操作，通过子类对父类进行扩展增加新的行为，符合“开闭原则” -缺点： 每个不同的实现都需要定义一个子类，会导致类的个数增加，系统更加庞大 #### [redis的库存如何与数据库的库存保持一致]() redis的数量不是库存,他的作用仅仅只是为了阻挡多余的请求透穿到DB，起到一个保护的作用 因为秒杀的商品有限，比如10个，让1万个请求区访问DB是没有意义的，因为最多也就只能10个 请求下单成功，所有这个是一个伪命题，我们是不需要保持一致的 #### [redis 预减成功，DB扣减库存失败怎么办]() -其实我们可以不用太在意，对用户而言，秒杀不中是正常现象，秒杀中才是意外，单个用户秒杀中 -1.本来就是小概率事件，出现这种情况对于用户而言没有任何影响 -2.对于商户而言，本来就是为了活动拉流量人气的，卖不完还可以省一部分费用，但是活动还参与了，也就没有了任何影响 -3.对网站而言，最重要的是体验，只要网站不崩溃，对用户而言没有任何影响 #### [为什么redis数量会减少为负数]() //预见库存 long stock = redisService.decr(GoodsKey.getMiaoshaGoodsStock,""+goodsId) ; if(stock <0){ localOverMap.put(goodsId, true); return Result.error(CodeMsg.MIAO_SHA_OVER); } 假如redis的数量为1,这个时候同时过来100个请求，大家一起执行decr数量就会减少成-99这个是正常的 进行优化后改变了sql写法和内存写法则不会出现上述问题 #### [为什么要单独维护一个秒杀结束标志]() -1.前提所有的秒杀相关的接口都要加上活动是否结束的标志，如果结束就直接返回，包括轮寻的接口防止一直轮寻 -2.管理后台也可以手动的更改这个标志，防止出现活动开始以后就没办法结束这种意外的事件 #### [rabbitmq如何做到消息不重复不丢失即使服务器重启]() -1.exchange持久化 -2.queue持久化 -3.发送消息设置MessageDeliveryMode.persisent这个也是默认的行为 -4.手动确认 #### [为什么threadlocal存储user对象，原理]() 1.并发编程中重要的问题就是数据共享，当你在一个线程中改变任意属性时，所有的线程都会因此受到影响，同时会看到第一个线程修改后的值
有时我们希望如此，比如：多个线程增大或减小同一个计数器变量
但是，有时我们希望确保每个线程，只能工作在它自己 的线程实例的拷贝上，同时不会影响其他线程的数据
举例： 举个例子，想象你在开发一个电子商务应用，你需要为每一个控制器处理的顾客请求，生成一个唯一的事务ID，同时将其传到管理器或DAO的业务方法中， 以便记录日志。一种方案是将事务ID作为一个参数，传到所有的业务方法中。但这并不是一个好的方案，它会使代码变得冗余。 你可以使用ThreadLocal类型的变量解决这个问题。首先在控制器或者任意一个预处理器拦截器中生成一个事务ID 然后在ThreadLocal中 设置事务ID，最后，不论这个控制器调用什么方法，都能从threadlocal中获取事务ID 而且这个应用的控制器可以同时处理多个请求， 同时在框架 层面，因为每一个请求都是在一个单独的线程中处理的，所以事务ID对于每一个线程都是唯一的，而且可以从所有线程的执行路径获取 运行结果可以看出每个线程都在维护自己的变量： Starting Thread: 0 : Fri Sep 21 23:05:34 CST 2018
Starting Thread: 2 : Fri Sep 21 23:05:34 CST 2018
Starting Thread: 1 : Fri Jan 02 05:36:17 CST 1970
Thread Finished: 1 : Fri Jan 02 05:36:17 CST 1970
Thread Finished: 0 : Fri Sep 21 23:05:34 CST 2018
Thread Finished: 2 : Fri Sep 21 23:05:34 CST 2018
局部线程通常使用在这样的情况下，当你有一些对象并不满足线程安全，但是你想避免在使用synchronized关键字
块时产生的同步访问，那么，让每个线程拥有它自己的对象实例
注意：局部变量是同步或局部线程的一个好的替代，它总是能够保证线程安全。唯一可能限制你这样做的是你的应用设计约束
所以设计threadlocal存储user不会对对象产生影响，每次进来一个请求都会产生自身的线程变量来存储 #### [maven 隔离]() maven隔离就是在开发中，把各个环境的隔离开来，一般分为 本地（local） 开发(dev) 测试(test) 线上(prod) 在环境部署中为了防止人工修改的弊端！ spring.profiles.active=@activatedProperties@ #### [redis 分布式锁实现方法]() 我用了四种方法 ， 分别指出了不同版本的缺陷以及演进的过程 orderclosetask V1---->>版本没有操作，在分布式系统中会造成同一时间，资源浪费而且很容易出现并发问题 V2--->>版本加了分布式redis锁，在访问核心方法前，加入redis锁可以阻塞其他线程访问,可以 很好的处理并发问题,但是缺陷就是如果机器突然宕机，或者线路波动等，就会造成死锁，一直 不释放等问题 V3版本-->>很好的解决了这个问题v2的问题，就是加入时间对比如果当前时间已经大与释放锁的时间 说明已经可以释放这个锁重新在获取锁，setget方法可以把之前的锁去掉在重新获取,旧值在于之前的 值比较，如果无变化说明这个期间没有人获取或者操作这个redis锁，则可以重新获取 V4---->>采用成熟的框架redisson,封装好的方法则可以直接处理，但是waittime记住要这只为0 #### [服务降级--服务熔断(过载保护)）]() 自动降级： 超时.失败次数,故障,限流 人工降级：秒杀，双11 9.所有秒杀相关的接口比如：秒杀，获取秒杀地址，获取秒杀结果，获取秒杀验证码都需要加上 秒杀是否开始结束的判断 #### [RPC事务补偿]() 当集中式进行服务化RPC演进成分布式的时候，事务则成为了进行分布式的一个痛点，本项目的做法为： 1.进行流程初始化，当分别调用不用服务化接口的时候，成功则进行流程，失败则返回并进行状态更新 将订单状态变为回滚 2.使用定时任务不断的进行处理rollback的订单进行回滚 #### [秒杀类似场景sql的写法注意事项]() 1.在秒杀一类的场景里面，因为数据量亿万级所有即使有的有缓存有的时候也是扛不住的，不可避免的透穿到DB 所有在写一些sql的时候就要注意： 1.一定要避免全表扫描，如果扫一张大表的数据就会造成慢查询，导致数据的连接池直接塞满,导致事故 首先考虑在where和order by 设计的列上建立索引 例如： 1. where 子句中对字段进行 null 值判断 . 2. 应尽量避免在 where 子句中使用!=或<>操作符 3. 应尽量避免在 where 子句中使用 or 来连接条件 4. in 和 not in 也要慎用，否则会导致全表扫描( 如果索引 会优先走索引 不会导致全表扫描 字段上建了索引后，使用in不会全表扫描，而用not in 会全表扫描 低版本的mysql是两种情况都会全表扫描。 5.5版本后以修。而且在优化大表连接查询的时候，有一个方法就是将join操作拆分为in查询) 5. select id from t where name like '%abc%' 或者 6.select id from t where name like '%abc' 或者 7. 若要提高效率，可以考虑全文检索。 8.而select id from t where name like 'abc%' 才用到索引 慢查询一般在测试环境不容易复现 9.应尽量避免在 where 子句中对字段进行表达式操作 where num/2 num=100*2 2.合理的使用索引 索引并不是越多越好，使用不当会造成性能开销 3.尽量避免大事务操作，提高系统并发能力 4.尽量避免象客户端返回大量数据，如果返回则要考虑是否需求合理，实在不得已则需要在设计一波了！！！！！ #### [网站访问统计实现]()  利用lua脚本进行对redis操作,登陆时，每次登陆成功则记录访问（具体你想在什么时段进行统计自己说了算） #### [项目进行dubbo+ZK改造]() ├── miaosha-admin 登录模块 │ ├── pom.xml │ └── miaosha-admin-api │ └── miaosha-admin-service │ └── miaosha-admin-web │ └── miaosha-common │ │ ├── miaosha-order 订单秒杀模块 │ ├── pom.xml │ └── miaosha-order-api │ └── miaosha-order-service │ └── miaosha-order-web │ └── miaosha-order-common │ │ ├── miaosha-message 消息模块 │ ├── pom.xml │ └── miaosha-message-api │ └── miaosha-message-service │ └── miaosha-message-web │ └── miaosha-message-common │ │ ================================================ FILE: docs/dubbo-admin.md ================================================ ### dubbo-admin 平台搭建与管理 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ #### [dubbo-admin-2.6.0 war包 请进入/docs/dubbo-admin/下载](/docs/dubbo-admin/dubbo-admin-2.6.0.war) 1.可直接 https://github.com/apache/incubator-dubbo/releases/tag/dubbo-2.6.0 下载后将dubbo-admin-2.6.0达成war包 2./docs/dubbo-admin/dubbo-admin-2.6.0.war获取war包 3.获取后 将war包放在tomcat的webapp目录 4.启动 window startup.bat linux ./bin/startup.sh 启动 -- 记得安装zk客户端才可以启动成功 5.访问 http://端口号:8080/dubbo-admin-2.6.0/ 可成功 6.账号密码 root/root ================================================ FILE: docs/dubbo-zk.md ================================================ ### dubbo + zk 使用与进阶 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ >目标 （希望大家仔细研究dubbo文档 源码分析正在更新中打算实现自己的rpc框架 请看dubbo-die ） http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-method.html dubbo文档地址 mapper 文件记得 在pom里面配置否则无法访问除了resources的mapper文件  **1.如何利用dubbo 进行服务降级 ？** 一些服务降级措施，当服务提供端某一个非关键的服务出错时候，dubbo可以对消费端的调用进行降级，这样服务消费端就避免了在去调用出错的服务提供端，而是使用自定义的返回值直接在在本地返回 **2.springboot + dubbo 配置 ？**  可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略  **3.使用方式 ？** 在dubbo的页面 可以手动 更改自己想要的效果，也可以更改返回值！点击overrides 更改  **4.解析** MockClusterInvoker 正常  force  fail  impl  **5.参数含义**  ------------------------------------------------------------------------------------------------------ **6.自定义服务降级**  **7.自定义服务降级---类 必须为service加上mock**  ================================================ FILE: docs/fenbushi-tcc.md ================================================ ### 分布式事务 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ >目标 （希望大家仔细研究redis.conf配置文件-本文很多基础的一带而过） 1.事务简介 2.分布式事务的前世今生 3.分布式事务解决方案 4.主流分布式事务框架介绍 整理大部分常用的场景与使用,如果有疑问或者你不懂的地方请联系我！ #### 1 分布式事务 >1.将多个节点的事务看成一个整体处理 >2.分布式事务由事务参与者，资源服务器，事务管理器等组成 >3.常见的分布式事务的例子： 支付，下订单等 >4.两段式事务和三段式事务（2pc,3pc） 基于XA的分布式事务 基于消息的最终一致性方案 TCC编程式补偿性方案 **redis分布式锁解决什么问题** 1.一个进程中的多个线程,多个线程并发访问同一个资源的时候,如何解决线程安全问题。 2.一个分布式架构系统中的两个模块同时去访问一个文件对文件进行读写操作 3.多个应用对同一条数据做修改的时候,如何保证数据的安全性 在但一个进程中,我们可以用到synchronized、lock之类的同步操作去解决,但是对于分布式架构下多进程的情况下, 如何做到跨进程的锁。就需要借助一些第三方手段来完成 **设计一个分布式所需要解决的问题,分布式锁解决方案（数据库方案）** 数据库解决方式,创建一个表叫做LOCK表 lock( id int(11) methodName varchar(100),--锁定的方法名称 memo varchar(1000) modifyTime timestamp unique key mn (method) --唯一约束 ) 在执行方法的时候,获取锁的伪代码 或者for update行锁 或者 乐观锁方式也是可以的 try{ exec insert into lock(methodName,memo) values(‘method’,’desc’); return true; }Catch(DuplicateException e){ return false; } 释放锁： delete from lock where methodName=’’; **（数据库方案）存在的问题以及思考** 1.锁没有失效时间,一旦解锁操作失败,就会导致锁记录一直在数据库中,其他线程无法再获得到锁 2.锁是非阻塞的,数据的insert操作,一旦插入失败就会直接报错。没有获得锁的线程并不会进入排队队列 要想再次获得锁就要再次触发获得锁操作 3.锁是非重入的,同一个线程在没有释放锁之前无法再次获得该锁 **ZK方案** ZK方案实现之前你要先了解ZK关于他的节点的几个特性： 有序节点：假如当前有一个父节点为/lock,我们可以在这个父节点下面创建子节点；zookeeper提供了一个可选的有序特性 例如我们可以创建子节点“/lock/node-”并且指明有序,那么zookeeper在生成子节点时会根据当前的子节点数量自动添加整数序号 也就是说如果是第一个创建的子节点,那么生成的子节点为/lock/node-0000000000,下一个节点则为/lock/node-0000000001,依次类推 临时节点：客户端可以建立一个临时节点,在会话结束或者会话超时后,zookeeper会自动删除该节点 事件监听：在读取数据时,我们可以同时对节点设置事件监听,当节点数据或结构变化时,zookeeper会通知客户端 当前zookeeper有如下四种事件： 1）节点创建 2）节点删除 3）节点数据修改 4）子节点变更 获取分布式锁的流程 ------- 假设所空间的根节点为/lock 1.客户端连接zookeeper,并在/lock下创建临时的且有序的子节点 第一个客户端对应的子节点为/lock/lock-0000000000,第二个为/lock/lock-0000000001,以此类推 2.--避免羊群效应--客户端获取/lock下的子节点列表,判断自己创建的子节点是否为当前子节点列表中序号最小的子节点, 如果是则认为获得锁,否则监听刚好在自己之前一位的子节点删除消息,获得子节点变更通知后重复此步骤直至获得锁 3.实行业务代码 4.流程完成后,删除对应的子节点并释放锁 （Watch机制） 对应分布式开源包Curator  **Redis分布式锁方案** Redis 中有许多的命令都可以实现分布式锁,但是比较常用的是SETNX这个命令来实现 有多种方案代码： 1.获取锁,释放锁 代码在redismanager 里面 （简单版）   closeOrder也有 不过是另一种！比较复杂！！ 加入时间对比如果当前时间已经大与释放锁的时间 说明已经可以释放这个锁重新在获取锁,setget方法可以把之前的锁去掉在重新获取,旧值在于之前的 值比较,如果无变化说明这个期间没有人获取或者操作这个redis锁,则可以重新获取  redis有成熟的框架redission **Redis多路复用机制（看不看都行）** linux的内核会把所有外部设备都看作一个文件来操作,对一个文件的读写操作会调用内核提供的系统命令, 返回一个 file descriptor（文件描述符）。对于一个socket的读写也会有响应的描述符,称为socketfd(socket 描述符)。 而IO多路复用是指内核一旦发现进程指定的一个或者多个文件描述符IO条件准备好以后就通知该进程 IO多路复用又称为事件驱动,操作系统提供了一个功能,当某个socket可读或者可写的时候,它会给一个通知。 当配合非阻塞socket使用时,只有当系统通知我哪个描述符可读了,我才去执行read操作,可以保证每次read都能读到有效数据。 操作系统的功能通过select/pool/epoll/kqueue之类的系统调用函数来使用,这些函数可以同时监视多个描述符的读写就绪情况 ,这样多个描述符的I/O操作都能在一个线程内并发交替完成,这就叫I/O多路复用,这里的复用指的是同一个线程 多路复用的优势在于用户可以在一个线程内同时处理多个socket的 io请求。达到同一个线程同时处理多个IO请求的目的。 而在同步阻塞模型中,必须通过多线程的方式才能达到目的 **Redis（2.6以后）--lua脚本** 1.减少网络开销,在Lua脚本中可以把多个命令放在同一个脚本中运行 2.原子操作,redis会将整个脚本作为一个整体执行,中间不会被其他命令插入。换句话说,编写脚本的过程中无需担心会出现竞态条件 3.复用性,客户端发送的脚本会永远存储在redis中,这意味着其他客户端可以复用这一脚本来完成同样的逻辑 4.脚本可以通过return 来返回客户端 例子： 利用lua脚本进行电话号或则IP限流 实例 具体请看 redislua类 KEYS[1] ARGV[1] ARGV[2] key 参数1 参数2 local num=redis.call('incr',KEYS[1]) if tonumber(num)==1 then redis.call('expire',KEYS[1],ARGV[1]) return 1 elseif tonumber(num)>tonumber(ARGV[2]) then return 0 else return 1 end **Redis（2.6以后）--lua--EVALSHA命令** 考虑到我们通过eval执行lua脚本,脚本比较长的情况下,每次调用脚本都需要把整个脚本传给redis 比较占用带宽。为了解决这个问题,redis提供了EVALSHA命令允许开发者通过脚本内容的SHA1摘要来执行脚本。该命令的用法和EVAL一样, 只不过是将脚本内容替换成脚本内容的SHA1摘要 1. Redis在执行EVAL命令时会计算脚本的SHA1摘要并记录在脚本缓存中 2. 执行EVALSHA命令时Redis会根据提供的摘要从脚本缓存中查找对应的脚本内容 如果找到了就执行脚本,否则返回“NOSCRIPT No matching script,Please use EVAL” **Redis（2.6以后）--lua脚本运行限制** redis的脚本执行是原子的,即脚本执行期间Redis不会执行其他命令 所有的命令必须等待脚本执行完以后才能执行。为了防止某个脚本执行时间过程导致Redis无法提供服务 Redis提供了lua-time-limit参数限制脚本的最长运行时间--默认是5秒钟 当脚本运行时间超过这个限制后,Redis将开始接受其他命令但不会执行（以确保脚本的原子性）,而是返回BUSY的错误 在第一个窗口中执行lua脚本的死循环 eval “while true do end” 0 在第二个窗口中运行get hello 最后第二个窗口的运行结果是Busy, 可以通过script kill命令终止正在执行的脚本 如果当前执行的lua脚本对redis的数据进行了修改,比如（set）操作,那么script kill命令没办法终止脚本的运行, 因为要保证lua脚本的原子性。如果执行一部分终止了,就违背了这一个原则 在这种情况下,只能通过 shutdown nosave命令强行终止 **Redis（2.6以后）--lua分布式锁**  ================================================ FILE: docs/fenbushi.md ================================================ ### 分布式系统 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ > 分布式系统历程----1  > 分布式系统历程----2  > 分布式系统历程----3  > 分布式系统历程----4  > 分布式系统历程----5  > 分布式系统历程----6  > 分布式系统历程----7  ================================================ FILE: docs/jemter-solve.md ================================================ ### 如何利用jmeter进行压测 ### 我的服务配置较低大数据量请在自己的服务器上搞下不然就崩了 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ >目标 （希望大家仔细研究redis.conf配置文件-本文很多基础的一带而过） 1.如何对秒杀生成大数据量对应的用户id和token来进行压测 2.利用jmeter进行接口压测 我这个版本只是简单的测试，你仍然需要把一些接口安全的放开或者自己写一个没有安全性防刷一类的接口测试性能 如果有疑问或者你不懂的地方请联系我！ #### 1 利用jmeter进行接口压测 （jmeter3.0 jdk1.7 版本以上需1.8 版本在tools里面） **秒杀生成大数据量对应的用户id和token** 在后端写模拟前端请求计算出不同的用户对应的token ， 在UserUtil类里面 生成文件格式：  代码类：   利用这个类可以生成大数据量的userId和token当前也可以自己改装生成你想要的 **利用jmeter进行接口压测** 1.点击右键生成线程组一类的  2.右键线程组选择配置原件并定义http默认值  3.右键监听器可以生成聚合报告等一类的  4.右键线程组添加sampler 添加请求http请求具体情况更具实际的来  5.右键线程组添加CSV DATA Set Config 设置用户参数和token 把生成的路径引进来  ================================================ FILE: docs/jvm-goods.md ================================================ ### 生产内存环境 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ ## 前言 注重实践,不会长篇大论,纯属浪费大家时间！属于进阶文章,感谢你的支持！ 解决问题： |_ 1.生产环境发生了内存溢出该如何处理 |_ 2.生产环境应该给服务器分配多少的内存 |_ 3.如何对垃圾回收起的性能进行调优 |_ 4.生产环境CPU的负载飙高应该如何处理 |_ 5.生产环境因该给应用分配多少的线程合适 |_ 6.不加log如何确定请求是否执行到某一段的代码 |_ 7.实时查看某个方法的入参与返回值 |_ 8.JVM的字节码实操 |_ 9.循环体中字符串拼接为什么效率很低 |_ 10.string常量池怎么回事 |_ 11.用字节码分析 i++，++i 到底哪种效率高 项目实战收获： |_ 1.熟练使用各种监控和调试工具 |_ 2.从容应对生产环境的各种调试和性能 |_ 3.熟悉JVM字节码指令 |_ 4.深入理解JVM自动回收机制学会GC调优 |_ 5.基于JDK命令行的监控 |_ JVM的参数类型 |_ 查看JVM运行时的参数 |_ Jstat查看JVM统计信息 |_ 演示内存溢出 |_ 导出内存映像文件 |_ MAT分析内存溢出 |_ jstack与线程的状态 |_ jstack实战死循环与锁 |_ 6.基于JVisualVM的可视化工具 |_ 监控本地java进程 |_ 监控远程java进程 |_ 7.基于Btrace的监控调试基于Btrace的监控调试 |_ Btrace入门 |_ 拦截器构造函数，同名函数 |_ 拦截器返回值，异常，行号 |_ 拦截器复杂参数，环境变量，正则匹配拦截 |_ 注意事项 |_ 8.tomcat的性能监控调优 |_ tomcat远程debug |_ tomcat-manager监控 |_ psi-probe监控 |_ tomcat优化 |_ 9.nginx的监控调优 |_ nginx的监控调优 |_ ngx_http_stub_status监控连接信息 |_ ngxtop监控请求信息 |_ nginx-rrd图形化监控 |_ nginx优化 |_ 10.jvm+gc调优 |_ JVM的内存结构以及各个分区 |_ 常见垃圾回收算法 |_ 垃圾回收期调优 |_ 如何分析内存日志 |_ 垃圾回收器 |_ GC日志格式详解 |_ ParallelGC调优 |_ G1调优 **基于JDK命令行工具监控** |_ JVM参数类型 |_ 运行时JVM参数查看 |_ jstat查看虚拟机统计信息 |_ jmap + MAT实战内存溢出 |_ jstack 实战死锁循环与死锁 | ID | Problem | Article | | --- | --- | :--- | | 000 |JVM参数类型 | 三种: 标准参数 , X参数 ,XX 参数 | | 001 |如何对本项目进行jmeter压测 | [解决思路](https://raw.githubusercontent.com/qiurunze123/imageall/master/miaosha.png) | ================================================ FILE: docs/linux.md ================================================ ### 秒杀nginx优化 有问题或者宝贵意见联系我的QQ,非常希望你的加入！ ##要求： >目标 1.并发优化 2.KeepALive长连接优化 3.压缩优化 4.配置缓存 #### [/docs/tools/nginx nginx优化相关包](/docs/tools) 安装：cd yum install -y gcc gcc-c++ ./configure --prefix=/usr/local/nginx --with-pcre=/home/qiurunze/下载/pcre-8.38 --with-http_stub_status_module --with-http_gzip_static_module --add-module=/home/qiurunze/下载/ngx_cache_purge-2.3 make make install ps -ef | grep nginx ./sbin/nginx -s reload http://nginx.org/en/docs/ 1.工作线程数和并发连接数 worker_processes 4; #cpu，如果nginx单独在一台机器上 worker_processes auto; events { worker_connections 4096;#每一个进程打开的最大连接数，超出了log中会有记录 multi_accept on; #可以一次建立多个连接 use epoll; } worker_rlimit_nofile 10240;每个进程打开的最大的文件数，受限于操作系统： vi /etc/security/limits.conf * hard nofile 102400 * soft nofile 102400 * soft core unlimited * soft stack 10240 2.操作系统优化 配置文件/etc/sysctl.conf sysctl -w net.ipv4.tcp_syncookies=1#防止一个套接字在有过多试图连接到达时引起过载 sysctl-w net.core.somaxconn=1024#默认128，连接队列 sysctl-w net.ipv4.tcp_fin_timeout=10 # timewait的超时时间 sysctl -w net.ipv4.tcp_tw_reuse=1 #os直接使用timewait的连接 sysctl -w net.ipv4.tcp_tw_recycle = 0 #回收禁用 3.Keepalive长连接 Nginx与upstream server： upstream server_pool{ server localhost:8080 weight=1 max_fails=2 fail_timeout=30s; keepalive 300; #300个长连接 } 同时要在location中设置： location / { proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; } 客户端与nginx（默认是打开的）： 4.keepalive_timeout 60s; #长连接的超时时间 keepalive_requests 100; #100个请求之后就关闭连接，可以调大 keepalive_disable msie6; #ie6禁用启用压缩 gzip on; gzip_disable "MSIE [1-6]\.(?!.*SV1)"; gzip_proxied any; gzip_types text/html text/plain application/x-javascript application/javascript text/css application/xml gzip_vary on; #Vary: Accept-Encoding gzip_static on; #如果有压缩好的 直接使用 5.状态监控 location = /nginx_status { stub_status on; access_log off; allow
Title: pojoToJson
*Description:
* * @param data * @return */ public static String objectToJson(Object data) { try { String string = MAPPER.writeValueAsString(data); return string; } catch (JsonProcessingException e) { e.printStackTrace(); } return null; } /** * 将json结果集转化为对象 * * @param jsonData json数据 * @param clazz 对象中的object类型 * @return */ public staticTitle: jsonToList
*Description:
* * @param jsonData * @param beanType * @return */ public static* SnowFlake的结构如下(每部分用-分开):
* 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
* 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0
* 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截) * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69
* 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId
* 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号
* 加起来刚好64位，为一个Long型。
* SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。 */ public class SnowflakeIdWorker { // ==============================Fields=========================================== /** * 开始时间截 (2015-01-01) */ private final long twepoch = 1420041600000L; /** * 机器id所占的位数 */ private final long workerIdBits = 5L; /** * 数据标识id所占的位数 */ private final long datacenterIdBits = 5L; /** * 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */ private final long maxWorkerId = -1L ^ (-1L << workerIdBits); /** * 支持的最大数据标识id，结果是31 */ private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); /** * 序列在id中占的位数 */ private final long sequenceBits = 12L; /** * 机器ID向左移12位 */ private final long workerIdShift = sequenceBits; /** * 数据标识id向左移17位(12+5) */ private final long datacenterIdShift = sequenceBits + workerIdBits; /** * 时间截向左移22位(5+5+12) */ private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; /** * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095) */ private final long sequenceMask = -1L ^ (-1L << sequenceBits); /** * 工作机器ID(0~31) */ private long workerId; /** * 数据中心ID(0~31) */ private long datacenterId; /** * 毫秒内序列(0~4095) */ private long sequence = 0L; /** * 上次生成ID的时间截 */ private long lastTimestamp = -1L; //==============================Constructors===================================== /** * 构造函数 * * @param workerId 工作ID (0~31) * @param datacenterId 数据中心ID (0~31) */ public SnowflakeIdWorker(long workerId, long datacenterId) { if (workerId > maxWorkerId || workerId < 0) { throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId)); } if (datacenterId > maxDatacenterId || datacenterId < 0) { throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId)); } this.workerId = workerId; this.datacenterId = datacenterId; } /** * 生成订单唯一ID * * @param workerId * @param datacenterId * @return */ public static long getOrderId(long workerId, long datacenterId) { SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0); return idWorker.nextId(); } /** * 获得下一个ID (该方法是线程安全的) * * @return SnowflakeId */ public synchronized long nextId() { long timestamp = timeGen(); //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常 if (timestamp < lastTimestamp) { throw new RuntimeException( String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp)); } //如果是同一时间生成的，则进行毫秒内序列 if (lastTimestamp == timestamp) { sequence = (sequence + 1) & sequenceMask; //毫秒内序列溢出 if (sequence == 0) { //阻塞到下一个毫秒,获得新的时间戳 timestamp = tilNextMillis(lastTimestamp); } } //时间戳改变，毫秒内序列重置 else { sequence = 0L; } //上次生成ID的时间截 lastTimestamp = timestamp; //移位并通过或运算拼到一起组成64位的ID return ((timestamp - twepoch) << timestampLeftShift) // | (datacenterId << datacenterIdShift) // | (workerId << workerIdShift) // | sequence; } /** * 阻塞到下一个毫秒，直到获得新的时间戳 * * @param lastTimestamp 上次生成ID的时间截 * @return 当前时间戳 */ protected long tilNextMillis(long lastTimestamp) { long timestamp = timeGen(); while (timestamp <= lastTimestamp) { timestamp = timeGen(); } return timestamp; } //==============================Test============================================= /** * 返回以毫秒为单位的当前时间 * * @return 当前时间(毫秒) */ protected long timeGen() { return System.currentTimeMillis(); } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/ValidatorUtil.java ================================================ package com.geekq.common.utils; import org.apache.commons.lang3.StringUtils; import java.util.regex.Matcher; import java.util.regex.Pattern; public class ValidatorUtil { private static final Pattern mobile_pattern = Pattern.compile("1\\d{10}"); public static boolean isMobile(String src) { if (StringUtils.isEmpty(src)) { return false; } Matcher m = mobile_pattern.matcher(src); return m.matches(); } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/md5/MD5Utils.java ================================================ package com.geekq.common.utils.md5; import org.apache.commons.codec.binary.Base64; import org.apache.commons.codec.digest.DigestUtils; import java.security.SecureRandom; /** * @author 邱润泽 */ public class MD5Utils { private static String getSalt = getSaltT(); public static final String getSaltT() { SecureRandom random = new SecureRandom(); byte bytes[] = new byte[15]; random.nextBytes(bytes); String salt = Base64.encodeBase64String(bytes); return salt; } public static String MD5(String keyName) { /** * 返回16 */ return DigestUtils.md5Hex(keyName); } /** * 测试使用 * * @param inputPass * @return */ public static String inputPassFormPass(String inputPass) { String str = "" + getSalt.charAt(0) + getSalt.charAt(2) + inputPass + getSalt.charAt(4) + getSalt.charAt(6); return MD5(str); } /** * 盐值salt 随机 二次加密 * * @param inputPass * @return */ public static String formPassFormPass(String inputPass) { String str = "" + getSalt.charAt(0) + getSalt.charAt(2) + inputPass + getSalt.charAt(4) + getSalt.charAt(6); return MD5(str); } /** * 第二次md5--反解密 用户登录验证 --- salt 可随机 * * @param formPass * @param salt * @return */ public static String formPassToDBPass(String formPass, String salt) { String str = "" + salt.charAt(0) + salt.charAt(2) + formPass + salt.charAt(4) + salt.charAt(6); return MD5(str); } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/numcal/BidConst.java ================================================ package com.geekq.common.utils.numcal; import java.math.BigDecimal; /** * 系统需要的常量 * * @author 邱润泽 */ public class BidConst { public static final int DISPLAY_SCALE = 2;//显示精度 public static final int CAL_SCALE = 8;//计算精度 public static final int STORE_SCALE = 4;//保存精度 public static final BigDecimal ZERO = new BigDecimal("0.0000");//系统中需要的zero public static final BigDecimal DEFALUT_BORROWLIMITAMOUNT = new BigDecimal( "2000.0000");//初始用户授信额度 public static final BigDecimal ACCOUNT_MANAGER_CHARGE_RATE = new BigDecimal("0.0500"); public static final String DEFAULT_ADMIN_NAME = "admin"; public static final String DEFAULT_ADMIN_PASSWORD = "1111"; public static final int CREDIT_BORROW_SCORE = 30;//信用信用分数 public final static int RETURN_TYPE_MONTH_INTEREST_PRINCIPAL = 0; // 还款方式 按月分期还款(等额本息) public final static int RETURN_TYPE_MONTH_INTEREST = 1; // 还款方式 按月到期还款(每月还利息,到期还本息) public final static int BIDREQUEST_TYPE_NORMAL = 0; // 普通信用标 public final static int BIDREQUEST_STATE_PUBLISH_PENDING = 0; // 待发布 public final static int BIDREQUEST_STATE_BIDDING = 1; // 招标中 public final static int BIDREQUEST_STATE_UNDO = 2; // 已撤销 public final static int BIDREQUEST_STATE_BIDDING_OVERDUE = 3; // 流标 public final static int BIDREQUEST_STATE_APPROVE_PENDING_1 = 4; // 满标1审 public final static int BIDREQUEST_STATE_APPROVE_PENDING_2 = 5; // 满标2审 public final static int BIDREQUEST_STATE_REJECTED = 6; // 满标审核被拒绝 public final static int BIDREQUEST_STATE_PAYING_BACK = 7; // 还款中 public final static int BIDREQUEST_STATE_COMPLETE_PAY_BACK = 8; // 已还清 public final static int BIDREQUEST_STATE_PAY_BACK_OVERDUE = 9; // 逾期 public final static int BIDREQUEST_STATE_PUBLISH_REFUSE = 10; // 发标审核拒绝状态 public static final BigDecimal SMALLEST_BID_AMOUNT = new BigDecimal("50.0000");//系统规定的最小投标金额 public static final BigDecimal SMALLEST_BIDREQUEST_AMOUNT = new BigDecimal("500.0000");//系统规定的最小借款金额 /** * =============================账户流水类型================================ */ public final static int ACCOUNT_ACTIONTYPE_DEPOSIT_OFFLINE_LOCAL = 0;// 资金流水类别：线下充值 public final static int ACCOUNT_ACTIONTYPE_WITHDRAW = 1;// 资金流水类别：提现 public final static int ACCOUNT_ACTIONTYPE_BIDREQUEST_SUCCESSFUL = 2;// 资金流水类别：成功借款 public final static int ACCOUNT_ACTIONTYPE_BID_SUCCESSFUL = 3;// 资金流水类别：成功投标 public final static int ACCOUNT_ACTIONTYPE_RETURN_MONEY = 4;// 资金流水类别：还款 public final static int ACCOUNT_ACTIONTYPE_CALLBACK_MONEY = 5;// 资金流水类别：回款 public final static int ACCOUNT_ACTIONTYPE_CHARGE = 6;// 资金流水类别：平台管理费 public final static int ACCOUNT_ACTIONTYPE_INTEREST_SHARE = 7;// 资金流水类别：利息管理费 public final static int ACCOUNT_ACTIONTYPE_WITHDRAW_MANAGE_CHARGE = 8;// 资金流水类别：提现手续费 public final static int ACCOUNT_ACTIONTYPE_RECHARGE_CHARGE = 9;// 资金流水类别：充值手续费 public final static int ACCOUNT_ACTIONTYPE_BID_FREEZED = 10;// 资金流水类别：投标冻结金额 public final static int ACCOUNT_ACTIONTYPE_BID_UNFREEZED = 11;// 资金流水类别：取消投标冻结金额 public final static int ACCOUNT_ACTIONTYPE_WITHDRAW_FREEZED = 12;// 资金流水类别：提现申请冻结金额 public final static int ACCOUNT_ACTIONTYPE_WITHDRAW_UNFREEZED = 13;// 资金流水类别:提现申请失败取消冻结金额 /** * =========还款状态=============== */ public final static int PAYMENT_STATE_NORMAL = 0; //正常待还 public final static int PAYMENT_STATE_DONE = 1; //已还 public final static int PAYMENT_STATE_OVERDUE = 2; //逾期 /** * ============系统账户流水类型============= */ public final static int SYSTEM_ACCOUNT_NONE = -1; //未指定 public final static int SYSTEM_ACCOUNT_ACTIONTYPE_MANAGE_CHARGE = 1;//系统账户收到账户管理费（借款管理费） public final static int SYSTEM_ACCOUNT_ACTIONTYPE_INTREST_MANAGE_CHARGE = 2;//系统账户收到利息管理费 public final static int SYSTEM_ACCOUNT_ACTIONTYPE_WITHDRAW_MANAGE_CHARGE = 3;//系统账户收到提现手续费 } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/numcal/BitStatesUtils.java ================================================ package com.geekq.common.utils.numcal; /** * 用户状态类，记录用户在平台使用系统中所有的状态。 * * @author 邱润泽 */ public class BitStatesUtils { public final static Long OP_BASIC_INFO = 1L; //用户注册成功的标示,及为默认初始状态 public final static Long OP_BIND_PHONE = 2L; //用户绑定手机状态码 public final static Long OP_BIND_EMAIL = 2L << 1;//用户绑定邮箱 public final static Long OP_BASE_INFO = 2L << 2;//填写基本资料 public final static Long OP_REAL_AUTH = 2L << 3;//用户实名认证 public final static Long OP_VEDIO_AUTH = 2L << 4;//视频认证 public final static Long OP_HAS_BIDRQUEST = 2l << 5;//当前用户有一个借款还在借款流程当中 /** * @param states 所有状态值 * @param value 需要判断状态值 * @return 是否存在 */ public static boolean hasState(long states, long value) { return (states & value) != 0; } /** * @param states 已有状态值 * @param value 需要添加状态值 * @return 新的状态值 */ public static long addState(long states, long value) { if (hasState(states, value)) { return states; } return (states | value); } /** * @param states 已有状态值 * @param value 需要删除状态值 * @return 新的状态值 */ public static long removeState(long states, long value) { if (!hasState(states, value)) { return states; } return states ^ value; } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/numcal/CalculateUtil.java ================================================ package com.geekq.common.utils.numcal; import java.math.BigDecimal; import java.math.RoundingMode; /** * 计算器Util * @author 邱润泽 */ public class CalculateUtil { public static final BigDecimal ONE_HUNDRED = new BigDecimal("100.0000"); public static final BigDecimal NUMBER_MONTHS_OF_YEAR = new BigDecimal( "12.0000"); /** * 获取月利率 */ public static BigDecimal getMonthlyRate(BigDecimal yearRate) { if (yearRate == null) return BigDecimal.ZERO; return yearRate.divide(ONE_HUNDRED).divide(NUMBER_MONTHS_OF_YEAR, BidConst.CAL_SCALE, RoundingMode.HALF_UP); } /** * 计算借款总利息 * * @param returnType 还款类型 * @param bidRequestAmount 借款金额 * @param yearRate 年利率 * @param monthes2Return 还款期限 * @return */ public static BigDecimal calTotalInterest(int returnType, BigDecimal bidRequestAmount, BigDecimal yearRate, int monthes2Return) { BigDecimal totalInterest = BigDecimal.ZERO; BigDecimal monthlyRate = getMonthlyRate(yearRate); if (returnType == BidConst.RETURN_TYPE_MONTH_INTEREST_PRINCIPAL) {// 按月分期 // 只借款一个月 if (monthes2Return == 1) { totalInterest = bidRequestAmount.multiply(monthlyRate) .setScale(BidConst.CAL_SCALE, RoundingMode.HALF_UP); } else { BigDecimal temp1 = bidRequestAmount.multiply(monthlyRate); BigDecimal temp2 = (BigDecimal.ONE.add(monthlyRate)) .pow(monthes2Return); BigDecimal temp3 = (BigDecimal.ONE.add(monthlyRate)).pow( monthes2Return).subtract(BigDecimal.ONE); // 算出每月还款 BigDecimal monthToReturnMoney = temp1.multiply(temp2).divide( temp3, BidConst.CAL_SCALE, RoundingMode.HALF_UP); // 算出总还款 BigDecimal totalReturnMoney = monthToReturnMoney .multiply(new BigDecimal(monthes2Return)); // 算出总利息 totalInterest = totalReturnMoney.subtract(bidRequestAmount); } } else if (returnType == BidConst.RETURN_TYPE_MONTH_INTEREST) {// 按月到期 BigDecimal monthlyInterest = DecimalFormatUtil .amountFormat(bidRequestAmount.multiply(monthlyRate)); totalInterest = monthlyInterest.multiply(new BigDecimal( monthes2Return)); } return DecimalFormatUtil.formatBigDecimal(totalInterest, BidConst.STORE_SCALE); } /** * 计算每期利息 * * @param returnType 还款类型 * @param bidRequestAmount 借款金额 * @param yearRate 年利率 * @param monthIndex 第几期 * @param monthes2Return 还款期限 * @return */ public static BigDecimal calMonthlyInterest(int returnType, BigDecimal bidRequestAmount, BigDecimal yearRate, int monthIndex, int monthes2Return) { BigDecimal monthlyInterest = BigDecimal.ZERO; BigDecimal monthlyRate = getMonthlyRate(yearRate); if (returnType == BidConst.RETURN_TYPE_MONTH_INTEREST_PRINCIPAL) {// 按月分期 // 只借款一个月 if (monthes2Return == 1) { monthlyInterest = bidRequestAmount.multiply(monthlyRate) .setScale(BidConst.CAL_SCALE, RoundingMode.HALF_UP); } else { BigDecimal temp1 = bidRequestAmount.multiply(monthlyRate); BigDecimal temp2 = (BigDecimal.ONE.add(monthlyRate)) .pow(monthes2Return); BigDecimal temp3 = (BigDecimal.ONE.add(monthlyRate)).pow( monthes2Return).subtract(BigDecimal.ONE); BigDecimal temp4 = (BigDecimal.ONE.add(monthlyRate)) .pow(monthIndex - 1); // 算出每月还款 BigDecimal monthToReturnMoney = temp1.multiply(temp2).divide( temp3, BidConst.CAL_SCALE, RoundingMode.HALF_UP); // 算出总还款 BigDecimal totalReturnMoney = monthToReturnMoney .multiply(new BigDecimal(monthes2Return)); // 算出总利息 BigDecimal totalInterest = totalReturnMoney .subtract(bidRequestAmount); if (monthIndex < monthes2Return) { monthlyInterest = (temp1.subtract(monthToReturnMoney)) .multiply(temp4).add(monthToReturnMoney) .setScale(BidConst.CAL_SCALE, RoundingMode.HALF_UP); } else if (monthIndex == monthes2Return) { BigDecimal temp6 = BigDecimal.ZERO; // 汇总最后一期之前所有利息之和 for (int i = 1; i < monthes2Return; i++) { BigDecimal temp5 = (BigDecimal.ONE.add(monthlyRate)) .pow(i - 1); monthlyInterest = (temp1.subtract(monthToReturnMoney)) .multiply(temp5) .add(monthToReturnMoney) .setScale(BidConst.CAL_SCALE, RoundingMode.HALF_UP); temp6 = temp6.add(monthlyInterest); } monthlyInterest = totalInterest.subtract(temp6); } } } else if (returnType == BidConst.RETURN_TYPE_MONTH_INTEREST) {// 按月到期 monthlyInterest = DecimalFormatUtil.amountFormat(bidRequestAmount .multiply(monthlyRate)); } return monthlyInterest; } /** * 计算每期还款 * * @param returnType 还款类型 * @param bidRequestAmount 借款金额 * @param yearRate 年利率 * @param monthIndex 第几期 * @param monthes2Return 还款期限 * @return */ public static BigDecimal calMonthToReturnMoney(int returnType, BigDecimal bidRequestAmount, BigDecimal yearRate, int monthIndex, int monthes2Return) { BigDecimal monthToReturnMoney = BigDecimal.ZERO; BigDecimal monthlyRate = getMonthlyRate(yearRate); if (returnType == BidConst.RETURN_TYPE_MONTH_INTEREST_PRINCIPAL) {// 按月分期 if (monthes2Return == 1) { monthToReturnMoney = bidRequestAmount.add( bidRequestAmount.multiply(monthlyRate)).setScale( BidConst.CAL_SCALE, RoundingMode.HALF_UP); } else { BigDecimal temp1 = bidRequestAmount.multiply(monthlyRate); BigDecimal temp2 = (BigDecimal.ONE.add(monthlyRate)) .pow(monthes2Return); BigDecimal temp3 = (BigDecimal.ONE.add(monthlyRate)).pow( monthes2Return).subtract(BigDecimal.ONE); // 算出每月还款 monthToReturnMoney = temp1.multiply(temp2).divide(temp3, BidConst.CAL_SCALE, RoundingMode.HALF_UP); } } else if (returnType == BidConst.RETURN_TYPE_MONTH_INTEREST) {// 按月到期 BigDecimal monthlyInterest = bidRequestAmount.multiply(monthlyRate) .setScale(BidConst.CAL_SCALE, RoundingMode.HALF_UP); if (monthIndex == monthes2Return) { monthToReturnMoney = bidRequestAmount.add(monthlyInterest) .setScale(BidConst.CAL_SCALE, RoundingMode.HALF_UP); } else if (monthIndex < monthes2Return) { monthToReturnMoney = monthlyInterest; } } return DecimalFormatUtil.formatBigDecimal(monthToReturnMoney, BidConst.STORE_SCALE); } /** * 计算一次投标实际获得的利息=投标金额/借款金额 *总利息 * * @param bidRequestAmount 借款金额 * @param monthes2Return 还款期数 * @param yearRate 年利率 * @param returnType 还款类型 * @param acturalBidAmount 投标金额 * @return */ public static BigDecimal calBidInterest(BigDecimal bidRequestAmount, int monthes2Return, BigDecimal yearRate, int returnType, BigDecimal acturalBidAmount) { // 借款产生的总利息 BigDecimal totalInterest = calTotalInterest(returnType, bidRequestAmount, yearRate, monthes2Return); // 所占比例 BigDecimal proportion = acturalBidAmount.divide(bidRequestAmount, BidConst.CAL_SCALE, RoundingMode.HALF_UP); BigDecimal bidInterest = totalInterest.multiply(proportion); return DecimalFormatUtil.formatBigDecimal(bidInterest, BidConst.STORE_SCALE); } /** * 计算利息管理费 * * @param interest * 利息 * @param interestManagerChargeRate * 利息管理费比例 * @return */ /** public static BigDecimal calInterestManagerCharge(BigDecimal interest) { return DecimalFormatUtil.formatBigDecimal( interest.multiply(BidConst.INTEREST_MANAGER_CHARGE_RATE), BidConst.SCALE); } */ /** * 计算借款管理费 * * @param bidRequestAmount 借款金额 * @return */ public static BigDecimal calAccountManagementCharge( BigDecimal bidRequestAmount) { BigDecimal accountManagementCharge = DecimalFormatUtil .formatBigDecimal(bidRequestAmount .multiply(BidConst.ACCOUNT_MANAGER_CHARGE_RATE), BidConst.CAL_SCALE); return accountManagementCharge; } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/numcal/DecimalFormatUtil.java ================================================ package com.geekq.common.utils.numcal; import java.math.BigDecimal; import java.math.RoundingMode; /** * 大数字格式化工具类 * * @author 邱润泽 */ public class DecimalFormatUtil { //金额 public static BigDecimal amountFormat(BigDecimal number) { number = number.setScale(BidConst.STORE_SCALE, RoundingMode.HALF_UP); return number; } //利率 public static BigDecimal rateFormat(BigDecimal number) { number = number.setScale(BidConst.STORE_SCALE, RoundingMode.HALF_UP); return number; } public static BigDecimal decimalRateFormat(BigDecimal number) { return number.multiply(BigDecimal.valueOf(100)); } //月利率 public static BigDecimal monthRateFormat(BigDecimal number) { return number.multiply(BigDecimal.valueOf(100)).divide( BigDecimal.valueOf(12), BidConst.CAL_SCALE, RoundingMode.HALF_UP); } public static BigDecimal formatBigDecimal(BigDecimal data, int scal) { if (null == data) return new BigDecimal(0.00); return data.setScale(scal, BigDecimal.ROUND_HALF_UP); } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/resultbean/AbstractResult.java ================================================ package com.geekq.common.utils.resultbean; import com.geekq.common.enums.ResultStatus; public class AbstractResult { private ResultStatus status; private int code; private String message; AbstractResult() { } protected AbstractResult(ResultStatus status, String message) { this.code = status.getCode(); this.status = status; this.message = message; } protected AbstractResult(ResultStatus status) { this.code = status.getCode(); this.message = status.getMessage(); this.status = status; } public static boolean isSuccess(AbstractResult result) { return result != null && result.status == ResultStatus.SUCCESS && result.getCode() == ResultStatus.SUCCESS.getCode(); } public AbstractResult withError(ResultStatus status) { this.status = status; return this; } public AbstractResult withError(String message) { this.status = ResultStatus.SYSTEM_ERROR; this.message = message; return this; } public AbstractResult withError(int code, String message) { this.status = ResultStatus.SYSTEM_ERROR; this.code = code; this.message = message; return this; } public AbstractResult success() { this.status = ResultStatus.SUCCESS; return this; } public ResultStatus getStatus() { return this.status; } public String getMessage() { return this.message == null ? this.status.getMessage() : this.message; } public int getCode() { return this.code; } public void setCode(int code) { this.code = code; } } ================================================ FILE: miaosha-admin/miaosha-admin-common/src/main/java/com/geekq/common/utils/resultbean/ResultGeekQ.java ================================================ package com.geekq.common.utils.resultbean; import com.geekq.common.enums.ResultStatus; import java.io.Serializable; public class ResultGeekQ
<#assign currentMenu="bankInfo"/>
<#include "common/leftmenu-tpl.ftl" />
绑定银行卡
<#if userinfo.realAuth>
<#else>
请先完成实名认证之后，才能进行银行卡绑定；
<#assign currentMenu = "bankInfo" />
<#include "common/leftmenu-tpl.ftl" />
绑定银行卡
你已经绑定了银行卡
| 开户名： ${userinfo.anonymousRealName} | 开户行：${bankInfo.bankType.bankName} |
| 支行名称： ${bankInfo.bankName} | 银行账号：${bankInfo.anonymousAccountNumber} |
<#assign currentMenu="bidRequest" />
<#include "common/leftmenu-tpl.ftl" />
借款项目
| 标题 | 发标时间 | 借款金额(元) | 期限 | 利率 | 总利息 | 状态 |
|---|---|---|---|---|---|---|
| ${data.title} 信 | ${(data.publishTime?string("yyyy-MM-dd HH:mm:SS"))!'未发布'} | ${data.bidRequestAmount} | ${data.monthes2Return}月 | ${data.currentRate}% | ${data.totalRewardAmount} | ${data.bidRequestStateDisplay} |
<#assign currentMenu="bid" />
<#include "common/leftmenu-tpl.ftl" />
投资项目
| 投资借款 | 投资时间 | 投资金额(元) | 利息 | 状态 |
|---|---|---|---|---|
| ${data.bidRequestTitle} | ${data.bidTime?string("yyyy-MM-dd HH:mm:SS")} | ${data.availableAmount} 元 | ${data.actualRate} % | ${data.bidRequestStateDisplay} |
信用贷
认证后可借金额 ¥ ${account.remainBorrowLimit}
申请条件仅限广州地区
- <#if !(userinfo.baseInfo)> 填写基本资料 <#else>填写基本资料
- <#if !(userinfo.realAuth)> 身份认证 <#else>身份认证
-
<#if (userinfo.authScore
- 视频认证 <#if !(userinfo.vedioAuth)> <#else>
信用借款
可借金额：${account.remainBorrowLimit}
借款信息
借款提示
你目前有标正在申请的流程当中，不能再次发标；或者你恶意的进入了发标流程，请按照正常流程完成发标前的相关资料提交，谢谢！
借款人
${bidRequest.title}借款
| 借款金额 | ${bidRequest.bidRequestAmount} | 年化利率 | ${bidRequest.currentRate}% |
| 借款期限 | ${bidRequest.monthes2Return}月 | 总可得利息 | ${bidRequest.totalRewardAmount} |
| 还款方式 | ${bidRequest.returnTypeDisplay} | 最小投标 | ${bidRequest.minBidAmount} |
| 风控意见 | ${bidRequest.note} | ||
| 剩余时间 | |||
| 投标总数 | ${bidRequest.bidCount} |
| 还需金额 | ${bidRequest.remainAmount} 元 |
| 投标进度 | |
|
|
|
投标中 <#elseif account?? && !self>
| 可用余额 | ${account.usableAmount} |
| 已投 | |
| 还需要 | ${bidRequest.remainAmount} |
|
|
|
登录投标 <#if bidRequest.bidRequestState==4 || bidRequest.bidRequestState==5>
满标审核中
<#if bidRequest.bidRequestState==7>还款中
<#if bidRequest.bidRequestState==8>已还清
借款人信息
| 出生时间 | ${(realAuth.birthDate)!""} | 借款额度 | ${bidRequest.bidRequestAmount} | 性别 | ${realAuth.sexDisplay} | 住房条件 | ${userInfo.houseCondition.title} |
| 文化程度 | ${userInfo.educationBackground.title} | 每月收入 | ${userInfo.incomeGrade.title} | 婚姻情况 | ${userInfo.marriage.title} | 子女情况 | ${userInfo.kidCount.title} |
材料信息
| 材料类型 | 材料数量 |
|---|---|
| ${file.fileType.title} | 1 |
还款情况
| 还款状态 | 最近一周 | 最近1月 | 最近6月 | 6个月前 | 总计[?] |
|---|---|---|---|---|---|
| 提前还款 | 0 | 0 | 0 | 0 | 0 |
| 准时还款 | 0 | 0 | 0 | 0 | 0 |
| 逾期已还 | 0 | 0 | 0 | 0 | 0 |
| 逾期未还 | 0 | 0 | 0 | 0 | 0 |
投标记录
| 投标人 | 年利率 | 有效金额(¥) | 投标时间 | 类型 | |
|---|---|---|---|---|---|
| ${bid.bidUser.username} | ${bid.actualRate}% | ${bid.availableAmount} | ${bid.bidTime?string("yyyy-MM-dd HH:mm:ss")} | 手动投标 | |
|
暂时没有投标数据 |
|||||
邮件激活结果
<#if success> 您的邮件已经成功激活,请登录系统查看! <#else> 您的邮件激活失败,失败原因是:${msg}!
专注于高级Java开发工程师的培养
版权所有： 2015广州小码哥教育科技有限公司
地 址： 广州市天河区棠下荷光三横路盛达商务园D座5楼
电 话： 020-29007520 邮箱： service@520it.com
专注于高级Java开发工程师的培养
版权所有： 2015广州小码哥教育科技有限公司
地 址： 广州市天河区棠下荷光三横路盛达商务园D座5楼
电 话： 020-29007520 邮箱： service@520it.com
投资列表
| 借款人 | 借款标题 | 年利率 | 金额 | 还款方式 | 进度 | 操作 |
|---|
${data.persent} %
目前没有符合要求的标
<#assign currentMenu="iplog" />
<#include "common/leftmenu-tpl.ftl" />
登录日志
| 用户 | 登录时间 | 登录ip | 登录状态 |
|---|---|---|---|
| ${data.username} | ${data.loginTime?string("yyyy-MM-dd HH:mm:SS")} | ${data.ip} | ${data.displayState} |
- 投资理财
- 稳定投资、高收益、短期限，易融贷先行赔付，保障投资人权益。
- 投资理财
- 稳定投资、高收益、短期限，易融贷先行赔付，保障投资人权益。
- 投资理财
- 稳定投资、高收益、短期限，易融贷先行赔付，保障投资人权益。
进行中借款
| 借款人 | 借款标题 | 年利率 | 金额 | 还款方式 | 借款期限 | 进度 | 操作 |
|---|---|---|---|---|---|---|---|
| ${data.createUser.username } | ${data.title} | ${data.currentRate}% | ${data.bidRequestAmount} | ${data.returnTypeDisplay} | ${data.monthes2Return}月 |
${data.persent} %
|
查看 |
|
目前暂时没有进行中的借款 |
|||||||
<#assign currentMenu="moneyWithdraw"/>
<#include "common/leftmenu-tpl.ftl" />
账户提现
1. 本平台工作日会处理当天 17:00 之前的提款申请。
2. 为了确保银行转账成功，请您确认银行账号信息的 正确性。
3. 单笔提现范围-普通用户500.00 元 ~ 500000.00 元。
4. 单笔提现范围-VIP用户500.00 元 ~ 500000.00 元。
5. 目前提现服务费：1万元(含) 之内：2.00 元/笔；1万元（以上） ：5.00 元/笔。
6. 为避免信用卡套现，故充值15日内未投资提现按提现金额的0.4%收取提现费用。
7. 本次可提现 = 可用余额 - 净值保证金 - 不可提现金额 + 投标冻结 - 最高服务费 - 返还体验金
可提现金额：${account.usableAmount} 元
冻结金额：${account.freezedAmount} 元
<#if haveProcessing>
<#elseif bankInfo??>
<#else>
您有提现申请正在处理中，请完这个提现申请完成后再次申请；
请先绑定银行卡，再申请提现；
<#assign currentMenu="account" />
<#include "common/leftmenu-tpl.ftl" />
账户总额：${account.totalAmount}元
可用金额：${account.usableAmount}元
冻结金额：${account.freezedAmount}元
待收利息：${account.unReceiveInterest}元
待收本金：${account.unReceivePrincipal}元
待还本息：${account.unReturnAmount}元
<#assign currentMenu="realAuth"/>
<#include "common/leftmenu-tpl.ftl" />
实名认证
<#assign currentMenu = "realAuth" />
<#include "common/leftmenu-tpl.ftl" />
<#if (auditing)??>
<#else>
实名认证
实名认证资料已经提交，等待业务员审核，请耐心等待；如果急需审核请联系客服；
实名认证
你已经通过实名认证
| 真实姓名： ${realAuth.realname} | 性别：${realAuth.sexDisplay} |
| 证件号码： ${realAuth.idNumber} | 出生日期：${(realAuth.birthDate)!''} |
线下充值
账户充值
1. 由于银行系统的限制，充值功能建议使用 IE 内核（IE8及以上）的浏览器。
2. 请注意：为打击信用卡套现行为，充值资金必须经过投资回款后方能允许提现。
| 银行名称 | 开户人姓名 | 银行帐号 | 开户行支行名称 |
|---|---|---|---|
| ${bank.accountname} | ${bank.banknumber} | ${bank.bankforkname} |
第一步:
请选择往以上一个账号汇款或转账您所要充值的金额（若您是跨行转账，推荐选择建行）。注：请保存您的交易记录信息。
第二步:
款或转账成功后，再选择你所汇款或转账的账号，并填写以下完整的信息后，提交您的线下充值申请。我们将会在下个工作日核对您的申请。
系统暂不支持，请采用线下充值
<#assign currentMenu="recharge" />
<#include "common/leftmenu-tpl.ftl" />
充值明细
账户充值
| 平台账号 | 交易号 | 充值时间 | 充值金额 | 充值状态 |
|---|---|---|---|---|
| ${data.tradeCode} | ${data.tradeTime?string("yyyy-MM-dd")} | ${data.amount} 元 | ${data.stateDisplay} |
<#assign currentMenu="recharge" />
<#include "common/leftmenu-tpl.ftl" />
还款明细
账户充值
| 借款 | 还款金额 | 还款本金 | 还款利息 | 还款期数 | 还款期限 | 还款状态 |
|---|---|---|---|---|---|---|
| ${data.bidRequestTitle} | ${data.totalAmount}元 | ${data.principal}元 | ${data.interest}元 | ${data.monthIndex}期 | ${data.deadLine?string("yyyy-MM-dd")} | <#if data.state=0> 立刻还款 <#else> ${data.stateDisplay} |
<#assign currentMenu="userFile"/>
<#include "common/leftmenu-tpl.ftl" />
<#assign currentMenu="userInfo" />
<#include "common/leftmenu-tpl.ftl" />
个人资料
你好，世界！
你好，世界2！
| 货品编号 | 货品名称 | 品牌 | 默认销售价 | 默认成本价 | |||
|---|---|---|---|---|---|---|---|
| 货品编号 | 货品名称 | 品牌 | 默认销售价 | 默认成本价 | |||
| 货品编号 | 货品名称 | 品牌 | 默认销售价 | 默认成本价 | |||
| 货品编号 | 货品名称 | 品牌 | 默认销售价 | 默认成本价 | |||
| 货品编号 | 货品名称 | 品牌 | 默认销售价 | 默认成本价 |
专注于高级Java开发工程师的培养
版权所有： 2015广州小码哥教育科技有限公司
地 址： 广州市天河区棠下荷光三横路盛达商务园D座5楼
电 话： 020-29007520 邮箱： service@520it.com
',
trigger: 'hover focus',
title: '',
delay: 0,
html: false,
container: false,
viewport: {
selector: 'body',
padding: 0
}
}
Tooltip.prototype.init = function (type, element, options) {
this.enabled = true
this.type = type
this.$element = $(element)
this.options = this.getOptions(options)
this.$viewport = this.options.viewport && $(this.options.viewport.selector || this.options.viewport)
var triggers = this.options.trigger.split(' ')
for (var i = triggers.length; i--;) {
var trigger = triggers[i]
if (trigger == 'click') {
this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
} else if (trigger != 'manual') {
var eventIn = trigger == 'hover' ? 'mouseenter' : 'focusin'
var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
}
}
this.options.selector ?
(this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
this.fixTitle()
}
Tooltip.prototype.getDefaults = function () {
return Tooltip.DEFAULTS
}
Tooltip.prototype.getOptions = function (options) {
options = $.extend({}, this.getDefaults(), this.$element.data(), options)
if (options.delay && typeof options.delay == 'number') {
options.delay = {
show: options.delay,
hide: options.delay
}
}
return options
}
Tooltip.prototype.getDelegateOptions = function () {
var options = {}
var defaults = this.getDefaults()
this._options && $.each(this._options, function (key, value) {
if (defaults[key] != value) options[key] = value
})
return options
}
Tooltip.prototype.enter = function (obj) {
var self = obj instanceof this.constructor ?
obj : $(obj.currentTarget).data('bs.' + this.type)
if (self && self.$tip && self.$tip.is(':visible')) {
self.hoverState = 'in'
return
}
if (!self) {
self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
$(obj.currentTarget).data('bs.' + this.type, self)
}
clearTimeout(self.timeout)
self.hoverState = 'in'
if (!self.options.delay || !self.options.delay.show) return self.show()
self.timeout = setTimeout(function () {
if (self.hoverState == 'in') self.show()
}, self.options.delay.show)
}
Tooltip.prototype.leave = function (obj) {
var self = obj instanceof this.constructor ?
obj : $(obj.currentTarget).data('bs.' + this.type)
if (!self) {
self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
$(obj.currentTarget).data('bs.' + this.type, self)
}
clearTimeout(self.timeout)
self.hoverState = 'out'
if (!self.options.delay || !self.options.delay.hide) return self.hide()
self.timeout = setTimeout(function () {
if (self.hoverState == 'out') self.hide()
}, self.options.delay.hide)
}
Tooltip.prototype.show = function () {
var e = $.Event('show.bs.' + this.type)
if (this.hasContent() && this.enabled) {
this.$element.trigger(e)
var inDom = $.contains(this.$element[0].ownerDocument.documentElement, this.$element[0])
if (e.isDefaultPrevented() || !inDom) return
var that = this
var $tip = this.tip()
var tipId = this.getUID(this.type)
this.setContent()
$tip.attr('id', tipId)
this.$element.attr('aria-describedby', tipId)
if (this.options.animation) $tip.addClass('fade')
var placement = typeof this.options.placement == 'function' ?
this.options.placement.call(this, $tip[0], this.$element[0]) :
this.options.placement
var autoToken = /\s?auto?\s?/i
var autoPlace = autoToken.test(placement)
if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
$tip
.detach()
.css({ top: 0, left: 0, display: 'block' })
.addClass(placement)
.data('bs.' + this.type, this)
this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
var pos = this.getPosition()
var actualWidth = $tip[0].offsetWidth
var actualHeight = $tip[0].offsetHeight
if (autoPlace) {
var orgPlacement = placement
var $container = this.options.container ? $(this.options.container) : this.$element.parent()
var containerDim = this.getPosition($container)
placement = placement == 'bottom' && pos.bottom + actualHeight > containerDim.bottom ? 'top' :
placement == 'top' && pos.top - actualHeight < containerDim.top ? 'bottom' :
placement == 'right' && pos.right + actualWidth > containerDim.width ? 'left' :
placement == 'left' && pos.left - actualWidth < containerDim.left ? 'right' :
placement
$tip
.removeClass(orgPlacement)
.addClass(placement)
}
var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
this.applyPlacement(calculatedOffset, placement)
var complete = function () {
var prevHoverState = that.hoverState
that.$element.trigger('shown.bs.' + that.type)
that.hoverState = null
if (prevHoverState == 'out') that.leave(that)
}
$.support.transition && this.$tip.hasClass('fade') ?
$tip
.one('bsTransitionEnd', complete)
.emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
complete()
}
}
Tooltip.prototype.applyPlacement = function (offset, placement) {
var $tip = this.tip()
var width = $tip[0].offsetWidth
var height = $tip[0].offsetHeight
// manually read margins because getBoundingClientRect includes difference
var marginTop = parseInt($tip.css('margin-top'), 10)
var marginLeft = parseInt($tip.css('margin-left'), 10)
// we must check for NaN for ie 8/9
if (isNaN(marginTop)) marginTop = 0
if (isNaN(marginLeft)) marginLeft = 0
offset.top = offset.top + marginTop
offset.left = offset.left + marginLeft
// $.fn.offset doesn't round pixel values
// so we use setOffset directly with our own function B-0
$.offset.setOffset($tip[0], $.extend({
using: function (props) {
$tip.css({
top: Math.round(props.top),
left: Math.round(props.left)
})
}
}, offset), 0)
$tip.addClass('in')
// check to see if placing tip in new offset caused the tip to resize itself
var actualWidth = $tip[0].offsetWidth
var actualHeight = $tip[0].offsetHeight
if (placement == 'top' && actualHeight != height) {
offset.top = offset.top + height - actualHeight
}
var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
if (delta.left) offset.left += delta.left
else offset.top += delta.top
var isVertical = /top|bottom/.test(placement)
var arrowDelta = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
var arrowOffsetPosition = isVertical ? 'offsetWidth' : 'offsetHeight'
$tip.offset(offset)
this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], isVertical)
}
Tooltip.prototype.replaceArrow = function (delta, dimension, isHorizontal) {
this.arrow()
.css(isHorizontal ? 'left' : 'top', 50 * (1 - delta / dimension) + '%')
.css(isHorizontal ? 'top' : 'left', '')
}
Tooltip.prototype.setContent = function () {
var $tip = this.tip()
var title = this.getTitle()
$tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
$tip.removeClass('fade in top bottom left right')
}
Tooltip.prototype.hide = function (callback) {
var that = this
var $tip = this.tip()
var e = $.Event('hide.bs.' + this.type)
function complete() {
if (that.hoverState != 'in') $tip.detach()
that.$element
.removeAttr('aria-describedby')
.trigger('hidden.bs.' + that.type)
callback && callback()
}
this.$element.trigger(e)
if (e.isDefaultPrevented()) return
$tip.removeClass('in')
$.support.transition && this.$tip.hasClass('fade') ?
$tip
.one('bsTransitionEnd', complete)
.emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
complete()
this.hoverState = null
return this
}
Tooltip.prototype.fixTitle = function () {
var $e = this.$element
if ($e.attr('title') || typeof ($e.attr('data-original-title')) != 'string') {
$e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
}
}
Tooltip.prototype.hasContent = function () {
return this.getTitle()
}
Tooltip.prototype.getPosition = function ($element) {
$element = $element || this.$element
var el = $element[0]
var isBody = el.tagName == 'BODY'
var elRect = el.getBoundingClientRect()
if (elRect.width == null) {
// width and height are missing in IE8, so compute them manually; see https://github.com/twbs/bootstrap/issues/14093
elRect = $.extend({}, elRect, { width: elRect.right - elRect.left, height: elRect.bottom - elRect.top })
}
var elOffset = isBody ? { top: 0, left: 0 } : $element.offset()
var scroll = { scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop() }
var outerDims = isBody ? { width: $(window).width(), height: $(window).height() } : null
return $.extend({}, elRect, scroll, outerDims, elOffset)
}
Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
return placement == 'bottom' ? { top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2 } :
placement == 'top' ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :
placement == 'left' ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
/* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }
}
Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
var delta = { top: 0, left: 0 }
if (!this.$viewport) return delta
var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
var viewportDimensions = this.getPosition(this.$viewport)
if (/right|left/.test(placement)) {
var topEdgeOffset = pos.top - viewportPadding - viewportDimensions.scroll
var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
if (topEdgeOffset < viewportDimensions.top) { // top overflow
delta.top = viewportDimensions.top - topEdgeOffset
} else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
}
} else {
var leftEdgeOffset = pos.left - viewportPadding
var rightEdgeOffset = pos.left + viewportPadding + actualWidth
if (leftEdgeOffset < viewportDimensions.left) { // left overflow
delta.left = viewportDimensions.left - leftEdgeOffset
} else if (rightEdgeOffset > viewportDimensions.width) { // right overflow
delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
}
}
return delta
}
Tooltip.prototype.getTitle = function () {
var title
var $e = this.$element
var o = this.options
title = $e.attr('data-original-title')
|| (typeof o.title == 'function' ? o.title.call($e[0]) : o.title)
return title
}
Tooltip.prototype.getUID = function (prefix) {
do prefix += ~~(Math.random() * 1000000)
while (document.getElementById(prefix))
return prefix
}
Tooltip.prototype.tip = function () {
return (this.$tip = this.$tip || $(this.options.template))
}
Tooltip.prototype.arrow = function () {
return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
}
Tooltip.prototype.enable = function () {
this.enabled = true
}
Tooltip.prototype.disable = function () {
this.enabled = false
}
Tooltip.prototype.toggleEnabled = function () {
this.enabled = !this.enabled
}
Tooltip.prototype.toggle = function (e) {
var self = this
if (e) {
self = $(e.currentTarget).data('bs.' + this.type)
if (!self) {
self = new this.constructor(e.currentTarget, this.getDelegateOptions())
$(e.currentTarget).data('bs.' + this.type, self)
}
}
self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
}
Tooltip.prototype.destroy = function () {
var that = this
clearTimeout(this.timeout)
this.hide(function () {
that.$element.off('.' + that.type).removeData('bs.' + that.type)
})
}
// TOOLTIP PLUGIN DEFINITION
// =========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.tooltip')
var options = typeof option == 'object' && option
if (!data && option == 'destroy') return
if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.tooltip
$.fn.tooltip = Plugin
$.fn.tooltip.Constructor = Tooltip
// TOOLTIP NO CONFLICT
// ===================
$.fn.tooltip.noConflict = function () {
$.fn.tooltip = old
return this
}
}(jQuery);
/* ========================================================================
* Bootstrap: popover.js v3.3.2
* http://getbootstrap.com/javascript/#popovers
* ========================================================================
* Copyright 2011-2015 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// POPOVER PUBLIC CLASS DEFINITION
// ===============================
var Popover = function (element, options) {
this.init('popover', element, options)
}
if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
Popover.VERSION = '3.3.2'
Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
placement: 'right',
trigger: 'click',
content: '',
template: '
'
})
// NOTE: POPOVER EXTENDS tooltip.js
// ================================
Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
Popover.prototype.constructor = Popover
Popover.prototype.getDefaults = function () {
return Popover.DEFAULTS
}
Popover.prototype.setContent = function () {
var $tip = this.tip()
var title = this.getTitle()
var content = this.getContent()
$tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
$tip.find('.popover-content').children().detach().end()[ // we use append for html objects to maintain js events
this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
](content)
$tip.removeClass('fade top bottom left right in')
// IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
// this manually by checking the contents.
if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
}
Popover.prototype.hasContent = function () {
return this.getTitle() || this.getContent()
}
Popover.prototype.getContent = function () {
var $e = this.$element
var o = this.options
return $e.attr('data-content')
|| (typeof o.content == 'function' ?
o.content.call($e[0]) :
o.content)
}
Popover.prototype.arrow = function () {
return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
}
Popover.prototype.tip = function () {
if (!this.$tip) this.$tip = $(this.options.template)
return this.$tip
}
// POPOVER PLUGIN DEFINITION
// =========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.popover')
var options = typeof option == 'object' && option
if (!data && option == 'destroy') return
if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.popover
$.fn.popover = Plugin
$.fn.popover.Constructor = Popover
// POPOVER NO CONFLICT
// ===================
$.fn.popover.noConflict = function () {
$.fn.popover = old
return this
}
}(jQuery);
/* ========================================================================
* Bootstrap: scrollspy.js v3.3.2
* http://getbootstrap.com/javascript/#scrollspy
* ========================================================================
* Copyright 2011-2015 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// SCROLLSPY CLASS DEFINITION
// ==========================
function ScrollSpy(element, options) {
var process = $.proxy(this.process, this)
this.$body = $('body')
this.$scrollElement = $(element).is('body') ? $(window) : $(element)
this.options = $.extend({}, ScrollSpy.DEFAULTS, options)
this.selector = (this.options.target || '') + ' .nav li > a'
this.offsets = []
this.targets = []
this.activeTarget = null
this.scrollHeight = 0
this.$scrollElement.on('scroll.bs.scrollspy', process)
this.refresh()
this.process()
}
ScrollSpy.VERSION = '3.3.2'
ScrollSpy.DEFAULTS = {
offset: 10
}
ScrollSpy.prototype.getScrollHeight = function () {
return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)
}
ScrollSpy.prototype.refresh = function () {
var offsetMethod = 'offset'
var offsetBase = 0
if (!$.isWindow(this.$scrollElement[0])) {
offsetMethod = 'position'
offsetBase = this.$scrollElement.scrollTop()
}
this.offsets = []
this.targets = []
this.scrollHeight = this.getScrollHeight()
var self = this
this.$body
.find(this.selector)
.map(function () {
var $el = $(this)
var href = $el.data('target') || $el.attr('href')
var $href = /^#./.test(href) && $(href)
return ($href
&& $href.length
&& $href.is(':visible')
&& [[$href[offsetMethod]().top + offsetBase, href]]) || null
})
.sort(function (a, b) { return a[0] - b[0] })
.each(function () {
self.offsets.push(this[0])
self.targets.push(this[1])
})
}
ScrollSpy.prototype.process = function () {
var scrollTop = this.$scrollElement.scrollTop() + this.options.offset
var scrollHeight = this.getScrollHeight()
var maxScroll = this.options.offset + scrollHeight - this.$scrollElement.height()
var offsets = this.offsets
var targets = this.targets
var activeTarget = this.activeTarget
var i
if (this.scrollHeight != scrollHeight) {
this.refresh()
}
if (scrollTop >= maxScroll) {
return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)
}
if (activeTarget && scrollTop < offsets[0]) {
this.activeTarget = null
return this.clear()
}
for (i = offsets.length; i--;) {
activeTarget != targets[i]
&& scrollTop >= offsets[i]
&& (!offsets[i + 1] || scrollTop <= offsets[i + 1])
&& this.activate(targets[i])
}
}
ScrollSpy.prototype.activate = function (target) {
this.activeTarget = target
this.clear()
var selector = this.selector +
'[data-target="' + target + '"],' +
this.selector + '[href="' + target + '"]'
var active = $(selector)
.parents('li')
.addClass('active')
if (active.parent('.dropdown-menu').length) {
active = active
.closest('li.dropdown')
.addClass('active')
}
active.trigger('activate.bs.scrollspy')
}
ScrollSpy.prototype.clear = function () {
$(this.selector)
.parentsUntil(this.options.target, '.active')
.removeClass('active')
}
// SCROLLSPY PLUGIN DEFINITION
// ===========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.scrollspy')
var options = typeof option == 'object' && option
if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.scrollspy
$.fn.scrollspy = Plugin
$.fn.scrollspy.Constructor = ScrollSpy
// SCROLLSPY NO CONFLICT
// =====================
$.fn.scrollspy.noConflict = function () {
$.fn.scrollspy = old
return this
}
// SCROLLSPY DATA-API
// ==================
$(window).on('load.bs.scrollspy.data-api', function () {
$('[data-spy="scroll"]').each(function () {
var $spy = $(this)
Plugin.call($spy, $spy.data())
})
})
}(jQuery);
/* ========================================================================
* Bootstrap: tab.js v3.3.2
* http://getbootstrap.com/javascript/#tabs
* ========================================================================
* Copyright 2011-2015 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// TAB CLASS DEFINITION
// ====================
var Tab = function (element) {
this.element = $(element)
}
Tab.VERSION = '3.3.2'
Tab.TRANSITION_DURATION = 150
Tab.prototype.show = function () {
var $this = this.element
var $ul = $this.closest('ul:not(.dropdown-menu)')
var selector = $this.data('target')
if (!selector) {
selector = $this.attr('href')
selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
}
if ($this.parent('li').hasClass('active')) return
var $previous = $ul.find('.active:last a')
var hideEvent = $.Event('hide.bs.tab', {
relatedTarget: $this[0]
})
var showEvent = $.Event('show.bs.tab', {
relatedTarget: $previous[0]
})
$previous.trigger(hideEvent)
$this.trigger(showEvent)
if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) return
var $target = $(selector)
this.activate($this.closest('li'), $ul)
this.activate($target, $target.parent(), function () {
$previous.trigger({
type: 'hidden.bs.tab',
relatedTarget: $this[0]
})
$this.trigger({
type: 'shown.bs.tab',
relatedTarget: $previous[0]
})
})
}
Tab.prototype.activate = function (element, container, callback) {
var $active = container.find('> .active')
var transition = callback
&& $.support.transition
&& (($active.length && $active.hasClass('fade')) || !!container.find('> .fade').length)
function next() {
$active
.removeClass('active')
.find('> .dropdown-menu > .active')
.removeClass('active')
.end()
.find('[data-toggle="tab"]')
.attr('aria-expanded', false)
element
.addClass('active')
.find('[data-toggle="tab"]')
.attr('aria-expanded', true)
if (transition) {
element[0].offsetWidth // reflow for transition
element.addClass('in')
} else {
element.removeClass('fade')
}
if (element.parent('.dropdown-menu')) {
element
.closest('li.dropdown')
.addClass('active')
.end()
.find('[data-toggle="tab"]')
.attr('aria-expanded', true)
}
callback && callback()
}
$active.length && transition ?
$active
.one('bsTransitionEnd', next)
.emulateTransitionEnd(Tab.TRANSITION_DURATION) :
next()
$active.removeClass('in')
}
// TAB PLUGIN DEFINITION
// =====================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.tab')
if (!data) $this.data('bs.tab', (data = new Tab(this)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.tab
$.fn.tab = Plugin
$.fn.tab.Constructor = Tab
// TAB NO CONFLICT
// ===============
$.fn.tab.noConflict = function () {
$.fn.tab = old
return this
}
// TAB DATA-API
// ============
var clickHandler = function (e) {
e.preventDefault()
Plugin.call($(this), 'show')
}
$(document)
.on('click.bs.tab.data-api', '[data-toggle="tab"]', clickHandler)
.on('click.bs.tab.data-api', '[data-toggle="pill"]', clickHandler)
}(jQuery);
/* ========================================================================
* Bootstrap: affix.js v3.3.2
* http://getbootstrap.com/javascript/#affix
* ========================================================================
* Copyright 2011-2015 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// AFFIX CLASS DEFINITION
// ======================
var Affix = function (element, options) {
this.options = $.extend({}, Affix.DEFAULTS, options)
this.$target = $(this.options.target)
.on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
.on('click.bs.affix.data-api', $.proxy(this.checkPositionWithEventLoop, this))
this.$element = $(element)
this.affixed =
this.unpin =
this.pinnedOffset = null
this.checkPosition()
}
Affix.VERSION = '3.3.2'
Affix.RESET = 'affix affix-top affix-bottom'
Affix.DEFAULTS = {
offset: 0,
target: window
}
Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {
var scrollTop = this.$target.scrollTop()
var position = this.$element.offset()
var targetHeight = this.$target.height()
if (offsetTop != null && this.affixed == 'top') return scrollTop < offsetTop ? 'top' : false
if (this.affixed == 'bottom') {
if (offsetTop != null) return (scrollTop + this.unpin <= position.top) ? false : 'bottom'
return (scrollTop + targetHeight <= scrollHeight - offsetBottom) ? false : 'bottom'
}
var initializing = this.affixed == null
var colliderTop = initializing ? scrollTop : position.top
var colliderHeight = initializing ? targetHeight : height
if (offsetTop != null && scrollTop <= offsetTop) return 'top'
if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'
return false
}
Affix.prototype.getPinnedOffset = function () {
if (this.pinnedOffset) return this.pinnedOffset
this.$element.removeClass(Affix.RESET).addClass('affix')
var scrollTop = this.$target.scrollTop()
var position = this.$element.offset()
return (this.pinnedOffset = position.top - scrollTop)
}
Affix.prototype.checkPositionWithEventLoop = function () {
setTimeout($.proxy(this.checkPosition, this), 1)
}
Affix.prototype.checkPosition = function () {
if (!this.$element.is(':visible')) return
var height = this.$element.height()
var offset = this.options.offset
var offsetTop = offset.top
var offsetBottom = offset.bottom
var scrollHeight = $('body').height()
if (typeof offset != 'object') offsetBottom = offsetTop = offset
if (typeof offsetTop == 'function') offsetTop = offset.top(this.$element)
if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)
var affix = this.getState(scrollHeight, height, offsetTop, offsetBottom)
if (this.affixed != affix) {
if (this.unpin != null) this.$element.css('top', '')
var affixType = 'affix' + (affix ? '-' + affix : '')
var e = $.Event(affixType + '.bs.affix')
this.$element.trigger(e)
if (e.isDefaultPrevented()) return
this.affixed = affix
this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null
this.$element
.removeClass(Affix.RESET)
.addClass(affixType)
.trigger(affixType.replace('affix', 'affixed') + '.bs.affix')
}
if (affix == 'bottom') {
this.$element.offset({
top: scrollHeight - height - offsetBottom
})
}
}
// AFFIX PLUGIN DEFINITION
// =======================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.affix')
var options = typeof option == 'object' && option
if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.affix
$.fn.affix = Plugin
$.fn.affix.Constructor = Affix
// AFFIX NO CONFLICT
// =================
$.fn.affix.noConflict = function () {
$.fn.affix = old
return this
}
// AFFIX DATA-API
// ==============
$(window).on('load', function () {
$('[data-spy="affix"]').each(function () {
var $spy = $(this)
var data = $spy.data()
data.offset = data.offset || {}
if (data.offsetBottom != null) data.offset.bottom = data.offsetBottom
if (data.offsetTop != null) data.offset.top = data.offsetTop
Plugin.call($spy, data)
})
})
}(jQuery);
================================================
FILE: miaosha-admin/miaosha-admin-web/src/main/webapp/js/bootstrap-3.3.2-dist/js/npm.js
================================================
// This file is autogenerated via the `commonjs` Grunt task. You can require() this file in a CommonJS environment.
require('../../js/transition.js')
require('../../js/alert.js')
require('../../js/button.js')
require('../../js/carousel.js')
require('../../js/collapse.js')
require('../../js/dropdown.js')
require('../../js/modal.js')
require('../../js/tooltip.js')
require('../../js/popover.js')
require('../../js/scrollspy.js')
require('../../js/tab.js')
require('../../js/affix.js')
================================================
FILE: miaosha-admin/miaosha-admin-web/src/main/webapp/js/jquery/jquery-2.1.3.js
================================================
/*!
* jQuery JavaScript Library v2.1.3
* http://jquery.com/
*
* Includes Sizzle.js
* http://sizzlejs.com/
*
* Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
* Released under the MIT license
* http://jquery.org/license
*
* Date: 2014-12-18T15:11Z
*/
(function( global, factory ) {
if ( typeof module === "object" && typeof module.exports === "object" ) {
// For CommonJS and CommonJS-like environments where a proper `window`
// is present, execute the factory and get jQuery.
// For environments that do not have a `window` with a `document`
// (such as Node.js), expose a factory as module.exports.
// This accentuates the need for the creation of a real `window`.
// e.g. var jQuery = require("jquery")(window);
// See ticket #14549 for more info.
module.exports = global.document ?
factory( global, true ) :
function( w ) {
if ( !w.document ) {
throw new Error( "jQuery requires a window with a document" );
}
return factory( w );
};
} else {
factory( global );
}
// Pass this if window is not defined yet
}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
// Support: Firefox 18+
// Can't be in strict mode, several libs including ASP.NET trace
// the stack via arguments.caller.callee and Firefox dies if
// you try to trace through "use strict" call chains. (#13335)
//
var arr = [];
var slice = arr.slice;
var concat = arr.concat;
var push = arr.push;
var indexOf = arr.indexOf;
var class2type = {};
var toString = class2type.toString;
var hasOwn = class2type.hasOwnProperty;
var support = {};
var
// Use the correct document accordingly with window argument (sandbox)
document = window.document,
version = "2.1.3",
// Define a local copy of jQuery
jQuery = function( selector, context ) {
// The jQuery object is actually just the init constructor 'enhanced'
// Need init if jQuery is called (just allow error to be thrown if not included)
return new jQuery.fn.init( selector, context );
},
// Support: Android<4.1
// Make sure we trim BOM and NBSP
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
// Matches dashed string for camelizing
rmsPrefix = /^-ms-/,
rdashAlpha = /-([\da-z])/gi,
// Used by jQuery.camelCase as callback to replace()
fcamelCase = function( all, letter ) {
return letter.toUpperCase();
};
jQuery.fn = jQuery.prototype = {
// The current version of jQuery being used
jquery: version,
constructor: jQuery,
// Start with an empty selector
selector: "",
// The default length of a jQuery object is 0
length: 0,
toArray: function() {
return slice.call( this );
},
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
return num != null ?
// Return just the one element from the set
( num < 0 ? this[ num + this.length ] : this[ num ] ) :
// Return all the elements in a clean array
slice.call( this );
},
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems ) {
// Build a new jQuery matched element set
var ret = jQuery.merge( this.constructor(), elems );
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
ret.context = this.context;
// Return the newly-formed element set
return ret;
},
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function( callback, args ) {
return jQuery.each( this, callback, args );
},
map: function( callback ) {
return this.pushStack( jQuery.map(this, function( elem, i ) {
return callback.call( elem, i, elem );
}));
},
slice: function() {
return this.pushStack( slice.apply( this, arguments ) );
},
first: function() {
return this.eq( 0 );
},
last: function() {
return this.eq( -1 );
},
eq: function( i ) {
var len = this.length,
j = +i + ( i < 0 ? len : 0 );
return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
},
end: function() {
return this.prevObject || this.constructor(null);
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: push,
sort: arr.sort,
splice: arr.splice
};
jQuery.extend = jQuery.fn.extend = function() {
var options, name, src, copy, copyIsArray, clone,
target = arguments[0] || {},
i = 1,
length = arguments.length,
deep = false;
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
// Skip the boolean and the target
target = arguments[ i ] || {};
i++;
}
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
target = {};
}
// Extend jQuery itself if only one argument is passed
if ( i === length ) {
target = this;
i--;
}
for ( ; i < length; i++ ) {
// Only deal with non-null/undefined values
if ( (options = arguments[ i ]) != null ) {
// Extend the base object
for ( name in options ) {
src = target[ name ];
copy = options[ name ];
// Prevent never-ending loop
if ( target === copy ) {
continue;
}
// Recurse if we're merging plain objects or arrays
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
if ( copyIsArray ) {
copyIsArray = false;
clone = src && jQuery.isArray(src) ? src : [];
} else {
clone = src && jQuery.isPlainObject(src) ? src : {};
}
// Never move original objects, clone them
target[ name ] = jQuery.extend( deep, clone, copy );
// Don't bring in undefined values
} else if ( copy !== undefined ) {
target[ name ] = copy;
}
}
}
}
// Return the modified object
return target;
};
jQuery.extend({
// Unique for each copy of jQuery on the page
expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
// Assume jQuery is ready without the ready module
isReady: true,
error: function( msg ) {
throw new Error( msg );
},
noop: function() {},
isFunction: function( obj ) {
return jQuery.type(obj) === "function";
},
isArray: Array.isArray,
isWindow: function( obj ) {
return obj != null && obj === obj.window;
},
isNumeric: function( obj ) {
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
// subtraction forces infinities to NaN
// adding 1 corrects loss of precision from parseFloat (#15100)
return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
},
isPlainObject: function( obj ) {
// Not plain objects:
// - Any object or value whose internal [[Class]] property is not "[object Object]"
// - DOM nodes
// - window
if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
return false;
}
if ( obj.constructor &&
!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
return false;
}
// If the function hasn't returned already, we're confident that
// |obj| is a plain object, created by {} or constructed with new Object
return true;
},
isEmptyObject: function( obj ) {
var name;
for ( name in obj ) {
return false;
}
return true;
},
type: function( obj ) {
if ( obj == null ) {
return obj + "";
}
// Support: Android<4.0, iOS<6 (functionish RegExp)
return typeof obj === "object" || typeof obj === "function" ?
class2type[ toString.call(obj) ] || "object" :
typeof obj;
},
// Evaluates a script in a global context
globalEval: function( code ) {
var script,
indirect = eval;
code = jQuery.trim( code );
if ( code ) {
// If the code includes a valid, prologue position
// strict mode pragma, execute code by injecting a
// script tag into the document.
if ( code.indexOf("use strict") === 1 ) {
script = document.createElement("script");
script.text = code;
document.head.appendChild( script ).parentNode.removeChild( script );
} else {
// Otherwise, avoid the DOM node creation, insertion
// and removal by using an indirect global eval
indirect( code );
}
}
},
// Convert dashed to camelCase; used by the css and data modules
// Support: IE9-11+
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function( string ) {
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
},
nodeName: function( elem, name ) {
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
},
// args is for internal usage only
each: function( obj, callback, args ) {
var value,
i = 0,
length = obj.length,
isArray = isArraylike( obj );
if ( args ) {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.apply( obj[ i ], args );
if ( value === false ) {
break;
}
}
}
// A special, fast, case for the most common use of each
} else {
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
} else {
for ( i in obj ) {
value = callback.call( obj[ i ], i, obj[ i ] );
if ( value === false ) {
break;
}
}
}
}
return obj;
},
// Support: Android<4.1
trim: function( text ) {
return text == null ?
"" :
( text + "" ).replace( rtrim, "" );
},
// results is for internal usage only
makeArray: function( arr, results ) {
var ret = results || [];
if ( arr != null ) {
if ( isArraylike( Object(arr) ) ) {
jQuery.merge( ret,
typeof arr === "string" ?
[ arr ] : arr
);
} else {
push.call( ret, arr );
}
}
return ret;
},
inArray: function( elem, arr, i ) {
return arr == null ? -1 : indexOf.call( arr, elem, i );
},
merge: function( first, second ) {
var len = +second.length,
j = 0,
i = first.length;
for ( ; j < len; j++ ) {
first[ i++ ] = second[ j ];
}
first.length = i;
return first;
},
grep: function( elems, callback, invert ) {
var callbackInverse,
matches = [],
i = 0,
length = elems.length,
callbackExpect = !invert;
// Go through the array, only saving the items
// that pass the validator function
for ( ; i < length; i++ ) {
callbackInverse = !callback( elems[ i ], i );
if ( callbackInverse !== callbackExpect ) {
matches.push( elems[ i ] );
}
}
return matches;
},
// arg is for internal usage only
map: function( elems, callback, arg ) {
var value,
i = 0,
length = elems.length,
isArray = isArraylike( elems ),
ret = [];
// Go through the array, translating each of the items to their new values
if ( isArray ) {
for ( ; i < length; i++ ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret.push( value );
}
}
// Go through every key on the object,
} else {
for ( i in elems ) {
value = callback( elems[ i ], i, arg );
if ( value != null ) {
ret.push( value );
}
}
}
// Flatten any nested arrays
return concat.apply( [], ret );
},
// A global GUID counter for objects
guid: 1,
// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function( fn, context ) {
var tmp, args, proxy;
if ( typeof context === "string" ) {
tmp = fn[ context ];
context = fn;
fn = tmp;
}
// Quick check to determine if target is callable, in the spec
// this throws a TypeError, but we will just return undefined.
if ( !jQuery.isFunction( fn ) ) {
return undefined;
}
// Simulated bind
args = slice.call( arguments, 2 );
proxy = function() {
return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
};
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
return proxy;
},
now: Date.now,
// jQuery.support is not used in Core but other projects attach their
// properties to it so it needs to exist.
support: support
});
// Populate the class2type map
jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
class2type[ "[object " + name + "]" ] = name.toLowerCase();
});
function isArraylike( obj ) {
var length = obj.length,
type = jQuery.type( obj );
if ( type === "function" || jQuery.isWindow( obj ) ) {
return false;
}
if ( obj.nodeType === 1 && length ) {
return true;
}
return type === "array" || length === 0 ||
typeof length === "number" && length > 0 && ( length - 1 ) in obj;
}
var Sizzle =
/*!
* Sizzle CSS Selector Engine v2.2.0-pre
* http://sizzlejs.com/
*
* Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
* Released under the MIT license
* http://jquery.org/license
*
* Date: 2014-12-16
*/
(function( window ) {
var i,
support,
Expr,
getText,
isXML,
tokenize,
compile,
select,
outermostContext,
sortInput,
hasDuplicate,
// Local document vars
setDocument,
document,
docElem,
documentIsHTML,
rbuggyQSA,
rbuggyMatches,
matches,
contains,
// Instance-specific data
expando = "sizzle" + 1 * new Date(),
preferredDoc = window.document,
dirruns = 0,
done = 0,
classCache = createCache(),
tokenCache = createCache(),
compilerCache = createCache(),
sortOrder = function( a, b ) {
if ( a === b ) {
hasDuplicate = true;
}
return 0;
},
// General-purpose constants
MAX_NEGATIVE = 1 << 31,
// Instance methods
hasOwn = ({}).hasOwnProperty,
arr = [],
pop = arr.pop,
push_native = arr.push,
push = arr.push,
slice = arr.slice,
// Use a stripped-down indexOf as it's faster than native
// http://jsperf.com/thor-indexof-vs-for/5
indexOf = function( list, elem ) {
var i = 0,
len = list.length;
for ( ; i < len; i++ ) {
if ( list[i] === elem ) {
return i;
}
}
return -1;
},
booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
// Regular expressions
// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
whitespace = "[\\x20\\t\\r\\n\\f]",
// http://www.w3.org/TR/css3-syntax/#characters
characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
// Loosely modeled on CSS identifier characters
// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
identifier = characterEncoding.replace( "w", "w#" ),
// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
// Operator (capture 2)
"*([*^$|!~]?=)" + whitespace +
// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
"*\\]",
pseudos = ":(" + characterEncoding + ")(?:\\((" +
// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
// 1. quoted (capture 3; capture 4 or capture 5)
"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
// 2. simple (capture 6)
"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
// 3. anything else (capture 2)
".*" +
")\\)|)",
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
rwhitespace = new RegExp( whitespace + "+", "g" ),
rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
rpseudo = new RegExp( pseudos ),
ridentifier = new RegExp( "^" + identifier + "$" ),
matchExpr = {
"ID": new RegExp( "^#(" + characterEncoding + ")" ),
"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
"ATTR": new RegExp( "^" + attributes ),
"PSEUDO": new RegExp( "^" + pseudos ),
"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
// For use in libraries implementing .is()
// We use this for POS matching in `select`
"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
},
rinputs = /^(?:input|select|textarea|button)$/i,
rheader = /^h\d$/i,
rnative = /^[^{]+\{\s*\[native \w/,
// Easily-parseable/retrievable ID or TAG or CLASS selectors
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
rsibling = /[+~]/,
rescape = /'|\\/g,
// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
funescape = function( _, escaped, escapedWhitespace ) {
var high = "0x" + escaped - 0x10000;
// NaN means non-codepoint
// Support: Firefox<24
// Workaround erroneous numeric interpretation of +"0x"
return high !== high || escapedWhitespace ?
escaped :
high < 0 ?
// BMP codepoint
String.fromCharCode( high + 0x10000 ) :
// Supplemental Plane codepoint (surrogate pair)
String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
},
// Used for iframes
// See setDocument()
// Removing the function wrapper causes a "Permission Denied"
// error in IE
unloadHandler = function() {
setDocument();
};
// Optimize for push.apply( _, NodeList )
try {
push.apply(
(arr = slice.call( preferredDoc.childNodes )),
preferredDoc.childNodes
);
// Support: Android<4.0
// Detect silently failing push.apply
arr[ preferredDoc.childNodes.length ].nodeType;
} catch ( e ) {
push = { apply: arr.length ?
// Leverage slice if possible
function( target, els ) {
push_native.apply( target, slice.call(els) );
} :
// Support: IE<9
// Otherwise append directly
function( target, els ) {
var j = target.length,
i = 0;
// Can't trust NodeList.length
while ( (target[j++] = els[i++]) ) {}
target.length = j - 1;
}
};
}
function Sizzle( selector, context, results, seed ) {
var match, elem, m, nodeType,
// QSA vars
i, groups, old, nid, newContext, newSelector;
if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
setDocument( context );
}
context = context || document;
results = results || [];
nodeType = context.nodeType;
if ( typeof selector !== "string" || !selector ||
nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
return results;
}
if ( !seed && documentIsHTML ) {
// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
// Speed-up: Sizzle("#ID")
if ( (m = match[1]) ) {
if ( nodeType === 9 ) {
elem = context.getElementById( m );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document (jQuery #6963)
if ( elem && elem.parentNode ) {
// Handle the case where IE, Opera, and Webkit return items
// by name instead of ID
if ( elem.id === m ) {
results.push( elem );
return results;
}
} else {
return results;
}
} else {
// Context is not a document
if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
contains( context, elem ) && elem.id === m ) {
results.push( elem );
return results;
}
}
// Speed-up: Sizzle("TAG")
} else if ( match[2] ) {
push.apply( results, context.getElementsByTagName( selector ) );
return results;
// Speed-up: Sizzle(".CLASS")
} else if ( (m = match[3]) && support.getElementsByClassName ) {
push.apply( results, context.getElementsByClassName( m ) );
return results;
}
}
// QSA path
if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
nid = old = expando;
newContext = context;
newSelector = nodeType !== 1 && selector;
// qSA works strangely on Element-rooted queries
// We can work around this by specifying an extra ID on the root
// and working up from there (Thanks to Andrew Dupont for the technique)
// IE 8 doesn't work on object elements
if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
groups = tokenize( selector );
if ( (old = context.getAttribute("id")) ) {
nid = old.replace( rescape, "\\$&" );
} else {
context.setAttribute( "id", nid );
}
nid = "[id='" + nid + "'] ";
i = groups.length;
while ( i-- ) {
groups[i] = nid + toSelector( groups[i] );
}
newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
newSelector = groups.join(",");
}
if ( newSelector ) {
try {
push.apply( results,
newContext.querySelectorAll( newSelector )
);
return results;
} catch(qsaError) {
} finally {
if ( !old ) {
context.removeAttribute("id");
}
}
}
}
}
// All others
return select( selector.replace( rtrim, "$1" ), context, results, seed );
}
/**
* Create key-value caches of limited size
* @returns {Function(string, Object)} Returns the Object data after storing it on itself with
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
* deleting the oldest entry
*/
function createCache() {
var keys = [];
function cache( key, value ) {
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
if ( keys.push( key + " " ) > Expr.cacheLength ) {
// Only keep the most recent entries
delete cache[ keys.shift() ];
}
return (cache[ key + " " ] = value);
}
return cache;
}
/**
* Mark a function for special use by Sizzle
* @param {Function} fn The function to mark
*/
function markFunction( fn ) {
fn[ expando ] = true;
return fn;
}
/**
* Support testing using an element
* @param {Function} fn Passed the created div and expects a boolean result
*/
function assert( fn ) {
var div = document.createElement("div");
try {
return !!fn( div );
} catch (e) {
return false;
} finally {
// Remove from its parent by default
if ( div.parentNode ) {
div.parentNode.removeChild( div );
}
// release memory in IE
div = null;
}
}
/**
* Adds the same handler for all of the specified attrs
* @param {String} attrs Pipe-separated list of attributes
* @param {Function} handler The method that will be applied
*/
function addHandle( attrs, handler ) {
var arr = attrs.split("|"),
i = attrs.length;
while ( i-- ) {
Expr.attrHandle[ arr[i] ] = handler;
}
}
/**
* Checks document admin of two siblings
* @param {Element} a
* @param {Element} b
* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
*/
function siblingCheck( a, b ) {
var cur = b && a,
diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
( ~b.sourceIndex || MAX_NEGATIVE ) -
( ~a.sourceIndex || MAX_NEGATIVE );
// Use IE sourceIndex if available on both nodes
if ( diff ) {
return diff;
}
// Check if b follows a
if ( cur ) {
while ( (cur = cur.nextSibling) ) {
if ( cur === b ) {
return -1;
}
}
}
return a ? 1 : -1;
}
/**
* Returns a function to use in pseudos for input types
* @param {String} type
*/
function createInputPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === type;
};
}
/**
* Returns a function to use in pseudos for buttons
* @param {String} type
*/
function createButtonPseudo( type ) {
return function( elem ) {
var name = elem.nodeName.toLowerCase();
return (name === "input" || name === "button") && elem.type === type;
};
}
/**
* Returns a function to use in pseudos for positionals
* @param {Function} fn
*/
function createPositionalPseudo( fn ) {
return markFunction(function( argument ) {
argument = +argument;
return markFunction(function( seed, matches ) {
var j,
matchIndexes = fn( [], seed.length, argument ),
i = matchIndexes.length;
// Match elements found at the specified indexes
while ( i-- ) {
if ( seed[ (j = matchIndexes[i]) ] ) {
seed[j] = !(matches[j] = seed[j]);
}
}
});
});
}
/**
* Checks a node for validity as a Sizzle context
* @param {Element|Object=} context
* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
*/
function testContext( context ) {
return context && typeof context.getElementsByTagName !== "undefined" && context;
}
// Expose support vars for convenience
support = Sizzle.support = {};
/**
* Detects XML nodes
* @param {Element|Object} elem An element or a document
* @returns {Boolean} True iff elem is a non-HTML XML node
*/
isXML = Sizzle.isXML = function( elem ) {
// documentElement is verified for cases where it doesn't yet exist
// (such as loading iframes in IE - #4833)
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
return documentElement ? documentElement.nodeName !== "HTML" : false;
};
/**
* Sets document-related variables once based on the current document
* @param {Element|Object} [doc] An element or document object to use to set the document
* @returns {Object} Returns the current document
*/
setDocument = Sizzle.setDocument = function( node ) {
var hasCompare, parent,
doc = node ? node.ownerDocument || node : preferredDoc;
// If no document and documentElement is available, return
if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
return document;
}
// Set our document
document = doc;
docElem = doc.documentElement;
parent = doc.defaultView;
// Support: IE>8
// If iframe document is assigned to "document" variable and if iframe has been reloaded,
// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
// IE6-8 do not support the defaultView property so parent will be undefined
if ( parent && parent !== parent.top ) {
// IE11 does not have attachEvent, so all must suffer
if ( parent.addEventListener ) {
parent.addEventListener( "unload", unloadHandler, false );
} else if ( parent.attachEvent ) {
parent.attachEvent( "onunload", unloadHandler );
}
}
/* Support tests
---------------------------------------------------------------------- */
documentIsHTML = !isXML( doc );
/* Attributes
---------------------------------------------------------------------- */
// Support: IE<8
// Verify that getAttribute really returns attributes and not properties
// (excepting IE8 booleans)
support.attributes = assert(function( div ) {
div.className = "i";
return !div.getAttribute("className");
});
/* getElement(s)By*
---------------------------------------------------------------------- */
// Check if getElementsByTagName("*") returns only elements
support.getElementsByTagName = assert(function( div ) {
div.appendChild( doc.createComment("") );
return !div.getElementsByTagName("*").length;
});
// Support: IE<9
support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
// Support: IE<10
// Check if getElementById returns elements by name
// The broken getElementById methods don't pick up programatically-set names,
// so use a roundabout getElementsByName test
support.getById = assert(function( div ) {
docElem.appendChild( div ).id = expando;
return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
});
// ID find and filter
if ( support.getById ) {
Expr.find["ID"] = function( id, context ) {
if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
var m = context.getElementById( id );
// Check parentNode to catch when Blackberry 4.6 returns
// nodes that are no longer in the document #6963
return m && m.parentNode ? [ m ] : [];
}
};
Expr.filter["ID"] = function( id ) {
var attrId = id.replace( runescape, funescape );
return function( elem ) {
return elem.getAttribute("id") === attrId;
};
};
} else {
// Support: IE6/7
// getElementById is not reliable as a find shortcut
delete Expr.find["ID"];
Expr.filter["ID"] = function( id ) {
var attrId = id.replace( runescape, funescape );
return function( elem ) {
var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
return node && node.value === attrId;
};
};
}
// Tag
Expr.find["TAG"] = support.getElementsByTagName ?
function( tag, context ) {
if ( typeof context.getElementsByTagName !== "undefined" ) {
return context.getElementsByTagName( tag );
// DocumentFragment nodes don't have gEBTN
} else if ( support.qsa ) {
return context.querySelectorAll( tag );
}
} :
function( tag, context ) {
var elem,
tmp = [],
i = 0,
// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
results = context.getElementsByTagName( tag );
// Filter out possible comments
if ( tag === "*" ) {
while ( (elem = results[i++]) ) {
if ( elem.nodeType === 1 ) {
tmp.push( elem );
}
}
return tmp;
}
return results;
};
// Class
Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
if ( documentIsHTML ) {
return context.getElementsByClassName( className );
}
};
/* QSA/matchesSelector
---------------------------------------------------------------------- */
// QSA and matchesSelector support
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
rbuggyMatches = [];
// qSa(:focus) reports false when true (Chrome 21)
// We allow this because of a bug in IE8/9 that throws an error
// whenever `document.activeElement` is accessed on an iframe
// So, we allow :focus to pass through QSA all the time to avoid the IE error
// See http://bugs.jquery.com/ticket/13378
rbuggyQSA = [];
if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
// Build QSA regex
// Regex strategy adopted from Diego Perini
assert(function( div ) {
// Select is set to empty string on purpose
// This is to test IE's treatment of not explicitly
// setting a boolean content attribute,
// since its presence should be enough
// http://bugs.jquery.com/ticket/12359
docElem.appendChild( div ).innerHTML = "" +
"";
// Support: IE8, Opera 11-12.16
// Nothing should be selected when empty strings follow ^= or $= or *=
// The test attribute must be unknown in Opera but "safe" for WinRT
// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
if ( div.querySelectorAll("[msallowcapture^='']").length ) {
rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
}
// Support: IE8
// Boolean attributes and "value" are not treated correctly
if ( !div.querySelectorAll("[selected]").length ) {
rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
}
// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
rbuggyQSA.push("~=");
}
// Webkit/Opera - :checked should return selected option elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
// IE8 throws error here and will not see later tests
if ( !div.querySelectorAll(":checked").length ) {
rbuggyQSA.push(":checked");
}
// Support: Safari 8+, iOS 8+
// https://bugs.webkit.org/show_bug.cgi?id=136851
// In-page `selector#id sibing-combinator selector` fails
if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
rbuggyQSA.push(".#.+[+~]");
}
});
assert(function( div ) {
// Support: Windows 8 Native Apps
// The type and name attributes are restricted during .innerHTML assignment
var input = doc.createElement("input");
input.setAttribute( "type", "hidden" );
div.appendChild( input ).setAttribute( "name", "D" );
// Support: IE8
// Enforce case-sensitivity of name attribute
if ( div.querySelectorAll("[name=d]").length ) {
rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
}
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
// IE8 throws error here and will not see later tests
if ( !div.querySelectorAll(":enabled").length ) {
rbuggyQSA.push( ":enabled", ":disabled" );
}
// Opera 10-11 does not throw on post-comma invalid pseudos
div.querySelectorAll("*,:x");
rbuggyQSA.push(",.*:");
});
}
if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
docElem.webkitMatchesSelector ||
docElem.mozMatchesSelector ||
docElem.oMatchesSelector ||
docElem.msMatchesSelector) )) ) {
assert(function( div ) {
// Check to see if it's possible to do matchesSelector
// on a disconnected node (IE 9)
support.disconnectedMatch = matches.call( div, "div" );
// This should fail with an exception
// Gecko does not error, returns false instead
matches.call( div, "[s!='']:x" );
rbuggyMatches.push( "!=", pseudos );
});
}
rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
/* Contains
---------------------------------------------------------------------- */
hasCompare = rnative.test( docElem.compareDocumentPosition );
// Element contains another
// Purposefully does not implement inclusive descendent
// As in, an element does not contain itself
contains = hasCompare || rnative.test( docElem.contains ) ?
function( a, b ) {
var adown = a.nodeType === 9 ? a.documentElement : a,
bup = b && b.parentNode;
return a === bup || !!( bup && bup.nodeType === 1 && (
adown.contains ?
adown.contains( bup ) :
a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
));
} :
function( a, b ) {
if ( b ) {
while ( (b = b.parentNode) ) {
if ( b === a ) {
return true;
}
}
}
return false;
};
/* Sorting
---------------------------------------------------------------------- */
// Document admin sorting
sortOrder = hasCompare ?
function( a, b ) {
// Flag for duplicate removal
if ( a === b ) {
hasDuplicate = true;
return 0;
}
// Sort on method existence if only one input has compareDocumentPosition
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
if ( compare ) {
return compare;
}
// Calculate position if both inputs belong to the same document
compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
a.compareDocumentPosition( b ) :
// Otherwise we know they are disconnected
1;
// Disconnected nodes
if ( compare & 1 ||
(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
// Choose the first element that is related to our preferred document
if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
return -1;
}
if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
return 1;
}
// Maintain original admin
return sortInput ?
( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
0;
}
return compare & 4 ? -1 : 1;
} :
function( a, b ) {
// Exit early if the nodes are identical
if ( a === b ) {
hasDuplicate = true;
return 0;
}
var cur,
i = 0,
aup = a.parentNode,
bup = b.parentNode,
ap = [ a ],
bp = [ b ];
// Parentless nodes are either documents or disconnected
if ( !aup || !bup ) {
return a === doc ? -1 :
b === doc ? 1 :
aup ? -1 :
bup ? 1 :
sortInput ?
( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
0;
// If the nodes are siblings, we can do a quick check
} else if ( aup === bup ) {
return siblingCheck( a, b );
}
// Otherwise we need full lists of their ancestors for comparison
cur = a;
while ( (cur = cur.parentNode) ) {
ap.unshift( cur );
}
cur = b;
while ( (cur = cur.parentNode) ) {
bp.unshift( cur );
}
// Walk down the tree looking for a discrepancy
while ( ap[i] === bp[i] ) {
i++;
}
return i ?
// Do a sibling check if the nodes have a common ancestor
siblingCheck( ap[i], bp[i] ) :
// Otherwise nodes in our document sort first
ap[i] === preferredDoc ? -1 :
bp[i] === preferredDoc ? 1 :
0;
};
return doc;
};
Sizzle.matches = function( expr, elements ) {
return Sizzle( expr, null, null, elements );
};
Sizzle.matchesSelector = function( elem, expr ) {
// Set document vars if needed
if ( ( elem.ownerDocument || elem ) !== document ) {
setDocument( elem );
}
// Make sure that attribute selectors are quoted
expr = expr.replace( rattributeQuotes, "='$1']" );
if ( support.matchesSelector && documentIsHTML &&
( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
try {
var ret = matches.call( elem, expr );
// IE 9's matchesSelector returns false on disconnected nodes
if ( ret || support.disconnectedMatch ||
// As well, disconnected nodes are said to be in a document
// fragment in IE 9
elem.document && elem.document.nodeType !== 11 ) {
return ret;
}
} catch (e) {}
}
return Sizzle( expr, document, null, [ elem ] ).length > 0;
};
Sizzle.contains = function( context, elem ) {
// Set document vars if needed
if ( ( context.ownerDocument || context ) !== document ) {
setDocument( context );
}
return contains( context, elem );
};
Sizzle.attr = function( elem, name ) {
// Set document vars if needed
if ( ( elem.ownerDocument || elem ) !== document ) {
setDocument( elem );
}
var fn = Expr.attrHandle[ name.toLowerCase() ],
// Don't get fooled by Object.prototype properties (jQuery #13807)
val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
fn( elem, name, !documentIsHTML ) :
undefined;
return val !== undefined ?
val :
support.attributes || !documentIsHTML ?
elem.getAttribute( name ) :
(val = elem.getAttributeNode(name)) && val.specified ?
val.value :
null;
};
Sizzle.error = function( msg ) {
throw new Error( "Syntax error, unrecognized expression: " + msg );
};
/**
* Document sorting and removing duplicates
* @param {ArrayLike} results
*/
Sizzle.uniqueSort = function( results ) {
var elem,
duplicates = [],
j = 0,
i = 0;
// Unless we *know* we can detect duplicates, assume their presence
hasDuplicate = !support.detectDuplicates;
sortInput = !support.sortStable && results.slice( 0 );
results.sort( sortOrder );
if ( hasDuplicate ) {
while ( (elem = results[i++]) ) {
if ( elem === results[ i ] ) {
j = duplicates.push( i );
}
}
while ( j-- ) {
results.splice( duplicates[ j ], 1 );
}
}
// Clear input after sorting to release objects
// See https://github.com/jquery/sizzle/pull/225
sortInput = null;
return results;
};
/**
* Utility function for retrieving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/
getText = Sizzle.getText = function( elem ) {
var node,
ret = "",
i = 0,
nodeType = elem.nodeType;
if ( !nodeType ) {
// If no nodeType, this is expected to be an array
while ( (node = elem[i++]) ) {
// Do not traverse comment nodes
ret += getText( node );
}
} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
// Use textContent for elements
// innerText usage removed for consistency of new lines (jQuery #11153)
if ( typeof elem.textContent === "string" ) {
return elem.textContent;
} else {
// Traverse its children
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
ret += getText( elem );
}
}
} else if ( nodeType === 3 || nodeType === 4 ) {
return elem.nodeValue;
}
// Do not include comment or processing instruction nodes
return ret;
};
Expr = Sizzle.selectors = {
// Can be adjusted by the user
cacheLength: 50,
createPseudo: markFunction,
match: matchExpr,
attrHandle: {},
find: {},
relative: {
">": { dir: "parentNode", first: true },
" ": { dir: "parentNode" },
"+": { dir: "previousSibling", first: true },
"~": { dir: "previousSibling" }
},
preFilter: {
"ATTR": function( match ) {
match[1] = match[1].replace( runescape, funescape );
// Move the given value to match[3] whether quoted or unquoted
match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
if ( match[2] === "~=" ) {
match[3] = " " + match[3] + " ";
}
return match.slice( 0, 4 );
},
"CHILD": function( match ) {
/* matches from matchExpr["CHILD"]
1 type (only|nth|...)
2 what (child|of-type)
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
4 xn-component of xn+y argument ([+-]?\d*n|)
5 sign of xn-component
6 x of xn-component
7 sign of y-component
8 y of y-component
*/
match[1] = match[1].toLowerCase();
if ( match[1].slice( 0, 3 ) === "nth" ) {
// nth-* requires argument
if ( !match[3] ) {
Sizzle.error( match[0] );
}
// numeric x and y parameters for Expr.filter.CHILD
// remember that false/true cast respectively to 0/1
match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
// other types prohibit arguments
} else if ( match[3] ) {
Sizzle.error( match[0] );
}
return match;
},
"PSEUDO": function( match ) {
var excess,
unquoted = !match[6] && match[2];
if ( matchExpr["CHILD"].test( match[0] ) ) {
return null;
}
// Accept quoted arguments as-is
if ( match[3] ) {
match[2] = match[4] || match[5] || "";
// Strip excess characters from unquoted arguments
} else if ( unquoted && rpseudo.test( unquoted ) &&
// Get excess from tokenize (recursively)
(excess = tokenize( unquoted, true )) &&
// advance to the next closing parenthesis
(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
// excess is a negative index
match[0] = match[0].slice( 0, excess );
match[2] = unquoted.slice( 0, excess );
}
// Return only captures needed by the pseudo filter method (type and argument)
return match.slice( 0, 3 );
}
},
filter: {
"TAG": function( nodeNameSelector ) {
var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
return nodeNameSelector === "*" ?
function() { return true; } :
function( elem ) {
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
};
},
"CLASS": function( className ) {
var pattern = classCache[ className + " " ];
return pattern ||
(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
classCache( className, function( elem ) {
return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
});
},
"ATTR": function( name, operator, check ) {
return function( elem ) {
var result = Sizzle.attr( elem, name );
if ( result == null ) {
return operator === "!=";
}
if ( !operator ) {
return true;
}
result += "";
return operator === "=" ? result === check :
operator === "!=" ? result !== check :
operator === "^=" ? check && result.indexOf( check ) === 0 :
operator === "*=" ? check && result.indexOf( check ) > -1 :
operator === "$=" ? check && result.slice( -check.length ) === check :
operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
false;
};
},
"CHILD": function( type, what, argument, first, last ) {
var simple = type.slice( 0, 3 ) !== "nth",
forward = type.slice( -4 ) !== "last",
ofType = what === "of-type";
return first === 1 && last === 0 ?
// Shortcut for :nth-*(n)
function( elem ) {
return !!elem.parentNode;
} :
function( elem, context, xml ) {
var cache, outerCache, node, diff, nodeIndex, start,
dir = simple !== forward ? "nextSibling" : "previousSibling",
parent = elem.parentNode,
name = ofType && elem.nodeName.toLowerCase(),
useCache = !xml && !ofType;
if ( parent ) {
// :(first|last|only)-(child|of-type)
if ( simple ) {
while ( dir ) {
node = elem;
while ( (node = node[ dir ]) ) {
if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
return false;
}
}
// Reverse direction for :only-* (if we haven't yet done so)
start = dir = type === "only" && !start && "nextSibling";
}
return true;
}
start = [ forward ? parent.firstChild : parent.lastChild ];
// non-xml :nth-child(...) stores cache data on `parent`
if ( forward && useCache ) {
// Seek `elem` from a previously-cached index
outerCache = parent[ expando ] || (parent[ expando ] = {});
cache = outerCache[ type ] || [];
nodeIndex = cache[0] === dirruns && cache[1];
diff = cache[0] === dirruns && cache[2];
node = nodeIndex && parent.childNodes[ nodeIndex ];
while ( (node = ++nodeIndex && node && node[ dir ] ||
// Fallback to seeking `elem` from the start
(diff = nodeIndex = 0) || start.pop()) ) {
// When found, cache indexes on `parent` and break
if ( node.nodeType === 1 && ++diff && node === elem ) {
outerCache[ type ] = [ dirruns, nodeIndex, diff ];
break;
}
}
// Use previously-cached element index if available
} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
diff = cache[1];
// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
} else {
// Use the same loop as above to seek `elem` from the start
while ( (node = ++nodeIndex && node && node[ dir ] ||
(diff = nodeIndex = 0) || start.pop()) ) {
if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
// Cache the index of each encountered element
if ( useCache ) {
(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
}
if ( node === elem ) {
break;
}
}
}
}
// Incorporate the offset, then check against cycle size
diff -= last;
return diff === first || ( diff % first === 0 && diff / first >= 0 );
}
};
},
"PSEUDO": function( pseudo, argument ) {
// pseudo-class names are case-insensitive
// http://www.w3.org/TR/selectors/#pseudo-classes
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
// Remember that setFilters inherits from pseudos
var args,
fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
Sizzle.error( "unsupported pseudo: " + pseudo );
// The user may use createPseudo to indicate that
// arguments are needed to create the filter function
// just as Sizzle does
if ( fn[ expando ] ) {
return fn( argument );
}
// But maintain support for old signatures
if ( fn.length > 1 ) {
args = [ pseudo, pseudo, "", argument ];
return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
markFunction(function( seed, matches ) {
var idx,
matched = fn( seed, argument ),
i = matched.length;
while ( i-- ) {
idx = indexOf( seed, matched[i] );
seed[ idx ] = !( matches[ idx ] = matched[i] );
}
}) :
function( elem ) {
return fn( elem, 0, args );
};
}
return fn;
}
},
pseudos: {
// Potentially complex pseudos
"not": markFunction(function( selector ) {
// Trim the selector passed to compile
// to avoid treating leading and trailing
// spaces as combinators
var input = [],
results = [],
matcher = compile( selector.replace( rtrim, "$1" ) );
return matcher[ expando ] ?
markFunction(function( seed, matches, context, xml ) {
var elem,
unmatched = matcher( seed, null, xml, [] ),
i = seed.length;
// Match elements unmatched by `matcher`
while ( i-- ) {
if ( (elem = unmatched[i]) ) {
seed[i] = !(matches[i] = elem);
}
}
}) :
function( elem, context, xml ) {
input[0] = elem;
matcher( input, null, xml, results );
// Don't keep the element (issue #299)
input[0] = null;
return !results.pop();
};
}),
"has": markFunction(function( selector ) {
return function( elem ) {
return Sizzle( selector, elem ).length > 0;
};
}),
"contains": markFunction(function( text ) {
text = text.replace( runescape, funescape );
return function( elem ) {
return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
};
}),
// "Whether an element is represented by a :lang() selector
// is based solely on the element's language value
// being equal to the identifier C,
// or beginning with the identifier C immediately followed by "-".
// The matching of C against the element's language value is performed case-insensitively.
// The identifier C does not have to be a valid language name."
// http://www.w3.org/TR/selectors/#lang-pseudo
"lang": markFunction( function( lang ) {
// lang value must be a valid identifier
if ( !ridentifier.test(lang || "") ) {
Sizzle.error( "unsupported lang: " + lang );
}
lang = lang.replace( runescape, funescape ).toLowerCase();
return function( elem ) {
var elemLang;
do {
if ( (elemLang = documentIsHTML ?
elem.lang :
elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
elemLang = elemLang.toLowerCase();
return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
}
} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
return false;
};
}),
// Miscellaneous
"target": function( elem ) {
var hash = window.location && window.location.hash;
return hash && hash.slice( 1 ) === elem.id;
},
"root": function( elem ) {
return elem === docElem;
},
"focus": function( elem ) {
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
},
// Boolean properties
"enabled": function( elem ) {
return elem.disabled === false;
},
"disabled": function( elem ) {
return elem.disabled === true;
},
"checked": function( elem ) {
// In CSS3, :checked should return both checked and selected elements
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
var nodeName = elem.nodeName.toLowerCase();
return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
},
"selected": function( elem ) {
// Accessing this property makes selected-by-default
// options in Safari work properly
if ( elem.parentNode ) {
elem.parentNode.selectedIndex;
}
return elem.selected === true;
},
// Contents
"empty": function( elem ) {
// http://www.w3.org/TR/selectors/#empty-pseudo
// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
// but not by others (comment: 8; processing instruction: 7; etc.)
// nodeType < 6 works because attributes (2) do not appear as children
for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
if ( elem.nodeType < 6 ) {
return false;
}
}
return true;
},
"parent": function( elem ) {
return !Expr.pseudos["empty"]( elem );
},
// Element/input types
"header": function( elem ) {
return rheader.test( elem.nodeName );
},
"input": function( elem ) {
return rinputs.test( elem.nodeName );
},
"button": function( elem ) {
var name = elem.nodeName.toLowerCase();
return name === "input" && elem.type === "button" || name === "button";
},
"text": function( elem ) {
var attr;
return elem.nodeName.toLowerCase() === "input" &&
elem.type === "text" &&
// Support: IE<8
// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
},
// Position-in-collection
"first": createPositionalPseudo(function() {
return [ 0 ];
}),
"last": createPositionalPseudo(function( matchIndexes, length ) {
return [ length - 1 ];
}),
"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
return [ argument < 0 ? argument + length : argument ];
}),
"even": createPositionalPseudo(function( matchIndexes, length ) {
var i = 0;
for ( ; i < length; i += 2 ) {
matchIndexes.push( i );
}
return matchIndexes;
}),
"odd": createPositionalPseudo(function( matchIndexes, length ) {
var i = 1;
for ( ; i < length; i += 2 ) {
matchIndexes.push( i );
}
return matchIndexes;
}),
"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
var i = argument < 0 ? argument + length : argument;
for ( ; --i >= 0; ) {
matchIndexes.push( i );
}
return matchIndexes;
}),
"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
var i = argument < 0 ? argument + length : argument;
for ( ; ++i < length; ) {
matchIndexes.push( i );
}
return matchIndexes;
})
}
};
Expr.pseudos["nth"] = Expr.pseudos["eq"];
// Add button/input type pseudos
for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
Expr.pseudos[ i ] = createInputPseudo( i );
}
for ( i in { submit: true, reset: true } ) {
Expr.pseudos[ i ] = createButtonPseudo( i );
}
// Easy API for creating new setFilters
function setFilters() {}
setFilters.prototype = Expr.filters = Expr.pseudos;
Expr.setFilters = new setFilters();
tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
var matched, match, tokens, type,
soFar, groups, preFilters,
cached = tokenCache[ selector + " " ];
if ( cached ) {
return parseOnly ? 0 : cached.slice( 0 );
}
soFar = selector;
groups = [];
preFilters = Expr.preFilter;
while ( soFar ) {
// Comma and first run
if ( !matched || (match = rcomma.exec( soFar )) ) {
if ( match ) {
// Don't consume trailing commas as valid
soFar = soFar.slice( match[0].length ) || soFar;
}
groups.push( (tokens = []) );
}
matched = false;
// Combinators
if ( (match = rcombinators.exec( soFar )) ) {
matched = match.shift();
tokens.push({
value: matched,
// Cast descendant combinators to space
type: match[0].replace( rtrim, " " )
});
soFar = soFar.slice( matched.length );
}
// Filters
for ( type in Expr.filter ) {
if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
(match = preFilters[ type ]( match ))) ) {
matched = match.shift();
tokens.push({
value: matched,
type: type,
matches: match
});
soFar = soFar.slice( matched.length );
}
}
if ( !matched ) {
break;
}
}
// Return the length of the invalid excess
// if we're just parsing
// Otherwise, throw an error or return tokens
return parseOnly ?
soFar.length :
soFar ?
Sizzle.error( selector ) :
// Cache the tokens
tokenCache( selector, groups ).slice( 0 );
};
function toSelector( tokens ) {
var i = 0,
len = tokens.length,
selector = "";
for ( ; i < len; i++ ) {
selector += tokens[i].value;
}
return selector;
}
function addCombinator( matcher, combinator, base ) {
var dir = combinator.dir,
checkNonElements = base && dir === "parentNode",
doneName = done++;
return combinator.first ?
// Check against closest ancestor/preceding element
function( elem, context, xml ) {
while ( (elem = elem[ dir ]) ) {
if ( elem.nodeType === 1 || checkNonElements ) {
return matcher( elem, context, xml );
}
}
} :
// Check against all ancestor/preceding elements
function( elem, context, xml ) {
var oldCache, outerCache,
newCache = [ dirruns, doneName ];
// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
if ( xml ) {
while ( (elem = elem[ dir ]) ) {
if ( elem.nodeType === 1 || checkNonElements ) {
if ( matcher( elem, context, xml ) ) {
return true;
}
}
}
} else {
while ( (elem = elem[ dir ]) ) {
if ( elem.nodeType === 1 || checkNonElements ) {
outerCache = elem[ expando ] || (elem[ expando ] = {});
if ( (oldCache = outerCache[ dir ]) &&
oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
// Assign to newCache so results back-propagate to previous elements
return (newCache[ 2 ] = oldCache[ 2 ]);
} else {
// Reuse newcache so results back-propagate to previous elements
outerCache[ dir ] = newCache;
// A match means we're done; a fail means we have to keep checking
if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
return true;
}
}
}
}
}
};
}
function elementMatcher( matchers ) {
return matchers.length > 1 ?
function( elem, context, xml ) {
var i = matchers.length;
while ( i-- ) {
if ( !matchers[i]( elem, context, xml ) ) {
return false;
}
}
return true;
} :
matchers[0];
}
function multipleContexts( selector, contexts, results ) {
var i = 0,
len = contexts.length;
for ( ; i < len; i++ ) {
Sizzle( selector, contexts[i], results );
}
return results;
}
function condense( unmatched, map, filter, context, xml ) {
var elem,
newUnmatched = [],
i = 0,
len = unmatched.length,
mapped = map != null;
for ( ; i < len; i++ ) {
if ( (elem = unmatched[i]) ) {
if ( !filter || filter( elem, context, xml ) ) {
newUnmatched.push( elem );
if ( mapped ) {
map.push( i );
}
}
}
}
return newUnmatched;
}
function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
if ( postFilter && !postFilter[ expando ] ) {
postFilter = setMatcher( postFilter );
}
if ( postFinder && !postFinder[ expando ] ) {
postFinder = setMatcher( postFinder, postSelector );
}
return markFunction(function( seed, results, context, xml ) {
var temp, i, elem,
preMap = [],
postMap = [],
preexisting = results.length,
// Get initial elements from seed or context
elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
// Prefilter to get matcher input, preserving a map for seed-results synchronization
matcherIn = preFilter && ( seed || !selector ) ?
condense( elems, preMap, preFilter, context, xml ) :
elems,
matcherOut = matcher ?
// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
// ...intermediate processing is necessary
[] :
// ...otherwise use results directly
results :
matcherIn;
// Find primary matches
if ( matcher ) {
matcher( matcherIn, matcherOut, context, xml );
}
// Apply postFilter
if ( postFilter ) {
temp = condense( matcherOut, postMap );
postFilter( temp, [], context, xml );
// Un-match failing elements by moving them back to matcherIn
i = temp.length;
while ( i-- ) {
if ( (elem = temp[i]) ) {
matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
}
}
}
if ( seed ) {
if ( postFinder || preFilter ) {
if ( postFinder ) {
// Get the final matcherOut by condensing this intermediate into postFinder contexts
temp = [];
i = matcherOut.length;
while ( i-- ) {
if ( (elem = matcherOut[i]) ) {
// Restore matcherIn since elem is not yet a final match
temp.push( (matcherIn[i] = elem) );
}
}
postFinder( null, (matcherOut = []), temp, xml );
}
// Move matched elements from seed to results to keep them synchronized
i = matcherOut.length;
while ( i-- ) {
if ( (elem = matcherOut[i]) &&
(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
seed[temp] = !(results[temp] = elem);
}
}
}
// Add elements to results, through postFinder if defined
} else {
matcherOut = condense(
matcherOut === results ?
matcherOut.splice( preexisting, matcherOut.length ) :
matcherOut
);
if ( postFinder ) {
postFinder( null, results, matcherOut, xml );
} else {
push.apply( results, matcherOut );
}
}
});
}
function matcherFromTokens( tokens ) {
var checkContext, matcher, j,
len = tokens.length,
leadingRelative = Expr.relative[ tokens[0].type ],
implicitRelative = leadingRelative || Expr.relative[" "],
i = leadingRelative ? 1 : 0,
// The foundational matcher ensures that elements are reachable from top-level context(s)
matchContext = addCombinator( function( elem ) {
return elem === checkContext;
}, implicitRelative, true ),
matchAnyContext = addCombinator( function( elem ) {
return indexOf( checkContext, elem ) > -1;
}, implicitRelative, true ),
matchers = [ function( elem, context, xml ) {
var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
(checkContext = context).nodeType ?
matchContext( elem, context, xml ) :
matchAnyContext( elem, context, xml ) );
// Avoid hanging onto element (issue #299)
checkContext = null;
return ret;
} ];
for ( ; i < len; i++ ) {
if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
} else {
matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
// Return special upon seeing a positional matcher
if ( matcher[ expando ] ) {
// Find the next relative operator (if any) for proper handling
j = ++i;
for ( ; j < len; j++ ) {
if ( Expr.relative[ tokens[j].type ] ) {
break;
}
}
return setMatcher(
i > 1 && elementMatcher( matchers ),
i > 1 && toSelector(
// If the preceding token was a descendant combinator, insert an implicit any-element `*`
tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
).replace( rtrim, "$1" ),
matcher,
i < j && matcherFromTokens( tokens.slice( i, j ) ),
j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
j < len && toSelector( tokens )
);
}
matchers.push( matcher );
}
}
return elementMatcher( matchers );
}
function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
var bySet = setMatchers.length > 0,
byElement = elementMatchers.length > 0,
superMatcher = function( seed, context, xml, results, outermost ) {
var elem, j, matcher,
matchedCount = 0,
i = "0",
unmatched = seed && [],
setMatched = [],
contextBackup = outermostContext,
// We must always have either seed elements or outermost context
elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
// Use integer dirruns iff this is the outermost matcher
dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
len = elems.length;
if ( outermost ) {
outermostContext = context !== document && context;
}
// Add elements passing elementMatchers directly to results
// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
// Support: IE<9, Safari
// Tolerate NodeList properties (IE: "length"; Safari: