JavaScript

1、javaScript的概念:是一种表述语言,也是一种基于对象(Object)和事件驱动(EventDriven)的,安全性好的脚本语言,运行在客户端,从而减轻服务器端的负担,总结如下:

  1.javaScript主要用来向HTML页面找那个添加交互行为。

  2.javaScript是一种脚本语言,语法和java类似。

  3.javaScript一般用来编写客户端脚本。

  4.javaScript是一种解释性语言,边执行边解释。

2、javaScript由核心语法ECMAScript、浏览器对象模型(BOM) 主要用于管理窗口与窗口之间的通讯,因此其核心对象是window、文档对象模型(DOM)三部分组成.

3、网页中引入javaScript三种方式:

  1.使用标签内部样式

  2.使用外部js文件

  3.直接在HTML标签中的行内样式。

4.javaScript的作用

1.实现页面表单验证

2.实现页面交互特效

5.javaScript的特点

  1.被设计用来向Html页面添加交互行为

  2.是一种英特网上最流行的脚本语言

  3.一般用于编写客户端脚本

  4.是一种解释性语言

6.引入javaScript的方式

   1.使用

亲自试一试

#当你需要在某个页面同时执行两个变化处时使用{}

JavaScript 代码块

JavaScript 语句通过代码块的形式进行组合。

块由左花括号开始,由右花括号结束。

块的作用是使语句序列一起执行。

JavaScript 函数是将语句组合在块中的典型例子。

下面的例子将运行可操作两个 HTML 元素的函数:

实例

function myFunction()
{
document.getElementById("demo").innerHTML="Hello World";
document.getElementById("myDIV").innerHTML="How are you?";
}

亲自试一试


JavaScript 对大小写敏感。

JavaScript 对大小写是敏感的。

当编写 JavaScript 语句时,请留意是否关闭大小写切换键。

函数 getElementById 与 getElementbyID 是不同的。

同样,变量 myVariable 与 MyVariable 也是不同的。

空格

JavaScript 会忽略多余的空格。您可以向脚本添加空格,来提高其可读性。下面的两行代码是等效的:

var name="Hello";
var name = "Hello";
提示JavaScript 是脚本语言。浏览器会在读取代码时,逐行地执行脚本代码。而对于传统编程来说,会在执行前对所有代码进行编译。

JavaScript 变量

与代数一样,JavaScript 变量可用于存放值(比如 x=2)和表达式(比如 z=x+y)。

变量可以使用短名称(比如 x 和 y),也可以使用描述性更好的名称(比如 age, sum, totalvolume)。

  • 变量必须以字母开头
  • 变量也能以 $ 和 _ 符号开头(不过我们不推荐这么做)
  • 变量名称对大小写敏感(y 和 Y 是不同的变量)

提示:JavaScript 语句和 JavaScript 变量都对大小写敏感。

JavaScript 数据类型

JavaScript 变量还能保存其他数据类型,比如文本值 (name="Bill Gates")。

在 JavaScript 中,类似 "Bill Gates" 这样一条文本被称为字符串。

JavaScript 变量有很多种类型,但是现在,我们只关注数字和字符串。

当您向变量分配文本值时,应该用双引号或单引号包围这个值。

当您向变量赋的值是数值时,不要使用引号。如果您用引号包围数值,该值会被作为文本来处理。


我们使用 var 关键词来声明变量:

var carname;
提示 一个好的编程习惯是,在代码开始处,统一对需要的变量进行声明。

JavaScript 函数和事件

上面例子中的 JavaScript 语句,会在页面加载时执行。

通常,我们需要在某个事件发生时执行代码,比如当用户点击按钮时。

如果我们把 JavaScript 代码放入函数中,就可以在事件发生时调用该函数。

您将在稍后的章节学到更多有关 JavaScript 函数和事件的知识。

通常的做法是把函数放入 部分中,或者放在页面底部。这样就可以把它们安置到同一处位置,不会干扰页面的内容。

提示在面向对象的语言中,属性和方法常被称为对象的成员。

提示在面向对象的语言中,使用 camel-case 标记法的函数是很常见的。您会经常看到 someMethod() 这样的函数名,而不是 some_method()。

函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。

调用带参数的函数

在调用函数时,您可以向其传递值,这些值被称为参数。

这些参数可以在函数中使用。

您可以发送任意多的参数,由逗号 (,) 分隔:

myFunction(argument1,argument2)

当您声明函数时,请把参数作为变量来声明:

function myFunction(var1,var2)
{
这里是要执行的代码
}

变量和参数必须以一致的顺序出现。第一个变量就是第一个被传递的参数的给定的值,以此类推。

实例




亲自试一试

上面的函数会当按钮被点击时提示 "Welcome Bill Gates, the CEO"。

函数很灵活,您可以使用不同的参数来调用该函数,这样就会给出不同的消息:

实例



亲自试一试

?????根据您点击的不同的按钮,上面的例子会提示 "Welcome Harry Potter, the Wizard" 或 "Welcome Bob, the Builder"。

在您仅仅希望退出函数时 ,也可使用 return 语句。返回值是可选的:

function myFunction(a,b)
{
if (a>b)
  {
  return;
  }
x=a+b
}

如果 a 大于 b,则上面的代码将退出函数,并不会计算 a 和 b 的总和。

局部 JavaScript 变量

在 JavaScript 函数内部声明的变量(使用 var)是局部变量,所以只能在函数内部访问它。(该变量的作用域是局部的)。

您可以在不同的函数中使用名称相同的局部变量,因为只有声明过该变量的函数才能识别出该变量。

只要函数运行完毕,本地变量就会被删除。

全局 JavaScript 变量

在函数外声明的变量是全局变量,网页上的所有脚本和函数都能访问它。

JavaScript 变量的生存期

JavaScript 变量的生命期从它们被声明的时间开始。

局部变量会在函数运行以后被删除。

全局变量会在页面关闭后被删除。

向未声明的 JavaScript 变量来分配值

如果您把值赋给尚未声明的变量,该变量将被自动作为全局变量声明。

这条语句:

carname="Volvo";

将声明一个全局变量 carname,即使它在函数内执行。

JavaScript 运算符

条件运算符

JavaScript 还包含了基于某些条件对变量进行赋值的条件运算符。

语法

variablename=(condition)?value1:value2 

例子

greeting=(visitor=="PRES")?"Dear President ":"Dear ";

如果变量 visitor 中的值是 "PRES",则向变量 greeting 赋值 "Dear President ",否则赋值 "Dear"。

条件语句用于基于不同的条件来执行不同的动作。

条件语句

通常在写代码时,您总是需要为不同的决定来执行不同的动作。您可以在代码中使用条件语句来完成该任务。

在 JavaScript 中,我们可使用以下条件语句:

  • if 语句 - 只有当指定条件为 true 时,使用该语句来执行代码
  • if...else 语句 - 当条件为 true 时执行代码,当条件为 false 时执行其他代码
  • if...else if....else 语句 - 使用该语句来选择多个代码块之一来执行
  • switch 语句 - 使用该语句来选择多个代码块之一来执行

switch 语句用于基于不同的条件来执行不同的动作。

JavaScript Switch 语句

请使用 switch 语句来选择要执行的多个代码块之一。

语法

switch(n)
{
case 1:
  执行代码块 1
  break;
case 2:
  执行代码块 2
  break;
default:
  n 与 case 1 和 case 2 不同时执行的代码
}

工作原理:首先设置表达式 n(通常是一个变量)。随后表达式的值会与结构中的每个 case 的值做比较。如果存在匹配,则与该 case 关联的代码块会被执行。请使用 break 来阻止代码自动地向下一个 case 运行。

[javascript]  view plain  copy
  1.   
  2.   
  3.   
  4.   
  5. "button" οnclick="myFunction()">点击这里  
  6. "demo">

      
  7.   
  8.   
  9.   

JavaScript For 循环

循环可以将代码块执行指定的次数。

JavaScript 循环

如果您希望一遍又一遍地运行相同的代码,并且每次的值都不同,那么使用循环是很方便的。

我们可以这样输出数组的值:

