jQuery实现表格拖动排序

by admin on 2018年11月14日

 
以专业进入scalaz讨论前我们要理顺一些基础的scalaz结构成概念以及技艺。scalaz是出于任意多态(ad-hoc
polymorphism)类型(typeclass)组成。scalaz
typeclass在scala中之应用有赖于scala
compiler的同样起特别效果:隐式转换(implicit
conversion),使程序表述还简单。由于隐式转换是一样项compiler功能,在先后编译(compile)的时候是由compiler来进展类型转换代码的有及代表的。

原理就是下mousedown、mouseover、mouseup事件实现拖动,并因而Ajax实现保存结果。

 
让咱们事先了解一下作用域(scope)和绑定(binding)。这半样还是在编译程序时compiler需要解决的题材。所谓作用域解析(scope
resolution)就是一旦确定一个绑定在一个意域里是可视的,否则程序无法透过编译。

JS代码如下:

作用域就是一个绑定以一个次范围外的可视型。作用域可以是有类的中还是是某个方法还是函数的其中,基本上用{}就好创造一个初的作用域了。在scala作用域可以是多重叠的,一个域得是叫其他一个意向域内。外部域的绑定在其间域内是可视的,反的则不然:

图片 1图片 2

1 class Foo(x: Int) {
2   def temp = {
3     val y = x + 1  //x是本地域外的一个绑定
4   }  
5 }
<!--题目调序功能-->
<script type="text/javascript">
    var moveStart = false; //是否开始移动
    var curTr; //待移动的tr
    var tarTr; //目标tr

    _run(function () {
        //鼠标按下
        $("#tableDataList").find("tr").find("td:not(:last)").mousedown(function () {
            moveStart = true;
            curTr = $(this).parent();
            curTr.find("td").addClass("highlightTd");
            curTr.addClass("pointer");
        });

        //鼠标移入
        $("#tableDataList").find("tr").mouseover(function () {
            var ch = "input[type='checkbox']";
            if (moveStart == true && curTr.find(ch).attr("subid") != $(this).find(ch).attr("subid")) {
                if (curTr.offset().top > $(this).offset().top) { //上移
                    tarTr = $(this);
                    tarTr.focus();
                    tarTr.before(curTr);
                }
                else { //下移
                    tarTr = $(this);
                    tarTr.focus();
                    tarTr.after(curTr);
                }
            }
        });

        //鼠标移出
        $("#tableDataList").find("tr").mouseup(function () {
            if (moveStart == true) {
                moveStart = false;
                curTr.find("td").removeClass("highlightTd");
                curTr.removeClass("pointer");

                var subjectIds = ""; //存储ID集合
                $("#tableDataList").find("input[type='checkbox'][id!='checkAll']").each(function () {
                    subjectIds += $(this).attr("subId") + ",";
                });
                if (subjectIds != "") {
                    //Ajax请求保存数据
                    $.ajax({
                        type: "POST",
                        url: "#{ChangeSubjectsSortUrl}",
                        data: "subjectIds=" + subjectIds.substr(0, subjectIds.length - 1), //传参
                        success: function (data) {
                            if (data == "ok") {
                                var i = 0;
                                $("#tableDataList").find("tr:not(:first)").each(function () {
                                    i++;
                                    $(this).find("td:eq(3)").html(i); //更新题目序号显示
                                });
                            }
                        }
                    });
                }
            }
        });
    });
</script>

每当上述之例证里x在temp{}内是可视的。一个作用域内之绑定好屏蔽(shadow)外域定义的绑定:

View Code

 

HTML代码如下(说明:框架会活动把<!– BEGIN list –>和<!– END
list –>之间的情绑定为列表):

1 class Foo(x: Int) {
2   def temp = {
3     val x = 0      //本地域绑定。屏蔽了外域的x
4     val y = x + 1  //y=1,x是本地域的一个绑定
5   }  
6 }

图片 3图片 4

 

