H5-Chapter2-语言基础

本章附件：chapter2 语言基础

Chapter2 语言基础

一．语法

区分大小写：person和Person是两个不同的变量
标识符：变量名、函数名、参数名、方法名，统称为标识符

必须以字母、下划线或美元符号开头，由字母、下划线、美元符号和数字组成

不能使用关键字作为标识符

注释：

单行注释：//

多行注释：/* */

关键字和保留字(public,private,protected,static……)
语句：

Javascript的语句末尾推荐以分号结束，但这个分号并不是必须的。

二．声明变量

用var声明变量(现在不建议使用)

ES6开始，可以使用let和const声明变量

三．数据类型

ECMAScript有6种简单数据类型：Number、Boolean、Null、Undefined、String、Symbol

另有复杂数据类型Object，所有自定义的类型都是Object类型的子类型

typeof运算符可以测试数据的类型(以字符串形式返回数据的类型)

Number可以分为整数和浮点数

String用双引号、单引号或反引号括起来

Boolean只有两个值：true和false

Null只有一个值：null

Undefined只有一个值：undefined

弱数据类型

如果用双引号作为字符串的定界符，那么字符串里可以出现单引号；如果用单引号作为字符串的定界符，那么字符串里可以出现单引号。否则就要使用转义符：


let s1= 'I\'m a student.'
let s2= "It's \"true\"!"

四．类型转换

字符串转换为数值：parseInt(字符串, 进制)，parseFloat(字符串)
任意类型转换为数值：Number(参数)
非Null、非Undefined类型转换为字符串：toString ()
Null、Undefined类型转换为字符串：String(参数)
数值转换为字符串：toFixed(小数位数)

五．模板字符串插值

在模板字符串中可以使用${ }来插值：


let n = 10;
let interpolatedString = `${n} 的平方是：${n * n}`;
alert(interpolatedString);

六．运算符

算术运算符：++，--，+，-，*，/，%，**
关系运算符：>，>=，<，<=

==，!= 转换为相同的类型后再进行比较

===，!== 不进行类型转换，直接进行比较

条件运算符：expression? value1:value2
赋值运算符与复合赋值运算符

七．语句

If语句、switch语句、while语句、do while语句、for语句、for in语句、for of语句、break语句、continue语句、标签语句、with语句

Javascript中的条件表达式可以是任意类型，而不限于布尔表达式。对于非布尔类型的条件表达式，javascript会自动进行类型转换，将表达式转换为布尔类型。

switch语句在进行比较每个条件的值时，会使用全等运算符，而不会进行类型转换。

粗略来说，for in语句可以枚举对象的属性，for of语句可以遍历可迭代对象的元素。对不可迭代对象使用for of语句会抛出异常。

八．函数

定义函数的模板是：


function 函数名(可选的参数){
函数体
}

函数可以没有参数。如果有多个参数，参数之间要用逗号隔开。

函数可以没有返回值。如果有返回值，则需要把要返回的值放在return后面。如果return后面没有返回值，则函数被调用时遇到return就会立即终止函数的执行，即return后面的语句永远不会被执行。没有返回值的函数默认会返回undefined。

函数可以被赋值给一个变量，C语言和python语言也支持该操作。

没有名字的函数称为匿名函数。

ES6中增加了箭头函数(类似于Java语言中的Lambda表达式)。箭头函数的模板是：

(可选的参数)=>函数体

如果函数体只有一条语句，则该语句的值会作为函数的返回值，而无需明确写出return

例如：


let f = (x, y) => x + y;
console.log (f(2, 6));

如果函数体超过一条语句，则函数体部分的写法同普通函数的函数体。例如：


let max = (x, y, z) => {
let m = x;
if (y > m) {
m = y;
}
if (z > m) {
m = z;
}
return m;
};
console.log(max(2, 9, 6));

九．字符串上的操作

属性length：返回字符的个数

方法：

concat( )：连接

字符串操作方法：

slice(start, end)、substring(start, end)：返回[start, end)之间的子字符串；如果省略end则截取到末尾

substr(start, length)：返回从start开始的连续length个字符构成的字符串；如果省略length则截取到末尾

字符串位置方法：

indexOf(子串)，indexOf(字串，起始位置)：从左向右查找子串

lastIndexOf(字串)，lastIndexOf(字串，起始位置)：从右向左查找子串

字符串包含方法：

startWith(字符串)、endWith(字符串)、includes(字符串)

trim( )：删除字符串前后的空格

repaet(n)：将字符串重复n次

padStart(n，填充字符串)：用填充字符串填充原字符串的左边，直到达到指定的长度。

padEnd(n，填充字符串)：用填充字符串填充原字符串的右边，直到达到指定的长度。

如果不指定填充字符串，默认用空格来填充

tolLowerCase( )：全部转换为小写字符

toUpperCase( )：全部转换为大写字符

字符串1.localCompare(字符串2)：根据字符串1大于、等于、小于字符串2，返回1、0、-1

字符串的迭代与解构：

字符串是可迭代的，可以在字符串上使用for in和for of循环

[…字符串]可以返回一个由字符串中的各个字符组成的数组

split(分割符)：根据指定的分隔符将字符串切割，返回切割后的数组：


let s=”hello, world,student”;
let a=s.split(“,”);
alert(a);       //[“hello”, “ world”,”student”];

