javaWeb核心技术第四篇之Javascript第二篇事件和正则表达式
程序员文章站
2022-10-25 15:45:29
- 事件 - 表单提交(掌握) "onsubmit" - 单击事件(掌握) "onclick" - 页面加载成功事件(掌握) "onload" - 焦点事件:(掌握) - 获取焦点 "onfocus" - 失去焦点 "onblur" - 表单事件(了解) - ondblclick 双击事件 ... ......
- 事件
- 表单提交(掌握)
"onsubmit"
- 单击事件(掌握)
"onclick"
- 页面加载成功事件(掌握)
"onload"
- 焦点事件:(掌握)
- 获取焦点
"onfocus"
- 失去焦点
"onblur"
- 表单事件(了解)
- ondblclick 双击事件
- onreset; 重置
- onchange; 改变(熟练使用)
- 鼠标事件:(了解)
- onmouseover 悬停
- onmouseout 移出
- onmousedown 按下
- onmouseup 弹起
- onmousemove 移动
- 键盘事件:(了解)
- onkeydown 按下
- onkeyup 弹起
- onkeypress 按下并弹起
- dom(文档对象模型):操作html文档
"html加载到内存中时,是以一棵树的形式存在的,可以通过document操作所有的节点"
- html文档与dom树的关系：理解
- html里所有的标签、标签的属性、文本都会转换成dom树里的节点
- a.整个html文档抽象成的对象,叫作document 文档节点
- b.标签转换成的节点对象，叫作element 元素节点
- c.标签属性转换成的节点对象，叫作attribute 属性节点
- d.文本转换成的节点对象，叫作text 文本节点
- 查询(获取元素对象)★★
- document.getelementbyid("id"); 获取一个元素对象
- document.getelementsbytagname("标签名"); 获取一种元素对象 数组接收
- document.getelementsbyclassname("class属性值"); 获取一类元素对象 数组接收
- document.getelementsbyname("name属性值"); 获取多个元素对象 数组接收
- 元素(element)
- 方式1简单方法操作:★★
- 元素.innerhtml = "<h1>文本内容</h1>"; 添加
- 元素.innerhtml = ""; 删除
- 方式2扩展:了解
- 添加
- var ele = document.createelement("标签名"); 创建元素节点(创建一个标签)
"var ele = document.createelement("h1"); <h1></h1>"
- var text = document.createtextnode("值"); 创建文本节点(创建一个值)
"var text = document.createtextnode(""); "客""
- 元素节点.appendchild(文本节点); 给元素节点添加文本信息
"ele.appendchild(text); <h1>客</h1>"
- 元素.appendchild(子元素对象); 将元素节点追加到指定标签中
"将创建好的h1标签添加到页面的指定标签中"
- 删除
- 元素.remove(); 自杀
- 属性:(attribute)
- 方式1简单方法操作:★★
- 元素.属性名称; 获取指定属性的值
- 元素.属性名称 = "属性值"; 设置指定属性的值
- 方式2扩展:了解
- 查(获取):
- 元素.getattribute("属性名称");
- 增:
- 元素.setattribute("属性名称","属性值");
- 删:
- 元素.removeattribute("属性名称");
- 引用数据类型(对象)
- 注意:string,number,boolen称为伪对象,可以直接使用相应的方法或属性
- array:数组
- 语法:
- new array(); 创建空数组
- new array(3); 创建包含指定个数的数组
- new array(ele1,ele2...); 创建包含指定元素的数组
- 特征:
- 数组长度可变
- 数组中可以存放任何类型的值
- 常用属性
- length 长度
- 常用方法
- join("分隔符"); 按指定的分隔符分割
- shift(); 删除并返回数组中的第一个元素
- unshift(); 向数组的开头添加一个或多个元素,并返回新数组的长度
- pop(); 删除并返回数组中的最后一个元素
- push(); 向数组的末尾添加一个或多个元素,返回新数组的长度
- sort(); 操作数组结构 对数组进行排序
"//初始化设置元素的时候,排序不起作用的"
- reverse(); 颠倒数组中元素的顺序
- string
- 语法
- new string(); 返回一个object对象
- 常用属性
- length
- 常用方法
- substring(startindex,endindex);
- slice(startindex,endindex);
- charat();
- split();
- number
- 语法:
- new number(); 返回一个object对象
- boolean
- new boolean(); 返回一个object对象
- boolean(值); 将给定值转为boolean类型
- math
- 常用操作
- math.round();
- math.pi;
- math.random();
- date
- 语法
- new date();
- 常用方法
- tolocalestring(); 转为字符串
- reg(正则)
- 1.编写正则表达式
- 格式: /^正则表达式$/
- 2.校验
- 正则表达式.test(); 返回boolean类型的值
- 全局函数
- parseint(); 尝试转换为int类型
- parsefloat(); 尝试转换为float类型
- string(); 强制转换为string类型
- number(); 强制转换为number类型
- encodeuri(); 编码
- decodeuri(); 解码
- eval(); 将字符串转换称js可以执行的代码
/*
<!doctype html public "-//w3c//dtd xhtml 1.0 transitional//en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html; charset=gb2312" />
<title>正则表达式,常用的正则表达式,js正则表达式,正则表达式数字,正则表达式空格</title>
<meta name="description" content="正则表达式（英文：regular expression）在计算机科学中，是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。正则表达式通常缩写成“regex”，单数有regexp、regex，复数有regexps、regexes、regexen。" />
<meta http-equiv="x-ua-compatible" content="ie=emulateie7" />
<meta http-equiv="content-language" content="zh-cn" />
<base target="_blank" />
<link href="http://static.xixik.com/common/css/style.css?t=20091210.css" rel="stylesheet" type="text/css" />
<link href="http://static.xixik.com/common/css/container.css?t=20091210.css" rel="stylesheet" type="text/css" />
<style type="text/css" rel="stylesheet" media="screen" />
/* copyright (c) 2006-2009 114.xixik.com all rights reserved. */
table,td,th{
border-collapse:collapse;
font-size:14px;
}
table{
width:778px;
}
.code{
padding:2px;
border:1px #ccc solid;
background-color:#e5e5e5;
font-family:fixedsys;
}
</style>
</head>
<body>
<div class="commoncontainer">
<div class="noborder">
<div class="maincontainer">
<h2>常用的正则表达式</h2>
<p><strong>常用正则表达式</strong></p>
<p>正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。</p>
<p>用户名：/^[a-z0-9_-]{3,16}$/</p>
<p>密码：/^[a-z0-9_-]{6,18}$/</p>
<p>十六进制值：/^#?([a-f0-9]{6}|[a-f0-9]{3})$/</p>
<p>电子邮箱：/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/</p>
<p>url：/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/</p>
<p>ip 地址：/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/</p>
<p>html 标签：/^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/</p>
<p>unicode编码中的汉字范围：/^[u4e00-u9fa5],{0,}$/</p>
<p>匹配中文字符的正则表达式： [\u4e00-\u9fa5]<br>评注：匹配中文还真是个头疼的事，有了这个表达式就好办了</p>
<p>匹配双字节字符(包括汉字在内)：[^\x00-\xff]<br>评注：可以用来计算字符串的长度（一个双字节字符长度计2，ascii字符计1）</p>
<p>匹配空白行的正则表达式：\n\s*\r<br>评注：可以用来删除空白行</p>
<p>匹配html标记的正则表达式：<(\s*?)[^>]*>.*?</\1>|<.*? /><br>评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力</p>
<p>匹配首尾空白字符的正则表达式：^\s*|\s*$<br>评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式</p>
<p>匹配email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*<br>评注：表单验证时很实用</p>
<p>匹配网址url的正则表达式：[a-za-z]+://[^\s]*<br>评注：网上流传的版本功能很有限，上面这个基本可以满足需求</p>
<p>匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-za-z][a-za-z0-9_]{4,15}$<br>评注：表单验证时很实用</p>
<p>匹配国内电话号码：\d{3}-\d{8}|\d{4}-\d{7}<br>评注：匹配形式如 0511-4405222 或 021-87888822</p>
<p>匹配腾讯qq号：[1-9][0-9]{4,}<br>评注：腾讯qq号从10000开始</p>
<p>匹配*邮政编码：[1-9]\d{5}(?!\d)<br>评注：*邮政编码为6位数字</p>
<p>匹配身份证：\d{15}|\d{18}<br>评注：*的身份证为15位或18位</p>
<p>匹配ip地址：\d+\.\d+\.\d+\.\d+<br>评注：提取ip地址时有用</p>
<p>匹配特定数字：<br>^[1-9]\d*$ //匹配正整数<br>^-[1-9]\d*$ //匹配负整数<br>^-?[1-9]\d*$ //匹配整数<br>^[1-9]\d*|0$ //匹配非负整数（正整数 + 0）<br>^-[1-9]\d*|0$ //匹配非正整数（负整数 + 0）<br>^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ //匹配正浮点数<br>^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ //匹配负浮点数<br>^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$ //匹配浮点数<br>^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$ //匹配非负浮点数（正浮点数 + 0）<br>^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$ //匹配非正浮点数（负浮点数 + 0）<br>评注：处理大量数据时有用，具体应用时注意修正</p>
<p>匹配特定字符串：<br>^[a-za-z]+$ //匹配由26个英文字母组成的字符串<br>^[a-z]+$ //匹配由26个英文字母的大写组成的字符串<br>^[a-z]+$ //匹配由26个英文字母的小写组成的字符串<br>^[a-za-z0-9]+$ //匹配由数字和26个英文字母组成的字符串<br>^\w+$ //匹配由数字、26个英文字母或者下划线组成的字符串</p>
<h2>表达式全集</h2>
<p>正则表达式有多种不同的风格。下表是在pcre中元字符及其在正则表达式上下文中的行为的一个完整列表：</p>
<table width="778" bordercolor=#cccccc cellspacing=1 cellpadding=2 border=1>
<tr>
<th>字符</th>
<th>描述</th>
</tr>
<tr>
<th style="text-align:center;">\</th>
<td>将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“<code>n</code>”匹配字符“<code>n</code>”。“<code>\n</code>”匹配一个换行符。序列“<code>\\</code>”匹配“<code>\</code>”而“<code>\(</code>”则匹配“<code>(</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">^</th>
<td>匹配输入字符串的开始位置。如果设置了regexp对象的multiline属性，^也匹配“<code>\n</code>”或“<code>\r</code>”之后的位置。</td>
</tr>
<tr>
<th style="text-align:center;">$</th>
<td>匹配输入字符串的结束位置。如果设置了regexp对象的multiline属性，$也匹配“<code>\n</code>”或“<code>\r</code>”之前的位置。</td>
</tr>
<tr>
<th style="text-align:center;">*</th>
<td>匹配前面的子表达式零次或多次。例如，zo*能匹配“<code>z</code>”以及“<code>zoo</code>”。*等价于{0,}。</td>
</tr>
<tr>
<th style="text-align:center;">+</th>
<td>匹配前面的子表达式一次或多次。例如，“<code>zo+</code>”能匹配“<code>zo</code>”以及“<code>zoo</code>”，但不能匹配“<code>z</code>”。+等价于{1,}。</td>
</tr>
<tr>
<th style="text-align:center;">?</th>
<td>匹配前面的子表达式零次或一次。例如，“<code>do(es)?</code>”可以匹配“<code>do</code>”或“<code>does</code>”中的“<code>do</code>”。?等价于{0,1}。</td>
</tr>
<tr>
<th style="text-align:center;">{<span style="font-family:times new roman; font-style:italic;">n</span>}</th>
<td><span style="font-family:times new roman; font-style:italic;">n</span>是一个非负整数。匹配确定的<span style="font-family:times new roman; font-style:italic;">n</span>次。例如，“<code>o{2}</code>”不能匹配“<code>bob</code>”中的“<code>o</code>”，但是能匹配“<code>food</code>”中的两个o。</td>
</tr>
<tr>
<th style="text-align:center;">{<span style="font-family:times new roman; font-style:italic;">n</span>,}</th>
<td><span style="font-family:times new roman; font-style:italic;">n</span>是一个非负整数。至少匹配<span style="font-family:times new roman; font-style:italic;">n</span>次。例如，“<code>o{2,}</code>”不能匹配“<code>bob</code>”中的“<code>o</code>”，但能匹配“<code>foooood</code>”中的所有o。“<code>o{1,}</code>”等价于“<code>o+</code>”。“<code>o{0,}</code>”则等价于“<code>o*</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">{<span style="font-family:times new roman; font-style:italic;">n</span>,<span style="font-family:times new roman; font-style:italic;">m</span>}</th>
<td><span style="font-family:times new roman; font-style:italic;">m</span>和<span style="font-family:times new roman; font-style:italic;">n</span>均为非负整数，其中<span style="font-family:times new roman; font-style:italic;">n</span><=<span style="font-family:times new roman; font-style:italic;">m</span>。最少匹配<span style="font-family:times new roman; font-style:italic;">n</span>次且最多匹配<span style="font-family:times new roman; font-style:italic;">m</span>次。例如，“<code>o{1,3}</code>”将匹配“<code>fooooood</code>”中的前三个o。“<code>o{0,1}</code>”等价于“<code>o?</code>”。请注意在逗号和两个数之间不能有空格。</td>
</tr>
<tr>
<th style="text-align:center;">?</th>
<td>当该字符紧跟在任何一个其他限制符（*,+,?，{<span style="font-family:times new roman; font-style:italic;">n</span>}，{<span style="font-family:times new roman; font-style:italic;">n</span>,}，{<span style="font-family:times new roman; font-style:italic;">n</span>,<span style="font-family:times new roman; font-style:italic;">m</span>}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“<code>oooo</code>”，“<code>o+?</code>”将匹配单个“<code>o</code>”，而“<code>o+</code>”将匹配所有“<code>o</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">.</th>
<td>匹配除“<code>\</code><span style="font-family:times new roman; font-style:italic;"><code>n</code></span>”之外的任何单个字符。要匹配包括“<code>\</code><span style="font-family:times new roman; font-style:italic;"><code>n</code></span>”在内的任何字符，请使用像“<code>[.\</code><span style="font-family:times new roman; font-style:italic;"><code>n</code></span><code>]</code>”的模式。</td>
</tr>
<tr>
<th style="text-align:center;">(pattern)</th>
<td>匹配pattern并获取这一匹配。所获取的匹配可以从产生的matches集合得到，在vbscript中使用submatches集合，在jscript中则使用$0…$9属性。要匹配圆括号字符，请使用“<code>\(</code>”或“<code>\)</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">(?:pattern)</th>
<td>匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“<code>(|)</code>”来组合一个模式的各个部分是很有用。例如“<code>industr(?:y|ies)</code>”就是一个比“<code>industry|industries</code>”更简略的表达式。</td>
</tr>
<tr>
<th style="text-align:center;">(?=pattern)</th>
<td>正向预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“<code>windows(?=95|98|nt|2000)</code>”能匹配“<code>windows2000</code>”中的“<code>windows</code>”，但不能匹配“<code>windows3.1</code>”中的“<code>windows</code>”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。</td>
</tr>
<tr>
<th style="text-align:center;">(?!pattern)</th>
<td>负向预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“<code>windows(?!95|98|nt|2000)</code>”能匹配“<code>windows3.1</code>”中的“<code>windows</code>”，但不能匹配“<code>windows2000</code>”中的“<code>windows</code>”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始</td>
</tr>
<tr>
<th style="text-align:center;">x|y</th>
<td>匹配x或y。例如，“<code>z|food</code>”能匹配“<code>z</code>”或“<code>food</code>”。“<code>(z|f)ood</code>”则匹配“<code>zood</code>”或“<code>food</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">[xyz]</th>
<td>字符集合。匹配所包含的任意一个字符。例如，“<code>[abc]</code>”可以匹配“<code>plain</code>”中的“<code>a</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">[^xyz]</th>
<td>负值字符集合。匹配未包含的任意字符。例如，“<code>[^abc]</code>”可以匹配“<code>plain</code>”中的“<code>p</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">[a-z]</th>
<td>字符范围。匹配指定范围内的任意字符。例如，“<code>[a-z]</code>”可以匹配“<code>a</code>”到“<code>z</code>”范围内的任意小写字母字符。</td>
</tr>
<tr>
<th style="text-align:center;">[^a-z]</th>
<td>负值字符范围。匹配任何不在指定范围内的任意字符。例如，“<code>[^a-z]</code>”可以匹配任何不在“<code>a</code>”到“<code>z</code>”范围内的任意字符。</td>
</tr>
<tr>
<th style="text-align:center;">\b</th>
<td>匹配一个单词边界，也就是指单词和空格间的位置。例如，“<code>er\b</code>”可以匹配“<code>never</code>”中的“<code>er</code>”，但不能匹配“<code>verb</code>”中的“<code>er</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">\b</th>
<td>匹配非单词边界。“<code>er\b</code>”能匹配“<code>verb</code>”中的“<code>er</code>”，但不能匹配“<code>never</code>”中的“<code>er</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">\cx</th>
<td>匹配由x指明的控制字符。例如，\cm匹配一个control-m或回车符。x的值必须为a-z或a-z之一。否则，将c视为一个原义的“<code>c</code>”字符。</td>
</tr>
<tr>
<th style="text-align:center;">\d</th>
<td>匹配一个数字字符。等价于[0-9]。</td>
</tr>
<tr>
<th style="text-align:center;">\d</th>
<td>匹配一个非数字字符。等价于[^0-9]。</td>
</tr>
<tr>
<th style="text-align:center;">\f</th>
<td>匹配一个换页符。等价于\x0c和\cl。</td>
</tr>
<tr>
<th style="text-align:center;">\n</th>
<td>匹配一个换行符。等价于\x0a和\cj。</td>
</tr>
<tr>
<th style="text-align:center;">\r</th>
<td>匹配一个回车符。等价于\x0d和\cm。</td>
</tr>
<tr>
<th style="text-align:center;">\s</th>
<td>匹配任何空白字符，包括空格、制表符、换页符等等。等价于[\f\n\r\t\v]。</td>
</tr>
<tr>
<th style="text-align:center;">\s</th>
<td>匹配任何非空白字符。等价于[^\f\n\r\t\v]。</td>
</tr>
<tr>
<th style="text-align:center;">\t</th>
<td>匹配一个制表符。等价于\x09和\ci。</td>
</tr>
<tr>
<th style="text-align:center;">\v</th>
<td>匹配一个垂直制表符。等价于\x0b和\ck。</td>
</tr>
<tr>
<th style="text-align:center;">\w</th>
<td>匹配包括下划线的任何单词字符。等价于“<code>[a-za-z0-9_]</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">\w</th>
<td>匹配任何非单词字符。等价于“<code>[^a-za-z0-9_]</code>”。</td>
</tr>
<tr>
<th style="text-align:center;">\x<span style="font-family:times new roman; font-style:italic;">n</span></th>
<td>匹配<span style="font-family:times new roman; font-style:italic;">n</span>，其中<span style="font-family:times new roman; font-style:italic;">n</span>为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“<code>\x41</code>”匹配“<code>a</code>”。“<code>\x041</code>”则等价于“<code>\x04&1</code>”。正则表达式中可以使用ascii编码。.</td>
</tr>
<tr>
<th style="text-align:center;">\<span style="font-family:times new roman; font-style:italic;">num</span></th>
<td>匹配<span style="font-family:times new roman; font-style:italic;">num</span>，其中<span style="font-family:times new roman; font-style:italic;">num</span>是一个正整数。对所获取的匹配的引用。例如，“<code>(.)\1</code>”匹配两个连续的相同字符。</td>
</tr>
<tr>
<th style="text-align:center;">\<span style="font-family:times new roman; font-style:italic;">n</span></th>
<td>标识一个八进制转义值或一个向后引用。如果\<span style="font-family:times new roman; font-style:italic;">n</span>之前至少<span style="font-family:times new roman; font-style:italic;">n</span>个获取的子表达式，则<span style="font-family:times new roman; font-style:italic;">n</span>为向后引用。否则，如果<span style="font-family:times new roman; font-style:italic;">n</span>为八进制数字（0-7），则<span style="font-family:times new roman; font-style:italic;">n</span>为一个八进制转义值。</td>
</tr>
<tr>
<th style="text-align:center;">\<span style="font-family:times new roman; font-style:italic;">nm</span></th>
<td>标识一个八进制转义值或一个向后引用。如果\<span style="font-family:times new roman; font-style:italic;">nm</span>之前至少有<span style="font-family:times new roman; font-style:italic;">nm</span>个获得子表达式，则<span style="font-family:times new roman; font-style:italic;">nm</span>为向后引用。如果\<span style="font-family:times new roman; font-style:italic;">nm</span>之前至少有<span style="font-family:times new roman; font-style:italic;">n</span>个获取，则<span style="font-family:times new roman; font-style:italic;">n</span>为一个后跟文字<span style="font-family:times new roman; font-style:italic;">m</span>的向后引用。如果前面的条件都不满足，若<span style="font-family:times new roman; font-style:italic;">n</span>和<span style="font-family:times new roman; font-style:italic;">m</span>均为八进制数字（0-7），则\<span style="font-family:times new roman; font-style:italic;">nm</span>将匹配八进制转义值<span style="font-family:times new roman; font-style:italic;">nm</span>。</td>
</tr>
<tr>
<th style="text-align:center;">\<span style="font-family:times new roman; font-style:italic;">nml</span></th>
<td>如果<span style="font-family:times new roman; font-style:italic;">n</span>为八进制数字（0-3），且<span style="font-family:times new roman; font-style:italic;">m和l</span>均为八进制数字（0-7），则匹配八进制转义值<span style="font-family:times new roman; font-style:italic;">nm</span>l。</td>
</tr>
<tr>
<th style="text-align:center;">\u<span style="font-family:times new roman; font-style:italic;">n</span></th>
<td>匹配<span style="font-family:times new roman; font-style:italic;">n</span>，其中<span style="font-family:times new roman; font-style:italic;">n</span>是一个用四个十六进制数字表示的unicode字符。例如，\u00a9匹配版权符号（?）。</td>
</tr>
</table>
<p>以下是以php的语法所写的示例 </p>
<p>验证字符串是否只含数字与英文，字符串长度并在4~16个字符之间 </p>
<div dir=ltr style="text-align: left">
<div style="font-family: monospace"><pre class=de1><span class=kw2><strong><?php</strong></span>
<span class=re0><font color=#000088>$str</font></span> <span class=sy0><font color=#339933>=</font></span> <span class=st_h><font color=#0000ff>'a1234'</font></span><span class=sy0><font color=#339933>;</font></span>
<span class=kw1><font color=#b1b100>if</font></span> <span class=br0><font color=#009900>(</font></span><span class=kw3><font color=#990000>preg_match</font></span><span class=br0><font color=#009900>(</font></span><span class=st0><font color=#0000ff>"^[a-za-z0-9]{4,16}$"</font></span><span class=sy0><font color=#339933>,</font></span> <span class=re0><font color=#000088>$str</font></span><font color=#009900><span class=br0>)</span><span class=br0>)</span></font> <span class=br0><font color=#009900>{</font></span>
<span class=kw1><font color=#b1b100>echo</font></span> <span class=st0><font color=#0000ff>"驗證成功"</font></span><span class=sy0><font color=#339933>;</font></span>
<span class=br0><font color=#009900>}</font></span> <span class=kw1><font color=#b1b100>else</font></span> <span class=br0><font color=#009900>{</font></span>
<span class=kw1><font color=#b1b100>echo</font></span> <span class=st0><font color=#0000ff>"驗證失敗"</font></span><span class=sy0><font color=#339933>;</font></span>
<span class=br0><font color=#009900>}</font></span>
<span class=sy1><strong>?></strong></span>
</pre></div></div>
<p>简易的*身份证字号验证 </p>
<div class=mw-geshi dir=ltr style="text-align: left">
<div class="php source-php" style="font-family: monospace"><pre class=de1><span class=kw2><strong><?php</strong></span>
<span class=re0><font color=#000088>$str</font></span> <span class=sy0><font color=#339933>=</font></span> <span class=st_h><font color=#0000ff>'a1234'</font></span><span class=sy0><font color=#339933>;</font></span>
<span class=kw1><font color=#b1b100>if</font></span> <span class=br0><font color=#009900>(</font></span><span class=kw3><font color=#990000>preg_match</font></span><span class=br0><font color=#009900>(</font></span><span class=st0><font color=#0000ff>"/^\w[12]\d{8}$/"</font></span><span class=sy0><font color=#339933>,</font></span> <span class=re0><font color=#000088>$str</font></span><font color=#009900><span class=br0>)</span><span class=br0>)</span></font> <span class=br0><font color=#009900>{</font></span>
<span class=kw1><font color=#b1b100>echo</font></span> <span class=st0><font color=#0000ff>"驗證成功"</font></span><span class=sy0><font color=#339933>;</font></span>
<span class=br0><font color=#009900>}</font></span> <span class=kw1><font color=#b1b100>else</font></span> <span class=br0><font color=#009900>{</font></span>
<span class=kw1><font color=#b1b100>echo</font></span> <span class=st0><font color=#0000ff>"驗證失敗"</font></span><span class=sy0><font color=#339933>;</font></span>
<span class=br0><font color=#009900>}</font></span>
<span class=sy1><strong>?></strong></span>
</pre></div></div>
<p>以下示例是用 perl 语言写的，与上面的示例功能相同 </p>
<div class=mw-geshi dir=ltr style="text-align: left">
<div class="perl source-perl" style="font-family: monospace"><pre class=de1><span class=kw3><font color=#000066>print</font></span> <span class=re0><font color=#0000ff>$str</font></span> <span class=sy0><font color=#339933>=</font></span> <span class=st0><font color=#ff0000>"a1234"</font></span> <span class=sy0><font color=#339933>=~</font></span> <span class=kw3><font color=#000066>m</font></span><span class=sy0><font color=#339933>:^</font></span><span class=br0><font color=#009900>[</font></span>a<span class=sy0><font color=#339933>-</font></span>za<span class=sy0><font color=#339933>-</font></span>z0<span class=sy0><font color=#339933>-</font></span><span class=nu0><font color=#cc66cc>9</font></span><font color=#009900><span class=br0>]</span><span class=br0>{</span></font><span class=nu0><font color=#cc66cc>4</font></span><span class=sy0><font color=#339933>,</font></span><span class=nu0><font color=#cc66cc>16</font></span><span class=br0><font color=#009900>}</font></span><span class=co5><font color=#0000ff>$:</font></span> <span class=sy0><font color=#339933>?</font></span> <span class=st0><font color=#ff0000>"comfirm"</font></span> <span class=sy0><font color=#339933>:</font></span> <span class=st0><font color=#ff0000>"failed"</font></span><span class=sy0><font color=#339933>;</font></span>
</pre></div></div>
<div class=mw-geshi dir=ltr style="text-align: left">
<div class="perl source-perl" style="font-family: monospace"><pre class=de1><span class=kw3><font color=#000066>print</font></span> <span class=re0><font color=#0000ff>$str</font></span> <span class=sy0><font color=#339933>=</font></span> <span class=st0><font color=#ff0000>"a1234"</font></span> <span class=sy0><font color=#339933>=~</font></span> <span class=kw3><font color=#000066>m</font></span><span class=st0><font color=#ff0000>"^</font><span class=es0><strong><font color=#000099>\w</font></strong></span><font color=#ff0000>[12]</font><span class=es0><strong><font color=#000099>\d</font></strong></span><font color=#ff0000>{8}$"</font></span> <span class=sy0><font color=#339933>?</font></span> <span class=st0><font color=#ff0000>"comfirm"</font></span> <span class=sy0><font color=#339933>:</font></span> <span class=st0><font color=#ff0000>"invaild"</font></span><span class=sy0><font color=#339933>;</font></span>
</pre></div></div>
<h2>如何写出高效率的正则表达式</h2>
<p>如果纯粹是为了挑战自己的正则水平，用来实现一些特效（例如使用正则表达式计算质数、解线性方程），效率不是问题；如果所写的正则表达式只是为了满足一两次、几十次的运行，优化与否区别也不太大。但是，如果所写的正则表达式会百万次、千万次地运行，效率就是很大的问题了。我这里总结了几条提升正则表达式运行效率的经验（工作中学到的，看书学来的，自己的体会），贴在这里。如果您有其它的经验而这里没有提及，欢迎赐教。</p>
<p>为行文方便，先定义两个概念。</p>
<p><b>误匹配</b>：指正则表达式所匹配的内容范围超出了所需要范围，有些文本明明不符合要求，但是被所写的正则式“击中了”。例如，如果使用<font color=#3366ff>\d{11}</font>来匹配11位的手机号，<font color=#3366ff>\d{11}</font>不单能匹配正确的手机号，它还会匹配<font color=#cc33cc>98765432100</font>这样的明显不是手机号的字符串。我们把这样的匹配称之为误匹配。
<p><b>漏匹配</b>：指正则表达式所匹配的内容所规定的范围太狭窄，有些文本确实是所需要的，但是所写的正则没有将这种情况囊括在内。例如，使用<font color=#3366ff>\d{18}</font>来匹配18位的身份证号码，就会漏掉结尾是字母x的情况。 </li></ul>
<p>写出一条正则表达式，既可能<b>只出现</b>误匹配（条件写得极宽松，其范围大于目标文本），也可能<b>只出现</b>漏匹配（只描述了目标文本中多种情况种的一种），还可能<b>既有误匹配又有漏匹配</b>。例如，使用<font color=#3366ff>\w+\.com</font>来匹配.com结尾的域名，既会误匹配<font color=#cc33cc>abc_.com</font>这样的字串（合法的域名中不含下划线，<font color=#3366ff>\w</font>包含了下划线这种情况），又会漏掉<font color=#cc33cc>ab-c.com</font>这样的域名（合法域名中可以含中划线，但是<font color=#3366ff>\w</font>不匹配中划线）。</p>
<p>精准的正则表达式意味着既无误匹配且无漏匹配。当然，现实中存在这样的情况：只能看到有限数量的文本，根据这些文本写规则，但是这些规则将会用到海量的文本中。这种情况下，尽可能地（如果不是完全地）消除误匹配以及漏匹配，并提升运行效率，就是我们的目标。本文所提出的经验，主要是针对这种情况。</p>
<p><b>掌握语法细节</b>。正则表达式在各种语言中，其语法大致相同，细节各有千秋。明确所使用语言的正则的语法的细节，是写出正确、高效正则表达式的基础。例如，perl中与<font color=#3366ff>\w</font>等效的匹配范围是<font color=#3366ff>[a-za-z0-9_]</font>；perl正则式不支持肯定逆序环视中使用可变的重复（variable repetition inside lookbehind，例如<font color=#3366ff>(?<=.*)abc</font>），但是.net语法是支持这一特性的；又如，javascript连逆序环视（lookbehind,如<font color=#3366ff>(?<=ab)c</font>）都不支持，而perl和python是支持的。《精通正则表达式》第3章《正则表达式的特性和流派概览》明确地列出了各大派系正则的异同，这篇文章也简要地列出了几种常用语言、工具中正则的比较。对于具体使用者而言，至少应该详细了解正在使用的那种工作语言里正则的语法细节。
<p><b>先粗后精，</b><b>先加后减</b>。使用正则表达式语法对于目标文本进行描述和界定，可以像画素描一样，先大致勾勒出框架，再逐步在局步实现细节。仍举刚才的手机号的例子，先界定<font color=#3366ff>\d{11}</font>，总不会错；再细化为<font color=#3366ff>1[358]\d{9}</font>，就向前迈了一大步（至于第二位是不是3、5、8，这里无意深究，只举这样一个例子，说明逐步细化的过程）。这样做的目的是先消除漏匹配（刚开始先尽可能多地匹配，做加法），然后再一点一点地消除误匹配（做减法）。这样有先有后，在考虑时才不易出错，从而向“不误不漏”这个目标迈进。
<p><b>留有余地</b>。所能看到的文本sample是有限的，而待匹配检验的文本是海量的，暂时不可见的。对于这样的情况，在写正则表达式时要跳出所能见到的文本的圈子，开拓思路，作出“战略性前瞻”。例如，经常收到这样的垃圾短信：“发*票”、“发#漂”。如果要写规则屏蔽这样烦人的垃圾短信，不但要能写出可以匹配当前文本的正则表达式 <font color=#3366ff>发[*#](?:票|漂)</font>，还要能够想到 <font color=#3366ff>发.(?:票|漂|飘)</font>之类可能出现的“变种”。这在具体的领域或许会有针对性的规则，不多言。这样做的目的是消除漏匹配，延长正则表达式的生命周期。
<p><b>明确</b>。具体说来，就是<b>谨慎</b>用点号这样的元字符，<b>尽可能</b>不用星号和加号这样的任意量词。只要能确定范围的，例如\w，就不要用点号；只要能够预测重复次数的，就不要用任意量词。例如，写析取twitter消息的脚本，假设一条消息的xml正文部分结构是<span class=”msg”>…</span>且正文中无尖括号，那么<font color=#3366ff><span class=”msg”>[^<]{1,480}</span></font>这种写法<b>的思路</b>要好于<font color=#3366ff><span class=”msg”>.*</span></font>，原因有二：一是使用<font color=#3366ff>[^<]</font>，它保证了文本的范围不会超出下一个小于号所在的位置；二是明确长度范围，<font color=#3366ff>{1,480}</font>，其依据是一条twitter消息大致能的字符长度范围。当然，480这个长度是否正确还可推敲，但是这种思路是值得借鉴的。说得狠一点，“滥用点号、星号和加号是不环保、不负责任的做法”。
<p><b>不要让稻草压死骆驼</b>。每使用一个普通括号()而不是非捕获型括号<font color=#3366ff>(?:…)</font>，就会保留一部分内存等着你再次访问。这样的正则表达式、无限次地运行次数，无异于一根根稻草的堆加，终于能将骆驼压死。养成合理使用(?:…)括号的习惯。
<p><b>宁简勿繁</b>。将一条复杂的正则表达式拆分为两条或多条简单的正则表达式，编程难度会降低，运行效率会提升。例如用来消除行首和行尾空白字符的正则表达式<font color=#3366ff>s/^\s+|\s+$//g;</font>，其运行效率理论上要低于<font color=#3366ff>s/^\s+//g; s/\s+$//g;</font> 。这个例子出自《精通正则表达式》第五章，书中对它的评论是“它几乎总是最快的，而且显然最容易理解”。既快又容易理解，何乐而不为？工作中我们还有其它的理由要将c==<font color=#3366ff>(a|b)</font>这样的正则表达式拆为a和b两条表达式分别执行。例如，虽然a和b这两种情况只要有一种能够击中所需要的文本模式就会成功匹配，但是如果只要有一条子表达式（例如a）会产生误匹配，那么不论其它的子表达式（例如b）效率如何之高，范围如何精准，c的总体精准度也会因a而受到影响。
<p><b>巧妙定位</b>。有时候，我们需要匹配的the，是作为单词的the（两边有空格），而不是作为单词一部分的t-h-e的有序排列（例如toge<font color=#cc33cc>the</font>r中的the）。在适当的时候用上<font color=#3366ff>^</font>，<font color=#3366ff>$</font>，<font color=#3366ff>\b</font>等等定位锚点，能有效提升找到成功匹配、淘汰不成功匹配的效率。 </li></ol></p>
<p style="text-indent: 2em"><strong>正则表达式：</strong> <a href="http://114.xixik.com/regex/">http://114.xixik.com/regex/</a></p>
<p style="text-indent: 2em"><strong>html转义字符：</strong> <a href="http://114.xixik.com/character/">http://114.xixik.com/character/</a></p>
</div>
</div>
</div>
<script src="http://w.cnzz.com/c.php?id=30039331" language="javascript" charset="gb2312"></script>
</body>
</html>
*/
/*
回顾:
css:
层叠样式表
作用:
渲染页面
提供工作效率,将html和样式分离
和html的整合
方式1:内联样式表
通过标签的style属性 <xxx style="..."/>
方式2:内部样式表
通过head的子标签style子标签
<style type="text/css">
选择器{
属性:值;
属性1:值1;
}
</style>
方式3:外部样式表
有一个独立css文件.后缀名:.css
在html中通过link标签导入
选择器:
id选择器
html元素有id属性且有值 <xx id="d1">
css中通过 # 导入 #d1{...}
类选择器
html元素有class属性且有值 <xx class="c1">
css中通过 . 导入 .c1{...}
元素选择器
css中通过标签名即可 xx{...}
属性选择器
html元素有一个属性且有值 <xx att="val1">
css中通过元素名[属性="值"]使用 xx[att="val1"]{...}
后代选择器
选择器 后代选择器
锚伪类(了解)
//////////////////
字体 文本 背景 列表 分类(clear display:none block inline)
框模型:
一个元素外边有内边距 边框 外边距
顺序:上右下左
//////////////////////////////////////
js
javascript 脚本语言 解释性 基于对象 事件驱动函数
js的组成:
ecmascript(语法)
bom(浏览器对象模型)
dom(文档对象模型)
html和js的整合
方式1:内部编写js
<script type="text/javascript">js代码</script>
方式2:
外部有一个独立的js文件 后缀名:.js
在html中通过script的src属性导入
<script src="js的路径"></script>
注意:
一旦使用了src属性,那么script标签体中的js代码将不再执行了.
变量:
var 变量名=初始化值;
数据类型:
原始类型(5种)
undefined
null
string 用引号引起来的内容
number
boolean
通过typeof可以判断一个值或者变量是否是原始类型,若是原始类型,还可以判断属于那种.
typeof 变量|值
引用类型
运算符:
关系运算符:
两边值都是字符串,比较ascii码
两边都是数字,和java一样
一边是数字,一遍是字符串形式的数字, 可以比较
一边是数字,一遍是普通字符串 可以比较 值永远是false
等性运算符
"66"==66 true
"666"===666 false
js的语句
if while for 和java一样
//////////////////
获取元素:
var obj=document.getelementbyid("id值");
获取元素的value属性
var val=document.getelementbyid("id值").value;
设置元素的value属性
document.getelementbyid("id值").value="sdfsdf";
获取元素的标签体
var ht=document.getelementbyid("id值").innerhtml;
设置元素的标签体
document.getelementbyid("id值").innerhtml="ssss";
定义函数:
方式1:function 函数名(参数列表){函数体}
方式2:
var 函数名=function(参数列表){函数体}
注意:
函数声明的时候不用声明返回值类型
参数列表上不要写参数类型
通过return结束方法和将值返回
事件:
onclick 单击
onsubmit 表单提交
onload 页面加载成功或者元素加载成功
事件和函数绑定
方式1:通过元素的事件属性
<xxx onxxx="函数名(参数列表)">
方式2:派发事件
document.getelementbyid("id值").onxxx=function(){...};
document.getelementbyid("id值").onxxx=函数名;
/////////////////////////////////
案例1-定时弹出广告
需求:
打开页面后4秒,展示广告,2秒之后,该广告隐藏.再停2秒,继续展示.
技术分析:
定时器
定时器(bom-window对象)
setinterval(code,毫秒数):周期执行
settimeout(code,毫秒数):延迟多长事件后 只执行一次.
清除定时器
clearinterval(id):
cleartimeout(id):
步骤分析:
1.确定事件
2.编写函数
a.获取元素
b.操作元素
////////////////////////
1.html页面,先把广告隐藏
2.页面加载成功事件 onload
3.编写函数
定时器:
操作元素:
document.getelementbyid("")
操作css属性
document.getelementbyid("id").style.属性="值"
属性:就是css中属性 css属性有"-" 例如:backgroud-color
若有"-" 只需要将"-"删除,后面第一个字母变大写即可
注意:
只要是window对象的属性和方法,可以把window省略
window.onload 等价于 onload
window.setinterval() 等价于 setinterval()
////////////////////
bom(浏览器对象模型)总结
所有的浏览器都有5个对象
window:窗口
location:定位信息 (地址栏)
history:历史
window对象详解:
如果文档包含框架（frame 或 iframe 标签），浏览器会为 html 文档创建一个 window 对象，
并为每个框架创建一个额外的 window 对象。
常用的属性:
通过window可以获取其他的四个对象
window.location 等价域 location
window.history 等价于 history
...
常用的方法
消息框
alert("...."):警告框
confirm("你确定要删除吗?"):确定框 返回值:boolean
prompt("请输入您的姓名"):输入框 返回值:你输入的内容
定时器
设置定时器
setinterval(code,毫秒数):周期执行
settimeout(code,毫秒数):延迟多长事件后 只执行一次.
例如:
setinterval(showad,4000);
serinterval("showad()",4000);
清除定时器
clearinterval(id):
cleartimeout(id):
打开和关闭
open(url):打开
close():关闭
/////////////////////////
location:定位信息
常用属性:
href:获取或者设置当前页面的url(定位信息)
location.href; 获取url
location.href="...";设置url 相当于 a标签
//////////////////////
history:历史
back();后退
forward():向前
★go(int)
go(-1) 相当于 back()
go(1) 相当于 forward()
//////////////////////////////////////
案例2-表单校验plus
需求:
提示信息不用弹出框,将信息追加在文本框后面
技术分析:
确定事件 表单提交的时候 onsubmit
文本框失去焦点的时候 onblur
编写函数
获取元素
document.getelementbyid("id值");
操作元素(获取元素的值,操作标签体,操作标签value属性)
/////////////////
步骤分析:
1.表单
2.表单提交的时候 确定事件 onsubmit()
3.校验用户名和密码
4.获取用户名和密码的对象及值
5.判断内容,当为空的时候,获取响应的span元素
往span元素中显示错误信息
////////////////////////
注意:
在方法中(function()) this指代的是当前的元素(当前dom对象)
例如:
<input type="text" name="username" id="username" onblur="losefocus(this.value)">
方法:
function losefocus(obj){
alert(obj);
}
/////////////////////////////
事件总结:
常见的事件:
焦点事件:★
onfocus
onblur
表单事件:★
onsubmit
onchange 改变
页面加载事件:★
onload
鼠标事件(掌握)
onclick
鼠标事件(了解)
ondblclick:双击
onmousedown:按下
onmouserup:弹起
onmousemove:移动
onmouserover:悬停
onmouserout:移出
键盘事件(理解)
onkeydown:按下
onkeyup:弹起
onkeypress:按住
////////////
绑定事件:
方式1:
元素的事件属性
方式2:
派发事件
///////////////////
了解
阻止默认事件的发生
阻止事件传播
/////////////////
案例3-隔行换色
需求:
一个表格,隔一行换一个色
技术分析:
事件:onload
获取元素:dom操作
///////////////
获取元素:
document.getelementbyid("id"):通过id获取一个元素
document.getelementsbytagname("标签名"):通过标签名获取一种元素(多个)返回一个数组
array:
常用属性:
length:数组的长度
////////////////////////
步骤分析:
1.html表格一加载的时候 确定事件 onload
2.编写函数
a.获取元素(所有的tr元素)
b.操作(若当前行是偶数的话加一个样式,若是奇数的话,加另一个样式)
////////
//页面加载成功
onload=function(){
//1.获取所有的tr
var arr=document.getelementsbytagname("tr");
//alert(arr);
//alert(arr.length);
//2.判断奇偶数 添加不同的样式 遍历数组
for(var i=1;i<arr.length;i++){
if(i%2==0){
arr[i].style.backgroundcolor="#ffffcc";
}else{
arr[i].style.backgroundcolor="#bcd68d";
}
}
}
//////////////////////////
案例4:全选或者全不选
步骤分析:
1.确定事件 最上面那个复选框的单击事件 onclick
2.编写函数:让所有的复选框和最上面的复选框状态保持一致
a.获取最上面这个复选框选中状态 通过checkbox的checked属性即可
b.获取其他的复选框,设置他们的checked属性即可
可以通过以下两种方案获取元素
document.getelementsbyclassname():需要给下面所有的复选框添加class属性
document.getelementsbyname():需要给下面所有的复选框添加name属性
//////////////////////////////////
dom(文档对象模型)
当浏览器接受到html代码的时候,浏览器会将所有的代码装载到内存中,形成一棵树(document树)
节点(node)
文档节点 document
元素节点 element
属性节点 attribute
文本节点 text
获取节点:
通过document可以获取其他节点:
常用方法:
document.getelementbyid("id值"):获取一个特定的元素
document.getelementsbytagname("标签名"):通过标签名获取一种元素(多个)
document.getelementsbyclassname("class属性的值"):通过class属性获取一类元素(多个)
document.getelementsbyname("name属性的值"):通过name属性获取一类元素(多个)
设置获取获取节点的value属性
dom对象.value;获取
dom对象.value="";设置
设置或者获取节点的标签体
dom对象.innerhtml;获取
dom对象.innerhtml="";设置
获取或者设置style属性
dom对象.style.属性;获取
dom对象.style.属性="";设置
获取或者设置属性
dom对象.属性
/////////////////////////
对于htmldom的操作若在js或者htmldom 查找不到 去查找xml dom
关于文档的操作 在 xml dom 的document中
关于元素的操作 在 xml dom 的element中
appendchild(dom对象):在一个元素下添加孩子
//////////////////////////////////////
案例5-左右选中.
需求:
技术分析:
1.确定事件,按钮的单击事件
2.编写函数:
点击移动单|多个的:
a.获取左边选中的选项 select对象.options--数组
遍历数组 判断是否选中 option对象.selected
b.将其追加到右边的下拉选中
rightselect对象.appendchild(option);
点击移动所有的
a.获取左边的所有的选项
b.一个个的追加过去
///////////////////////
案例6-省市联动
需求:
选中省的时候,动态的查询当前省下的所有市,然后展示在市的下拉选中
技术分析:
数组:
////////////////////////
数组:
语法:
new array();//长度为0
new array(size);//指定长度的
new array(e1,e2..);//指定元素
非官方
var arr4=["aa","bb"];
常用属性:
length
注意:
数组是可变的
数组可以存放任意值
常用方法:(了解)
存放值:对内容的操作
pop():弹 最后一个
push():插入 到最后
shift():删除第一个
unshift():插入到首位
打印数组:
join(分隔符):将数组里的元素按照指定的分隔符打印
拼接数组:
concat():连接两个或更多的数组，并返回结果。
对结构的操作:
sort();排序
reverse();反转
////////////////////////
步骤分析:
1.省的下拉选 的选项中添加value属性 当成数组的索引
2.初始化市
3.选择省的时候,onchange事件
4.编写函数,
通过获取的索引获取对象的市的数组 this.value
遍历数组,将数组里面的每个值组装option 添加到select中即可
//////////////////////////////
引用类型总结:
原始类型中的string number boolean都是伪对象,可以调用相应的方法
array:数组
string:
语法:
new string(值|变量);//返回一个对象
string(值|变量);//返回原始类型
常用方法:
substring(start,end):[start,end)
substr(start,size):从索引为指定的值开始向后截取几个
charat(index):返回在指定位置的字符。
indexof(""):返回字符串所在索引
replace():替换
split():切割
常用属性:length
boolean:
语法:
new boolean(值|变量);
boolean(值|变量);
非0数字 非空字符串 非空对象 转成true
number
语法:
new number(值|变量);
number(值|变量);
注意:
null====>0
fale====>0 true====>1
字符串的数字=====>对应的数字
其他的nan
date:
new date();
常用方法:
tolocalstring()
regexp:正则表达式
语法:
直接量语法 /正则表达式/参数
直接量语法 /正则表达式/
new regexp("正则表达式")
new regexp("正则表达式","参数")
参数:
i:忽略大小写
g:全局
常用方法:
test() :返回值为boolean
math:
math.常量|方法
math.pi
math.random() [0,1)
全局:
★
decodeuri() 解码某个编码的 uri。
encodeuri() 把字符串编码为 uri。
number():强制转换成数字
string():转成字符串
parseint():尝试转换成整数
parsefloat():尝试转换成小数
eval() 计算 javascript 字符串，并把它作为脚本代码来执行。
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
上午回顾:
bom(浏览器对象模型)
window对象:窗口
注意:
若是window对象的属性和方法,调用的时候可以省略window
常用属性:
通过window可以获取其他的四个对象
window.location 等价于 location
常用方法:
消息框
alert() 警告框
confirm() 确认框 返回值:boolean
prompt() 输入框 返回值:输入的内容
定时器
设置
setinterval(code,毫秒数):循环
settimeout(code,毫秒数):延迟 只执行一次
清除
clearinterval(id):
cleartimeout(id):
打开和关闭
open(url)
close()
location对象:定位信息 地址栏
常用属性:
href:获取或者设置当前页面的url
location.href:获取
location.href="url":设置 相当于超链接
history对象:操作历史
常用方法:
go()
////////////////////////////
事件:
焦点:★
onfocus:获取焦点
onblur:失去焦点
表单事件:★
onsubmit: form表单里的
onchange:改变(下拉选)
页面或者对象加载:★
onload:
鼠标:★
onclick:单击
键盘:
onkeyup:
dom(★)
获取元素的方法(4个) document
操作元素的属性 dom对象.属性;
引用类型:
array
string
substring
全局:
编码2个
强制转化 number string
尝试 parsexxx
eval() 解析字符串形式的js代码
math random()