<div class="Activity_Select_Index_Con">
    <b class="Activity_Select_Index_Title">题目 <a href="#{viewAllLink}" title="预览所有题目"
        class="frmBox">
        <img src="~img/edit.gif" />预览问卷</a> <a href="#{addLink}" title="添加题目" class="frmLink"
            loadto="divEdit" nolayout="999">
            <img src="~img/add.gif" />添加</a> <a href="javascript:void(0);" onclick="batchDeleteClick()">
                <img src="~img/delete.gif" />
                删除</a></b>
    <div class="SIMPO_Table" style="width: 100%">
        <table id="tableDataList" border="0" cellspacing="0" cellpadding="0" style="-moz-user-select: none;"
            onselectstart="javascript:return false;">
            <tr>
                <th width="36">
                    <input type="checkbox" name="checkbox" id="checkAll" onclick="checkAllClick(this)" />
                </th>
                <th width="131">
                    <b>题目名称</b>
                </th>
                <th width="131">
                    <b>题目类型</b>
                </th>
                <th width="114">
                    <b>题目顺序</b>
                </th>
                <th width="114">
                    <b>题目分值</b>
                </th>
                <th width="100" align="center">
                    <b>操作</b>
                </th>
            </tr>
            <!-- BEGIN list -->
            <tr>
                <td align="center" valign="middle">
                    <input type="checkbox" name="checkbox" id="checkbox" subid="#{edu_QnSubject.Id}" />
                </td>
                <td align="center" valign="middle">
                    <a href="#{PreviewItemLink}" class="SIMPO_Table_Name frmBox">#{edu_QnSubject.Title}</a>
                </td>
                <td align="center" valign="middle">
                    #{edu_QnSubject.TypeId}
                </td>
                <td align="center" valign="middle">
                    #{edu_QnSubject.Sort}
                </td>
                <td align="center" valign="middle">
                    #{edu_QnSubject.Score}
                </td>
                <td align="center" valign="middle">
                    <a href="#{edu_QnSubject.EditLink}" title="修改题目" class="frmLink" loadto="divEdit"
                        nolayout="999">
                        <img src="~img/edit.gif" />修改</a> <a href="javascript:void(0)" onclick="delSubject(this)">
                            <img src="~img/delete.gif" />删除</a>
                    <form name="frmDelete" method="post" action="#{edu_QnSubject.DeleteLink}">
                    <input type="hidden" name="templateId" value="#{templateId}" />
                    </form>
                </td>
            </tr>
            <!-- END list -->
        </table>
    </div>
</div>

绑定屏蔽是分优先次序如下:

View Code

1、本地声明、定义或者经过继承又或当同一源代码文件内之package定义的绑定最优先

Controller代码如下:

2、明式申明的import如:import
obj.Foo 所定义之绑定潮优先

图片 5图片 6

3、通配符式的import如:import
obj._ 所定义之绑定再次之

/// <summary>
/// 调整题目顺序
/// </summary>
public void ChangeSubjectsSort(int templateId)
{
    string subjectIds = ctx.Post("subjectIds");
    string[] subjectIdArray = subjectIds.Split(',');
    for (int i = 0; i < subjectIdArray.Length; i++)
    {
        Edu_QnSubject qnSubject = edu_QnSubjectService.findById<Edu_QnSubject>(int.Parse(subjectIdArray[i]));
        qnSubject.Sort = i + 1;
        Result result = edu_QnSubjectService.update(qnSubject); //保存
    }
    echoText("ok");
}

4、同一package但处于不同源代码文件内之绑定最次优先

View Code

我们所以个例证来示范scope
binding的预顺序:

 效果图(静态图片看不到动态效果,这里表示一下):

 1 package test;
 2 
 3 // This object contains the bindings/scope tests
 4 object Test {
 5 
 6   def main(arg : Array[String]) : Unit = {
 7     testSamePackage()
 8     testWildcardImport()
 9     testExplicitImport()
10     testInlineDefinition()
11   }
12 
13   // This looks for a binding 'x' within the same package (test) as this scope.
14   def testSamePackage() {
15      println(x)  // 在另外文件的test package. prints: Externally bound x object in package test
16   }
17 
18   // This defines a new scope with an 'x' binding that we can import with a wildcard.
19   object Wildcard {
20     def x = "Wildcard Import x"
21   }
22 
23   // This function will print the value in the binding 'x' after importing from the Wildcard object
24   // using a wildcard import.
25   def testWildcardImport() {
26     import Wildcard._
27     println(x)  // prints: Wildcard Import x
28   }
29 
30   // This defines another binding of 'x' that we can import explicitly.
31   object Explicit {
32     def x = "Explicit Import x"
33   }
34 
35   def testExplicitImport() {
36     import Explicit.x  
37     import Wildcard._
38     println(x)  // .x优先于._  prints: Explicit Import x
39   }
40 
41   // This defines an inline binding for x.  Note that with all the imports, there are no ambiguous naming conflicts.
42   def testInlineDefinition() {
43     val x = "Inline definition x" //即使写在最前,本地binding x还是最优先
44     import Explicit.x
45     import Wildcard._
46     println(x)  // prints:  Inline definition x
47   }
48 }

图片 7

 

scala compiler
在编译程序时会见根据事态自行进行隐式转换,即代码替代。在少种植状态下scala会进行隐蔽转换:

