JavaScript学习-基本语法

一、注释

JavaScript 注释可用于提高代码的可读性。

JavaScript 不会执行注释。

单行注释以 // 开头。

多行注释以 /*开始，以 */ 结尾。

// 这是JavaScript单行注释
/*
这是
JavaScript
多行注释
*/

二、变量

1、命名

变量名以字母、$ 或 _ 符号开头；

变量名区分大小写；

2、声明

使用 var 关键词来声明变量：

var x                // x 为 undefined

未经过初始化的变量其数据类型为undefined。

JavaScript 变量均为对象。当您声明一个变量时，就创建了一个新的对象。

3、初始化

可以在声明的同时进行初始化：

var x = 123；// x为数字
var str = "abc";// str为字符串

三、数据类型

JavaScript数据类型包括：字符串、数字、布尔、数组、对象、Null、Undefined。

1、字符串string

1.1 字符串声明

字符串可以是引号中的任意文本。您可以使用单引号或双引号。

var carname1="Bill Gates";
var carname2='Bill Gates';
alert(typeof(carname1));
alert(typeof(carname2));

你会看到弹出的提示均为string。

1.2 字符串对象的属性和方法

字符串长度

var text="Hello World!"
alert(text + "长度为:" + text.length);

输出：

Hello World!长度为:12

indexOf() 方法

var str="Hello world!"
document.write(str.indexOf("Hello") + "<br />")
document.write(str.indexOf("World") + "<br />")
document.write(str.indexOf("world"))

match()方法

var str="Hello world!"
document.write(str.match("world") + "<br />")
document.write(str.match("World") + "<br />")
document.write(str.match("worlld") + "<br />")
document.write(str.match("world!"))

replace()方法

var str="Visit Microsoft!"
document.write(str.replace(/Microsoft/,"W3School"))

2、数字

要点

JavaScript 只有一种数字类型。

可以使用也可以不使用小数点来书写数字。

极大或极小的数字可通过科学（指数）计数法来写。

所有 JavaScript 数字均为 64 位。

整数（不使用小数点或指数计数法）最多为 15 位。

小数的最大位数是 17，但是浮点运算并不总是 100% 准确。

如果前缀为 0，则 JavaScript 会把数值常量解释为八进制数，如果前缀为 0 和 “x”，则解释为十六进制数。

数字的属性和方法

属性：

MAX_VALUE // 可表示的最大的数。

MIN_VALUE // 可表示的最小的数。

NEGATIVE_INFINITIVE //负无穷大，溢出时返回该值。

POSITIVE INFINITIVE //正无穷大，溢出时返回该值。

NaN// 非数字值

prototype // 使您有能力向对象添加属性和方法。

constructor // 返回对创建此对象的 Number 函数的引用。

方法：

toExponential() // 把对象的值转换为指数计数法

toFixed() // 把数字转换为字符串，结果的小数点后有指定位数的数字。

toPrecision() // 把数字格式化为指定的长度。

toString() // 把数字转换为字符串，使用指定的基数。

toLocaleString // 把数字转换为字符串，使用本地数字格式顺序。

valueOf() // 返回一个 Number 对象的基本数字值。

3、布尔

Boolean 对象

您可以将 Boolean 对象理解为一个产生逻辑值的对象包装器。

Boolean（逻辑）对象用于将非逻辑值转换为逻辑值（true 或者 false）。

布尔（逻辑）只能有两个值：true 或 false。

创建 Boolean 对象

使用关键词 new 来定义 Boolean 对象。下面的代码定义了一个名为 myBoolean 的逻辑对象：

var myBoolean=new Boolean()；

注释：如果逻辑对象无初始值或者其值为 0、-0、null、”“、false、undefined 或者 NaN，那么对象的值为 false。否则，其值为 true（即使当自变量为字符串 “false” 时）！

示例：检查逻辑值

var b1=new Boolean( 0)
var b2=new Boolean(1)
var b3=new Boolean("")
var b4=new Boolean(null)
var b5=new Boolean(NaN)
var b6=new Boolean("false")

document.write("0 是逻辑的 "+ b1 +"<br />")
document.write("1 是逻辑的 "+ b2 +"<br />")
document.write("空字符串是逻辑的 "+ b3 + "<br />")
document.write("null 是逻辑的 "+ b4+ "<br />")
document.write("NaN 是逻辑的 "+ b5 +"<br />")
document.write("字符串 'false' 是逻辑的 "+ b6 +"<br />")

输出：

0 是逻辑的 false
1 是逻辑的 true
空字符串是逻辑的 false
null 是逻辑的 false
NaN 是逻辑的 false
字符串 'false' 是逻辑的 true

4、数组