document.write(cars[0] + "
"); document.write(cars[1] + "
"); document.write(cars[2] + "
"); document.write(cars[3] + "
"); document.write(cars[4] + "
"); document.write(cars[5] + "
");

不过通常我们这样写:

for (var i=0;i");
}

亲自试一试

不同类型的循环

JavaScript 支持不同类型的循环:

  • for - 循环代码块一定的次数
  • for/in - 循环遍历对象的属性
  • while - 当指定的条件为 true 时循环指定的代码块
  • do/while - 同样当指定的条件为 true 时循环指定的代码块

JavaScript 错误 - Throw、Try 和 Catch

try 语句测试代码块的错误。

catch 语句处理错误。

throw 语句创建自定义错误。

JavaScript 测试和捕捉

try 语句允许我们定义在执行时进行错误测试的代码块。

catch 语句允许我们定义当 try 代码块发生错误时,所执行的代码块。

JavaScript 语句 try 和 catch 是成对出现的。

语法

try
  {
  //在这里运行代码
  }
catch(err)
  {
  //在这里处理错误
  }

实例

在下面的例子中,我们故意在 try 块的代码中写了一个错字。

catch 块会捕捉到 try 块中的错误,并执行代码来处理它。












Throw 语句

throw 语句允许我们创建自定义错误。

正确的技术术语是:创建或抛出异常(exception)。

如果把 throw 与 try 和 catch 一起使用,那么您能够控制程序流,并生成自定义的错误消息。

语法

throw exception

异常可以是 JavaScript 字符串、数字、逻辑值或对象。

实例

本例检测输入变量的值。如果值是错误的,会抛出一个异常(错误)。catch 会捕捉到这个错误,并显示一段自定义的错误消息:

[javascript]  view plain  copy
  1.   
  2.   
  3.   
  4.   
  5.   
  6. My First JavaScript

      
  7. Please input a number between 5 and 10:

      
  8. "demo" type="text">  
  9. "button" οnclick="myFunction()">Test Input  
  10. "mess">

      
  11.   
  12.   
JavaScript 可用来在数据被送往服务器前对 HTML 表单中的这些输入数据进行验证。

必填(或必选)项目

下面的函数用来检查用户是否已填写表单中的必填(或必选)项目。假如必填或必选项为空,那么警告框会弹出,并且函数的返回值为 false,否则函数的返回值则为 true(意味着数据没有问题):

function validate_required(field,alerttxt)
{
with (field)
{
if (value==null||value=="")
  {alert(alerttxt);return false}
else {return true}
}
}

下面是连同 HTML 表单的代码:







Email:

E-mail 验证

下面的函数检查输入的数据是否符合电子邮件地址的基本语法。

意思就是说,输入的数据必须包含 @ 符号和点号(.)。同时,@ 不可以是邮件地址的首字符,并且 @ 之后需有至少一个点号:

function validate_email(field,alerttxt)
{
with (field)
{
apos=value.indexOf("@")
dotpos=value.lastIndexOf(".")
if (apos<1||dotpos-apos<2) 
  {alert(alerttxt);return false}
else {return true}
}
}

下面是连同 HTML 表单的完整代码:







Email:



        • 在html中使用javascript
        • javascript类型一览
        • javascript Object类型
        • javascript Function类型
        • javascript String类型
        • javascript Date类型
        • javascript RegExp类型
        • javascript Array类型
        • javascript Global对象
        • BOM
        • DOM
        • JSON
        • Ajax

说明:本笔记所有内容几乎都摘自JavaScript高级程序设计(第三版),记笔记只是为了让自己记得更牢,如有侵权行为我会删除此文章。在此我极力向大家推荐这本书,确实写的很好。 
另外下面大部分例子都是在chrome的控制台中调试的,关于控制台的使用方法,参考Chrome控制台使用详解。在此只补充一点:想要多行输入只需Shift+Enter即可。

1.在html中使用javascript

引入脚本

<script type="text/javascript" src="script_path">script>
 
   
   
   
   
  • 1

直接嵌入代码

<script type="text/javascript">
    alert("hello world");
script>
 
   
   
   
   
  • 1
  • 2
  • 3

需要注意的是当有src属性时,嵌入的代码会被忽略

其它常用属性

属性 作用
defer 延迟 表示脚本延迟到文档完全被解析和显示之后再执行,只对外部脚本有效
async 异步 表示立即下载脚本,但不能影响其它操作,比如下载其它资源或等待加载其它脚本,只对外部脚本有效
type 说明脚本类型
src 包含外部脚本

关于defer与async的详细说明: 
defer的作用是让脚本延迟到整个页面都解析完毕后再运行,设置defer属性相当于告诉浏览器立即下载,但延迟到遇到标签后再执行,html5规范要求脚本按照它们出现的先后顺序执行,并且先于DOMContentLoaded事件执行,但在现实中延迟脚本并不一定会按照顺序执行,也不一定会在DOMContentLoaded事件触发前执行 
async的作用是不让页面等待脚本下载和执行,从而异步加载页面其他内容,因此,异步脚本最好不要在加载期间修改DOM,异步脚本一定会在页面的load事件前执行,但可能会在DOMContentLoaded事件触发之前或之后执行,异步脚本不按照它们在页面出现的顺序执行

2.javascript类型一览

基本类型:undefined,null,boolean,number,string 
引用类型:object 
可以用typeof操作符查看类型,需要注意的是typeof并不是函数, 
可以用typeof(myvarlue)的形式,也可以用typeof myvarlue

typeof返回值说明

返回值 出现情况
undefined 如果这个值未定义
boolean 如果这个值是布尔值
string 如果这个值是字符串
number 如果这个值是数值
object 如果这个值是对象或null
function 如果这个值是函数

来看一个例子

var str1 = 'hello world';
var str2
console.log(typeof str1); //string
console.log(typeof str2); //undefined
console.log(typeof str3); //undefined
console.log(typeof 66); //number
console.log(typeof null); //object
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

需要注意的是对声明了未初始化和未声明的变量执行typeof都返回undefined 
对于null返回object是因为null被认为是一个空的对象引用 
另外,undefined是派生自null的,因此以下相等性测试返回true

console.log(null == undefined); //true
 
   
   
   
   
  • 1

3.javascript Object类型

var animal1 = new Object();
//or animal = Object(); new可以省略
animal1.name = 'dog';
animal1.color = 'white';
console.log(animal1.name); //dog
console.log(animal1['color']); //white
//另一种方式创建对象
var animal2 = {}; //此方式其实并没有调用Object构造函数
animal2.name = 'cat';
//带初始化值
var animal3 = Object({name:'cat',age:10});
var animal4 = {name:'cat',age:10};
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

4.javascript Function类型

3种创建函数的方式

//第一种
function hello(name)
{
     
    alert('hello ' + name);
}
//第二种
var hello = function(name)
{
     
    alert('hello ' + name);
};
//第三种
var hello = new Function('name','alert("hello " + name)');
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

这三种方式不推荐使用第三种,因为第三种语法会导致解析两次代码从而影响性能,关于第一种和第二种的区别见下例

//调用在声明前面,但结果仍然正确
hello('world');
function hello(name)
{
     
    alert('hello ' + name);
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
//调用在声明前面,会出错
hello('world');
var hello = function(name)
{
     
    alert('hello ' + name);
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

这是因为用第一种方式时,解析器会率先读取函数声明,并使其在执行任何代码之前可用;而对于第二种方式,则必须等到解析器执行到它所在的代码行,才会真正被解释执行。

javascript的函数在对待参数方面是比较特殊的。它不介意传递进去多少个参数,也不在乎传递进来的参数是什么数据类型。也就是说,即便你定义的函数只接收两个参数,在调用这个函数时也未必一定要传递两个参数,可以传递一个,三个甚至不传递参数,而解析器永远不会有什么怨言。之所以会这样,是因为ECMAScript中的参数在内部是用一个数组来表示的。函数接收到的始终是这个数组,而不关心数组中包含哪些参数。如果这个数组中不包含任何元素,无所谓;如果包含多个元素,也没有问题。在函数内部可以通过arguments对象来访问这个参数数组。

一个例子

function hello(name)
{
     
    console.log('hello ' + name);
    console.log('hello ' + arguments[0]);
    console.log('hello ' + arguments[1]);
    console.log('hello ' + arguments[2]);
    console.log(arguments.length);
}
hello('world','you');
//结果为
//hello world
//hello world
//hello you
//hello undefined
//2
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

javascript的函数实际上是对象。函数也有属性和方法。每个函数都有两个属性:length和prototype。length表示函数希望接收的参数个数,prototype是保存实例方法的真正所在。每个函数都包含两个方法:apply()和call(),这两个函数的作用都是在特定的作用域中调用函数,apply()接收两个参数,一个是作用域,另一个是参数数组,第二个参数可以是Array,也可以是arguments对象,call()与apply()的不同之处在于参数的传递方式。

一个例子

function hello1(name)
{
     
    alert('hello' + name);
}
function hello2()
{
     
    alert('hello')
}
hello1.length; //1
hello2.length; //0
function sum(num1,num2)
{
     
    return num1 + num2;
}
function callSum1(num1,num2)
{
     
    return sum.apply(this,arguments);
}
function callSum2(num1,num2)
{
     
    return sum.apply(this,[num1,num2]);
}
function callSum3(num1,num2)
{
     
    return sum.call(this,num1,num2);
}
callSum1(10,10); //20
callSum2(10,10); //20
callSum3(10,10); //20
//通过call扩充函数的作用域
var color = 'red';
var o = {color:'blue'};
function sayColor()
{
     
    console.log(this.color);
}
sayColor(); //red
sayColor.call(this); //red
sayColor.call(window); //red
sayColor.call(o); //blue
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

5.javascript String类型

主要是与string相关的函数的使用,直接看例子吧

var str1 = 'hello';
//输出指定位置字符
str1.charAt(0); //h
//输出指定位置字符的编码
str1.charCodeAt(0); //104
//通过索引访问
str1[0]; //h
//连接字符串
str1.concat(' world'); //hello world
//slice
str1.slice(1); //ello
str1.slice(1,3); //el
//substring
str1.substring(1); //ello
str1.substring(1,3); //el
//substr,注意与slice与substring的区别
str1.substr(1); //ello
str1.substr(1,3); //ell
//indexof lastIndexOf
str1.indexOf('l'); //2
str1.indexOf('l',3); //3
str1.lastIndexOf('l'); //3
str1.lastIndexOf('l',2); //2
//trim 删除前后空格
var str2 = ' hello ';
str2.trim(); //hello
//大小写转换
var str3 = 'Hello';
str3.toLowerCase(); //hello
str3.toUpperCase(); //HELLO
//模式匹配
vat str4 = 'hello world';
var pattern = /hello/;
//match
var matches = str4.match(pattern);
matches.index; //0
matches[0]; //hello
//search 返回第一个匹配项的索引,没有匹配项则返回-1
str4.search(pattern); //0
//replace
str4.replace('l','x'); //hexlo world
str4.replace(/l/g,'x'); //hexxo worxd
//split
var colors = 'red,blue,green,yellow';
colors.split(','); //['red','blue','green','yellow']
colors.split(',',2); //['red','blue']
colors.split(/[^\,]+/); //['',',',',',',','']
//字符串比较 localeCompare
var str5 = 'hello';
str5.localeCompare('world'); //-1
str5.localeCompare('black'); //1
str5.localeCompare('hello'); //0
//fromCharCode 将字符编码转换成相应字符
String.fromCharCode(104,101,108,108,111); //hello

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

以上所有方法都不会改变原字符串,另外上面对replace方法介绍比较简略,下面详细说明一下 
直接看例子

var str = 'left hello world right';
//$n 引用分组
str.replace(/(hello) (world)/,'$2 $1'); //left world hello right
//$$ 表示$
str.replace(/(hello) (world)/,'$$'); //left $ right
//$& 表示匹配的项
str.replace(/(hello) (world)/,'$&'); //left hello world right
//$' 表示匹配项之后的字符串
str.replace(/(hello) (world)/,"$'"); //left right right
//$` 表示匹配项之前的字符串
str.replace(/(hello) (world)/,'$`'); //left left right
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

另外,replace的第二个参数也可以是函数。在只有一个匹配项时,会向这个函数传递3个参数:模式的匹配项,模式匹配项在字符串中的位置和原始字符串。在正则表达式中定义了多个捕获组的情况下,传递给函数的参数依次是模式的匹配项,第一个捕获组的匹配项,第二个捕获组的匹配项……,但最后两个参数仍然分别是模式的匹配项在字符串中的位置和原始字符串,这个函数应该返回一个字符串作为替换文本。

来看一个摘自Javascript高级程序设计(第三版)的例子

function htmlEscape(text)
{
     
    return text.replace(/[<>"&]/g,function(match,pos,originalText){
     
        switch(match){
            case "<":
                return "<";
            case ">":
                return ">";
            case "&":
                return "&";
            case "\"":
                return """;
        }
    });
}
htmlEscape("

hello world!

"
); //<p class="greeting">hello world!</p>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

6.javascript Date类型

var mytime = new Date();
mytime.getFullYear(); //四位的年份
mytime.getMonth(); //月份
mytime.getDate(); //天数
mytime.getDay(); //星期
mytime.getHours(); //小时
mytime.getMinutes(); //分钟
mytime.getSeconds(); //秒数
mytime.getMilliseconds(); //毫秒数
mytime.toLocaleString(); //与特定时区相关的时间格式
Date.now(); //总毫秒数
//设置时间,表示 2015年9月20号17时20分30秒
//月份是用0-11表示的,所以8表示9月
var mytime1 = new Date(2015,8,20,17,20,30);

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

7.javascript RegExp类型

创建正则表达式的方法 
var mypattern = /pattern/flags 或 
var mypattern = new RegExp(‘pattern’,’flags’) 
由于用构造函数创建时可能需要双重转义,所以用第一种方式有时更简洁

flags的取值

作用
g 表示全局模式,即模式被应用于所有的字符串,而非发现第一个匹配项时立即停止
i 忽略大小写
m 多行模式,即在到达一行文本末尾时还会继续查找下一行中是否存在模式匹配的项

一个例子

var mypattern1 = /hello/i;
var mypattern2 = /hello/;
//test方法用来测试给定字符串中是否存在匹配模式
mypattern1.test('Hello world'); //true
mypattern2.test('Hello world'); //false
//RegExp实例属性
//是否设置了g标志
mypattern1.global; //false
//是否设置了i标志
mypattern1.ignoreCase; //true
//开始搜索下一个匹配项的字符位置,从0算起
mypattern1.lastIndex; //0
//是否设置了m标志
mypattern1.multiline; //false
//正则表达式的字符串表示,按照字面量形式返回
mypattern1.source; //hello

//exec
var mypattern3 = /(he)l(lo)/i;
var matches = mypattern3.exec('Hello world');
//匹配项在字符串中的位置
matches.index; //0
//输入的字符串
matches.input; //Hello world
//匹配到的字符串
matches[0]; //Hello
//匹配到的第一个分组
matches[1]; //He
//匹配到的第二个分组
matches[2]; //lo
//匹配到的第三个分组,在此没有第三个分组,为undefined
matches[3]; //undefined
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

对exec的补充说明:对于exec而言,即使在模式中设置了全局标志(g),它每次也只返回一个匹配项。在不设置全局标志的情况下,在同一个字符串上多次调用exec将始终返回第一个匹配项的信息。而在设置全局标志的情况下,每次调用exec则都会在字符串中继续查找新匹配项。

8.javascript Array类型

var animal1 = new Array();
//or var animal = Array()
//指定数组长度
var animal2 = Array(10);
//带初始化值
var animal3 = Array('dog','cat','fox');
//另一种方式
var animal4 = []; //并没有调用Array构造函数
var animal5 = ['mouse','cat'];
//访问元素
console.log(animal5[0]); //mouse
console.log(animal5.length); //2
//检测数组
Array.isArray(animal5); //true
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

一些方法,假定数组名为myarr

名称 作用
myarr.toString() 返回数组的字符串表示,以逗号分隔,为了取得每一项的值调用每一项的toString()方法
myarr.valueOf() 还是返回这个数组
myarr.toLocaleString() 返回数组的字符串表示,为了取得每一项的值调用每一项的toLocaleString()方法
myarr.join() 返回数组的字符串表示,默认以逗号分隔,可以自己指定分隔符
myarr.push() 在末尾添加元素,参数个数不限,返回修改后的数组长度
myarr.pop() 移除末尾项,返回移除的元素
myarr.shift() 移除第一项,返回移除的元素
myarr.unshift() 在头部添加元素,参数个数不限,返回修改后的数组长度
myarr.sort() 正向排序,此方法默认是按字符串比较的方式排序的(即使是数字),可以给它传递一个比较函数来自定义比较行为,比较函数接收两个参数,如果第一个参数位于第二个参数之前则返回一个负数,相等返回0,之后返回正数,此方法返回经过排过序的数组
myarr.reverse() 反向排序,其它同sort
myarr.concat() 基于数组的项以及参数的项创建一个新数组并返回
myarr.slice() 基于数组中的一个或多个项创建一个新数组并返回,可以接受一或两个参数来指明返回项的起始和结束位置(包含起始位置项,不包含结束位置项),若不传递参数返回所有项,传递一个参数时结束位置默认为末尾
myarr.splice() 参数个数不限,第一参数指定要删除元素的第一项位置,第二个参数指定要删除的项数,后续参数指定插入的元素,返回由删除的元素组成的数组
myarr.indexOf() 正向查找,接收两个参数,第一个为要查找的项,第二个为表示查找起点位置的索引(可选,默认从开头查找),如果没找到返回-1,找到的话返回索引
myarr.lastIndexOf() 反向查找,其它同indexOf

一个例子

//sort reverse
var myarr1 = [1,2,15,10,9];
myarr1.sort(); //[1,10,15,2,9]
function mycompare(value1,value2)
{
     
    return value1 - value2;
}
myarr1.sort(mycompare); //[1,2,9,10,15]
myarr1.reverse(mycompare); //[15,10,9,2,1]
//concat
var myarr2 = [1,2];
myarr2.concat(); //[1,2]
myarr2.concat(3); //[1,2,3]
myarr2.concat(3,['white','black']); //[1,2,3,'white','black']
//slice
var myarr3 = [1,2,3,4,5];
myarr3.slice(); //[1,2,3,4,5]
myarr3.slice(1); //[2,3,4,5]
myarr3.slice(1,3); //[2,3]
myarr3.slice(1,1); //[]
//splice
var myarr4 = [1,2,3,4];
myarr4.splice(0,1); //返回[1]
console.log(myarr4); //[2,3,4]
myarr4.splice(0,0,'white','black'); //返回[]
console.log(myarr4); //['white','black',2,3,4]
//indexOf lastIndexOf
var myarr5 = ['white','black','pink','white'];
myarr5.indexOf('white'); //0
myarr5.lastIndexOf('white'); //3
myarr5.indexOf('white',1); //3
myarr5.lastIndexOf('white',2); //0
myarr5.indexOf('yellow'); //-1
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

以下方法为迭代方法,每个方法都接收两个参数:要在每一项上运行的函数和(可选的)运行该函数的作用域对象,这些方法都不改变原数组。传入这些方法中的函数会接收三个参数:数组项的值,该项在数组中的位置和数组对象本身。在此假定数组名为myarr

方法名 作用
myarr.every() 对数组中的每一项运行给定函数,如果该函数对每一项都返回true,则返回true
myarr.filter() 对数组中的每一项运行给定函数,返回该函数会返回true的项组成的数组
myarr.forEach() 对数组中的每一项运行给定函数,无返回值
myarr.map() 对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组
myarr.some() 对数组的每一项运行给定函数,只要存在某一项让函数返回true,就返回true

一个例子

function myfunc1(item,index,array)
{
     
    return item > 2;
}
function myfunc2(item,index,array)
{
     
    return item % 2 == 0;
}
function myfunc3(item,index,array)
{
     
    return item * 2;
}
function myfunc4(item,index,array)
{
     
    console.log(item);
}
var myarr = [1,2,3,4,5];
//every
myarr.every(myfunc1); //false
//some
myarr.some(myfunc1); //true
//filter
myarr.filter(myfunc2); //[2,4]
//map
myarr.map(myfunc3); //[2,4,6,8,10]
//forEach
myarr.forEach(myfunc4); //1 2 3 4 5
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

最后再介绍两个方法reduce()和reduceRigth()。这两个方法都会迭代数组的所有项,然后构建一个最终返回的值。区别是reduce从前往后,reduceRight从后往前。这两个方法都接收两个参数:一个在每一项上调用的函数和(可选的)初始值。传递给它俩的函数接收4个参数:前一个值,当前值,项的索引和数组对象。

一个例子

function mysum(prev,cur,index,array)
{
     
    return prev + cur;
}
myarr = [1,2,3];
myarr.reduce(mysum); //6
myarr.reduce(mysum,5); //11
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

9.javascript Global对象

在javascript中,不属于任何其他对象的属性和方法,最终都是Global对象的属性和方法。事实上,没有全局变量或全局函数,所有全局作用域中定义的属性和函数,都属于Global对象。ECMAScript虽然没有指出如何直接访问Global对象,但web浏览器都是将这个全局对象作为window对象的一部分加以实现的。因此,在全局作用域中声明的所有变量和函数就都成了window对象的属性。 
除了用window对象,我们可以用下列方式获得Global对象

var global = function(){
     
    return this;
}();
 
   
   
   
   
  • 1
  • 2
  • 3

在此介绍一些Global对象比较有用的方法 
首先是URI编码方法,看例子

//encodeURI
var uri = 'http://www.test.com/illegal value.html?user=username';
encodeURI(uri);
//http://www.test.com/illegal%20value.html?user=username
//encodeURIComponent
encodeURIComponent(uri);
//http%3A%2F%2Fwww.test.com%2Fillegal%20value.html%3Fuser%3Dusername
//另外可以用decodeURI和decodeURIComponent对编码的结果解码

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

它们的区别是encodeURI不会对本身属于URI的特殊字符进行编码,例如冒号,正斜杠,问号等;而encodeURIComponent()则会对它发现的任何非标准字符进行编码。

另一比较有用的方法是eval 
eval接收一个参数,它会把传入的参数当代码执行,看下面的例子

eval('2 + 3 * 4'); //14
eval("alert('hello world')"); //hello world
 
   
   
   
   
  • 1
  • 2

10.BOM

取得窗口位置

var leftPos = (typeof window.screenLeft == 'number') ?
                window.screenLeft : window.screenX;
var topPos = (typeof window.screenTop == 'number') ?
                window.screenTop : window.screenY;
//这样写主要是保持兼容性,有的浏览器只支持screenLeft,有的只
//支持screenX,有的都支持
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

移动窗口与调整窗口大小

//moveTo 两个参数:新位置的x和y坐标
//moveBy 两个参数:水平和垂直方向上移动的像素数
//resizeTo 两个参数:新宽度与新高度
//resizeBy 两个参数:新窗口与原窗口的宽度和高度之差
//这四个方法可能会被浏览器禁用
window.moveTo(50,100);
window.moveBy(20,20);
window.resizeTo(300,300);
window.resizeBy(20,-10);
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

取得页面视图的大小

var pageWidth = window.innerWidth;
var pageHeight = window.innerHeight;
if(typeof pageWidth != 'number')
{
    if(document.compatMode == 'CSS1Compat')
    {
        pageWidth = document.documentElement.clientWidth;
        pageHeight = document.documentElement.clientHeight;
    }else{
        pageWidth = document.body.clientWidth;
        pageHeight = documetn.body.clientHeight;
    }
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

间歇调用与超时调用

//1秒后执行函数
var timeoutId = setTimeout(function(){
     alert('hello world');},1000);
//取消调用
clearTimeout(timeoutId);
//每隔1秒执行一次函数
var intervalId = setInterval(function(){
     alert('hello world');},1000);
//取消调用
clearInterval(intervalId);
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

系统对话框

//prompt 第一个参数是显示给用户的文本提示
//       第二个参数是文本框中的默认值
var expre = prompt("输入表达式","expression");
alert(eval(expre));
if(confirm('你认为结果对吗'))
{
    alert('Very good');
}else{
    alert('Sorry');
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

location对象

属性名 作用
hash 返回URL中#后的字符(包含#号)
host 返回服务器名和端口号
hostname 返回不带端口号的服务器名称
href 返回完整的URL
pathname 返回URL中的目录和文件名
port 返回端口号
protocol 返回协议,http:或https:
search 返回查询字符串,例如:’?name=username’
//打开指定网址
location.assign('http://www.test.com'); //或
window.location = 'http://www.test.com'; //或
location.href = 'http://www.test.com'; //或
location.replace('http://www.test.com');
//replace与上面三种方法的区别是它不会在历史记录中生成新记录
//因此不能通过后退按钮回到前一个页面

//重新加载
location.reload(); //有可能从缓存加载
location.reload(true); //强制从服务器加载

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

navigator对象 
此对象属性很多,在此只列举常用的

//检测插件(非ie)
for(var i=0;i//浏览器名称
navigator.appName;
//cookie是否启用
navigator.cookieEnabled;
//浏览器所在的系统平台
navigator.platform;
//浏览器的用户代理字符串
navigator.userAgent;

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

history对象

history.go(-1); //后退一页
history.go(2); //前进两页
history.go('test.com'); //跳转到历史记录中包含'test.com'的第一个位置
//可能后退,也可能前进,具体看哪个位置最近
history.forward(); //前进一页
history.back(); //后退一页
history.length; //历史记录的数量

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

11.DOM

节点类型

英文表示 对应的数字
ELEMENT_NODE 1
ATTRIBUTE_NODE 2
TEXT_NODE 3
CDATA_SECTION_NODE 4
ENTITY_REFERENCE_NODE 5
ENTITY_NODE 6
PROCESSING_INSTRUCTION_NODE 7
COMMENT_NODE 8
DOCUMENT_NODE 9
DOCUMENT_TYPE_NODE 10
DOCUMENT_FRAGMENT_NODE 11
NOTATION_NODE 12
//确定节点类型
//在ie中无效
if(someNode.nodeType == Node.ELEMENT_NODE)
{
    alert("Node is an element");
}
//适用于所有浏览器
if(someNode.nodeType == 1)
{
    alert("Node is an element");
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

节点的属性及方法

//读取节点属性的方法
someNode.nodeName; //标签名
someNode.nodeValue; //值
someNode.parentNode; //父节点
someNode.firstChild;
someNode.lastChild;
someNode.previousSibling; //同一列表中someNode的前一节点
someNode.nextSibling; //同一列表中someNode的后一节点
someNode.hasChildNodes(); //有子节点时返回true
var firstChild = someNode.childNodes[0];
var secondChild = someNode.chileNodes.item(1);
var count = someNode.childNodes.length;

//改变节点
someNode.appendChild(newNode);
someNode.insertBefore(newNode,someNode.firstChild);
someNode.replaceChild(newNode,someNode.firstChild);
someNode.removeChild(someNode.firstChild);
var newNode = oldNode.cloneNode(true); //深复制,若参数是false则为浅复制

 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

document对象

document.documentElement; //取得对的引用
document.title; //取得文档标题
document.body; //取得对的引用
document.URL; //取得完整的URL
document.domain; //取得域名
document.referrer; //取得来源页面的URL

//取得元素
document.getElementById("id");
document.getElementsByTagName("img");
document.getElementsByName("color");
document.anchors; //包含文档中所有带name特性的元素
document.forms; //包含文档中的所有
元素 document.images; //包含文档中的所有元素 document.links; //包含文档中所有带href特性的元素 //特性 someNode.getAttribute("attributeName"); someNode.setAttribute("attributeName","value"); someNode.removeAttribute("attributeName"); //创建元素 var div = document.createElement("div"); div.id = "mydiv"; div.className = "box"; //创建文本节点 var textNode = document.createTextNode("hello"); textNode.appendData(text); //将text添加到节点的末尾 textNode.deleteData(offset,count); //从offset指定的位置开始删除count个字符 textNode.insertData(offset,text); //在offset指定的位置插入text textNode.replaceData(offset,count,text); //用text替换从offset指定的位置开始到offset+count位置处的文本 textNode.splitText(offset); //从offset指定的位置将当前文本分成两个文本节点 textNode.substringData(offset,count); //提取从offset指定位置开始到offset+count为止处的字符串
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

dom扩展

//querySelector
document.querySelector("body"); //取得body元素
document.querySelector("#mydiv"); //取得id为mydiv的元素
document.querySelector(".classname"); //取得类为classname的第一个元素
document.body.querySelector("img.button"); //取得类为button的第一个图象元素

//querySelectorAll
document.querySelectorAll(".classname"); //取得类为classname的所有元素
document.querySelectorAll("p strong"); //取得所有

元素中的所有元素 //dom元素新属性 myNode.childElementCount; //返回子元素(不包含文本节点和注释)的个数 myNode.firstElementChild; //第一个元素 myNode.lastElementChild; //最后一个元素 myNode.previousElementSibling; //前一个同辈元素 myNode.nextElementSilling; //后一个同辈元素

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

html5新规范

//取得指定类名的元素,类名的先后顺序无所谓
document.getElementsByClassName("username current");

//
div.classList.remove("user"); //删除user div.classList.toggle("user"); //有user删除,没有添加 div.classList.add("user"); //无user添加,有不添加 div.classList.contains("user"); //存在user返回true,否则返回false //焦点管理 var button = document.getElementById("myButton"); button.focus(); document.activeElement === button; //true button.hasFocus(); //true //其它 document.readyState; //若为loading,表示正在加载文档,若为complete,表示已经加载完文档 document.compatMode; //若为CSS1Compat,表示标准模式,若为BackCompat,表示混杂模式 document.head; //引用元素 document.charset = "utf-8"; //字符编码 //

la

var div = document.getElementById("content"); div.innerHTML; //

la

div.outerHTML; //

la

//insertAdjacentHTML //两个参数:插入位置和要插入的HTML文本 //作为前一个同辈元素插入 element.insertAdfacentHTML("beforebegin","

la

"
); //作为第一个子元素插入 element.insertAdjacentHTML("afterbegin","

la

"
); //作为最后一个子元素插入 element.insertAdjacentHTML("beforeend","

la

"
); //作为最后一个同辈元素插入 element.insertAdjacentHTML("afterend","

la

"
); //scrollIntoView //传入true或不传参数那么窗口滚动之后会让调用元素的顶部与视口顶部尽可能平齐 //传入false调用元素会尽可能全部出现在视口中 document.forms[0].scrollIntoView();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

添加与移除事件

var btn = document.getElementById("myBtn");
var handler = function(){
     alert(this.id);};
btn.addEventListener("click",handler,false);
//false表示在冒泡阶段调用事件处理程序,若为true则表示在捕获阶段调用处理程序
btn.removeEventListener("click",handler,false); //移除事件

//一个通用的事件添加与移除程序
var EventUtil = {
    addHandler:function(element,type,handler){
     
        if(element.addEventListener){
            element.addEventListener(type,handler,false);
        else if(element.attachEvent){
            element.attachEvent("on"+type,handler);
        else{
            element["on"+type] = handler;
        }
    }
    removeHandler:function(element,type,handler){
     
        if(element.removeEventListener){
            element.removeEventListener(type,handler,false);
        }else if(element.detachEvent){
            element.detachEvent("on"+type,handler);
        else{
            element["on"+type] = null;
        }
    }
};
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

ui事件

事件名 说明
load 当页面完全加载后在window上面触发,当所有框架都加载完毕时在框架集上面触发,当图象加载完毕时在元素上面触发,或者当嵌入的内容加载完毕时在≶object>元素上面触发
unload 当页面完全卸载后再window上面触发,当所有框架都卸载后再框架集上面触发,或者当嵌入的内容卸载完毕后再元素上面触发
abort 在用户停止下载过程时,如果嵌入的内容没有加载完,则在上面触发
error 当发生javascript错误时在window上面触发,当无法加载图像时在元素上面触发,当无法加载嵌入内容时在元素上面触发,或者当有一或多个框架无法加载时在框架集上面触发
select 当用户选择文本框中的一或多个字符时触发
resize 当窗口或框架的大小变化时在window或框架上面触发
scroll 当用户滚动带滚动条的元素中的内容时,在该元素上面触发

焦点事件

事件名 说明
blur 在元素失去焦点时触发,这个事件不会冒泡
focus 在元素获得焦点时触发,这个事件不会冒泡
focusin 在元素获得焦点时触发,会冒泡
focusout 在元素失去焦点时触发,会冒泡

鼠标与滚轮事件

事件名 说明
click 单击鼠标按钮或按下回车时触发
dblclick 双击鼠标按钮时触发
mousedown 按下任意鼠标按钮时触发
mouseenter 在鼠标光标从元素外部首次移到元素范围之内时触发,不冒泡
mouseleave 在位于元素上方的鼠标光标移到元素范围之外时触发,不冒泡
mousemove 当鼠标指针在元素内部移动时重复的触发
mouseout 当鼠标指针位于一个元素上方,然后用户将其移入另一个元素时触发
mouseover 在鼠标指针位于一个元素外部,然后用户将其首次移入另一个元素边界之内时触发
mouseup 在用户释放鼠标按钮时触发

键盘与文本事件

事件名 说明
keydown 当用户按下键盘的任意键时触发,如果按住不放会重复触发该事件
keypress 当用户按下键盘的字符键时触发,如果按住不放会重复触发该事件
keyup 当用户释放键盘上的键时触发
textInput 在文本插入文本框之前会触发textInput事件

表单相关

var form = document.getElementById("myform");
form.submit(); //提交表单
form.reset(); //重置表单
var field1 = form.elements[0]; //取得表单第一个字段
var field2 = form.elements["textbox1"]; //取得名为textbox1的字段
var fieldCount = form.elements.length;

//取得选择的文本
textbox.value.substring(textbox.selectionStart,textbox.selectionEnd);
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

html5验证

/*





*/
//必填字段没有值是无效的,字段中的值与pattern不匹配也是无效的
if(document.forms[0].elements[0].checkValidity()){
    //有效时执行的代码
}else{
    //无效时执行的代码
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

12.JSON

用JSON.stringify()序列化Javascript对象 
用JSON.parse()将json格式的数据转成Javascript对象

var book = {
    title:"JavaScript",
    authors:"John",
    edition:3
};
var jsonText = JSON.stringify(book);
jsonText; 
//{"title":"JavaScript","authors":"John","edition":3}
JSON.parse(jsonText); 
//Object {title: "JavaScript", authors: "John", edition: 3}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

JSON.stringify()还可以接收另外两个参数 
第一个是过滤器,可以是数组也可以是函数 
第二个是一个选项,表示是否在JSON字符串中保留缩进

var book = {
    title:"JavaScript",
    authors:["John","Mike"],
    edition:3
};
var jsonText = JSON.stringify(book,['title','authors']);
jsonText;
//{"title":"JavaScript","authors":["John","Mike"]}
var myfun = function(key,value){
     
    switch(key){
        case "authors":
            return value.join(",");
        case "edition":
            return undefined;
        default:
            return value;
    }
}
jsonText = JSON.stringify(book,myfun);
//{"title":"JavaScript","authors":"John,Mike"}
//如果返回undefined,相应属性会被忽略
//每个级别缩进4个空格
JSON.stringify(book,myfun,4);
//{
     
//    "title": "JavaScript",
//    "authors": "John,Mike"
//}
//设置缩进字符
JSON.stringify(book,myfun,"--");
//{
     
//--"title": "JavaScript",
//--"authors": "John,Mike"
//}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

JSON.parse()可以接收第二个参数,该参数是函数,其用法与JSON.stringify的第二个参数类似。另外对象还有toJSON方法,假如把一个对象传入JSON.stringify(),序列化该对象的顺序如下: 
1.如果存在toJSON()方法而且能通过它取得有效的值,则调用该方法,否则按默认顺序执行序列化。 
2.如果提供了第二个参数,应使用这个函数过滤器,传入函数过滤器的值是第1步返回的值。 
3.对第2步返回的每个值进行相应的序列化。 
4.如果提供了第三个参数,执行相应的格式化。

13.Ajax

get请求

var xhr = new XMLHttpRequest();
xhr.open("get","test.php",false); //false表示同步请求
xhr.send(null);
if( (xhr.status>=200 && xhr.status<300) || xhr.status==304 ){
    alert(xhr.responseText);
}else{
    alert("Request was unsucessful:" + xhr.status);
}
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
     
    if(xhr.readyState == 4){
        if ((xhr.status>=200 && xhr.status < 300) || xhr.status == 304){
            alert(xhr.responseText);
        }else{
            alert("Request was unsuccessful:" + xhr.status);
        }
    }
};
xhr.open("get","test.php",true); //异步发送请求
xhr.send(null);
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

http头部信息

名称 说明
Accept 浏览器能够处理的内容类型
Accept-Charset 浏览器能够显示的字符集
Accept-Encoding 浏览器能够处理的压缩编码
Accept-Language 浏览器当前设置的语言
Connection 浏览器与服务器之间连接的类型
Cookie 当前页面设置的任何Cookie
Host 发出请求的页面所在的域
Referer 发出请求的页面的URI
User-Agent 浏览器的用户代理字符串
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
     
    if(xhr.readyState == 4){
        if ((xhr.status>=200 && xhr.status < 300) || xhr.status == 304){
            alert(xhr.responseText);
        }else{
            alert("Request was unsuccessful:" + xhr.status);
        }
    }
};
xhr.open("get","test.php",true); //异步发送请求
//设置要发送的头部信息
//最好不要使用浏览器正常发送的字段名称
//并且有的浏览器允许开发人员重写默认的头部信息
//但有的浏览器不允许这样做
xhr.setRequestHeader("myHeader","myValue");
//取得指定头部的信息
xhr.getResponseHeader("Use-Agent");
//取得所有头部信息
xhr.getAllResponseHeaders();
xhr.send(null);
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

post请求

var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function(){
     
    if(xhr.readyState == 4){
        if ((xhr.status>=200 && xhr.status < 300) || xhr.status == 304){
            alert(xhr.responseText);
        }else{
            alert("Request was unsuccessful:" + xhr.status);
        }
    }
};
xhr.open("post","test.php",true); //异步发送请求
xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
var data = "username=John&hobby=running";
//还可以用FormData
//var form = document.getElementById("user-info");
//var data = new FormData(form);
xhr.send(data);
 
   
   
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

可以用overrideMimeType方法确保以某种方式处理返回的内容

//确保把响应当作xml而非纯文本来处理
//此方法必须在send方法之前调用
xhr.overrideMimeType("text/xml");


此篇blog主要记载近期接触的JavaScript的内容

JavaScript是一门弱类型的脚本语言,主要用于HTML中

1.JavaScript的编写规范

   1.定义变量

         由于JavaScript是一门弱类型语言,所以不区分变量类型,所有变量都用var定义

         JavaScript的变量类型有: number型 String型 bool型  object型

[html]  view plain  copy
  1. >  
  2. <html>  
  3.     <head>  
  4.         <meta charset="UTF-8">  
  5.         <title>JavaScript变量title>  
  6.         <script type="text/javascript">  
  7.             //定义一个number类型变量  
  8.             var num = 10;  
  9.             //定义一个String型变量  
  10.             var str = "Nice_try";  
  11.             //定义一个bool型变量  
  12.             var boo = true;  
  13.             //定义一个object型变量  
  14.             var obj = null;  
  15.             //控制台输出num的数据类型和值  
  16.             console.log(typeof(num)+" "+num);  
  17.             //网页绘制出str的数据类型和值  
  18.             document.write(typeof(str) +" "+ str);  
  19.             //控制台输出boo的数据类型和值  
  20.             console.log(typeof(boo)+" "+boo);  
  21.             //控制台输出obj的数据类型和值  
  22.             console.log(typeof(obj)+" "+obj);  
  23.             //number类型转换为string型  
  24.             num = num + " ";  
  25.             console.log(typeof(num)+" "+num);  
  26.             //string类型转换为number型  
  27.             num = parseInt(num);  
  28.             console.log(typeof(num)+" "+num);  
  29.             //注意,将string型转换为number型时,遇到字母,就会停止转换  
  30.             var str2 = "12a3";  
  31.             var num2 = parseInt(str2);  
  32.             console.log(typeof(num2)+ " " + num2);  
  33.         script>  
  34.     head>  
  35.     <body>  
  36.     body>  
  37. html>  

2.定义函数

   定义函数的关键词是function

[html]  view plain  copy
  1. >  
  2. <html>  
  3.     <head>  
  4.         <meta charset="UTF-8">  
  5.         <title>JavaScript变量title>  
  6.         <script type="text/javascript">  
  7.             //声明一个无返回值的函数  
  8.             function fun1(a,b){  
  9.                 //控制台输出a+b的值  
  10.                 console.log(a+b);  
  11.             }  
  12.             //声明一个含有返回值的函数  
  13.             function fun2(a,b){  
  14.                 return a+b;  
  15.             }  
  16.               
  17.             //调用函数1  
  18.             fun1(5,4);  
  19.             //调用函数2  
  20.             var sum;  
  21.             sum = fun2(5,4);  
  22.             console.log(sum);  
  23.         script>  
  24.     head>  
  25.     <body>  
  26.     body>  
  27. html>  

3.定义数组

  定义数组的关键词也是var  格式: 数组类型 数组名 = [值1,值2,...,值n]

  对数组的操作主要有  取值,修改,添加,遍历

  整个数组属于object类型,数组里的元素属于元素自己的类型

[html]  view plain  copy
  1. >  
  2. <html>  
  3.     <head>  
  4.         <meta charset="UTF-8">  
  5.         <title>JavaScript数组title>  
  6.         <script type="text/javascript">  
  7.             //定义一个数组  array  
  8.             var arr = [0,1,2,3];  
  9.             //控制台输出数组类型,这里可以看到,整个数组,属于object类型  
  10.             console.log(typeof(arr));  
  11.             //取出数组的第0个元素,并输出在控制台,同时输出其类型  
  12.             console.log("取出数组里的值");  
  13.             console.log(typeof(arr[0]) + " " + arr[0]);  
  14.             //修改数组的第2号元素  
  15.             console.log("修改数组里的元素");  
  16.             arr[2] = 5;  
  17.             console.log("修改后,arr[2]="+arr[2]);  
  18.             /**向数组里面插入一个元素  
  19.              * 虽然不按下标插入也可以,但是一般按下标顺序插入,  
  20.              * */  
  21.             console.log("向数组里插入值");  
  22.             arr[4] = 4;  
  23.             console.log("arr[4]=" + arr[4]);  
  24.             // 不按下标插入是可以的,这里是测试函数  
  25.             // arr[10] = 10;console.log("arr[10]=" + arr[10]);  
  26.             //遍历数组,遍历数组采用的是循环遍历法  
  27.             console.log("循环遍历数组");  
  28.             for(var i = 0; i< arr.length; ++i){  
  29.                   
  30.                 console.log("arr[" + i + "]=" +arr[i]);  
  31.             }  
  32.         script>  
  33.     head>  
  34.     <body>  
  35.     body>  
  36. html>  

4.定义分支

   分支结构是程序结构中的重要一环

  常用分支方式 有 

  1.if(表达式){函数}  当表达式返回true时,执行函数,否者下一步

  2.if(表达式){函数1} else{函数2}  当表达式返回true时,执行函数1,否者执行函数2

  3.if(表达式1){函数1} elseif(表达式2){函数2}...   当表达式1满足时,执行函数1,否者判断表达式2,当表达式2返回true时,执行函数2,以此类推...


[html]  view plain  copy
  1. >  
  2. <html>  
  3.     <head>  
  4.         <meta charset="UTF-8">  
  5.         <title>JavaScript分支结构title>  
  6.         <script type="text/javascript">  
  7.             var a = 10;  
  8.             var b = 3;  
  9.             var c = 5;  
  10.             // if(){}分支结构  
  11.             if( a > 5){  
  12.                 //当a大于1时,输出a的值,同时输出a>5  
  13.                 console.log("a =" + a + " a>5" );  
  14.             }  
  15.             //if(){}else{}分支结构  
  16.             if( b > 5){  
  17.                 //当b>5时(满足表达式),输出b的值,同时输出b>5  
  18.                 console.log("b = " + b + " b>5");  
  19.             }  
  20.             else{  
  21.                 //当表达式不满足时,控制台输出b的值,同时输出b<5  
  22.                 console.log("b = " + b + " b<5");  
  23.             }  
  24.             //if(){} else(){}分支结构  
  25.             if(c > 5){  
  26.                 //满足条件c>5输出c的值,并输出c>5  
  27.                 console.log("c = "+ c +" c>5");  
  28.             }  
  29.             else if(c < 5){  
  30.                 //满足条件c<5输出c的值,并输出c<5  
  31.                 console.log("c = " + c + " c<5");  
  32.             }  
  33.             else{  
  34.                 //两个条件都不满足,输出C=5  
  35.                 console.log("c = " + c + " c=5");  
  36.             }  
  37.         script>  
  38.     head>  
  39.     <body>  
  40.     body>  
  41. html>  

5.定义循环

  循环结构也是程序流程结构中的重要一环

  常用循环结构有

  1.for ( 表达式1;表达式2;表达式3){循环体;}

  2.do{循环体}while(表达式);

  3.while(表达式){循环体};

  这三种循环中,最常用的是for循环和while循环

  for循环和while循环的区别:

    当知道循环体的执行次数时,一般使用for循环.

    当不知道循环体执行次数时,一般使用while循环.

    两者并没什么区别

  do-while循环和while循环的区别

    do-while循环是先执行循环体,然后判断表达式是否满足,do-while循环至少执行一次

    while循环是先判断表达式,然后执行循环体.

    相同条件下,do-while循环比while循环多执行一次

  for循环的执行顺序:

   第一次执行时   表达式1  - - 表达式2  - - 循环体  - - 表达式3

   之后执行时      表达式2 - - - 循环体 ---- - 表达式3

[html]  view plain  copy
  1. >  
  2. <html>  
  3.     <head>  
  4.         <meta charset="UTF-8">  
  5.         <title>JavaScript循环结构title>  
  6.         <script type="text/javascript">  
  7.             var a = 10;  
  8.             var i = 0;  
  9.               
  10.             //do-while循环  
  11.             do{  
  12.                 ++i;  
  13.                 console.log("这是第" + i +"次执行do-while循环体");  
  14.                 --a;   
  15.             }  
  16.             while(a > 1);  
  17.             //重置a和i的值  
  18.              a = 10;  
  19.              i = 0;  
  20.             //while循环  
  21.             while( a > 1){  
  22.                 ++i;  
  23.                 console.log("这是第" + i +"次执行while循环体");  
  24.                 --a;  
  25.             }  
  26.             //for循环  
  27.             for( var j = 0; j < 10; ++j ){  
  28.                 console.log("这是第" + (j+1) + "次执行for循环体");  
  29.             }  
  30.             //死循环  到自己电脑上面玩去,我反正是崩溃两次了  
  31. //          while(true){  
  32. //              document.write("卧槽,死循环了...  ");  
  33. //          }  
  34.               
  35.         script>  
  36.     head>  
  37.     <body>  
  38.     body>  
  39. html>  

这些是JS的相知识,包括它的基础与语法、函数讲解、运算符、对象方法、各种事件、DOM与XML复杂处理、页面系列方法、正则操作、浏览器与操作系统有关、表单相关操作、JQry框架相关、主流函数等相关知识。

基础与语法:
1:区分大小写(与Java、C、Perl类似)。
2:变量是弱类型,可以将它初始化为任意值,用var申明时并不一定在初始化。eg: var test="hi", test2=25, test3。首字母只:字母|_|$。
3:结尾分号可有可无(没有碰到过)。
4:注释为//和/**/,与Java、C和PHP相同。
5:括号表明代码块(()和{})。
6:关键字:break,else,new,var,case,finally,return,void,catch,for,switch,while,contin。
 function,this,with,default,if,throw,delete,in,try,do,instanceof,typeof。
7:保留字:abstract,enum,int,short,boolean,export,interface,static,byte,extends,long,super,char,final,native,synchronized。
 class,float,package,transient,debugger,implements,protected,volatile,do le,import,p lic。
8:原始类型(primitive type):Underfined,NUll,Boolean,Number,String。
9:isFinit(值):判断值是否为无穷大|小。
10:isNaN(值):Not a Number,一个奇怪的特殊值,常在转换失败时产生。eg: isNaN("bl")将返回tr;
转换:
toString():转换成字符串:
var bFound = false; alert(bFound.toString()); //outputs "false"。
Number默认模式:var iNum1=10,fNum2=10.0;alert(iNum1.tostring()); //outputs "10" alert(iNuM2.toString());//outputs "10"。
Number基模式:var iNum=10; alert(iNum1.toString(2));//outputs "1010" alert(iNum1.toString(8));//outouts "12" toString(16)-A。
parseint()|parseFloat():转换成数值型:
parseInt("值",进制):转换成数字(只对String类型调用才能正确运行,其它返回NaN):1234bl-1234,0xA-10,22.5-22,bl-NaN。
parseInt():丢弃小数部分,保留整数部分、Math.ceil():向上取整,有小数就整数部分加、Math.round():四舍五入、Math.floor():向下取整。
parseFloat():转换成浮点数:第一个小数点有效、只认识十进制。1234blut=1234.0,0xA-NaN,22.5-22.5,2.35.6-2.35,0807-807,bl-NaN。
强制类型转换:
Boolean():""-false,hi-tr,100-tr,null-false,0-false,new object()-tr。
Number():false-0,tr-1,undefined-NaN,null-0,5.5-5.5,56-56,5.6.7-NaN,new Object()-NaN,100-100。
String():null-"null"。
引用类型:Object类,Boolean类,Number类,String。
申明时只有一个参数时()可以省略,多个参数进不可以。eg: var 0=new Object|var 0=new Object(参数1,参数2,参数3)。

 

函数:
对象.toFixed(小数位数值):定位小数位数方法(0-20位)。
对象.toExponential(位数):定位浮点数位数。99.toExponential(1)-9e+1。
对象.Math.round(val*100)/100:保留两位小数。
对象.toPrecision():返回数字的预定义形式或指数形式。99.toPrecision(1)-1e+2。前三种方法都会进行舍入操作。
charAt()|charCodeAt():访问的是字符串中的单个字符(得到字符串的字符|得到字符串字符的字符代码)。
concat():用于一个或多个字符中的连接(像+号)。
indexOf()|lastIndexOf():寻找字符在字符串中出现的位置(从开始位置找|从最后位置找(0开始算))。
对象.localeCompare(值):排序比较。对值而言:对象排在前返回-1,与值相等返回0,排在后返回1(区分大小写)。
对象.slice(开始位置,结束位置):从字符串中截取子串的方法(0算起不包括开始位置),长度省略时为默认字符串的本身长度。
对象.s string(开始位置,结束位置):它的用法与slice()函数差不多,但当开始位置值为负数数它会解析成0,而slice()不会如此。
对象.toLowerCase|toLocaleLowerCase():用作值的小写转换,后者用在不同区域国家语言,不知编码运行语言情况下后者更佳。
对象.toUpperCase|toLocaleUpperCase():用作值的大写转换,后者用在不同区域国家语言,不知编码运行语言情况下后者更佳。

 

运算符:
一元运算符:
delete():删除对前定义对象属性或方法的使用,将其设置为underfined,删除开发者未定义的属性和方法叶引发错误。eg: delete o.name。
void():对任何值都返回undefined,作新窗口的打开不限空白页。eg: Me
前++|--,后++|--:借用C和Java的运算符。
+|-:一元加法和一元减法,应用于字符值数时会被转换成真正的数字"25"转换成25,一元减法运算会把字符串"25"转换成-25。
位运算符:重温整数,伴运算NOT,位运算AND,位运算OR,位运算XOR,左移运算,有符号右移运算,无符号右移运算。
Boolean运处符:NOT-!,AND-&&,OR-||……。

 

对象值有关:
ECMAScript语言为JavaScript实现提供了完整的面向对象语言能力,ECMA-262中定义了本地对象、内置对象和宿主对象三种不同类型的对象。
关键字this总是指向调用该方法的对象。
对象=null:面向对象中强制性废除对象收回内存方式。
document|表单名.对象名.val="值":得到|赋 页面对象值方式。
表单名.对象名.style.display="值":得到|赋 页面对象风格方式。
表单名.对象名.src="http://blog.163.com/wangxiaoxia1221@126/blog/值":得到|赋 页面图片值对象方式。
表单名.对象名.val.indexof("值"):得到对象指定下标位值方法。
对象.width=对象.width±值:设置对象宽方法。
对象.height=对象.height±值:设置对象高方法。
if(对象1.offsetWith-对象2.scrollLeft<=0) 对象2.scrollLeft=0:判断对象是否在最左。
对象.scrollLeft=对象.scrollLeft±10:向左|右滚动十个像素。
对象.innerHTML|TEXT:得到标签中的HTML内容|HTML标签中的值。
对象.οnmοuseοver=function{方法名()}:鼠标移在对象上时产生的方法。
对象.οnmοuseοut=function{方法名()}:鼠标移出对象时产自的方法。
document.all.对象.Execwb(6,1):打印对象实现(6,6)直接打印|(8,1)页面设置|(1,1)打开页面|(2,1)关闭所有打开的IE窗口。
document.all.对象.Execwb(7,1):打印预览对象实现(4,1)保存页面|(10,1)查看页面属性|(17,1)全选|(22,1)刷新|(45,1)关闭窗口无提示。
document.all.WebBrowser.Execwb(7,1):IE内置控件打印预览(6,6)直接打印|(8,1)页面设置|(1,1)打开页面|(2,1)关闭所有打开的IE窗口。
document.all.WebBrowser.Execwb(4,1):IE内置控件打印保存页面|(10,1)查看页面属性|(17,1)全选|(22,1)刷新|(45,1)关闭窗口无提示。
tab.offsetWidth、tab.offsetHeight:得到一个表格的宽和高。
window.document.body.scrollHeight、window.document.body.scrollWidth:得到一个页面的宽和高。

 

对象方法有关:
表单名.对象名.select()|focus():对象获得焦点方法。
οnclick="方法名(参数)":点击对象所产生方法。
onmousewheel=方法名(参数):鼠标滑动产生方法。
parent.对象名.focus():获得对象焦点方法。
onBlur="方法名(参数)":鼠标离开对象所产生的方法。
对象.lenght():得到对象大小方法。
对象.join(连接方式):连接字符串值方法。eg: var col=["red","bl"]; alert(col.join("-")); //outputs "red-bl";
toString|valOf():数组转换成字符串方法。
split(分隔符):字符串转换成数组方法。
concat(值):在数组末尾附加值方法。
对象.slice(开始位置,位置):从数组字符串中截取元素的方法(0算起不包括开始位置),位置省略时默认到数组最后位置。
对象.push|pop():在数组中添加|删除最后一个数组项。
对象.shift|unshift(值):在数组中的删除|添加第一个项方法。
对象.reverse():颠倒数组项方法。
对象.sort():对数组进行排序方法。
对象.splice(第一个位置,项数):删除数组多项方法。
对象.splice(插入位置,0,值//可多个):添加数组项而不删除方法。
对象.splice(插入位置,1//删除插入位置项,值//可多个):添加数组项而删除方法。
创建日期方法:
 var d = new Date(Date.parse("May 25, 2004"))。
 var d = new Date(Date.UTC(2004, 1, 5)): //outputs "2004年2月5号";
 var d = new Date(Date.UTC(2004, 1, 5, 13, 5)): //outputs "2004年2月5号下午1:05分";
 toDataString():以实现特定的格式显示Date的日期部分。
 toTimeString():以实现特定的格式显示Date的时间部分。
 toLocaleString():以地点的格式显示Date的日期和时间。
 toLocaleDateString():以地点特定的格式显示Date的日期部分。
 toLocaleTimeString():以地点特定的格式显示Date的时间部分。
 toUTCString():以实现特定的格式显示Date的UTC时间。
 getTimezoneOffset():说明某个时区与UTC时间的关系,判断时区使用的是否是夏令时。
encodeURI|decodeURI():处理完整的URI(统一资料标识符),对特殊字符进行编码|解码。
ecnodeURIComponent|decodeURIComponent():用于处理URI的一个片断,对所发现的所有非标准字符进行编码|解码,eg: #,%,&……。
eval(值):执行值,它是ECMAScript语言中最强大的方法。
本地内置对象:Global|Math对象,Math对象处理数学问题的所有公式,eg: alert(Math.max|min|abs(3,2,25)); //outputs "25"|"2"|绝值。
ceil()|floor|round()数字向上四舍五入|数字投下四舍五入|标准四舍五入,eg: alert(Math.ceil|round|floor(5.5)); //outputs 6|6|5。
Math.randow():返回0-1之间的随机小数。
prototype属性:创建新对象所依赖的原型,常用在函数构造方法中,可用还用来修改、添加新原型属性的方法。
_initialized:用来判断是否已给原型赋予其他语言中的类定义了。
append|join():把参数附加到字符串数组中|连接一组字符串。
call():对象冒充方法,eg: 方法.call(对象,参数1,……)。
apply():与call()方法类似,eg: 方法.applay(对象,参数数组(参数……))。
子类.prototype.inheritFrom(父类):类的另类继承方式之一。
子类.instanceOf(父类):类的另类继承方式之二。
有关document对象:它是window对象的属性,它的通用属性有:
 alinkColor激活链接颜色|bgColor页面背景|fgColor页面文本|lastModified最后修改时间|linkClor链接颜色
 referrer浏览历史最后URL|title标签文本//top.document.title="值"访问设值方式。
 vlinkColor访问过链接颜色|URL载入页面//document.URL="值"文章设值方式。
 它的集合对象:anchors锚|applets|embeds嵌入式对象|link链接集合。
 forms表单对象:document.form[数值]或document.forms[值]访问。
 images图像集合:document.images[数值]或document.forms[值]访问。
 它的对应方法:write|writeln()写入内容|open()打开已经载入的文档|close()关闭open()方法打开的文档
有关location对象:它是window对象和document对象的属性:
 hash返回URL地址中#后的内容|host服务器名|hostname可能不包括www的服务器名|href|assign当前载入的页面完整URL
 pathname:URL地址后的内容|port:URL中声明请求商品|portocal:URL中使用的协议,即//之前的内容|search:URL问号后面内容。
 replace当前载入的页面完整URL不留下历史|reload(tr)重载入页面,tr时从服务器端载入|toString返回location.href的值。
另外的两个对象:navigator有关浏览器信息,大数浏览器很多方法并不支持|screen有关用户屏幕作息。
锚 点的实现:定义,链接实现点击我连接到TOP、若要链接到同一文件夹内其它文档中的名为“top”的锚记,请键入 filename.html#top。
文字链接实现表单提交:确定,CheckUserDetails(){... document.myform.s mit())。
判断是否有按Ctrl+Enter键:(event.ctrlKey && event.keyCode == 13) || (event.altKey && event.keyCode == 83)。
JS传递参数包含汉字处理:三种编解码方式 js对文字进行编码涉及3个函数:escape,encodeURI,encodeURIComponent,相应3个解码函数:unescape,decodeURI,decodeURIComponent。

 

事件有关:
DOM标准定义事件类型:鼠标事件、键盘事件、HTML事件、突变事件。
鼠标事件:click,dbclick(双击),mousedown,mouseout,mosover,mouseup,mouseove(某个元素上持续发生)。
键盘事件:keydown,keypress,keyup。
HTML事件:load,unload,abort,error,select,change,s mit,reset,resize,scroll,focus,blur。
变化事件:KOMS treeModified,DOMNodeInserted,DomNodeRemoved,DOMNodeRemoveFromDocument,DOMNodeInsertecIntoDocument。
对象.attachEvent|detachEvent(函数,函数名): 对象添加|分离函数方法,eg: 
var f1|2=function(){alert(F1|2);}; var o=document.getElementById(ID名); o.οnclick=f1;o.attachEvent("onclick",f2);: 给对象添加方法的两种方式。
对象.addEventListener|removeEventListener(函数,函数名,tr|false//捕获|冒泡阶段): 对象添加|移除事件处理方法,eg: 
var f1|2=function(){alert(F1|2);}; var d=document.getElementById(ID名); 
o.οnclick=f1;o.addEventLister(onclick,f2,false);: 给对象添加事件方法的两种方式,删除事件方法前必须做一些删除事件处理函数方法。
oEvent.type|keyCode|shiftKey|altKey|ctrlKey: 得到事件类型|按键数值(回车:13,空格:32,回退:8)|Shitf是否被按|Alt是否被按|Ctrl是否被按方法。
oEvent.clientX|clientY|screenX|screenY: 在窗口区域内的位置离边界有多少像素|离桌面屏幕边界有多少像素。
oEvent.srcElement|target: IE|DOM中获取激发事件目标方法。
if (oEvent.isChar) String.fromCharCode(oEvent.charCode): DOM获取按键字符值方法。
oEvent.returnVal=false|oEvent.preventDefault(): 阻止某个事件的默认行为。
oEvent.calcelB lle=tr|oEvent.stopPropagation(): IE|mozilla中停止事件复制。
拖动项事件:dragstart,drap,dragend,使用事件时在前加on。
放置目标事件:dragenter,dragover,dragleave,drop,使用事件时在前加on。
拖动放置实现数据传输:oEvent.dataTransfer.setData(名,值); var s=oEvent.dataTransfer.getData(名);:名可以是text值或者url值。
dataTransfer判断放置目标动作特性:dropEffect(包括none,move,copy,link),effectAllwed(包括uninitialized,none,copy,link,move,copyLink,copyMove,all)
处理错误函数:onerror(错误信息,所在文件,行号)和try...catch结构。
删 除方式:删除

 

与DOM和XML有关:
与DOM有关:
getElementsByTabName():得到标签名方法,eg: var b=document.getElementsByTabName("img|input"); alert(b[0].tabName)。
getElementsByName():得到name特性指定的值,eg: var n=document.getElementsByName("radio"); alert(n[0].getAttribute("val"))。
getElementByID():得到ID特性指定的值,eg: var i=document.getElementById("div")。
createElement|createTextNode|appendChile():创建元素|创建节点|把创建好的文本节点加入到元素中。eg: 
 
removeChild(节点对象)|replaceChild(新节点,替换节点)|insertBefore(新节点,之后节点):删除节点|替换内容|新消息出现旧消息之前。 
createDocumentFragment():以文档碎片的方式加入节点,为之不变得十分缓慢。
DOM访问CSS样式:eg: 单个单词style.color,多个单词style.backgroundColor。
this.style.cssTest: DOM得到CSS内容方法。
DOM对象方法交互CSS样式:getPropertyVal(名),getPropertyPriority(),item(index),removeProperty(名),setProperty(名,值//import,priority)。
document.styleSheet[0].cssRules||document.styleSheets[0].rules: 得到使用了引用的CSS样式的规则方法。
对象.style|currentStyle.backgroundColor: 方法是错误的|得到CSS样式对象值。
document.defaultView.getComputedStyle(对象,null).backgroundColor: DOM得到CSS最终样式对象方法,此方法不可运用赋值运算。
对象.innerText|innerHTML|outerText|outerHTML: 给对象添加文本|HTML控件|删除文本|删除HTML控件方法。
document.implementation.hasFeature("Range","2.0"): DOM判断是否有Range方法实例。
与XML有关(以下的对象都表示:XmlDom对象):
对象.loadXML(xml代码):载入XML代码方法,load(文件):载入XML文件方法,对象会返回0,1,2,3,4五种可能值会触发onreadystatechange事件。
对象.documentElements.childNode[1]|对象.xml:得到XML节点方法。
对象.async=false:同步载入方式。
getAllResponseHeaders():得到HTTP请求发送时的头部全部信息。
对象.setReqstHeader(类型,值)|getResponseHerser(类型): 设置|得到指定头部信息。
XMLHTTP对象.open(get,地址,tr|false//同异步): 进行GET请求。
XMLHTTP对象.open(post,地址,false);XMLHTTP对象.setReqstHeader("Content-Type","application/s-www-form-urlencoded");
XMLHTTP对象.send(对象): 进行POST请求。

 

页面方法有关:
window.showModalDialog('页面','','dialogWidth=600px status=no ...'):页面中显示新页面窗口方法。
window.open("页面","newframe","top=20,width=20,height=10,men ar=no,toolbar=no,location=no,scrollbars=no"):打开新页面方式。
window.showModalDialog(" 页面","","dialogWidth="+screen.width+"px;dialogHeight="+screen.height+"px; status=no;help=no;scrollbars=no"):全屏式打开新窗口。
window|窗口对象.close():关闭页面方式。
alert("值"):弹出对话框方法一。
confirm("值"):弹出对话框方法二,返回boolean值。
prompt("值","值"):弹出对话框方法三,同时能接收值。
setInterval(方法名,时间间隔):每间隔内自动执行方法。    
clearInterval(对象):清除对象的Interval()方法。
window.location.href="http://blog.163.com/wangxiaoxia1221@126/blog/页面":实现页面跳转方法。
window.print():调用IE自身打印功能实现打印。
:禁止网页被复制方法。
:禁止网页被另存为方法。
Javascript:window.open('页面','','width=767,height=698'):屏蔽IE主菜单方式。
function click() {event.returnVal=false;|if(event.button=2)alert("禁止使用右键!");}:禁止使用右键方式。
13(回车键)|116(刷新键)|37(方向键)|78(新建IE窗口)|121(shitf+10合)
function keydown(){if(event.keyCode==8){event.keyCode=0;event.returnVal=false;alert("禁止退格")}}:屏蔽键盘相关按键事件。
moveBy(右移像数,上移像数):负值时按相反方向移。
moveTo(像数,像数):窗口位置
resizeBy(宽度增加像数大小,高度添加像数大小):相当对当前窗口大小,调整子窗口多少像数,负数为减少。
resizeTo(宽度,高度):窗口大小,不能使用负数。
IE提供:window.screenLeft|screenTop判断窗口位置,document.body.offsetWidth|offsetHeight:获取窗口大小。 
Mozilla和Opera和Safari提供:window.screenX|screenY判断窗口位置,
 window.innerWidth|innerHeight:获取窗口大小。
 window.outWidth|outHeight:浏览器窗口大小。
window.defaultStatus="值":设置用户离开当前页面前的显示信息。
window.status="值":设置窗口状态栏信息。
setTimeout(对象|方法,间隔毫秒):暂停时间后要执行的方法。
clearTimeout(对象):清理对象方法。
setInterval(对象|方法,间隔毫秒):时间间隔后循环执行的方法。
ClearInterval(对象):清理对象。
window.history.go|back|forward(数值):去前一页或后一页,window可以省略,history.length可得到试问历史页面数。
运用JS通过DOM实现页面元素的遍历实例:
 NodeIterator Example
 

Note: The NodeIterator object has only been implemented in Opera 
 TreeWalker instead.

Hello World!

  • List item 1
  • List item 2

  •  
  • List item 3


 
检查浏览器是否支持DOM方法:var bxmllevel=document.implementation.hasFeature("XML","1.0"),这种方式当浏览器只支持DOM的一部分功能时也会返回tr。
js关闭页面:javascript:window.close()、window.opener=null;window.close()关闭页面无任何提示;
js添加收藏:javascript:window.external.AddFavorite(document.URL,document.title);return false;
preg_match('#^([^\.]*)\.#',$host,$match);$host_user = $match[1];从地址得到要访问的数据库。
window.open('index.php','_parent','fullscreen=1');window.opener=null;window.open('','_self');window.close():JS打开新窗口,关闭原窗口。
JS刷新窗口方法:
 1    history.go(0)
 2    location.reload()
 3    location=location
 4    location.assign(location)
 5    document.execCommand('Refresh')
 6    window.navigate(location)
 7    location.replace(location)
 8    document.URL=location.href。 
 :页面自动刷新,其中20指每隔20秒刷新一次页面。
 :页面自动跳转,其中20指隔20秒后跳转到http://www.google.com页面。
 function myrefresh(){window.location.reload();}setTimeout('myrefresh()',1000):页面自动刷新js版。
 parent.location.reload():如何刷新包含该框架的页面用。
 self.opener.location.reload():窗口刷新父窗口。
 parent.otherFrameID.location.reload():如何刷新另一个框架的页面用。
 window.opener.document.location.reload():实现刷新。
 :开窗时刷新、:关闭时刷新。

 

与正则表达式有关:
JS中每个正则表达式都是一个对象,用 RegExp来表示,用RegExp.$1|$2……得到各个值。常用来测试:日期、信用卡号、URL、E-mail地址。
正则表达式所用到的元字符:( [ { \ ` $ | ) ? + ,。
var s="a bat, a cat"; var rs=/cat/; var a=rs.test|exec(s):判断某个值是否匹配指定模式方法,返回tr或false|一个条目。
var s="a bat, a cat"; var rs=/cat/gi; var a=rs.match|search(s):某个值在某个对象中的出现状况,返回一个数数|值出现的位置,gi是处理指令。
var s="Is red"; var r=/red/; var sr=s.replace(r, function(sMatch) { return "bl";}); alert(sr); //outputs "Is bl",替换值方法。
var s="red, bl"; var r=/\,/; var ar=s.split(r);按指定模式分隔值方法。
边界模式:`|$|\b|\B:以开关|结尾|单词边界|非单词边界。eg: /(\w+)\.$/|/`(\w+)/|/`(.+?)\b/: .前的单词|第一个单词|单词边界之前可以出现任意字符。
/\b(\S+?)\b/g|/(\w+)/g: 返回空格分开的所有单词。
/(w+$)/g|m: 返回最后一个单词|有换行会返回多个。
验证日期:day: /0[1-9]|[12][0-9]|3[01]/,month: /0[0-9]|1[0-2]/,year: /19|20\d{2}/,组合模式:/?:day\/?:month\/?:year/,还要整理。
验证货币:/^[\d.]*$/。
验证护照:/(P\d{7})|(G\d{8})/。
验证信用卡:reMasterCard: /^(5[1-5]\d{2})[\s\-]?(\d{4})[\s\-]?(\d{4})[\s\-]?(\d{4})$/。
验证车牌号码:/^[\一-\龥]?[a-zA-Z]-\w{5}$/;车牌号标准:第一个符是汉字、第二个是字母,后面四个是数字。
验证身份证号:/\d{17}[\d|X]|\d{15}/。
验证是否为汉字:/[^\一-\龥]/。
验证电话号码:function isTelephone(str){ var reg=/^[0-9]{11}$|^[0-9]{3,4}(\-[0-9]{7,8})$|^[0-9]{10,12}$/; return reg.test(str)}。
验证数字数值:function isNumber(str) {var reg=/^[0-9]{0,9}$/; return reg.test(str);}。
验证do le数值:function isDo leTwo(str) {var reg=/^(([0-9]{0,9}(\.)?(\d*[0-9])?)|(0\.\d*[1-9]))$/;return reg.test(str);}。
验证do le数值指定位:function isDo leTwo(str) {var reg=/^(([0-9]{0,9}(\.)?(([0-9]){1,2})?)|(0\.\d*[1-9]))$/;return reg.test(str);}。
验证电子邮件:reEmail: /^(?:\w+\.?)*\w+@(?:\w+\.)+\w+$/。
 function isEmail(str){    var reg = /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((\.[a-zA-Z0-9_-]{2,3}){1,2})$/;    return reg.test(str);}

 

与浏览器|操作系统有关:
浏览器的两种检测方式:对象/特征检测:document.getElementById和user-aget:navigator:userAgent字符串检测。
Netscapte Navigator3.0与IE3.0: parseFloat(navigator.appVersion)|navigator.userAgent.indexOf(Win95|Windows 95)可以得到浏览器版本号|OS。
对象/特征检测:浏览器检测前两步:var s=navigator.userAgent;var f=parseFloat(navigator.appVersion);: 将user-agent字条串保存到本地并得到浏览器版本。
isMinIE5|isIE5|isIE6|isIE7……: 检验IE版本。
sUserAgent.indexOf("Opera")>-1;:检测Opera浏览器。
sUserAgent.indexOf("KHTML")>-1||sUserAgent.indexOf("Konqror")>-1||sUserAgent.indexOf("AppleWebKit")>-1;: 检测Konqror/Safari浏览器。
sUserAgent.indexOf("compatible")>-1||sUserAgent.indexOf("MSIE")>-1&&!isOpera;: 检测IE浏览器。
sUserAgent.indexOf("Geoko")>-1&&!isKHTML;: 检测Mozilla浏览器。
sUserAgent.indexOf("Mozilla")==0&&navigator.appName=="Netscapt"&&fAppVersion>=4.0&&fAppVersion<5.0&&!isIE&!isOpera&&!isMoz&&!isKHTML;: 检测NC
操作系统:
navigator.platform=="Win32"||navigator.platform=="Windows;: 检测Windows系统。
navigator.platform=="Mac68K"||navigator.platform=="MacPPC";: 检测Macintosh系统。
navigator.platform=="X11"&&!isWin&&!isMac;:检测Unix系统。

 

与表单有关:
HTML表单特性:method,action,enctype,accept,accept- charset,,) />,
通过type运用的特性:text,radio,checkbox,file,password,button,s mit,reset,hidden,image。
获取表单引用的方法:document.getElementById("表单名")|document.forms[0]|document.forms["表单名"]。
访问表单字段方法:表单.elemetns[0]|elements[对象名]|对象名|[对象名]|document.getElemetnById(ID名)。
表单字体(除隐藏字体)包含的特性,方法和事件:disabled,form,blur,focus,onblur(),onfocus()。
文本框事件:change|select|focus|blur: 更改内容失去焦点时|选择内容时|得到焦点时|失去焦点时 发生。

 

与页面元素有关:
下拉列表:
 str.options[str.selectedIndex].val|text|selected:得到实际值|显示值|选择状态。
得到option选项的显示值:document.getElementById("id").options[document.getElementById("id").selectedIndex].text。
得 到option选项的实际 值:document.getElementById("id").options[document.getElementById("id").selectedIndex].val|document.getElementById("id").val。

 

相关框架:
JQry:
JQry相关功能(JQry能做对象DOM、处理相关对象事件、排序数据、产生各种页面效果等):
 JQry基础处理申明:$(document).ready(function() { …… });、简写:$(function() { …… });。
 监听所有对象点击对应的事件,eg:$("对象名").click(function() {alert("哈哈,胡素苗在自学 JQry!"); })。
 某一个对象添加样式,eg:$("#对象名").addClass("red");、某一个对象下级添加样式,eg:$("#orderedlist > li").addClass("bl");。
 某 一个对象相应事件发生时添加样式,eg:$("#orderedlist li:last").hover(function() {$(this).addClass("green");},function(){$(this).removeClass("green");});
 某一个对象遍历并处理,eg:$("#orderedlist").find("li").each(function(i) {$(this).html( $(this).html() + " 胡素苗! " + i );});。
 某一个对象实现监听处理,eg:$("#reset").click(function() {$("#form").each(function() {this.reset();});});。
 某一个对象判断是否有下级并处理,eg:$("li").not(":has(ul)").css("border", "1px solid black");。
 页面内针对对象存在某一属性时处理,eg:$("a[name]").css("background-color", "green");、$("form[name]").css("background-color", "bl");。
 某一个对象进行匹配验证处理,eg: $("a[href*=/content/gallery]").click(function() {  alert("hehe..."); });。
 处理对象相关事件展开与隐藏并带效果,eg: $("#faq").find("dd").hide().end().find("dt").click(function() { var answer  = $(this).next();
  if(answer.is("':visible")) {answer.slideUp();}else  { answer.slideDown(); }});。
 某 一个对象监听处理上级事件,eg:("a").hover(function() {$(this).parents("p").addClass("highlight");$(this).parents("p").css("background-color",yellow");}, 
  function() {$(this).parents("p").removeClass("highlight");$(this).parents("p").css("background-color", "#FFF"); });。
 定 义点击某一个对象时出现相应效果,eg:$(function() {$("a").toggle(function() {$(".st?").hide("slow");}, function() {$(".st?").show("fast");});});
  $(function () {$("a").toggle(function () {$(".st?").animate({ height: "hide",opacity: "hide"}, "slow");}, 
  function () {$(".st?").animate({ height: "show", opacity: "show"}, "slow");});});。

 

函数知识:
去除空格函数:
function trim(str){  //删除左右两端的空格
 return str.replace(/(^\s*)|(\s*$)/g, "");
}
function ltrim(str){  //删除左边的空格
 return str.replace(/(^\s*)/g,"");
}
function rtrim(str){  //删除右边的空格
 return str.replace(/(\s*$)/g,"");
}

 

其它知识:
window.retureVal="值"                 ——页面返回值方式。
"   ——返回上一页方法。
echo "": —



window.onload $(document).ready()
执行时机 必须等待网页中所有的内容加载完毕后(包括图片)才能执行 网页中所有DOM结构绘制完毕后就执行,可能DOM元素关联的东西并没有加载完
编写个数 不能同时编写多个,以下代码无法正确执行:window.onload =function({alert("test1");}window.onload = function(){alert("test2");}结果只会输出"test2" 能同时编写多个
简化写法 $(document).ready(function(){});可以简写成$(function(){});
 
 

一、选择网页元素

  jQuery的基本设计和主要用法,就是"选择某个网页元素,然后对其进行某种操作"。这是它区别于其他函数库的根本特点。
  使用jQuery的第一步,往往就是将一个选择表达式,放进构造函数jQuery()(简写为$),然后得到被选中的元素。

选择表达式可以是CSS选择器:

 $(document)//选择整个文档对象  
 $('#myId')//选择ID为myId的网页元素  
 $('div.myClass')//选择class为myClass的div元素  
 $('input[name=first]')//选择name属性等于first的input元素 

也可以是jQuery特有的表达式:

 $('a:first')//选择网页中第一个a元素  
 $('tr:odd')//选择表格的奇数行  
 $('#myForm :input')//选择表单中的input元素  
 $('div:visible') //选择可见的div元素  
 $('div:gt(2)')//选择所有的div元素,除了前三个  
 $('div:animated')//选择当前处于动画状态的div元素 
 
  
 二、改变结果集
  如果选中多个元素,jQuery提供过滤器,可以缩小结果集:

* $('div').has('p'); //选择包含p元素的div元素  
* $('div').not('.myClass'); //选择class不等于myClass的div元素  
* $('div').filter('.myClass'); //选择class等于myClass的div元素  
* $('div').first(); //选择第1个div元素  
* $('div').eq(5); //选择第6个div元素  

有时候,我们需要从结果集出发,移动到附近的相关元素,jQuery也提供了在DOM树上的移动方法:

 $('div').next('p'); //选择div元素后面的第一个p元素  
 $('div').parent(); //选择div元素的父元素  
 $('div').closest('form'); //选择离div最近的那个form父元素  
 $('div').children(); //选择div的所有子元素  
 $('div').siblings(); //选择div的同级元素 

 三、链式操作
  选中网页元素以后,就可以对它进行某种操作。
  jQuery允许将所有操作连接在一起,以链条的形式写出来,比如:

 $('div').find('h3').eq(2).html('Hello');  
 分解开来,就是下面这样:

1. $('div')                 //找到div元素 

2. .find('h3')           //选择其中的h3元素

3. .eq(2)               //选择第3个h3元素 

4. .html('Hello');  //将它的内容改为Hello  
  这是jQuery最令人称道、最方便的特点。它的原理在于每一步的jQuery操作,返回的都是一个jQuery对象,所以不同操作可以连在一起。
 jQuery还提供了.end()方法,使得结果集可以后退一步:

1. $('div')  
2. .find('h3')  
3. .eq(2)  
4. .html('Hello')  
5. .end()//退回到选中所有的h3元素的那一步  
6. .eq(0)//选中第一个h3元素  
7. .html('World'); //将它的内容改为World  

.end():回到最近的一个"破坏性"操作之前。如果之前没有破坏性操作,则返回一个空集。所谓的"破坏性"就是指任何改变所匹配的jQuery元素的操作。

示例
描述:选取所有的p元素,查找并选取span子元素,然后再回过来选取p元素

?
1
2
3
4
5
6
7
8
9
HTML 代码:
 
< p >< span >Hello span >,how are you? p >
jQuery 代码:
 
$("p").find("span").end()
结果:
 
< p >< span >Hello span > how are you? p >

-四、元素的操作:取值和赋值

  操作网页元素,最常见的需求是取得它们的值,或者对它们进行赋值。
  jQuery使用同一个函数,来完成取值(getter)和赋值(setter)。到底是取值还是赋值,由函数的参数决定。

 $('h1').html(); //html()没有参数,表示取出h1的值 
 $('h1').html('Hello'); //html()有参数Hello,表示对h1进行赋值  
常见的取值和赋值函数如下:

1. .html() 返回或设置被选元素的内容 (inner HTML)    
2. .text() 取出或设置text内容      
3. .attr() 取出或设置某个属性的值    
4. .width() 取出或设置某个元素的宽度    
5. .height() 取出或设置某个元素的高度  
6. .val() 取出或设置html内容 取出某个表单元素的值 
 
  需要注意的是,如果结果集包含多个元素,那么赋值的时候,将对其中所有的元素赋值;取值的时候,则是只取出第一个元素的值(.text()例外,它取出所有元素的text内容)。

  五、元素的操作:移动
.insertAfter(),把div元素移动p元素后面:

$('div').insertAfter('p');
.after(),把p元素加到div元素前面:
 

 $('p').after('div');
使用这种模式的操作方法,一共有四对

1. .insertAfter()和.after():在现存元素的外部,从后面插入元素  
2. .insertBefore()和.before():在现存元素的外部,从前面插入元素  
3. .appendTo()和.append():在现存元素的内部,从后面插入元素  
4. .prependTo()和.prepend()  :在现存元素的内部,从前面插入元素


1.after():
描述:
在所有段落中后插入一个jQuery对象(类似于一个DOM元素数组)。

?
1
2
3
4
5
6
7
8
9
HTML 代码:
 
< b >Hello b >< p >I would like to say: p >
jQuery 代码:
 
$("p").after( $("b") );
结果:
 
< p >I would like to say: p >< b >Hello b >

2.insertAfter():
描述:
把所有段落插入到一个元素之后。与 $("#foo").after("p")相同

?
1
2
3
4
5
6
7
8
9
HTML 代码:
 
< p >I would like to say: p >< div id = "foo" >Hello div >
jQuery 代码:
 
$("p").insertAfter("#foo");
结果:
 
< div id = "foo" >Hello div >< p >I would like to say: p >

3.before():
描述:
在所有段落中前插入一个jQuery对象(类似于一个DOM元素数组)。

?
1
2
3
4
5
6
7
8
9
HTML 代码:
 
< p >I would like to say: p >< b >Hello b >
jQuery 代码:
 
$("p").before( $("b") );
结果:
 
< b >Hello b >< p >I would like to say: p >


4.append():
描述:向所有段落中追加一些HTML标记。

?
1
2
3
4
5
6
7
8
9
HTML 代码:
 
< p >I would like to say: p >
jQuery 代码:
 
$("p").append("< b >Hello b >");
结果:
 
  < p >I would like to say: < b >Hello b > p >


5.appendTo()
描述:新建段落追加div中并加上一个class

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
HTML 代码:
 
< div > div >< div > div >
jQuery 代码:
 
  $("< p />")
   .appendTo("div")
   .addClass("test")
   .end()
   .addClass("test2");
结果:
 
< div >< p class = "test test2" > p > div >
< div >< p class = "test" > p > div >


6.prepend()
描述:向所有段落中前置一个jQuery对象(类似于一个DOM元素数组)。

?
1
2
3
4
5
6
7
8
9
10
HTML 代码:
 
< p >I would like to say: p >< b >Hello b >
 
jQuery 代码:
 
$("p").prepend( $("b") );
结果:
 
< p >< b >Hello b >I would like to say: p >


7.prependTo()
描述:把所有段落追加到ID值为foo的元素中。

?
1
2
3
4
5
6
7
8
9
HTML 代码:
 
< p >I would like to say: p >< div id = "foo" > div >
jQuery 代码:
 
$("p").prependTo("#foo");
结果:
 
< div id = "foo" >< p >I would like to say: p > div >

**六**、元素的操作:复制、删除和创建
  复制元素使用.clone()
  删除元素使用.remove()和.detach()。两者的区别在于,前者不保留被删除元素的事件,后者保留,有利于重新插入文档时使用。
  清空元素内容(但是不删除该元素)使用.empty()。
  创建新元素的方法非常简单,只要把新元素直接传入jQuery的构造函数就行了:
?
1
2
3
* $( '

Hello

'
);
* $( '
  • new list item
  • '
    );
    * $( 'ul' ).append( '
  • list item
  • '
    );

     


    七、工具方法
      除了对选中的元素进行操作以外,jQuery还提供一些工具方法(utility),不必选中元素,就可以直接使用。
    常用的工具方法有以下几种:

     $.trim() 去除字符串两端的空格。
     $.each() 遍历一个数组或对象。  
     $.inArray() 返回一个值在数组中的索引位置。如果该值不在数组中,则返回-1。  
     $.grep() 返回数组中符合某种标准的元素。   
     $.extend() 将多个对象,合并到第一个对象。   
     $.makeArray() 将对象转化为数组。  
     $.type() 判断对象的类别(函数对象、日期对象、数组对象、正则对象等等)。  
     $.isArray() 判断某个参数是否为数组。  
     $.isEmptyObject() 判断某个对象是否为空(不含有任何属性)。  
     $.isFunction() 判断某个参数是否为函数。  
     $.isPlainObject() 判断某个参数是否为用"{}"或"new Object"建立的对象。  
     $.support() 判断浏览器是否支持某个特性。 

    八、事件操作
     jQuery可以对网页元素绑定事件。根据不同的事件,运行相应的函数。

    ?
    1
    2
    3
    $( 'p' ).click( function (){
    alert( 'Hello' );
    });


    目前,jQuery主要支持以下事件:

     .blur() 表单元素失去焦点。  
     .change() 表单元素的值发生变化  
     .click() 鼠标单击  
     .dblclick() 鼠标双击  
     .focus() 表单元素获得焦点  
     .focusin() 子元素获得焦点  
     .focusout() 子元素失去焦点  
     .hover() 同时为mouseenter和mouseleave事件指定处理函数  
     .keydown() 按下键盘(长时间按键,只返回一个事件)  
     .keypress() 按下键盘(长时间按键,将返回多个事件)  
     .keyup() 松开键盘  
     .load() 元素加载完毕  
     .mousedown() 按下鼠标  
     .mouseenter() 鼠标进入(进入子元素不触发)  
     .mouseleave() 鼠标离开(离开子元素不触发)  
     .mousemove() 鼠标在元素内部移动  
     .mouseout() 鼠标离开(离开子元素也触发)  
     .mouseover() 鼠标进入(进入子元素也触发)  
     .mouseup() 松开鼠标  
     .ready() DOM加载完成  
     .resize() 浏览器窗口的大小发生改变  
     .scroll() 滚动条的位置发生变化  
     .select() 用户选中文本框中的内容  
     .submit() 用户递交表单  
     .toggle() 根据鼠标点击的次数,依次运行多个函数  
     .unload()  

     用户离开页面  
      以上这些事件在jQuery内部,都是.bind()的便捷方式。使用.bind()可以更灵活地控制事件,比如为多个事件绑定同一个函数:

    ?
    1
    2
    3
    4
    5
    6
    $( 'input' ).bind(
    'click change' ,  //同时绑定click和change事件
    function (){
    alert( 'Hello' );
    }
    );

     
    有时,你只想让事件运行一次,这时可以使用.one()方法。

    ?
    1
    2
    3
    $( "p" ).one( "click" ,  function (){
    alert( "Hello" );  //只运行一次,以后的点击不会运行
    });

    unbind()用来解除事件绑定。

    ?
    1
    $(

    你可能感兴趣的:(javascript,JavaScript知识点)