1、在盼一个种类的地方发现了另外一个类别:

 1 package learn.scalaz
 2 object ab {
 3  class A
 4  class B
 5  implicit def bToA(x: B): A = new A
 6 }
 7 object testApp extends App {
 8   import ab._
 9   val a: A = new B  //需要进行B => A的隐式转换
10 }

以此间由于A类和B类没有外继承关系,应该无法透过编译,但scala
compiler会首先尝试寻找B=>A的隐式转换实例,当找到bToA函数时compiler会把new
B替代成bToA(new B),如此这般才能够透过编译。

 

 

2、当一个列并无支持有方法时:

 

 

 1 package learn.scalaz
 2 object ab {
 3  class A {
 4    def printA = println("I am A")   
 5  }
 6  class B
 7  implicit def bToA(x: B): A = new A
 8 }
 9 object testApp extends App {
10   import ab._
11   (new B).printA   //需要进行B => A的隐式转换
12 }

 

scala compiler
在隐式转换中之隐式解析(implicit
resolution)会用以下的方针来找标示为implicit的实例:

1、能作用域解析的莫带前缀的隐式绑定即:如Bar,而Foo.Bar则无符合要求

这个在上述之例子里早已示范证明了。

2、如果上述措施无法解析隐式转换的话compiler会搜寻目标项目的隐式作用域(implicit
scope)内任何对象中的隐式转换。一个档的隐式作用域(implicit
scope)包括了关系这个项目的有所伴生模块(companion
module)内定义的隐式转换。例如:

def foo(implicit p:
Foo),这个措施的参数必须是Foo类型。如果compiler无法进行作用域解析的语虽必找隐式作用域内之相当隐式转换。比如Foo的伴生对象(companion
object),如下:

 1 object demo {
 2  object Container {
 3    trait Foo
 4    object Foo {
 5          implicit def x = new Foo {
 6             override def toString = "implicit x"
 7         }
 8    }
 9  }
10  import Container._
11  def foo(implicit p: Foo) = println(p)            //> foo: (implicit p: scalaz.learn.ex1.Container.Foo)Unit
12  foo                                              //> implicit x

compiler在object
Foo内找到了配合的隐式转换,程序通过了编译。

由compiler会首先进行作用域解析,失败后才找隐式转换作用域,所以我们可拿部分默认隐式转换放到隐式作用域里。然后另外编程人员可以经过import来覆载(override)使用他们友善之隐式转换。

综上所述以上所述:一个类型T的隐式作用域就是做是项目的所有类的伴生对象(companion
object)。也就是说,T的形成有或涉及到同组项目。在进行隐式转换解析过程中,compiler会搜寻这些品种的伴生对象。类型T的一部分如下:

1、所有类型T的父类:

 1 object demo {
 2  object Container {
 3    trait A
 4    trait B
 5    class T extends A with B
 6    object A {
 7     implicit def x = new T {
 8             override def toString = "implicit x"
 9         }
10    }
11  }
12  import Container._
13  def foo(implicit p: T) = println(p)            //> foo: (implicit p: scalaz.learn.demo.Container.Foo)Unit
14  foo                                              //> implicit x

花色T由A,B组成。compiler从A的伴生对象吃分析及隐式转换。

2、如果T是参数化类型,那么所有项目参数的重组类型及包嵌类的重组类型的伴生对象都以隐式转换解析域中。如在解析List[String]被,所有List和String的伴生对象还以解析域中:

 

 1 object demo {
 2  object Container {
 3    trait A
 4    trait B
 5    class T[A]
 6    object A {
 7     implicit def x = new T[A] {
 8             override def toString = "implicit x"
 9         }
10    }
11  }
12  import Container._
13  def foo(implicit p: T[A]) = println(p)           //> foo: (implicit p: scalaz.learn.demo.Container.T[scalaz.learn.demo.Container.
14                                                   //| A])Unit
15  foo                                              //> implicit x

 

A是T[A]的类参数。compiler从A的伴生对象中剖析及隐式转换。

3、如果T是个单例对象(singleton
object),那么T的包嵌对象(container object)就是解析域:

 

 1 object demo {
 2  object Container {
 3    object T {
 4      def x = "singleton object T"
 5    }
 6    implicit def x =  T 
 7  }
 8  import Container._
 9  def foo(implicit p: T.type) = println(p.x)       //> foo: (implicit p: scalaz.learn.demo.Container.T.type)Unit
10  foo                                              //> singleton object T

 

单例对象T定义于包嵌对象Container内。compiler从Container中分析到隐式转换。

马上是一样首隐式转换解析原理的座谈,不见面指向scala有关隐式转换语法和调用做另外解释,希望读者体谅。

 

 

 

 

 

 

 

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图