数组对象用来在单独的变量名中存储一系列的值。

数组下标是基于零的。

定义数组

我们使用关键词 new 来创建数组对象。下面的代码定义了一个名为 myArray 的数组对象：

var myArray=new Array()；

有两种向数组赋值的方法（你可以添加任意多的值，就像你可以定义你需要的任意多的变量一样）。

方法1：

var mycars=new Array()
mycars[0]="Saab"
mycars[1]="Volvo"
mycars[2]="BMW"

也可以使用一个整数自变量来控制数组的容量：

var mycars=new Array(3)
mycars[0]=”Saab”
mycars[1]=”Volvo”
mycars[2]=”BMW”

方法2：

var mycars=new Array("Saab","Volvo","BMW")；

注意：如果你需要在数组内指定数值或者逻辑值，那么变量类型应该是数值变量或者布尔变量，而不是字符变量。

访问数组

通过指定数组名以及索引号码，你可以访问某个特定的元素。

document.write(mycars[0]) // 输出：Saab

修改已有数组中的值

如需修改已有数组中的值，只要向指定下标号添加一个新值即可：

mycars[0]="Opel";

现在：

document.write(mycars[0]);// 输出：Opel

示例代码

创建数组：

var mycars = new Array()
mycars[0] = "Saab"
mycars[1] = "Volvo"
mycars[2] = "BMW"

for (i=0;i<mycars.length;i++)
{
document.write(mycars[i] + "<br />")
}

For…In 声明：

var x
var mycars = new Array()
mycars[0] = "Saab"
mycars[1] = "Volvo"
mycars[2] = "BMW"

for (x in mycars)
{
document.write(mycars[x] + "<br />")
}

合并两个数组 - concat()：

var arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"

var arr2 = new Array(3)
arr2[0] = "James"
arr2[1] = "Adrew"
arr2[2] = "Martin"

document.write(arr.concat(arr2))

用数组的元素组成字符串 - join()：

var arr = new Array(3);
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"

document.write(arr.join());

document.write("<br />");

document.write(arr.join("."));

文字数组 - sort()：

var arr = new Array(6)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr[3] = "James"
arr[4] = "Adrew"
arr[5] = "Martin"

document.write(arr + "<br />")
document.write(arr.sort())

数字数组 - sort()：

function sortNumber(a, b)
{
return a - b
}

var arr = new Array(6)
arr[0] = "10"
arr[1] = "5"
arr[2] = "40"
arr[3] = "25"
arr[4] = "1000"
arr[5] = "1"

document.write(arr + "<br />")
document.write(arr.sort(sortNumber))

5、对象

在 JavaScript 中，对象是拥有属性和方法的数据，所有事物都是对象。

此外，JavaScript 允许自定义对象。

JavaScript 提供多个内建对象，比如 String、Date、Array 等等。

对象只是带有属性和方法的特殊数据类型。

属性

属性是与对象相关的值。

访问对象属性的语法是：

objectName.propertyName

方法

方法是能够在对象上执行的动作。

您可以通过以下语法来调用方法：

objectName.methodName()

创建对象

创建直接的实例

使用new创建：

person=new Object();
person.firstname="Bill";
person.lastname="Gates";
person.age=56;
person.eyecolor="blue";

或使用对象字面量创建：

person={firstname:"John",lastname:"Doe",age:50,eyecolor:"blue"};

使用对象构造器

function person(firstname,lastname,age,eyecolor)
{
this.firstname=firstname;
this.lastname=lastname;
this.age=age;
this.eyecolor=eyecolor;
}

一旦您有了对象构造器，就可以创建新的对象实例，就像这样：

var myFather=new person("Bill","Gates",56,"blue");
var myMother=new person("Steve","Jobs",48,"green");

您可以通过为对象赋值，向已有对象添加新属性：

// 假设 person对象已存在
person.firstname="Bill";
person.lastname="Gates";
person.age=56;
person.eyecolor="blue";

在构造器函数内部定义对象的方法：

function person(firstname,lastname,age,eyecolor)
{
this.firstname=firstname;
this.lastname=lastname;
this.age=age;
this.eyecolor=eyecolor;

this.changeName=changeName;
function changeName(name)
{
this.lastname=name;
}
}

JavaScript 类？

JavaScript 是面向对象的语言，但 JavaScript 不使用类。

在 JavaScript 中，不会创建类，也不会通过类来创建对象（就像在其他面向对象的语言中那样）。

JavaScript 基于 prototype，而不是基于类的。

遍历对象的属性

JavaScript for…in 语句循环可以用来遍历对象的属性。

var person={fname:"Bill",lname:"Gates",age:56};
for (x in person)
{
txt=txt + person[x];
}

