jsTree搜索排序向上向下

  1 var _node = null, _all_match = 0, _current_match = 0;
  2 $(document).ready(function() {
  3     $(‘#area_setting_ou_tree‘).jstree({
  4         ‘core‘ : {
  5             ‘data‘ : {
  6                 "url" : "url",
  7                 "method" : "POST",
  8                 "dataType" : "json"
  9             },
 10             "multiple" : false,
 11             "check_callback" : true,
 12             "animation" : 0
 13         },
 14         ‘plugins‘: [
 15             "sort",
 16             "search",
 17             "types"
 18         ],
 19         ‘sort‘ : function(a, b) {
 20             return this.get_type(a) === this.get_type(b) ? (this.get_text(a) > this.get_text(b) ? 1 : -1) : (this.get_type(a) >= this.get_type(b) ? 1 : -1);
 21         },
 22         ‘search‘ : {
 23             ‘search_leaves_only‘ : true,
 24             ‘search_callback‘ : function(string,node){
 25                 if(string !== ‘‘ && node.type === ‘staff‘ && node.text.toLocaleLowerCase().match(string.toLocaleLowerCase())) {
 26                     _instance.open_all();
 27                     $(‘#‘ + node.id).addClass(‘jstree-search‘);
 28                 }else {
 29                     $(‘#‘ + node.id).removeClass(‘jstree-search‘);
 30                 }
 31             }
 32         },
 33         ‘types‘ : {
 34             "staff" : {
 35                 "icon" : "url"
 36             },
 37             "ou_end" : {
 38                 "icon" : "url"
 39             },
 40             "ou_not_end" : {
 41                 "icon" : "url"
 42             }
 43         }
 44     }).on(‘search.jstree‘, function() {
 45         var _selected_node = $(‘#area_setting_ou_tree ul li .jstree-search‘);
 46         if(_selected_node.length === 0) return;
 47
 48         var _instance =  $(‘#area_setting_ou_tree‘).jstree(true);
 49
 50         _all_match = _selected_node.length;
 51         $(‘#all_selected‘).text(_all_match);
 52         _current_match = 1;
 53         $(‘#current_selected‘).text(_current_match);
 54
 55         var node_id = ‘‘;
 56         _selected_node.each(function(index, dom) {
 57             node_id = $(this).attr(‘id‘);
 58             if(index === 0) {
 59                 _instance.select_node(node_id);
 60                 $(‘#‘ + node_id).addClass(‘jstree-search‘);
 61                 location.hash = ‘#‘ + node_id;
 62             }
 63             _node.add(node_id);
 64         });
 65     });
 66
 67     var _instance =  $(‘#area_setting_ou_tree‘).jstree(true);
 68     /*
 69      * search event for Tree
 70      */
 71     var area_setting_ou_tree_to = false;
 72     $(‘#area_setting_ou_tree_search‘).keyup(function () {
 73         setTimeout(function() {
 74             _all_match = 0;
 75             _current_match = 0;
 76             $(‘#current_selected‘).text(0);
 77             $(‘#all_selected‘).text(0);
 78             $(‘#area_set_main‘).html(‘‘);
 79             _node = null;
 80             _node = new DoubleLinkedList();
 81             var _instance =  $(‘#area_setting_ou_tree‘).jstree(true);
 82             _instance.deselect_all();
 83             $(‘#selected_message‘).css(‘visibility‘,‘visible‘);
 84             $(‘#pre_selected‘).prop(‘disabled‘,false);
 85             $(‘#next_selected‘).prop(‘disabled‘,false);
 86
 87             if(area_setting_ou_tree_to) { clearTimeout(area_setting_ou_tree_to); }
 88             area_setting_ou_tree_to = setTimeout(function () {
 89                 var company_department_tree_search_val = $(‘#area_setting_ou_tree_search‘).val();
 90                 $(‘#area_setting_ou_tree‘).jstree(true).search(company_department_tree_search_val);
 91             }, 250);
 92
 93             if($(‘#area_setting_ou_tree_search‘).val() === ‘‘) {
 94                 $(‘#selected_message‘).css(‘visibility‘,‘hidden‘);
 95                 $(‘#pre_selected‘).prop(‘disabled‘,true);
 96                 $(‘#next_selected‘).prop(‘disabled‘,true);
 97                 $(‘.jstree-search‘).removeClass(‘jstree-search‘);
 98                 $(‘#area_set_main‘).html(‘‘);
 99             }
100         }, 200);
101     });
102
103     /*
104      *   next step  for Tree
105      */
106     $(‘#next_selected‘).on(‘click‘, function(){
107         if(_node.size() === 0) return;
108         var _instance = $(‘#area_setting_ou_tree‘).jstree(true);
109
110         // selected node is not search results
111         var _current_selected = null;
112         if(_node.find(_instance.get_selected()[0])) {
113             _current_selected = _node.find(_instance.get_selected()[0]);
114         } else {
115             _current_selected = _node.getHead();
116             _current_match = 0;
117         }
118
119         if(_current_selected.next) {
120             var _temp = _current_selected.next.element;
121             _instance.deselect_all();
122             _instance.select_node(_temp);
123             location.hash = ‘#‘ + _temp;
124             showInstitutionByClickTree(_instance.get_type(_temp), _temp);
125             _current_match += 1;
126             $(‘#current_selected‘).text(_current_match);
127         } else {
128             //跳转到第一个
129             _current_match = 1;
130             var _temp = _node.getHead().next.element;
131             _instance.deselect_all();
132             _instance.select_node(_temp);
133             location.hash = ‘#‘ + _temp;
134             //showInstitutionByClickTree(_instance.get_type(_temp), _temp);
135             $(‘#current_selected‘).text(_current_match);
136         }
137
138     });
139     /*
140      *   previous step for Tree
141      */
142     $(‘#pre_selected‘).on(‘click‘, function(){
143         if(_node.size() === 0) return;
144         var _instance = $(‘#area_setting_ou_tree‘).jstree(true);
145
146         // selected node is not search results
147         var _current_selected = null;
148         if(!_node.find(_instance.get_selected()[0])) {
149             _current_selected = _node.findLast();
150             _current_match = _node.size();
151             var _temp = _current_selected.element;
152             _instance.deselect_all();
153             _instance.select_node(_temp);
154             location.hash = ‘#‘ + _temp;
155             showInstitutionByClickTree(_instance.get_type(_temp), _temp);
156             $(‘#current_selected‘).text(_current_match);
157             return;
158         }
159
160         _current_selected = _node.find(_instance.get_selected()[0]);
161         if(_current_selected.previous !=  _node.getHead()) {
162             var _temp = _current_selected.previous.element;
163             _instance.deselect_all();
164             _instance.select_node(_temp);
165             _current_match -= 1;
166             $(‘#current_selected‘).text(_current_match);
167         } else {
168             //跳转到最后一个
169             _current_selected = _node.findLast();
170             _current_match = _node.size();
171             var _temp = _current_selected.element;
172             _instance.deselect_all();
173             _instance.select_node(_temp);
174             $(‘#current_selected‘).text(_current_match);
175         }
176     });
177 });    

双链表

 1 function Node(element){
 2     this.element = element;
 3     this.next = null;
 4     this.previous = null;
 5 }
 6
 7 function DoubleLinkedList(){
 8     this._head = new Node("This is Head Node.");
 9     this._size = 0;
10 }
11
12 DoubleLinkedList.prototype.getHead = function(){
13     return this._head;
14 };
15
16 DoubleLinkedList.prototype.isEmpty = function(){
17     return this._size === 0;
18 };
19
20 DoubleLinkedList.prototype.size = function(){
21     return this._size;
22 };
23
24 DoubleLinkedList.prototype.findLast = function(){
25     var currNode = this.getHead();
26     while(currNode.next){
27         currNode = currNode.next;
28     }
29     return currNode;
30 };
31
32 DoubleLinkedList.prototype.add = function(item){
33     if(item == null)
34         return null;
35     this.insert(item);
36 };
37
38 DoubleLinkedList.prototype.remove = function(item){
39     if(item) {
40         var node = this.find(item);
41         if(node == null)
42             return ;
43         if (node.next === null) {
44             node.previous.next = null;
45             node.previous = null;
46         } else{
47             node.previous.next = node.next;
48             node.next.previous = node.previous;
49             node.next = null;
50             node.previous = null;
51         }
52         this._size--;
53     }
54 };
55
56 DoubleLinkedList.prototype.find = function(item){
57     if(item == null)
58         return null;
59     var currNode = this.getHead();
60     while(currNode && currNode.element !== item){
61         currNode = currNode.next;
62     }
63     return currNode;
64 };
65
66 DoubleLinkedList.prototype.insert = function(newElement, item){
67     var newNode = new Node(newElement);
68     var finder = item ? this.find(item) : null;
69     if(!finder){
70         var last = this.findLast();
71         newNode.previous = last;
72         last.next = newNode;
73     }
74     else{
75         newNode.next = finder.next;
76         newNode.previous = finder;
77         finder.next.previous = newNode;
78         finder.next = newNode;
79     }
80     this._size++;
81 };
82
83 DoubleLinkedList.prototype.dispReverse = function(){
84     var currNode = this.findLast();
85     while(currNode != this.getHead()){
86         console.log(currNode.element);
87         currNode = currNode.previous;
88     }
89 };
90
91 DoubleLinkedList.prototype.display = function(){
92     var currNode = this.getHead().next;
93     while(currNode){
94         console.log(currNode.element);
95         currNode = currNode.next;
96     }
97 };

jstree:版本号-3.0.9

API地址:https://www.jstree.com/api/

数据:ajax后台生成

数据结构:双链表

时间: 2024-10-11 05:18:34

jsTree搜索排序向上向下的相关文章

2.25 Java基础总结 ①多态②向上向下转型③instanceof

①多态②向上向下转型③instanceof 一.多态即相同行为,不同实现有两种方法:重载和重写分类:①静态多态:编译时已经确定效果,所用重载实现(不是指static)②动态多态:编译未知,运行已知(使用动态绑定和重写实现) 动态绑定:父类的引用指向子类的对象,执行相应的子类方法,而不是父类的,从而实现多态性 二.向上转型,向下转型向上转型:一个父类的引用可以指向不同的子类对象,或者说一个子类的对象可以被当做一个父类类型低精度向高精度转pet = cat;自动转,子类向父类 向下转型:强制转,有很

这就是搜索引擎--读书笔记八--检索模型与搜索排序

检索模型与搜索排序 前言 搜索结果排序是搜索引擎最核心的构成部分,很大程度上决定了搜索引擎的质量好坏以及用户接受与否.尽管搜索引擎在实际结果排序时融合了上百种排序因子,但最重要的两个因素还是用户查询和网页的内容相关性及网页链接情况.那么,我们得到用户搜索词之后,如何从内容相关性的角度上对网页进行排序输出呢? 判断网页内容是否与用户查询相关,这依赖于搜索引擎所采用的检索模型.搜索引擎的核心是判断哪些文档是和用户需求相关的,并按照相关程度排序输出,所以相关程度计算是将用户查询和文档进行匹配的过程,而

向上向下取整、舍入

向下取整 floor (地板) import math math.floor(-2.2) # -3.0 math.floor(2.2) # 2.0 向上取整 ceil (天花板) import math  math.ceil(-2.2) # -2.0 math.ceil(2.2) # 3.0 舍入 round round(2.24, 1) # 2.2 round(2.26, 1) # 2.3 向上向下取整.舍入,布布扣,bubuko.com

凭证转换规则分录类别定义向上向下按钮

1.凭证转换规则分录类别定义向上向下按钮  2.信息补录增加联查单据功能 3.付款结算查询时作废过滤不起作用问题 4.信息补录单  增加 Excel导出功能 来自为知笔记(Wiz)

向上/向下取整和四舍五入编程实现

在看Guava Cache的实现源码时,其中有个向上取整操作,它的源码如下: int segmentCapacity = initialCapacity / segmentCount; if (segmentCapacity * segmentCount < initialCapacity) {   ++segmentCapacity; } 关于向上取整.向下取整.四舍五入等操作,有不同的实现,效率上讲,也是基本可以忽略不计,毕竟用的比较少,这里对向上/向下取整和四舍五入的编程实现进行一下整理.

从向上向下转型到----抽象类接口(一)

对象的多态性-向上向下转型 向上转型:子类对象变为父类对象,格式:父类 父类对象 = 子类实例,自动转换; 向下转型:父类对象变为子类对象,格式:子类 子类对象 = (子类) 父类实例,强制转换; 注意:对象的多态性和方法复写是联系在一起的 向上转型: class A{ public void print(){ System.out.println("a") } } class B extends A{ public void print(){ System.out.println(&

Yii CGridView 关联表搜索排序实例

在这篇文章中,我准备讲解如何在CGridView中搜索或者排序关联表中的某一行,通过给Yii Blog demo添加一个list页面. 首先,检查你的blog demo里的protected\models\Comment.php,确保Comment模型有一个search的方法,如果没有,就用gii生成一个,我下载到的blog demo里倒是没有. 然后,写代码的时间到了,我们从 CommentController 开始,我们给它加一个 actionList: 1 2 3 4 5 6 7 8 9

js实现table排序(jQuery下的jquery.sortElements)

项目中要实现table排序的功能. 网上有非常多解决方式,非常多都基于jQuery. jquery.tablesorter.大小17KB.只是他的首页在ie10下兼容性有点问题. DataTables,大小75KB.功能强大,带分页,搜索等功能. 还有插件叫sortElements,非常小巧.仅仅有3KB.兼容性也不错.并且在Github上有818个星. 最后我选择用sortElements,实现非常easy: 1. 引入jQuery <script type="text/javascri

自定义类签发校验token-实现多方式登录-自定义反爬类-admin后台表管理字段自定义-群查接口-搜索-排序-分页

目录 复习 今日 签发token 校验token 案例:实现多方式登陆签发token 案例:自定义认证反爬规则的认证类 admin使用自定义User表:新增用户密码密文 群查接口各种筛选组件数据准备 drf搜索过滤组件 drf排序过滤组件 drf基础分页组件 复习 """ 频率组件:限制接口的访问频率 源码分析:初始化方法.判断是否有权限方法.计数等待时间方法 自定义频率组件: class MyThrottle(SimpleRateThrottle): scope = 'sm