javaScript 与 Java 是两种完全不同的语言，无论在概念上还是设计上。
JavaScript 语句 document.createElement("#") 是为 IE 浏览器添加新的元素
Java（由 Sun 发明）是更复杂的编程语言。
ECMA-262 是 JavaScript 标准的官方名称。
JavaScript 由 Brendan Eich 发明。它于 1995 年出现在 Netscape 中（该浏览器已停止更新），并于 1997 年被 ECMA（一个标准协会）采纳。
javaScript 是 Web 的编程语言。
http:/ /www.iis7.com/b/wzjk/
所有现代的 HTML 页面都使用 JavaScript
JavaScript 是互联网上最流行的脚本语言，这门语言可用于 HTML 和 web，更可广泛用于服务器、PC、笔记本电脑、平板电脑和智能手机等设备。
ECMA（欧洲电脑制造商协会）
:
JavaScript web 开发人员必须学习的 3 门语言：
1.HTML 定义了网页的内容
2.CSS 描述了网页的布局
3.JavaScript 网页的行为
:
JavaScript 是一种轻量级的编程语言。
JavaScript 是可插入 HTML 页面的编程代码。
JavaScript 插入 HTML 页面后，可由所有的现代浏览器执行
您会经常看到 document.getElementById("some id")。这个方法是 HTML DOM 中定义的。
DOM (Document Object Model)（文档对象模型）是用于访问 HTML 元素的正式 W3C 标准
JavaScript 能够改变任意 HTML 元素的大多数属性，而不仅仅是图片
JavaScript 常用于验证用户的输入
:::::::::::::::::::::::::::::
JavaScript 用法
HTML 中的脚本必须位于 <script> 与 </script> 标签之间。
脚本可被放置在 HTML 页面的 <body> 和 <head> 部分中。
如需在 HTML 页面中插入 JavaScript，请使用 <script> 标签。
<script> 和 </script> 会告诉 JavaScript 在何处开始和结束。
<script> 和 </script> 之间的代码行包含了 JavaScript
。。。。。。。。。。。
JavaScript函数和事件
我们需要在某个事件发生时执行代码，比如当用户点击按钮时。
如果我们把 JavaScript 代码放入函数中，就可以在事件发生时调用该函数
您可以在 HTML 文档中放入不限数量的脚本。
脚本可位于 HTML 的 <body> 或 <head> 部分中，或者同时存在于两个部分中。
通常的做法是把函数放入 <head> 部分中，或者放在页面底部。这样就可以把它们安置到同一处位置，不会干扰页面的内容
也可以把脚本保存到外部文件中。外部文件通常包含被多个网页使用的代码。
外部 JavaScript 文件的文件扩展名是 .js。
如需使用外部文件，请在 <script> 标签的 "src" 属性中设置该 .js 文件
外部脚本不能包含 <script> 标签
::::::::::::::::::::::::::::::::::
JavaScript 输出
JavaScript 没有任何打印或者输出的函数。
JavaScript 可以通过不同的方式来输出数据：
window.alert()：弹出警告框。
document.write()：方法将内容写到 HTML 文档中。
innerHTML：写入到 HTML 元素。
console.log()：写入到浏览器的控制台。
程序中调试是测试，查找及减少bug(错误)的过程
您只能在 HTML 输出中使用 document.write。如果您在文档加载后使用该方法，会覆盖整个文档。
:::::::::::::::::::::::::::::::
JavaScript 语法
JavaScript 是一个程序语言。语法规则定义了语言结构
JavaScript 是一个脚本语言。
它是一个轻量级，但功能强大的编程语言
在编程语言中，一般固定值称为字面量，如 3.14。
数字（Number）字面量 可以是整数或者是小数，或者是科学计数(e)
字符串（String）字面量 可以使用单引号或双引号
表达式字面量 用于计算 如：10+10(+ - /)
数组（Array）字面量 定义一个数组 :如：[40, 100, 1, 5, 25, 10]
对象（Object）字面量 定义一个对象:如：{firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"}
函数（Function）字面量 定义一个函数:如：function myFunction(a, b) { (返回)return a b;}
。。。。。。。。。。。。。。。。。。。。。。。。。
JavaScript 变量，在编程语言中，变量用于存储数据值。
JavaScript 使用关键字 var 来定义变量， 使用等号来为变量赋值，变量可以通过变量名访问。在指令式语言中，变量通常是可变的。字面量是一个恒定的值。
变量是一个名称。字面量是一个值。
。。。。。。。。。
JavaScript 操作符
JavaScript使用 算术运算符 来计算值。
JavaScript使用 赋值运算符给变量赋值。
赋值，算术和位运算符 "="，"+"，"-"，"*"，"/" 在 JS 运算符中描述。
条件，比较及逻辑运算符 "=="，"!="，"<"，">" 在 JS 比较运算符中描述。
。。。。。。。。
JavaScript 语句
在 HTML 中，JavaScript 语句向浏览器发出的命令，语句是用分号(;)分隔。
。。。。。。。。。
JavaScript 关键字，用于标识要执行的操作。
和其他任何编程语言一样，JavaScript 保留了一些关键字为自己所用。
var 关键字告诉浏览器创建一个新的变量。
JavaScript 同样保留了一些关键字，这些关键字在当前的语言版本中并没有使用，但在以后 JavaScript 扩展中会用到。
JavaScript 关键字必须以字母、下划线（）或美元符（$）开始。
后续的字符可以是字母、数字、下划线或美元符（数字是不允许作为首字符出现的，以便 JavaScript 可以轻易区分开关键字和数字）。
。。。。。。。。
JavaScript 注释
不是所有的 JavaScript 语句都是"命令"。双斜杠 // 后的内容将会被浏览器忽略。
。。。。。。。。。。
JavaScript 数据类型
JavaScript 有多种数据类型：数字，字符串，数组，对象等等。
数据类型的概念
编程语言中，数据类型是一个非常重要的内容。
为了可以操作变量，了解数据类型的概念非常重要。
。。。。。。。。
JavaScript 函数
JavaScript 语句可以写在函数内，函数可以重复引用：
引用一个函数 = 调用函数(执行函数内的语句)。
。。。。。。。。。。。
JavaScript 字母大小写
JavaScript 对大小写是敏感的。
当编写 JavaScript 语句时，请留意是否关闭大小写切换键。
函数 getElementById 与 getElementbyID 是不同的。
同样，变量 myVariable 与 MyVariable 也是不同的。
。。。。。。。。。
JavaScript 字符集
JavaScript 使用 Unicode 字符集。
Unicode 覆盖了所有的字符，包含标点等字符。
如需进一步了解，请学习完整的 Unicode 参考手册。
JavaScript 中，常见的是 "驼峰法" 的命名规则，如 lastName (而不是lastname)。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 语句
JavaScript 语句向浏览器发出的命令，语句的作用是告诉浏览器该做什么。
JavaScript 语句是发给浏览器的命令，这些命令的作用是告诉浏览器要做的事情。
。。。。。
分号 ;
分号用于分隔 JavaScript 语句。
通常我们在每条可执行的语句结尾添加分号。
使用分号的另一用处是在一行中编写多条语句。
您也可能看到不带有分号的案例。
在 JavaScript 中，用分号来结束语句是可选的。
。。。。。。。。。
JavaScript 代码块
JavaScript 可以分批地组合起来。
代码块以左花括号开始，以右花括号结束。
代码块的作用是一并地执行语句序列
您可以在文本字符串中使用反斜杠对代码行进行换行
。。。。。。。。。。。
JavaScript 语句标识符
JavaScript 语句通常以一个 "语句标识符" 为开始，并执行该语句。
语句标识符是保留关键字不能作为变量名使用。
下面列出了 JavaScript 语句标识符 (关键字) ：
break，用于跳出循环。
catch，语句块，在 try 语句块执行出错时执行 catch 语句块。
continue，跳过循环中的一个迭代。
do ... while，执行一个语句块，在条件语句为 true 时继续执行该语句块。
for，在条件语句为 true 时，可以将代码块执行指定的次数。
for ... in，用于遍历数组或者对象的属性（对数组或者对象的属性进行循环操作）。
function，定义一个函数
if ... else，用于基于不同的条件来执行不同的动作。
return，退出函数
switch，用于基于不同的条件来执行不同的动作。
throw，抛出（生成）错误 。
try，实现错误处理，与 catch 一同使用。
var，声明一个变量。
while，当条件语句为 true 时，执行语句块。
JavaScript 是脚本语言。浏览器会在读取代码时，逐行地执行脚本代码。而对于传统编程来说，会在执行前对所有代码进行编译。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 注释，可用于提高代码的可读性
JavaScript 不会执行注释。
我们可以添加注释来对 JavaScript 进行解释，或者提高代码的可读性
多行注释以 / 开始，以 / 结尾
在开头使用注释来阻止执行
不是所有的 JavaScript 语句都是"命令"。双斜杠 // 后的内容将会被浏览器忽略
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript变量
变量是用于存储信息的"容器"
您可以把变量看做存储数据的容器
变量必须以字母开头
变量也能以 $ 和 符号开头（不过我们不推荐这么做）
变量名称对大小写敏感（y 和 Y 是不同的变量）
JavaScript 语句和 JavaScript 变量都对大小写敏感
let允许你声明一个作用域被限制在块级中的变量、语句或者表达式。在Function中局部变量推荐使用let变量，避免变量名冲突。
。。。。。。。。。。
JavaScript 数据类型
JavaScript 变量还能保存其他数据类型，比如文本值 (name="Bill Gates")，在 JavaScript 中，类似 "Bill Gates" 这样一条文本被称为字符串。
JavaScript 变量有很多种类型，但是现在，我们只关注数字和字符串。
当您向变量分配文本值时，应该用双引号或单引号包围这个值。
当您向变量赋的值是数值时，不要使用引号。如果您用引号包围数值，该值会被作为文本来处理。
。。。。。。。。。。。。。。
声明（创建） JavaScript 变量
在 JavaScript 中创建变量通常称为"声明"变量。
我们使用 var 关键词来声明变量
变量声明之后，该变量是空的（它没有值）如：(var carname;)
如需向变量赋值，请使用等号:(var carname="123456789"是carname的赋值";)
如果重新声明 JavaScript 变量，该变量的值不会丢失：
在以下两条语句执行后，变量 carname 的值依然是 "Volvo"：
var carname="Volvo";
var carname；
一个好的编程习惯是，在代码开始处，统一对需要的变量进行声明。
。。。。。。。。。。
一条语句，多个变量
您可以在一条语句中声明很多变量。该语句以 var 开头，并使用逗号分隔变量即可：var lastname="Doe", age=30, job="carpenter";
声明也可横跨多行：
var lastname="Doe",
age=30,
job="carpenter";
一条语句中声明的多个可以赋同一个值：var x,y,z=1;
。。。。。。。。。。
Value = undefined
在计算机程序中，经常会声明无值的变量。未使用值来声明的变量，其值实际上是 undefined。
。。。。。。。。
JavaScript 算数
您可以通过 JavaScript 变量来做算数，使用的是 = 和 + 这类运算符
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 数据类型：
字符串：（String）
数字：(Number)
布尔：(Boolean)，有两个值：(true,真的)(false,假的)
数组：(Array)
对象：(Object)
未定义：（Undefined）
空：（Null）
。。。。。。。。。。。。
JavaScript 拥有动态类型
JavaScript 拥有动态类型。这意味着相同的变量可用作不同的类型：
var x; // x 为 undefined
var x = 5; // 现在 x 为数字
var x = "John"; // 现在 x 为字符串
。。。。。。。。。。。。。。。。。。。。。。
JavaScript 字符串：字符串是存储字符（比如 "Bill Gates"）的变量，字符串可以是引号中的任意文本。您可以使用单引号或双引号
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
JavaScript 数字，JavaScript 只有一种数字类型。数字可以带小数点，也可以不带
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
JavaScript 布尔，（逻辑）只能有两个值：true 或 false。布尔常用在条件测试中。
。。。。。。。。。。。。。
JavaScript 数组：[#,#,#,#,#]
数组下标是基于零的，所以第一个项目是 [0]，第二个是 [1]，以此类推。
。。。。。。。。
Undefined 和 Null：
Undefined 这个值表示变量不含有值。
可以通过将变量的值设置为 null 来清空变量
当您声明新变量时，可以使用关键词 "new" 来声明其类型。
JavaScript 变量均为对象。当您声明一个变量时，就创建了一个新的对象。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 对象
JavaScript 对象是拥有 "属性" 和 "方法" 的数据。
对象由花括号分隔。在括号内部，对象的属性以名称和值对的形式 (name : value) 来定义。属性由逗号分隔：
JavaScript 变量均为对象。当您声明一个变量时，就创建了一个新的对象。
对象也是一个变量，但对象可以包含多个值（多个变量）。
。。。。。。
对象属性
可以说 JavaScript "对象" 是 "变量" 的容器。
但是，我们通常认为 "JavaScript 对象是键值对的容器"。
键值对通常写法为 name : value (键与值以冒号分割)。
键值对在 JavaScript 对象通常称为 "对象属性"。
访问对象属性的两种方式: 1.对象 的(.) 属性 2.对象["属性"]
。。。。。。
对象方法
对象的方法定义了一个函数，并作为对象的属性存储。
对象方法通过添加 () 调用 (作为一个函数)
对象方法作为一个函数定义存储在对象属性中。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 函数
JavaScript 函数定义
JavaScript 使用关键字 function 定义函数。
函数可以通过声明定义，也可以是一个表达式。
函数声明后不会立即执行，会在我们需要的时候调用到。
分号是用来分隔可执行JavaScript语句。
由于函数声明不是一个可执行语句，所以不以分号结束。
JavaScript 函数可以通过一个表达式定义。
函数表达式可以存储在变量中。
在函数表达式存储在变量后，变量也可作为一个函数使用。
函数存储在变量中，不需要函数名称，通常通过变量名来调用。
函数同样可以通过内置的 JavaScript 函数构造器（Function()）定义。
函数是由事件驱动的或者当它被调用时执行的，可重复使用的代码块。
JavaScript 语句可以写在函数内，函数可以重复引用。
引用一个函数 = 调用函数(执行函数内的语句)。
函数就是包裹在花括号中的代码块，前面使用了关键词 function
语法如下：
function functionname()
{
执行代码
}
当调用该函数时，会执行函数内的代码。
可以在某事件发生时直接调用函数（比如当用户点击按钮时），并且可由 JavaScript 在任何位置进行调用。
javaScript 对大小写敏感。关键词 function 必须是小写的，并且必须以与函数名称相同的大小写来调用函数。
。。。。。。。。。
调用带参数的函数
调用带参数的函数，函数括号里面的值被称之为 "参数"。
在调用函数时，您可以向其传递值，这些值被称为 "参数"。
当您声明函数时，请把参数作为变量来声明，这些参数可以在函数中使用。
您可以发送任意多的参数，由逗号 (,) 分隔，变量和参数必须以一致的顺序出现。第一个变量就是第一个被传递的参数的给定的值，以此类推。
。。。。。。。。。
带有返回值的函数
有时，我们会希望函数将值返回调用它的地方。
通过使用 return 语句就可以实现。
在使用 return 语句时，函数会停止执行，并返回指定的值
语法：
function myFunction()
{
var x=5;
return x;
} //返回 "x=5"
注意： 整个 JavaScript 并不会停止执行，仅仅是函数。JavaScript 将继续执行代码，从调用函数的地方。
。。。。。。。。。。。
局部 JavaScript 变量
在 JavaScript 函数内部声明的变量（使用 var）是局部变量，所以只能在函数内部访问它。（该变量的作用域是局部的）。
您可以在不同的函数中使用名称相同的局部变量，因为只有声明过该变量的函数才能识别出该变量。
只要函数运行完毕，本地变量就会被删除
。。。。。。。。。。。
全局 JavaScript 变量
在函数外声明的变量是全局变量，网页上的所有脚本和函数都能访问它。
。。。。。。。。。。。。
JavaScript 变量的生存期
JavaScript 变量的生命期从它们被声明的时间开始。
"局部变量" 会在函数运行以后被删除。
"全局变量" 会在页面关闭后被删除。
。。。。。。。。。。。。。。。
如果您把值赋给尚未声明的变量，该变量将被自动作为 window 的一个属性，将声明 window 的一个属性 carname
非严格模式下给未声明变量赋值创建的全局变量，是全局对象的可配置属性，可以删除。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 作用域
作用域可访问变量的集合。
在 JavaScript 中, 对象和函数同样也是变量。
在 JavaScript 中, 作用域为可访问变量，对象，函数的集合。
JavaScript 函数作用域：作用域在函数内修改。
。。。。。。。。。。。
JavaScript 局部作用域
变量在函数内声明，变量为局部作用域。
局部变量：只能在函数内部访问，局部变量在声明的函数外不可以访问。
因为局部变量只作用于函数内，所以不同的函数可以使用相同名称的变量。
局部变量在函数开始执行时创建，函数执行完后局部变量会自动销毁。
。。。。。。。。。。。
JavaScript 全局变量
变量在函数外定义，即为全局变量。
全局变量有 全局作用域: 网页中所有脚本和函数均可使用。
如果变量在函数内没有声明（没有使用 var 关键字），该变量为全局变量。
。。。。。。。。。。。
JavaScript 变量生命周期
JavaScript 变量生命周期在它声明时初始化。
局部变量在函数执行完毕后销毁。
全局变量在页面关闭后销毁。
。。。。。。。。。。
函数参数
函数参数只在函数内起作用，是局部变量。
。。。。。。。。。。
HTML 中的全局变量
在 HTML 中, 全局变量是 window 对象: 所有数据变量都属于 window 对象。
你的全局变量，或者函数，可以覆盖 window 对象的变量或者函数。
局部变量，包括 window 对象可以覆盖全局变量和函数。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 事件
HTML 事件是发生在 HTML 元素上的事情。
当在 HTML 页面中使用 JavaScript 时， JavaScript 可以触发这些事件
HTML 事件可以是浏览器行为，也可以是用户行为。
以下是 HTML 事件的实例：
HTML 页面完成加载'
HTML input 字段改变时'
HTML 按钮被点击'
通常，当事件发生时，你可以做些事情。
在事件触发时 JavaScript 可以执行一些代码。
HTML 元素中可以添加事件属性，使用 JavaScript 代码来添加 HTML 元素
代码将修改自身元素的内容 (使用 this.innerHTML):
JavaScript代码通常是几行代码。比较常见的是通过事件属性来调用。
下面是一些常见的HTML事件：
onclick：当用户点击某个对象时调用的事件句柄。
ondblclick：当用户双击某个对象时调用的事件句柄。
oncontextmenu：在用户点击鼠标右键打开上下文菜单时触发
onmousemove：鼠标被移动。
onmousedown：鼠标按钮被按下。onmouseup：鼠标按键被松开。
onmouseenter：当鼠标指针移动到元素上时触发。onmouseleave：当鼠标指针移出元素时触发
onmouseover：鼠标移到某元素之上。onmouseout：鼠标从某元素移开
事件可以用于处理表单验证，用户输入，用户行为及浏览器动作：
页面加载时触发事件
页面关闭时触发事件
用户点击按钮执行动作
验证用户输入内容的合法性
可以使用多种方法来执行 JavaScript 事件代码：
HTML 事件属性可以直接执行 JavaScript 代码
HTML 事件属性可以调用 JavaScript 函数
你可以为 HTML 元素指定自己的事件处理程序
你可以阻止事件的发生。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 字符串
JavaScript 字符串用于存储和处理文本
字符串可以存储一系列字符，如 "John Doe"。
字符串可以是插入到引号中的任何字符。你可以使用单引号或双引号
你可以使用索引位置来访问字符串中的每个字符
字符串的索引从 0 开始，这意味着第一个字符索引值为 [0],第二个为 [1], 以此类推。
你可以在字符串中使用引号，字符串中的引号不要与字符串的引号相同(不可以同时使用同一种引号)
你也可以在字符串添加转义字符来使用引号
可以使用内置属性 length 来计算字符串的长度(有几个字符)
在 JavaScript 中，字符串写在单引号或双引号中
转义字符：
\'：单引号
\"：双引号
\：反斜杠
\n ：换行
\r：回车
\t：tab(制表符)
\b ：退格符
\f：换页符
。。。。。。。。。。。。
字符串可以是对象
通常， JavaScript 字符串是原始值，可以使用字符创建： var firstName = "John"
但我们也可以使用 "new" 关键字将字符串定义为一个对象： var firstName = new String("John")
不要创建 String 对象。它会拖慢执行速度，并可能产生其他副作用
。。。。。。。。。。。。
字符串属性和方法：
原始值字符串，如 "John", 没有属性和方法(因为他们不是对象)。
原始值可以使用 JavaScript 的属性和方法，因为 JavaScript 在执行方法和属性时可以把原始值当作对象
字符串属性：
constructor：返回创建字符串属性的函数
length：返回字符串的长度
prototype：允许您向对象添加属性和方法。Prototype 是全局属性，适用于所有的Javascript对象。
字符串方法：
harAt()：返回指定索引位置的字符，index 必需。表示字符串中某个位置的数字，即字符在字符串中的位置。负值是反的方向
charCodeAt()：返回指定索引位置字符的 Unicode 值(字符编码值)
concat()：连接两个或多个字符串，返回连接后的字符串
fromCharCode()：将 Unicode 转换为字符串
indexOf()：返回字符串中检索指定字符第一次出现的位置
lastIndexOf()：返回字符串中检索指定字符最后一次出现的位置
localeCompare()：用本地特定的顺序来比较两个字符串
match()：找到一个或多个正则表达式的匹配
replace()：替换与正则表达式匹配的子串
search()：检索与正则表达式相匹配的值
slice()：提取字符串的片断，并在新的字符串中返回被提取的部分
split()：把字符串分割为子字符串数组
substr()：从起始索引号提取字符串中指定数目的字符
substring()：提取字符串中两个指定的索引号之间的字符
toLocaleLowerCase()：根据主机的语言环境把字符串转换为小写，只有几种语言（如土耳其语）具有地方特有的大小写映射
toLocaleUpperCase()：根据主机的语言环境把字符串转换为大写，只有几种语言（如土耳其语）具有地方特有的大小写映射
toLowerCase()：把字符串转换为小写
toString() 返回字符串对象值
toUpperCase() 把字符串转换为大写
trim() 移除字符串首尾空白
valueOf() 返回某个字符串对象的原始值
::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 运算符
运算符 "=" 用于给 JavaScript 变量赋值。(给变量赋值)
算术运算符 "+" 用于把值加起来。用于字符串的 "+" 运算符：
"+" 运算符用于把文本值或字符串变量加起来（连接起来）。
如需把两个或多个字符串变量连接起来，请使用 "+" 运算符。
要想在两个字符串之间增加空格，需要把空格插入一个字符串之中，或者把空格插入表达式中(" ")
如果两个数字相加，返回数字相加的和。
如果数字与字符串相加，返回字符串。
。。。。。。。
算术运算符：
+：加法
-：减法
：乘法
/：除法
% ：取模（余数）
++：自增(递增)，前置型：。后置型：
--：自减(递减)，前置型：。后置型：
。 。。。。。。
赋值运算符：
赋值运算符用于给 JavaScript 变量赋值。
=
+=
-=
=
/=
%=
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 比较 和 逻辑运算符
比较和逻辑运算符用于测试 true 或者 false。
逻辑运算用来判断一件事情是“对”的还是“错”的。或者说是“成立”还是“不成立”。判断的结果是二值的。
即没有“可能是”或者“可能不是”。这个“可能”的用法是一个模糊概念。
在计算机里面进行的是 二进制运算。逻辑判断的结果只有二个值，称这二个值为“ 逻辑值”。
用数的符号表示就是“1”和“0”。其中“1”表示该逻辑运算的结果是“成立”的。如果一个逻辑运算式的结果为“0”。那么这个逻辑运算式表达的内容“不成立“。
比较和逻辑运算符用于测试 "true(真实的)" 或者 "false(错误的)"。
。。。。。。。
比较运算符：
==：等于
===：绝对等于（值和类型均相等）
!=：不等于
!==：绝对不等于（值和类型有一个不相等，或两个都不相等）
：大于，向左
<：小于，向右
=：大于或等于
<=：小于或等于
。。。。。。。
JavaScript == 与 === 区别
1、对于 string、number 等基础类型，== 和 === 是有区别的
a）不同类型间比较，== 之比较 "转化成同一类型后的值" 看 "值" 是否相等，=== 如果类型不同，其结果就是不等。
b）同类型比较，直接进行 "值" 比较，两者结果一样。
2、对于 Array,Object 等高级类型，== 和 === 是没有区别的
进行 "指针地址" 比较
3、基础类型与高级类型，== 和 === 是有区别的
a）对于 ==，将高级转化为基础类型，进行 "值" 比较
b）因为类型不同，=== 结果为 false
4、!= 为 == 的非运算，!== 为 === 的非运算
。。。。。。。
逻辑运算符：
逻辑非 "!"：not(相反)
逻辑与 "&&"：and(和)，当两个条件成立时会显示布尔值“true”，反之会显示“false”
逻辑或 " "：or(或者)，当一个或两个条件成立时会显示布尔值“true”，反之会显示“false”
可以在条件语句中使用比较运算符对值进行比较，然后根据结果来采取行动。
JavaScript 还包含了基于某些条件对变量进行赋值的条件运算符。
javascript条件语句
条件语句用于基于不同的条件来执行不同的动作。
条件语句
通常在写代码时，您总是需要为不同的决定来执行不同的动作。您可以在代码中使用条件语句来完成该任务。
在 JavaScript 中，我们可使用以下条件语句：
if 语句 - 只有当指定条件为 true 时，使用该语句来执行代码
if...else 语句 - 当条件为 true 时执行代码，当条件为 false 时执行其他代码
if...else if....else 语句- 使用该语句来选择多个代码块之一来执行
switch 语句 - 使用该语句来选择多个代码块之一来执行
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript if...Else 语句
。。。。。。。。。。。。。。。。。。
if 语句
只有当指定条件为 true 时，该语句才会执行代码
请使用小写的 if。使用大写字母（IF）会生成 JavaScript 错误！
if (condition(条件))
{
当条件为 true 时执行的代码
}
。。。。。。。。。。。。。。。。。。。。。。
使用 if....else 语句在条件为 true 时执行代码，在条件为 false 时执行其他代码。
语法：
if (condition(条件))
{
当条件为 true 时执行的代码
}
else
{
当条件不为 true 时执行的代码
}
。。。。。。。。。。。。。。。。。。。。。。
使用 if....，else if，...else 语句来选择多个代码块之一来执行。
语法：
if (condition1)
{
当条件 1 为 true 时执行的代码
}
else if (condition2)
{
当条件 2 为 true 时执行的代码
}
else
{
当条件 1 和 条件 2 都不为 true 时执行的代码
}
:::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript switch(切换) 语句
switch 语句用于基于不同的条件来执行不同的动作。
语法：
switch(n)
{
case 1:
执行代码块 1
break;
case 2:
执行代码块 2
break;
default:
与 case 1 和 case 2 不同时执行的代码
}
工作原理：首先设置表达式 n（通常是一个变量）。随后表达式的值会与结构中的每个 case 的值做比较。如果存在匹配，则与该 case 关联的代码块会被执行。请使用 break 来阻止代码自动地向下一个 case 运行。
。。。。。。。。
default 关键词
请使用 default 关键词来规定匹配不存在时做的事情
::::::::::::::::::::::::::::::::::::::::
JavaScript for 循环
循环可以将代码块执行指定的次数。
如果您希望一遍又一遍地运行相同的代码，并且每次的值都不同，那么使用循环是很方便的。
。。。。。。。。。。。。。。。。
JavaScript 支持不同类型的循环：
for - 循环代码块一定的次数
for/in - 循环遍历对象的属性
while - 当指定的条件为 true 时循环指定的代码块
do/while - 同样当指定的条件为 true 时循环指定的代码块
。。。。。。。。。。。。。。。。
for 循环
下面是 for 循环的语法：
for (语句 1; 语句 2; 语句 3)
{
被执行的代码块
}
语句 1 （代码块）开始前执行
语句 2 定义运行循环（代码块）的条件
语句 3 在循环（代码块）已被执行之后执行
语句 1
通常我们会使用语句 1 初始化循环中所用的变量 (var i=0)。
语句 1 是可选的，也就是说不使用语句 1 也可以。
您可以在语句 1 中初始化任意（或者多个）值。
同时您还可以省略语句 1（比如在循环开始前已经设置了值时）
语句 2
通常语句 2 用于评估初始变量的条件。
语句 2 同样是可选的。
如果语句 2 返回 true，则循环再次开始，如果返回 false，则循环将结束。
如果您省略了语句 2，那么必须在循环内提供 break。否则循环就无法停下来。这样有可能令浏览器崩溃。
语句 3*
通常语句 3 会增加初始变量的值。
语句 3 也是可选的。
语句 3 有多种用法。增量可以是负数 (i--)，或者更大 (i=i+15)。
语句 3 也可以省略（比如当循环内部有相应的代码时）
。。。。。。。。。。。。。。。。。。。。
for/in，循环语句循环遍历对象的属性。
:::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript while 循环
只要指定条件为 true，循环就可以一直执行代码块。
语法：
while (条件)
{
需要执行的代码
}
如果您忘记增加条件中所用变量的值，该循环永远不会结束。这可能导致浏览器崩溃。
。。。。。。。。。。。。。。
do/while 循环
do/while 循环是 while 循环的变体。该循环会在检查条件是否为真之前执行一次代码块，然后如果条件为真的话，就会重复这个循环。
do
{
需要执行的代码
}
while (条件)
别忘记增加条件中所用变量的值，否则循环永远不会结束！
。。。。。。。。。。。。。。。
while 使用 length 属性循环数组。
while 和 do/while 的区别 : do/while至少会执行一遍。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript Break 和 Continue 语句
break 语句用于跳出循环，可以不用花括号。
continue 用于跳过循环中的一个迭代(会继续执行该循环之后的代码（如果有的话）)。指定哪个就跳过哪个
continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下一个迭代。
continue 语句（带有或不带标签引用）只能用在循环中。
break 语句（不带标签引用），只能用在循环或 switch 中。
break 和 continue 语句仅仅是能够跳出代码块的语句。
语法:
break空格+标签名称;
continue空格+标签名称;
JavaScript 标签：
如需标记 JavaScript 语句，请在语句之前加上冒号。
通过标签引用，break 语句可用于跳出任何 JavaScript 代码块：
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript (typeof), (null), 和 (undefined)：
你可以使用 "typeof" 操作符 来检测变量的数据类型。
。。。。。。。。。。。。。。
在JavaScript中，数组是一种特殊的对象类型。 因此 typeof [#,#,#,#] 返回 object。
。。。。。。。。。。。。。。
null在 JavaScript 中 null 表示 "什么都没有"，但类型为对象。
null是一个只有一个值的特殊类型，表示一个空对象引用。
用 typeof 检测 null 返回是object。
你可以设置为 null 来清空对象。
。。。。。。。。。。。。。。
你可以设置为 undefined 来清空对象，但类型为 undefined。
undefined在 JavaScript 中, undefined 是一个没有设置值的变量，typeof 一个没有值的变量会返回 undefined。
任何变量都可以通过设置值为 undefined 来清空，
null 和 undefined 的值相等，但类型不等。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 类型转换：
Number() 转换为数字。
String() 转换为字符串。
Boolean() 转化为布尔值。
。。。。。。。。。。。。
javaScript中有 5 种不同的数据类型：
string(字符串)
number(数字)
boolean(布尔值)
object(对象)
function(函数)
。。。。。。。。。。。
3 种对象类型：
Object
Date
Array
。。。。。。。。。。。。。。。
2 个不包含任何值的数据类型：
null
undefined
请注意：
NaN 的数据类型是 number。
数组(Array)的数据类型是 object。
日期(Date)的数据类型为 object。
null 的数据类型是 object。
未定义变量的数据类型为 undefined。
如果对象是 JavaScript Array 或 JavaScript Date ，我们就无法通过 typeof 来判断他们的类型，因为都是 返回 Object。
。。。。。。。。。。。。。
constructor 属性
constructor 属性返回所有 JavaScript 变量的构造函数
你可以使用 constructor 属性来查看对象是否为数组 (包含字符串 "Array")
。。。。。。。。。。。。。。。。。。。。。。。。
javaScript 变量可以转换为新变量或其他数据类型：
通过使用 JavaScript 函数
通过 JavaScript 自身自动转换
。。。。。。。。。。
将数字转换为字符串
全局方法 String()：可以将数字转换为字符串，该方法可用于任何类型的数字，字母，变量，表达式。Number 方法 to String() 也是有同样的效果。
toExponential()：把对象的值转换为指数计数法。
toFixed()：把数字转换为字符串，结果的小数点后有指定位数的数字。
toPrecision()：把数字格式化为指定的长度。
。。。。。。。。。。。。。。。。。。。。。。
将布尔值转换为字符串
全局方法 String()：可以将布尔值转换为字符串。
。。。。。。。。。。。。。。。。。。。。。。
将字符串转换为数字
全局方法 Number()：可以将字符串转换为数字，空字符串转换为 0，其他的字符串会转换为 NaN (不是个数字)。
parseFloat()：解析一个字符串，并返回一个浮点数。
parseInt()：解析一个字符串，并返回一个整数。
全局方法 Number() 可将布尔值转换为数字。Number(false) // 返回 0，Number(true) // 返回 1
全局方法 Number() 可将日期转换为数字。d = new Date()，Number(d) // 返回 1404568027739
。。。。。。。。。。。。。。。。。。。。。
一元运算符 "+"：
操作符 "+" 可用于将变量转换为数字。
如果变量不能转换，它仍然会是一个数字，但值为 NaN (不是一个数字)。
当 JavaScript 尝试操作一个 "错误" 的数据类型时，会自动转换为 "正确" 的数据类型。
当你尝试输出一个对象或一个变量时 JavaScript 会自动调用变量的 toString() 方法。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
javascript 正则表达式：
正则表达式（英语：RegularExpression，在代码中常简写为regex、regexp或RE）使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。
搜索模式可用于文本搜索和文本替换。
。。。。。。。。。。。。。。。。。
什么是正则表达式？
正则表达式是由一个字符序列形成的搜索模式。
当你在文本中搜索数据时，你可以用搜索模式来描述你要查询的内容。
正则表达式可以是一个简单的字符，或一个更复杂的模式。
正则表达式可用于所有文本搜索和文本替换的操作。
语法：/正则表达式主体/修饰符(可选)
var patt = /runoob/i。
/runoob/i 是一个正则表达式。
runoob 是一个正则表达式主体 (用于检索)。
i 是一个修饰符 (搜索不区分大小写)。
正则表达式修饰符：
i：执行对大小写不敏感的匹配。
g：执行全局匹配（查找所有匹配而非在找到第一个匹配后停止）。
m ：执行多行匹配。
。。。。。。。。。。。
字符串方法：
在 JavaScript 中，正则表达式通常用于两个字符串方法 : search() 和 replace()。
search() 方法 用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串，并返回子串的起始位置。子字符串的位置按 "索引" 来排序。
replace() 方法 用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。先找到要替换的元素位置。
。。。。。。。。。。。
正则表达式模式：
方括号用于查找某个范围内的字符：
[abc]：查找方括号之间的任何字符。
[0-9]：查找任何从 0 至 9 的数字。
(x y)：查找任何以 分隔的选项。
元字符是拥有特殊含义的字符：
\d：查找数字。
\s：查找空白字符。
\b：匹配单词边界。
\uxxxx：查找以十六进制数 xxxx 规定的 Unicode 字符。
量词:
n+：匹配任何包含至少一个 n 的字符串。
n*：匹配任何包含零个或多个 n 的字符串。
n?：匹配任何包含零个或一个 n 的字符串。
。。。。。。。。。。。。。。。。。
RegExp 对象：
在 JavaScript 中，RegExp 对象是一个预定义了属性和方法的正则表达式对象。
test() 方法是一个正则表达式方法。
test() 方法用于检测一个字符串是否匹配某个模式，如果字符串中含有匹配的文本，则返回 true，否则返回 false。
exec() 方法是一个正则表达式方法。
exec() 方法用于检索字符串中的正则表达式的匹配。
该函数返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。会直接返回匹配结果。
JavaScript 错误 - throw、try 和 catch：
try 语句测试代码块的错误。
catch 语句处理错误。
throw 语句创建自定义错误。
。。。。。。。。。。
JavaScript 错误：
当 JavaScript 引擎执行 JavaScript 代码时，会发生各种错误。
可能是语法错误，通常是程序员造成的编码错误或错别字。
可能是拼写错误或语言中缺少的功能（可能由于浏览器差异）。
可能是由于来自服务器或用户的错误输出而导致的错误。
当然，也可能是由于许多其他不可预知的因素。
。。。。。。。。。。。。。。。。。。。。
当错误发生时，当事情出问题时，JavaScript 引擎通常会停止，并生成一个错误消息。
描述这种情况的技术术语是：JavaScript 将抛出一个错误。
。。。。。。。。。。。。。。。。。。。。
try 和 catch：
try 语句允许我们定义在执行时进行错误测试的代码块。
catch 语句允许我们定义当 try 代码块发生错误时，所执行的代码块。
try 和 catch 是成对出现的。
语法：
try {
//在这里运行代码
} catch(err) {
//在这里处理错误
}
。。。。。。。。。。
throw 语句：
throw 语句允许我们创建自定义错误。
正确的技术术语是：创建或抛出异常（exception）。
如果把 throw 与 try 和 catch 一起使用，那么您能够控制程序流，并生成自定义的错误消息。
语法：
throw exception(异常)
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 调试：
在编写 JavaScript 时，如果没有调试工具将是一件很痛苦的事情。
没有调试工具是很难去编写 JavaScript 程序的。你的代码可能包含语法错误，逻辑错误，如果没有调试工具，这些错误比较难于发现。
通常，如果 JavaScript 出现错误，是不会有提示信息，这样你就无法找到代码错误的位置。
。。。。。。。。。。。。。。。。。。
在程序代码中寻找错误叫做“代码调试”。
调试很难，但幸运的是，很多浏览器都内置了调试工具。
内置的调试工具可以开始或关闭，严重的错误信息会发送给用户。
有了调试工具，我们就可以设置断点 (代码停止执行的位置), 且可以在代码执行时检测变量。
浏览器启用调试工具一般是按下 F12 键，并在调试菜单中选择 "Console" 。
console.log() 方法：
如果浏览器支持调试，你可以使用 console.log() 方法在调试窗口上打印 JavaScript 值：
设置断点：
在调试窗口中，你可以设置 JavaScript 代码的断点。
在每个断点上，都会停止执行 JavaScript 代码，以便于我们检查 JavaScript 变量的值。
在检查完毕后，可以重新执行代码（如播放按钮）。
debugger 关键字：
debugger 关键字用于停止执行 JavaScript，并调用调试函数。
这个关键字与在调试工具中设置断点的效果是一样的。
如果没有调试可用，debugger 语句将无法工作。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 变量提升(hoisting)：
JavaScript 中，函数及变量的声明都将被提升到函数的最顶部。函数声明和变量声明总是会被解释器悄悄地被"提升"到方法体的最顶部。
JavaScript 中，变量可以在使用后声明，也就是变量可以先使用再声明。
JavaScript 只有声明的变量会提升，初始化的不会。
在头部声明你的变量
对于大多数程序员来说并不知道 JavaScript 变量提升。
如果程序员不能很好的理解变量提升，他们写的程序就容易出现一些问题。
为了避免这些问题，通常我们在每个作用域开始前声明这些变量，这也是正常的 JavaScript 解析步骤，易于我们理解。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 严格模式(use strict)：
JavaScript 严格模式(strict mode)不允许使用未声明的变量。
严格模式（strict mode）即在严格的条件下运行。
"use strict" 指令在 JavaScript 1.8.5 (ECMAScript5) 中新增。
它不是一条语句，但是是一个"字面量表达式"。
"use strict" 的目的是指定代码在严格条件下执行。
严格模式下你不能使用未声明的变量。
在函数内部声明是局部作用域 (只在函数内使用严格模式):
为什么使用严格模式？？？：
消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为。
消除代码运行的一些不安全之处，保证代码运行的安全。
提高编译器效率，增加运行速度。
为未来新版本的Javascript做好铺垫。
"严格模式"体现了Javascript更合理、更安全、更严谨的发展方向，包括IE 10在内的主流浏览器，都已经支持它，许多大项目已经开始全面拥抱它。
另一方面，同样的代码，在"严格模式"中，可能会有不一样的运行结果；一些在"正常模式"下可以运行的语句，在"严格模式"下将不能运行。掌握这些内容，有助于更细致深入地理解Javascript，让你变成一个更好的程序员。
严格模式的限制：
不允许使用未声明的变量，对象也是一个变量。未声明也不可以用。
不允许删除变量或对象。
不允许删除函数。
不允许变量重名。
不允许使用八进制。
不允许使用转义字符。
不允许对只读属性赋值。
不允许对一个使用getter方法读取的属性进行赋值。
不允许删除一个不允许删除的属性。
不允许变量名使用 "eval" 字符串。
不允许变量名使用 "arguments" 字符串。
不允许使用保留关键字。
由于一些安全原因，在作用域 eval() 创建的变量不能被调用。
禁止this关键字指向全局对象。
不允许使用以下这种语句:
"use strict";
with (Math){x = cos(2)}; // 报错
保留关键字：
为了向将来Javascript的新版本过渡，严格模式新增了以下一些保留关键字：
implements
interface
let
package
private
protected
public
static
yield
"use strict"(严格模式)， 指令只允许出现在脚本或函数的开头。
：
JavaScript 使用误区
赋值运算符应用错误。
在 JavaScript 程序中如果你在 if 条件语句中使用赋值运算符的等号 (=) 将会产生一个错误结果, 正确的方法是使用比较运算符的两个等号 (==)。
赋值语句返回变量的值。
比较运算符常见错误：
在常规的比较中，数据类型是被忽略的。
在严格的比较运算中，=== 为恒等计算符，同时检查表达式的值与类型，switch 语句会使用恒等计算符(===)进行比较。
加法与连接注意事项：
加法是两个数字相加。
连接是两个字符串连接。
JavaScript 的加法和连接都使用 "+" 运算符。
浮点型数据使用注意事项：
JavaScript 中的所有数据都是以 64 位浮点型数据(float) 来存储。
所有的编程语言，包括 JavaScript，对浮点型数据的精确度都很难确定。用整数的乘除法来解决。
avaScript 字符串分行：
JavaScript 允许我们在字符串中使用断行语句，但是 在字符串中直接使用回车换行是会报错的，字符串断行需要使用反斜杠()。
错误的使用分号：
注意分号的使用。
return 语句使用注意事项：
JavaScript 默认是在代码的最后一行自动结束。
avaScript 也可以使用多行来结束一个语句。
注意：不用对 return 语句进行断行。
数组中使用名字来索引：
许多程序语言都允许使用名字来作为数组的索引。
使用名字来作为索引的数组称为关联数组(或哈希)。
JavaScript 不支持使用名字来索引数组，只允许使用数字索引。
在 JavaScript 中, 对象 使用 名字作为索引。
如果你使用名字作为索引，当访问数组时，JavaScript 会把数组重新定义为标准对象。
执行这样操作后，数组的方法及属性将不能再使用，否则会产生错误:
定义数组元素，最后不能添加逗号。
定义对象，最后不能添加逗号。
Undefined 不是 Null：
在 JavaScript 中, null 用于对象, undefined 用于变量，属性和方法。
对象只有被定义才有可能为 null，否则为 undefined。
如果我们想测试对象是否存在，在对象还没定义时将会抛出一个错误。
程序块作用域：
在每个代码块中 JavaScript 不会创建一个新的作用域，一般各个代码块的作用域都是全局的。
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 表单
HTML 表单验证可以通过 JavaScript 来完成。
HTML 表单验证也可以通过浏览器来自动完成。
如果表单字段 (fname) 的值为空, required 属性会阻止表单提交：
。。。。。。。。。。
数据验证：
数据验证用于确保用户输入的数据是有效的。
典型的数据验证有：
必需字段是否有输入?
用户是否输入了合法的数据?
在数字字段是否输入了文本?
大多数情况下，数据验证用于确保用户正确输入数据。
数据验证可以使用不同方法来定义，并通过多种方式来调用。
服务端数据验证是在数据提交到服务器上后再验证。
客户端数据验证 side validation是在数据发送到服务器前，在浏览器上完成验证。
。。。。。。。。。。。。
HTML 约束验证：
HTML5 新增了 HTML 表单的验证方式：约束验证（constraint validation）。
约束验证是表单被提交时浏览器用来实现验证的一种算法。
HTML 约束验证基于：
HTML 输入属性
CSS 伪类选择器
DOM 属性和方法
。。。。。。。。。。。。。
约束验证 HTML 输入属性：
disabled：规定输入的元素不可用
max：规定输入元素的最大值
min：规定输入元素的最小值
pattern：规定输入元素值的模式
required：规定输入元素字段是必需的
type：规定输入元素的类型
。。。。。。。。。。。。。。
约束验证 CSS 伪类选择器：
:disabled：选取属性为 "disabled" 属性的 input 元素
:invalid：选取无效的 input 元素
:optional：选择没有"required"属性的 input 元素
:required：选择有"required"属性的 input 元素
:valid：选取有效值的 input 元素
::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 表单验证
JavaScript 可用来在数据被送往服务器前对 HTML 表单中的这些输入数据进行验证。
表单数据经常需要使用 JavaScript 来验证其正确性：
验证表单数据是否为空？
验证输入是否是一个正确的email地址？
验证日期是否输入正确？
验证表单输入内容是否为数字型？
::::::::::::::::::::::::::::::::::::::::::::
JavaScript 验证 API
约束验证 DOM 方法：
checkValidity()：如果 input 元素中的数据是合法的返回 true，否则返回 false。
setCustomValidity()：
设置 input 元素的 validationMessage 属性，用于自定义错误提示信息的方法。
使用setCustomValidity设置了自定义提示后，validity.customError就会变成true，则checkValidity总是会返回false。如果要重新判断需要取消自定义提示，方式如下：
setCustomValidity('')
setCustomValidity(null)
setCustomValidity(undefined)
。。。。。。。。。。。。
约束验证 DOM 属性：
validity ：布尔属性值，返回 input 输入值是否合法。
validationMessage：浏览器错误提示信息。
willValidate：指定 input 是否需要验证。
。。。。。。。。。。。。。。
Validity 属性
input 元素的 validity 属性包含一系列关于 validity 数据属性：
customError：设置为 true, 如果设置了自定义的 validity 信息。
patternMismatch：设置为 true, 如果元素的值不匹配它的模式属性。
rangeOverflow：设置为 true, 如果元素的值大于设置的最大值。
rangeUnderflow：设置为 true, 如果元素的值小于它的最小值。
stepMismatch：设置为 true, 如果元素的值不是按照规定的 step 属性设置。
tooLong：设置为 true, 如果元素的值超过了 maxLength 属性设置的长度。
typeMismatch：设置为 true, 如果元素的值不是预期相匹配的类型。
valueMissing：设置为 true，如果元素 (required 属性) 没有值。
valid：设置为 true，如果元素的值是合法的。
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
JavaScript 保留关键字
在 JavaScript 中，一些标识符是保留关键字，不能用作变量名或函数名。
javaScript 标准：
所有的现代浏览器完全支持 ECMAScript 3（ES3，JavaScript 的第三版，从 1999 年开始）。
ECMAScript 4（ES4）未通过。
ECMAScript 5（ES5，2009 年发布），是 JavaScript 最新的官方版本。
随着时间的推移，我们开始看到，所有的现代浏览器已经完全支持 ES5。
Javascript 的保留关键字不可以用作变量、标签或者函数名。有些保留关键字是作为 Javascript 以后扩展使用，以下是保留关键字 (按字母顺序排序)：
abstract，arguments
boolean，break，byte
case，catch，char，class，const，continue
debugger，default，delete，do，double
else，enum，eval，export，extends
false，final，finally，float，for，function
goto
if，implements，import，in，instanceof，int，interface
let，long
native，new，null
package，private，protected，public
return
short，static，super，switch，synchronized
this，throw，throws
transient，true，try，typeof
var，void，volatile
while，with
yield
。。。。。。。。。。。。。。。
JavaScript 对象、属性和方法：
您也应该避免使用 JavaScript 内置的对象、属性和方法的名称作为 Javascript 的变量或函数名：
Array
Date
eval
function
hasOwnProperty
Infinity
isFinite
isNaN
isPrototypeOf
length
Math
NaN
name
Number
Object
prototype
String
toString
undefined
valueOf
。。。。。。。。。
Java 保留关键字：
JavaScript 经常与 Java 一起使用。您应该避免使用一些 Java 对象和属性作为 JavaScript 标识符：
getClass
java
JavaArray
javaClass
JavaObject
JavaPackage
。。。。。。。。。。。。。
Windows 保留关键字：
JavaScript 可以在 HTML 外部使用。它可在许多其他应用程序中作为编程语言使用。
在 HTML 中，您必须（为了可移植性，您也应该这么做）避免使用 HTML 和 Windows 对象和属性的名称作为 Javascript 的变量及函数名：
HTML 事件句柄：
除此之外，您还应该避免使用 HTML 事件句柄的名称作为 Javascript 的变量及函数名。
onblur
onclick
onerror
onfocus
onkeydown
onkeypress
onkeyup
onmouseover
onload
onmouseup
onmousedown
onsubmit
。。。。。。。。。。。
非标准 JavaScript：
除了保留关键字，在 JavaScript 实现中也有一些非标准的关键字。
一个实例是 const 关键字，用于定义变量。 一些 JavaScript 引擎把 const 当作 var 的同义词。另一些引擎则把 const 当作只读变量的定义。
Const 是 JavaScript 的扩展。JavaScript 引擎支持它用在 Firefox 和 Chrome 中。但是它并不是 JavaScript 标准 ES3 或 ES5 的组成部分。建议：不要使用它。
::::::::::::::::::::::::::::::::::::::::::::::
JavaScript JSON
JSON 是用于存储和传输数据的格式。
JSON 通常用于服务端向网页传递数据 。
什么是 JSON?
JSON 英文全称 'JavaScript' 'Object' 'Notation'。
JSON 是一种轻量级的数据交换格式。
JSON是独立的语言。
JSON 易于理解。
JSON 使用 JavaScript 语法，但是 JSON 格式仅仅是一个文本，文本可以被任何编程语言读取及作为数据格式传递。
JSON 格式化后为 JavaScript 对象：
JSON 格式在语法上与创建 JavaScript 对象代码是相同的。
由于它们很相似，所以 JavaScript 程序可以很容易的将 JSON 数据转换为 JavaScript 对象。
JSON 语法规则：
数据为 键/值 对。
数据由逗号分隔。
大括号保存对象。
方括号保存数组。
JSON 数据：
一个名称对应一个值。
JSON 数据格式为 键/值 对，就像 JavaScript 对象属性。
键/值对包括字段名称（在双引号中），后面一个冒号，然后是值：
"name":"Runoob"
JSON 对象：
JSON 对象保存在大括号内。
就像在 JavaScript 中, 对象可以保存多个 键/值 对：
{"name":"Runoob", "url":"www.runoob.com"}
JSON 数组：
JSON 数组保存在中括号内。
就像在 JavaScript 中, 数组可以包含对象：
"sites":[
{"name":"Runoob", "url":"www.runoob.com"},
{"name":"Google", "url":"www.google.com"},
{"name":"Taobao", "url":"www.taobao.com"}
]
在以上实例中，对象 "sites" 是一个数组，包含了三个对象。
每个对象为站点的信息（网站名和网站地址）。
JSON.parse()：用于将一个 JSON 字符串转换为 JavaScript 对象。
JSON.stringify()：用于将 JavaScript 值转换为 JSON 字符串。
：
javascript void
:void(0) 含义
我们经常会使用到 javascript:void(0) 这样的代码，那么在 JavaScript 中 javascript:void(0) 代表的是什么意思呢？
javascript:void(0) 中最关键的是 void 关键字， void 是 JavaScript 中非常重要的关键字，该操作符指定要 "计算" 一个表达式但是不返回值。
语法格式如下：
<head>
<script type="text/javascript">
Ctrl+Enter 发布发布取消
推荐专栏
随时随地看视频