6、Null

可以通过将变量的值设置为 null 来清空变量。

7、Undefined

Undefined 这个值表示变量不含有值。

赋值

JavaScript 拥有动态类型。这意味着相同的变量可用作不同的类型。

var x = 123; // x为数字
x = "abc";// x为字符串

四、语句

JavaScript 语句向浏览器发出的命令。语句的作用是告诉浏览器该做什么。

分号用于分隔 JavaScript 语句。

通常我们在每条可执行的语句结尾添加分号。

使用分号的另一用处是在一行中编写多条语句。

在 JavaScript中，用分号来结束语句是可选的。

JavaScript 代码（或者只有 JavaScript）是 JavaScript 语句的序列。

浏览器会按照编写顺序来执行每条语句。

赋值语句

var x；
x = 123;// 为变量x赋值

条件语句

if(条件表达式){
语句块
}
if(条件表达式){
语句块
}else{
语句块
}
if(条件表达式){
语句块
}else if{
语句块
}else{
语句块
}

switch(表达式){
case 1:
代码块1
break;
case 2：
代码块2
break;
default:
默认执行的代码块

}

循环语句

for循环

将代码块执行指定的次数。

for (语句 1; 语句 2; 语句 3)
{
被执行的代码块
}

for/in 语句循环遍历对象的属性:

var person={fname:"John",lname:"Doe",age:25};

for (x in person)
{
txt=txt + person[x];
}

whie循环

While 循环会在指定条件为真时循环执行代码块。

while (条件)
{
需要执行的代码
}

do/while 循环是 while 循环的变体。该循环会执行一次代码块，再检查条件是否为真之前，然后如果条件为真的话，就会重复这个循环。

do
{
需要执行的代码
}
while (条件);

break和continue

break语句

break 语句可用于跳出循环。

break 语句跳出循环后，会继续执行该循环之后的代码（如果有的话）。

continue语句

continue 语句中断循环中的迭代，如果出现了指定的条件，然后继续循环中的下一个迭代。

JavaScript 标签

如需标记 JavaScript 语句，请在语句之前加上冒号：

abel:
语句

continue 语句（带有或不带标签引用）只能用在循环中。

break 语句（不带标签引用），只能用在循环或 switch 中。

通过标签引用，break 语句可用于跳出任何 JavaScript 代码块：

cars=["BMW","Volvo","Saab","Ford"];
list:
{
document.write(cars[0] + "<br>");
document.write(cars[1] + "<br>");
document.write(cars[2] + "<br>");
break list;
document.write(cars[3] + "<br>");
document.write(cars[4] + "<br>");
document.write(cars[5] + "<br>");
}

输出结果：

BMW
Volvo
Saab

五、代码块

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

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

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

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

函数

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

函数就是包裹在花括号中的代码块，前面使用关键词 function。

JavaScript 对大小写敏感。关键词 function 必须是小写的，并且必须以与函数名称相同的大小写来调用函数。

无参函数

function functionname(){
这里是要执行的代码
}

带参数的函数

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

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

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

myFunction(argument1,argument2)

当您声明函数时，请把参数作为变量来声明：

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

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

带有返回值的函数

有时，我们会希望函数将值返回调用它的地方。

通过使用 return 语句就可以实现。

在使用 return 语句时，函数会停止执行，并返回指定的值。

function myFunction()
{
var x=5;
return x;
}

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

局部 JavaScript 变量

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

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

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

全局 JavaScript 变量

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

JavaScript 变量的生存期

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

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

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

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

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

这条语句：

carname="Volvo";

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

六、 运算符

算术运算符

算术运算符用于执行变量与/或值之间的算术运算.

加：+
减：-
乘：*
除：/
取余：%
累加：++
递减：--

JavaScript 赋值运算符=

赋值运算符用于给 JavaScript 变量赋值。

赋值运算符除了直接使用之外，还可以与算术运算符结合使用：

=
+=
-=
*=
/=
%=

用于字符串的 + 运算符

+ 运算符用于把文本值或字符串变量加起来（连接起来）。

x=5+5;
document.write(x);

x="5"+"5";
document.write(x);

x=5+"5";
document.write(x);

x="5"+5;
document.write(x);

规则是：如果把数字与字符串相加，结果将成为字符串。

比较运算符

比较运算符在逻辑语句中使用，以测定变量或值是否相等。

==
===
!=
>
<
>=
<=

逻辑运算符

&&
||
!

条件运算符

variablename=(condition)?value1:value2 ;

七、JavaScript错误与异常处理

JavaScript 测试和捕捉

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

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

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

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

Throw 语句

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

正确的技术术语是：创建或抛出异常（exception）。

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

throw exception

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