ExtJs 核心函数简介

1.ExtJs提供的常用函数
2.get、fly、getCmp、getDom、getBody、getDoc
3.query函数和select函数
4.encode函数和decode函数
5.Ext.each函数
6.Ext.util.Format对数据进行格式化
7.Ext.util.TaskRunner
8.update方法局部更新网页内容

Ext中包含了几个以get开头的方法,这些方法可以用来得到文档中DOM、得到当前文档中的组件、得到Ext元素等,在使用中要注意区别使用
1、get方法
        get方法用来得到一个Ext元素,也就是类型为Ext.Element的对象,

Ext.Element类是Ext对DOM的封装,代表DOM的元素,可以为每一个DOM创建一个对应的Element对象,

可以通过Element对象上的方法来实现对DOM指定的操作,比如用hide方法可以隐藏元素

initDD方法可以让指定的DOM具有拖放特性等。get方法其实是Ext.Element.get的简写形式。
          get方法中只有一个参数,这个参数是混合参数,可以是DOM节点的id、也可以是一个Element、或者是一个DOM节点对象等。看下面的示例代码:

Ext.onReady(function(){

var e=new Ext.Element(“oa");

alert(Ext.get(“oa"));

alert(Ext.get(document.getElementById(“oa")));

alert(Ext.get(e));});

Html页面中包含一个id为oa的div,

代码如下:<div id=“oa">myoffice</div>

Ext.get(“oa")、Ext.get(document.getElementById(“oa"))、Ext.get(e)等三个方法都可以得到一个与DOM节点hello对应的Ext元素。

二: 1. Ext.fly和Ext.get

Ext.fly在参数方面与Ext.get的完全相同,但其内置控制返回Ext.Element的方法就完全不同,

Ext.fly从不保存享元对象的引用,每次调用方法都返回独立的享元对象。

其实区别在于“缓存”中,因为缓存的缘故,Ext.get需要为每个元素保存其引用,就形成了缓存,

如果有相同的调用就返回,但Ext.fly没有所谓的缓存机制,得到什么就返回什么,

不是多次使用的情况下“一次性地”使用该元素就应该使用Ext.fly(例如执行单项的任务)。

使用Ext.fly的例子:
        // 引用该元素一次即可,搞掂了就完工
        Ext.fly('elId').hide();
2、getCmp方法-获得Ext组件。
         getCmp方法用来获得一个Ext组件,也就是一个已经在页面中初始化了的Component或其子类的对象,

getCmp方法其实是Ext.ComponentMgr.get方法的简写形式。getCmp方法中只有一个参数,也就是组件的id。比如下面的代码:

Ext.onReady(function(){
var h=new Ext.Panel({
id:"h2",title:" ",renderTo:"hello",width:300,height:200});
Ext.getCmp("h2").setTitle("新的标题");
});
在代码中,我们使用Ext.getCmp("h2").来得到id为h2的组件,
并调用其setTitle方法来设置该面板的标题。

3、getDom方法-获得DOM节点

getDom方法能够得到文档中的DOM节点,该方法中包含一个参数,该参数可以是DOM节点的id、DOM节点对象或DOM节点对应的Ext元素(Element)等。比如下面的代码:

Ext.onReady(function(){
var e=new Ext.Element("hello");
Ext.getDom("hello");
Ext.getDom(e);
Ext.getDom(e.dom);});
Html:<div id="hello">tttt</div>
在上面的代码中,Ext.getDom("hello")、Ext.getDom(e)、Ext.getDom(e.dom)等三个语句返回都是同一个DOM节点对象。

4、getBody方法-得到文档的body节点元素(Element)。

该方法直接得到文档中与document.body这个DOM节点对应的ExtJS元素(Element),实质就是把document.body对象封装成ExtJS元素对象返回,该方法不带任何参数。比如下面的代码把面板h直接渲染到文档的body元素中。

 Ext.onReady(function(){
var h=new Ext.Panel({title:"测试",width:300,height:200});
h.render(Ext.getBody());
});

5、getDoc方法-获得与document对应的Ext元素(Element)

getDoc方法实质上就是把当前html文档对象,也就是把document对象封装成ExtJS的Element对象返回,该方法不带任何参数。

6.Ext.query函数和Ext.select函数批量获取元素

语法:
query( String path, Node root ) : Array 选定一个通过CSS/XPath选择符获取的DOM节点组成的数组。
选定一个通过CSS/XPath选择符获取的DOM节点组成的数组。Ext.DomQueryselect的简写方式。 参数项:
path : String 查询时使用的 XPath 或选择符
root : Node (可选)查询的起点(默认为 document)。
返回值:
Array @member Ext

7.select( String selector, Node root ) : Array 选择一组元素。
选择一组元素。 参数项:
selector : String 选择符 / xpath 查询(可以是以逗号分隔的选择符列表)
root : Node (可选)查询的起点(默认为:document)。
返回值:
Array 匹配选择符而形成的DOM元素数组,如果没有匹配的结果,返回一个空的数组

两者的区别:
Ext.query返回搜索到的元素数组,Ext.select返回的是一个Ext.CompositeElement类型的对象。

对于query返回的数组,只能循环迭代处理;而对于select返回的对象,可以调用它提供的各种函数执行特殊操作。
如:

  function selectP() {
var array = Ext.query('p');
for (var i = 0; i < array.length; i++) {
Ext.get(array[i]).highlight();
}
} function selectDiv() {
var array = Ext.query('div.red');
for (var i = 0; i < array.length; i++) {
Ext.get(array[i]).highlight();
}
}

在query和select函数中,可以通过css元素选择符来批量获取HTML页面中的元素
1、元素选择符:
     任意元素
     E 一个标签为 E 的元素
     E F 所有 E 元素的分支元素中含有标签为 F 的元素
     E > F 或 E/F 所有 E 元素的直系子元素中含有标签为 F 的元素
     E + F 所有标签为 F 并紧随着标签为 E 的元素之后的元素
     E ~ F 所有标签为 F 并与标签为 E 的元素是侧边的元素

2、属性选择符:
    @ 与引号的使用是可选的。例如:div[@foo='bar'] 也是一个有效的属性选择符。
    E[foo] 拥有一个名为 “foo” 的属性
    E[foo=bar] 拥有一个名为 “foo” 且值为 “bar” 的属性
    E[foo^=bar] 拥有一个名为 “foo” 且值以 “bar” 开头的属性
    E[foo$=bar] 拥有一个名为 “foo” 且值以 “bar” 结尾的属性 =bar] 拥有一个名为 “foo” 且值包含字串 “bar” 的属性
    E[foo%=2] 拥有一个名为 “foo” 且值能够被2整除的属性
    E[foo!=bar] 拥有一个名为 “foo” 且值不为 “bar” 的属性

3、CSS 值选择符:
   E{display=none} css 的“display”属性等于“none”
   E{display^=none} css 的“display”属性以“none”开始
   E{display$=none} css 的“display”属性以“none”结尾 =none} css 的“display”属性包含字串“none”
   E{display%=2} css 的“display”属性能够被2整除
   E{display!=none} css 的“display”属性不等于“none”

4、伪类:
     E:first-child E 元素为其父元素的第一个子元素
     E:last-child E 元素为其父元素的最后一个子元素
     E:nth-child(n) E 元素为其父元素的第 n 个子元素(由1开始的个数)
     E:nth-child(odd) E 元素为其父元素的奇数个数的子元素
     E:nth-child(even) E 元素为其父元素的偶数个数的子元素
     E:only-child E 元素为其父元素的唯一子元素
     E:checked E 元素为拥有一个名为“checked”且值为“true”的元素(例如:单选框或复选框)

E:first 结果集中第一个 E 元素
     E:last 结果集中最后一个 E 元素
     E:nth(n) 结果集中第 n 个 E 元素(由1开始的个数)
     E:odd :nth-child(odd) 的简写
     E:even :nth-child(even) 的简写
     E:contains(foo) E 元素的 innerHTML 属性中包含“foo”字串
     E:nodeValue(foo) E 元素包含一个 textNode 节点且 nodeValue 等于“foo”
     E:not(S) 一个与简单选择符 S 不匹配的 E 元素
     E:has(S) 一个包含与简单选择符 S 相匹配的分支元素的 E 元素
     E:next(S) 下一个侧边元素为与简单选择符 S 相匹配的 E 元素
     E:prev(S) 上一个侧边元素为与简单选择符 S 相匹配的 E 元素

5.encode函数和decode函数

Ext中有两个很重要的方法,一个是decode;一个是encode.顾名思义,一个是编码,一个是解码,你难道真的这么想吗?     严格的说,

一个是将json字符串转换成对象;一个是将对象转换成json字符串.
   注: Ext.decode()和Ext.encode()分别是是 Ext.util.JSON.decode()和Ext.util.JSON.encode的简写

 <link href="extjs/resources/css/ext-all.css" rel="stylesheet" type="text/css" />
<script src="extjs/ext-base.js" type="text/javascript"></script>
<script src="extjs/ext-all.js" type="text/javascript"></script>
<script type="text/javascript">
function ready() { //先使用decode方法,这个方法是将json字符串转换成对象的 //第一步:先定义一个json字符串吧
var 刘天王 = "{姓名:'刘德华',性别:'男',老家:'香港'}"; //第二步:现在我们要把刘天王转换成对象了
var who = Ext.decode(刘天王); //第三步:who成了对象后就相当于是类的对象了,里面的姓名,性别,老家都成了who的属性了,现在知道怎么通过对象访问属性了吧
var name = who.姓名; //获取who对象的[姓名]属性
var sex = who.性别; //获取who对象的[性别]属性
var home = who.老家; //获取who对象的[老家]属性 //第四步:下面将获取的信息组合起来
var result = "刘天王资料的信息:姓名是--" + name + ";性别--" + sex + ";老家--" + home; //第五步:我们把获取的who对象的信息用弹出消息的方式显示出来吧
Ext.Msg.alert("刘天王的资料信息", result); //以上就是将一个json字符串转换成对象后,再逐个访问对象的属性的示例 //下面使用encode方法
//encode方法很简单了,就是将上面生成的who对象再转换成第一步定义的json字符串 //定义一个到时间执行的函数
var getJson = function() {
//你完全可以把这段写在函数外面,之所以包含在里面纯属是为了在显示第一个消息框后再隔3秒显示下面这个消息窗口 var jsonStr = Ext.encode(who); //我们还是通过弹出消息的方式把这个json字符串显示出来吧
Ext.Msg.alert("jsonStr信息内容", jsonStr);
}; //下面这个方法意思是:在3秒之后会调用函数getJson执行里面包含的脚本 setTimeout(getJson, 3000); //Ext.decode()和Ext.encode()分别是是 Ext.util.JSON.decode()和Ext.util.JSON.encode的简写 }
Ext.onReady(ready);

6.Ext.each函数
    语法:Ext.each( Array/NodeList/Mixed array, Function fn, Object scope ) : void
    遍历array并对每项分别调用fn函数。如果array不是数组则只执行一次。

如果某项fn执行结果返回false(必须是false,undefined无效),遍历退出,后面的array项将不被遍历。

遍历过程中每次为fn传入参数分别为[当前数组项],[当前索引]和[数组array]三个参数。 Scope用于设定fn函数中的this指针。

 Ext.onReady(function () {
//1.数组 2.元素 2.索引 3.数组
Ext.each([1, 3, 5, 7], function(item, index, arry) {
alert("item:" + item + " index:" + index + " arry.length=" + arry.length);
});

7.Ext.util.Format对数据进行格式化
    ellipsis( String value, Number length, Boolean word ) : String 对大于指定长度部分的字符串,进行裁剪,增加省略号(“...”)的显示。
    对大于指定长度部分的字符串,进行裁剪,增加省略号(“...”)的显示。 参数项:
    value : String 要裁剪的字符串
    length : Number 允许的最大长度
    word : Boolean True表示尝试以一个单词来结束
    返回值:
    String 转换后的文本

 var str = "this";
var oStr = Ext.util.Format.ellipsis(str, 5,true);
alert(oStr);
var money = "1000";
var newmoney = Ext.util.Format.usMoney(money);
alert(newmoney);
var oDate = Ext.util.Format.date(new Date(), "Y-m-d H:i:s");
alert(oDate);

8、defaultValue( Mixed value, String defaultValue ) : String 检查一个引用值是否为空,若是则转换到缺省值。
检查一个引用值是否为空,若是则转换到缺省值。 参数项:
value : Mixed 要检查的引用值
defaultValue : String 默认赋予的值(默认为"")
返回值:
String

9、trim( String value ) : String 裁剪一段文本的前后多余的空格。
裁剪一段文本的前后多余的空格。
参数项:
value : String 要裁剪的文本
返回值:
String 裁剪后的文本

10.usMoney( Number/String value ) : String 格式化数字到美元货币
格式化数字到美元货币 参数项:
value : Number/String 要格式化的数字
返回值:
String 已格式化的货币

  var money = 10009.9;
var newmoney = Ext.util.Format.number(money, "0,000.00");
alert(newmoney);

11.date( Mixed value, String format ) : Function 将某个值解析成为一个特定格式的日期。
    将某个值解析成为一个特定格式的日期。
    参数项:
    value : Mixed 要格式化的值
    format : String (可选的)任何有效的日期字符串(默认为“月/日/年”)
    返回值:
   Function 日期格式函数
   如:Ext.util.Format.date(new Date(), "Y-m-d H:i:s");

12.dateRenderer( String format ) : Function 返回一个函数,该函数的作用是渲染日期格式,便于复用。
返回一个函数,该函数的作用是渲染日期格式,便于复用。 参数项:
format : String 任何有效的日期字符串
返回值:
Function 日期格式函数
如:renderer: Ext.util.Format.dateRenderer('Y年m月d日')

13.stripTags( Mixed value ) : String 剥去所有HTML标签。
剥去所有HTML标签。 参数项:
value : Mixed 要剥去的文本

14.number( Number v, String format ) : String 依据某种(字符串)格式来转换数字。例子 (123456.789): ...
依据某种(字符串)格式来转换数字。 例子 (123456.789): 0 - (123456) 只显示整数,没有小数位0.00 - (123456.78) 显示整数,保留两位小数位0.0000 - (123456.7890) 显示整数,保留四位小数位0,000 - (123,456) 只显示整数,用逗号分开0,000.00 - (123,456.78) 显示整数,用逗号分开,保留两位小数位0,0.00 - (123,456.78) 快捷方法,显示整数,用逗号分开,保留两位小数位在一些国际化的场合需要反转分组(,)和小数位(.),那么就在后面加上/i 例如: 0.000,00/i
参数项:
v : Number 要转换的数字。
format : String 格式化数字的“模”。
返回值:
String 已转换的数字。@public

15.undef( Mixed value ) : Mixed 检查一个引用值是否为underfined,若是的话转换其为空值。
检查一个引用值是否为underfined,若是的话转换其为空值。 参数项:
value : Mixed 要检查的值
返回值:
Mixed 转换成功为空白字符串,否则为原来的值

16.defaultValue( Mixed value, String defaultValue ) : String 检查一个引用值是否为空,若是则转换到缺省值。
检查一个引用值是否为空,若是则转换到缺省值。 参数项:
value : Mixed 要检查的引用值
defaultValue : String 默认赋予的值(默认为"")
返回值:
String
返回值:
String 剥去后的HTML标签

17.Ext.util.TaskRunner
执行一个连续的计划任务
Eg:// Start a simple clock task that updates a div once per second
var task = {
     run: function(){
               Ext.fly('clock').update(new Date().format('g:i:s A'));
              },
     interval: 1000
}
var runner = new Ext.util.TaskRunner();
runner.start(task);

18.

aaarticlea/png;base64,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" alt="" />

<script type="text/javascript">
Ext.onReady(function() {
var task = {
run: function() {
Ext.get('clock').update(new Date().format('g:i:s A'));
},
interval: 1000
}
var runner = new Ext.util.TaskRunner();
runner.start(task); });
</script>

19.update方法局部更新网页内容

<script type="text/javascript">
Ext.onReady(function() { Ext.get('updatePlain').on('click', function() {
Ext.get('result').getUpdater().update({
url: '07-02.html'
});
}); Ext.get('updateJavascript').on('click', function() {
Ext.get('result').getUpdater().update({
url: '07-03.html',
scripts: true
});
});
});

前台页面:

 <script type="text/javascript" src="../shared/examples.js"></script>
<div style="align:center; width:300px; margin:50px;">
<button id="updatePlain"><b>变化成静态页面</b></button>
<button id="updateJavascript"><b>变化成带javascript的页面</b></button>
</div>
<div id="result"> </div>
</body>
</html>
<script type='text/javascript'>
Ext.get('div').setWidth(100, {
duration: 2,
callback: this.highlight,
scope: this
});
</script>

Ext.Js核心函数( 三)的更多相关文章

  1. Ext JS学习第三天 我们所熟悉的javascript(二)

    •javascript之函数 •对于Ext开发者,我还是希望你能对javascript原生的东西非常了解.甚至熟练掌握运用.那么函数,无疑是非常重要的概念.首先在前面一讲,我们知道了函数也是一种数据类 ...

  2. Ext JS 6学习文档–第2章–核心概念

    核心概念 在下一章我们会构建一个示例项目,而在这之前,你需要学习一些在 Ext JS 中的核心概念,这有助于你更容易理解示例项目.这一章我们将学习以下知识点: 类系统,创建和扩展类 事件 Ext JS ...

  3. 【转】关于URL编码/javascript/js url 编码/url的三个js编码函数

    来源:http://www.cnblogs.com/huzi007/p/4174519.html 关于URL编码/javascript/js url 编码/url的三个js编码函数escape(),e ...

  4. 关于URL编码/javascript/js url 编码/url的三个js编码函数

    关于URL编码/javascript/js url 编码/url的三个js编码函数escape(),encodeURI(),encodeURIComponent() 本文为您讲述关于js(javasc ...

  5. url的三个js编码函数escape(),encodeURI(),encodeURIComponent()简介

    url的三个js编码函数escape(),encodeURI(),encodeURIComponent()简介 2014年10月12日 16806次浏览 引子 浏览器URl地址,上网一定会用到,但是浏 ...

  6. Ext JS 5初探(三)

    在上文提到了本地化文件的问题,然后在Ext JS 5的包里找了找,居然还没包含本地化包.我估计目前还不到考虑本地化的时候.在Sencha Touch中,是没有本地化包的,但是要让Ext JS也不包含本 ...

  7. url的三个js编码函数escape(),encodeURI(),encodeURIComponent()简介【转】

    引子 浏览器URl地址,上网一定会用到,但是浏览器地址有中文或者浏览器url参数操作的时候,经常会用到encodeURIComponent()和decodeURIComponent()以及encode ...

  8. js中的三种函数写法

    js中的三种函数写法 <script type="text/javascript"> //普通的声明方式 function myFun(m,n){ alert(m+n) ...

  9. [Ext JS 4] 实战之 带week(星期)的日期选择控件(三)

    前言 在 [Ext JS 4] 实战之 带week(星期)的日期选择控件(二) 的最后,有提到一个解决方案. 不过这方案有一个条件  ==> “2. 每年的周数从(1-52), 如果超过52 周 ...

随机推荐

  1. 设计模式---单一职责模式之桥模式(Bridge)

    一:概念 Bridge模式又叫做桥接模式,其实基于类的最小设计原则,通过使用封装,聚合以及继承等行为来让不同的类承担不同的责任他的主要特点是吧抽象与行为实现分离开来,从而可以保持各部分的独立性以及一对 ...

  2. vs2017_enterprise正式版离线安装包bt下载

    vs2017_enterprise正式版离线安装包bt下载 点击这里下载种子 磁力链接 安装前请先打开certificates目录,安装里面的三个证书 离线下载教程 : https://docs.mi ...

  3. jquery blockui 遮罩【转】

    参考 : http://bookshadow.com/weblog/2014/09/26/jquery-blockui-js-introduction/ blockUI.html blockUI.ht ...

  4. StiReport简单使用

    try { StiReport stiReport1 = new StiReport(); DataSet FDataSet = new DataSet(); DataTable table = ne ...

  5. Hadop 基础

    HDFS 体系结构 mapreduce 体系结构和算法 haddop 集群 zookeeper 操作:HBase 体系结构Hive /Sqoop 体系结构和基本操作: mapreduce 逻辑处理数据 ...

  6. img格式镜像转ISO格式

    在做汇编学习时,需要用比较老的Windows XP来进行调试学习,因此找了最老的Windows XP(CN_WINXP_PRO_ISO,无SP版本 ),下载后发现镜像文件格式是img的,而virtua ...

  7. python - 练习(获取windows硬件信息)

    import subprocess import re # info = subprocess.Popen("systeminfo",shell=True,stdout=subpr ...

  8. ROS Kinetic Install on Debian 9

    Not Succesed! 1.  配置源$ sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release - ...

  9. 【vim】保存文件并退出 :w=:wq

    这两个命令实际上并不完全等价,当文件被修改时两个命令时相同的.但如果未被修改,使用 :x 不会更改文件的修改时间,而使用 :wq 会改变文件的修改时间.

  10. UML和模式应用4:初始阶段(5)--用例编写的准则

    1.前言 本文主要介绍用例编写时所遵循的几条基本准则. 2.用例编写的准则 2.1 以本质的风格编写用例 如系统认证,而不要说 需要输入ID进行认证等 2.2 编写简洁的用例 如系统认证,不要说 这个 ...