十．数组

创建数组：


let a=new Array( );  //创建空数组
let a=new Array(3); //创建长度为3的数组，数组元素都是undefined
let a=new Array("teacher",1,true,null,undefined) //用指定的元素创建数组

或


let a = [ ];
let a=[, , ,];
let a=["teacher",1,true,null,undefined];

Array.from( )可将类数组对象转换为数组：Array.from(“hello”) //[“h”,”e”,”l”,”l”,”o”]

Array.of( )可以将一组参数转换为数组：Array.of(1,2,3,4) //[1，2，3，4]

Javascript中数组的长度可以伸缩：


let a= [“red”, “yellow”, “green”];
alert (a. length);    //3

a [4] =” blue”;


alert(a);          // [“red”, “yellow”, “green”, undefined, “blue”]
 
a.length=2;
alert(a);        // [“red”, “yellow”]

填充与复制

fill(填充值)：用填充值填充数组的所有元素：


let a=[0,1,2,3,4];
a.fill(10);
alert(a);         //[10, 10, 10, 10, 10]

fill(填充值, 起始位置): 用填充值填充从起始位置开始的所有元素：


let a=[0, 1, 2, 3, 4];
a.fill(10, 2);
alert(a);      // [0, 1, 10, 10, 10]

fill(填充值, 起始位置, 结束位置)：用填充值填充[起始位置，结束位置)之间的所有元素


let a=[0, 1, 2, 3, 4];
a.fill(10, 2, 4);
alert(a);        // [0, 1, 10, 10, 4]
copyWithin(目标位置, 起始位置, 结束位置)：将[起始位置，结束位置之间的元素复制到目标位置开始的元素中)：
let a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
a.copyWithin(0, 5, 8);
alert(a);             // [5, 6, 7, 3, 4, 5, 6, 7, 8, 9]

栈方法(在数组尾部执行的操作)：

push(参数列表)：将参数列表中的参数添加到数组的末尾，返回新数组的长度：


let colors=[“red”, “green”, “blue”];
let newLength=colors.push(“yellow”, “pink”);
alert(newLength);    //5
alert(colors);        //[“red”, “green”, “blue”, “yellow”, “pink”]

pop( )方法删除数组的最后一个元素，并返回该被删除的元素：


let colors=[“red”, “green”, “blue”];
let e=colors.pop( );
alert(colors);
alert(e);

队列方法(在数组头部执行的操作)

shift( )：删除数组的第一个元素，并返回该删除的元素：


let colors=[“red”, “green”, “blue”];
let e=a.shift( );
alert(e);        //red
alert(colors);    //[“green”, ”blue”]

unshift(参数列表)：将参数列表中的参数按从右到左的顺序加入数组的头部，返回数组的新长度：


let a=[1, 2, 3];
let len=a.unshift(4, 5);
alert(len);        //5
alert(a);         //[4, 5, 1, 2, 3]

逆置与排序方法：

reverse( )：将数组的元素逆置


let a=[1, 2, 3, 4, 5,];
a.reverse( );
alert(a);       //[5, 4, 3, 2, 1];

sort( )：将数组元素转换为字符串后进行升序排序, 返回该数组的引用：


let a=[20, 15, 1, 3];
let b=a.sort( );
alert(a);               //[1, 15, 20, 3]
alert(b);               //[1, 15, 20, 3]
alert(a===b);    //true

如果想自定义排序规则，需要给sort方法提供一个比较函数，比较函数接收2个参数：


let a=[20, 15, 1, 3];
a.sort(function (v1,v2)=>{
if(v1<v2) return -1;
else if(v1===v2) return 0;
else return 1;
});
alert(a);   //[1, 3, 15, 20]

操作方法

concat(参数列表)：返回一个新数组，其元素是调用方法的数组元素和参数列表：


let a=[1, 2, 3];
let b=[5, 6];
let r=a.concat(4, b);
alert(r);    //[1, 2, 3, 4, 5, 6];

slice(start, end)：返回原数组[start, end)之间的元素构成的数组，若省略end则返回原数组从start位置开始的所有元素构成的数组：


let a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
let r1=a.slice(1, 4);
alert(r1);     //[1, 2, 3];
let r2=a.slice(5);
alert(r2);     //[5, 6, 7, 8, 9]

splice方法可以用来在数组中删除、插入、替换元素

splice(start, length)：删除数组中从start位置开始的连续length个元素，返回被删除的元素组成的数组：


let a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
let b=a.splice(1,4);
alert(b);    //[1,2,3,4]
alert(a);    //[0, 5, 6, 7, 8, 9]

splice(start, 0, 要插入的元素列表)：将待插入的元素插入到start位置：


let a=[0, 1, 2, 3, 4];
a.splice(2, 0, -1,-2);
alert(a);      //[0, 1, -1, -2, 2, 3, 4]

splice(start, length, 要插入的元素列表): 从start位置开始删除连续的length个元素，并将待插入的元素插入到start位置，从而实现替换。该方法返回被删除的元素组成的数组


let a=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
let b=a.splice(1, 4, -1, -2, -3);
alert(a);       //[0, -1, -2, -3, 5, 6, 7, 8, 9]
alert(b);       //[1, 2, 3, 4]