引言
任何语言的核心所描述的都是这门语言在最基本的层面上如何工作,涉及语法、操作符、数据类型以及内置功能,在此基础之上才可以构建复杂的解决方案
本章接下来的内容主要基于ECMAScript第6版。ES6
语法
js的语法借鉴了c/c++,java。js是相对宽松的一门脚本语言
区分大小写
js,JS是俩个不同的声明
标识符
所谓标识符,就是变量、函数、属性或函数参数的名称
标识符由下划线,数字,字符组成。第一个字符不能是数字
注释
不会被程序执行,是给程序员看的代码
// 单行注解
/ *
多行注解
* /
严格模式
在js开头,或者某部分代码块中使用
"use strict";
语句
- 加分号也便于开发者通过删除空行来压缩代码(如果没有结尾的分号,只删除空行,则会导致语法错误)
- 加分号也有助于在某些情况下提升性能,因为解析器会尝试在合适的位置补上分号以纠正语法错误。
let sum = a + b // 没有分号也有效,但不推荐
let diff = a - b; // 加分号有效,推荐
语句可以被写在代码块中,if单个代码建议也加上大括号(方便阅读)
{
let sum=a+b;
}
关键字与保留字
保留字简单来说就是未来的关键字
关键字与保留字是js内部的标识符有特定的功能,我们声明的标识符不能和其重名
变量
ECMAScript变量是松散类型的,意思是变量可以用于保存任何类型的数据
有3个关键字可以声明变量:var、const和let。
var关键字
此段代码声明了var类型变量名为message的变量,不给初始值的情况下js默认会给一个undefined
var message;
js中的赋值可以赋任意值包括数据类型,这就意味着数值类型可以随时改变
下述代码给message赋值hi并且为字符串类型,随后又赋值了100为数值类型
var message = "hi";
message=100; //合法,但不推荐
1. var声明作用域
使用var操作符定义的变量会成为包含它的函数的局部变量,函数在运行完毕message会被销毁。并且只能在自己的作用域范围能够被使用
function test() {
var message = "hi"; // 局部变量
}
test();
console.log(message); // 出错!
在函数内定义变量时省略var操作符,可以创建一个全局变量:注意:必须在调用函数后使用
只要调用一次函数test(),就会定义这个变量,并且可以在函数外部访问到。
function test() {
message="hi"; //全局变量
}
test();
console.log(message); // "hi"
- 在严格模式下,如果像这样给未声明的变量赋值,则会导致抛出ReferenceError。
- 在局部作用域中定义的全局变量很难维护,也会造成困惑
定义多个变量
var message = "hi",
found = false,
age = 29;
2. var声明提升
使用var声明的变量会自动提升到函数作用域的顶部
此外,反复多次使用var声明同一个变量也没有问题:
function foo() {
console.log(age); // undefined
var age = 26;
}
foo(); // undefined
let 关键字
let声明的范围是块作用域,而var声明的范围是函数作用域。
if (true) {
var name = 'Matt';
console.log(name); // Matt
}
console.log(name); // Matt
if (true) {
let age = 26;
console.log(age); // 26
}
console.log(age); // ReferenceError: age没有定义
let不允许同一个块作用域中出现冗余声明,如果变量名存在作用域链遵循就近原则
let a=10;
let a=20; // erroe
1. 暂时性死区
let声明的变量不会在作用域中被提升。
// name会被提升
console.log(name); // undefined
var name = 'Matt';
// age不会被提升
console.log(age); // ReferenceError:age没有定义
let age = 26;
2. 全局声明
var name = 'Matt';
console.log(window.name); // 'Matt'
let age = 26;
console.log(window.age); // undefined
3. 条件声明
由于let的作用域是块级的可能会出现条件声明
let中根据不同的条件声明相同的变量这是没有必要的,代码也是不易理解的
if(a>10){
let b=300;
}else{
let b=20;
}
return b;
最好声明到外部,或者用三目运算符
let b
if(a>10){
b=300
}else{
b=20;
}
return b;
4. for循环中的let声明
var由于函数作用域再var循环中使用会出现问题
for (var i = 0; i < 5; ++i) {
// 循环逻辑
}
console.log(i); // 5
let的作用域是块级的所以是不会出现这个问题
const声明
const声明的变量必须给初始值
const的行为与let基本相同,唯一一个重要的区别是用它声明变量时必须同时初始化变量,且尝试修改const声明的变量会导致运行时错误。
const a=10;
a=100; // error
const声明的限制只适用于它指向的变量的引用,换句话说如果是个对象,你改变对象里面的值则不会报错
const obj={};
obj.name="zhangsan";
声明风格及最佳实践
- 不使用var
- const优先,let次之
数据类型
ECMAScript有6种简单数据类型。Undefined、Null(本质上是Object)、Boolean、Number、String和Symbol
还有一种复杂数据类型Objec
只有7种数据类型似乎不足以表示全部数据。但ECMAScript的数据类型很灵活,一种数据类型可以当作多种数据类型来使用
typeof操作符
typeof判断数据的数据类型
let message = "some string";
console.log(typeof message); // "string"
console.log(typeof(message)); // "string"
console.log(typeof 95); // "number"
Undefined类型
Undefined类型只有一个值,就是特殊值undefined
当使用var或let声明了变量但没有初始化时,就相当于给变量赋予了undefined值:
let message;
var t
console.log(message == undefined); // true
console.log(t== undefined); // true
- 声明了没有赋值和没有声明是由本质区别的 虽然typeof是返回是undefined类型
- 声明了没有赋值不会报错,没有声明使用了会报错
Null类型
Null类型同样只有一个值,即特殊值null
逻辑上讲,null值表示一个空对象指针,这也是给typeof传一个null会返回"object"的原因:
let car = null;
console.log(typeof car); // "object"
undefined值是由null值派生而来的
console.log(null == undefined); // true
Boolean类型
有两个字面值:true和false。
注意boolean的隐式转换
Number类型
1. 整数
十进制可以直接写出来
int a=10;
八进制开头必须是0,如果值超出8进制的范围会按十进制处理,忽略0
let octalNum1 = 070; // 八进制的56
let octalNum2 = 079; // 无效的八进制值,当成79 处理
let octalNum3 = 08; // 无效的八进制值,当成8 处理
十六进制开头必须是0x,十六进制数字中的字母大小写均可
let hexNum1 = 0xA; // 十六进制10
let hexNum2 = 0x1f; // 十六进制31
2. 浮点值
let a=10.1;
因为存储浮点值使用的内存空间是存储整数值的两倍,所以ECMAScript总是想方设法把值转换为整数
let floatNum1 = 1.; // 小数点后面没有数字,当成整数1 处理
let floatNum2 = 10.0; // 小数点后面是零,当成整数10 处理
对于非常大或非常小的数值,浮点值可以用科学记数法来表示
let floatNum = 3.125e7; // 等于31250000
let num=0.0000003 // 等于3e-7
浮点值的精确度最高可达17位小数,但在算术计算中远不如整数精确。
0.1+0.2=0.30000000000000004
3. 值的范围
ECMAScript并不支持表示这个世界上的所有数值
最小值通过Number.MIN_VALUE可以活动,最大值Number.MAX_VALUE
如果某个计算值超过这个数字会转换为无穷大(正负)无穷数值不能运算
4. NaN
表示不是一个数,在其他的语言中除0会报错
console.log(0/0); // NaN
console.log(-0/+0); // NaN
如果分子是非0值,分母是有符号0或无符号0,则会返回Infinity或-Infinity:
console.log(5/0); // Infinity
console.log(5/-0); // -Infinity
NaN与任何数值比较都等于自己
console.log(NaN == NaN); // false
isNaN来判断一个数是否为数值
把一个值传给isNaN()后,该函数会尝试把它转换为数值。某些非数值的值可以直接转换成数值
console.log(isNaN(NaN)); // true
console.log(isNaN(10)); // false,10 是数值
console.log(isNaN("10")); // false,可以转换为数值10
console.log(isNaN("blue")); // true,不可以转换为数值
console.log(isNaN(true)); // false,可以转换为数值1
5. 数值转换
Number()的转换规则如下
- 布尔值,true转换为1,false转换为0。
- 数值,直接返回。
- null,返回0。
- undefined,返回NaN。
- string,如果是数值(±广)直接转换为相应十进制,空字符返回0,其他情况返回NaN
let num1 = Number("Hello world! "); // NaN
let num2 = Number(""); // 0
let num3 = Number("000011"); // 11
let num4 = Number(true); // 1
parseInt()的转换规则如下
- 布尔值,true转换为1,false转换为0。
- 数值,整数直接返回,浮点数小数舍去
- null,返回0。
- undefined,返回NaN。
- string,如果是数值(±广)直接转换为相应十进制(整数),空字符返回NaN,结尾包含字符舍去
let num1 = parseInt("1234blue"); // 1234
let num2 = parseInt(""); // NaN
let num3 = parseInt("0xA"); // 10,解释为十六进制整数
let num4 = parseInt(22.5); // 22
let num5 = parseInt("70"); // 70,解释为十进制值
let num6 = parseInt("0xf"); // 15,解释为十六进制整数
parseFloat()的转换规则和parseInt()类似不过是带小数
第一个主要的区别是第一次出现的小数点是有效的,但第二次出现的小数点就无效了,此时字符串的剩余字符都会被忽略。"22.34.5"将转换成22.34。
parseFloat()函数的另一个不同之处在于,它始终忽略字符串开头的零,16进制直接返回0,因此不能指定底数
如果字符串表示整数则返回整数
let num1 = parseFloat("1234blue"); // 1234,按整数解析
let num2 = parseFloat("0xA"); // 0
let num3 = parseFloat("22.5"); // 22.5
let num4 = parseFloat("22.34.5"); // 22.34
let num5 = parseFloat("0908.5"); // 908.5
let num6 = parseFloat("3.125e7"); // 31250000
String类型
字符串可以使用双引号(")、单引号(')或反引号(`)标示
不过要注意的是,以某种引号作为字符串开头,必须仍然以该种引号作为字符串结尾。
let firstName = "John";
let lastName = 'Jacob';
let lastName = `Jingleheimerschmidt`
1. 字符字面量
// \u03a3由于是字面量所以被当作一个字符处理
let text = "This is the letter sigma: \u03a3."; // length==28
2. 字符串的特点
当操作字符串时,JavaScript 中的字符串是不可变的,这意味着对字符串的操作会创建一个新的字符串赋值,原始字符串本身不会被修改。
3. 转换为字符串
toString()方法可见于数值、布尔值、对象和字符串值。null和undefined值没有toString()方法。
let age = 11;
let ageAsString = age.toString(); // 字符串"11"
let found = true;
let foundAsString = found.toString(); // 字符串"true"
如果你不确定一个值是不是null或undefined,可以使用String()转型函数
- 如果值有toString()方法,则调用该方法(不传参数)并返回结果。
- 如果值是null,返回"null"。
- 如果值是undefined,返回"undefined"。
let value1 = 10;
let value2 = true;
let value3 = null;
let value4;
console.log(String(value1)); // "10"
console.log(String(value2)); // "true"
console.log(String(value3)); // "null"
console.log(String(value4)); // "undefined"
4. 模板字面量
模板字面量保留换行字符,可以跨行定义字符串:
let myMultiLineString = 'first line\nsecond line';
let myMultiLineTemplateLiteral = `first line
second line`;
console.log(myMultiLineString);
// first line
// second line"
console.log(myMultiLineTemplateLiteral);
// first line
// second line
console.log(myMultiLineString === myMultiLinetemplateLiteral); // true
由于模板字面量会保持反引号内部的空格,因此在使用时要格外注意。格式正确的模板字符串看起来可能会缩进不当:
// 这个模板字面量在换行符之后有25 个空格符
let myTemplateLiteral = `first line
second line`;
console.log(myTemplateLiteral.length); // 47
// 这个模板字面量以一个换行符开头
let secondTemplateLiteral = `
first line
second line`;
console.log(secondTemplateLiteral[0] === '\n'); // true
// 这个模板字面量没有意料之外的字符
let thirdTemplateLiteral = `first line
second line`;
console.log(thirdTemplateLiteral);
// first line
// second line
5. 字符串插值(用于md的限制用’'代替``)
字符串插值通过在${}中使用一个JavaScript表达式实现:
插值可以用于运算
const num='${1+1}' // num==2
插值可以用于调用方法
function foo(){
return "World"
}
console.log(`Hello, ${ foo() }! `); // Hello, World!
插值可以用于字符拼接
const str="hello";
const stl='${str} world'; // hello world
Symbol类型
Symbol(符号)是ECMAScript 6新增的数据类型。符号是原始值,且符号实例是唯一、不可变的。符号的用途是确保对象属性使用唯一标识符,不会发生属性冲突的危险。
1. 符号的基本用法
符号需要使用Symbol()函数初始化。
let sym = Symbol();
console.log(typeof sym); // symbol
调用Symbol()函数时,也可以传入一个字符串参数作为对符号的描述
let genericSymbol = Symbol();
let otherGenericSymbol = Symbol();
let fooSymbol = Symbol('foo');
let otherFooSymbol = Symbol('foo');
console.log(genericSymbol == otherGenericSymbol); // false
console.log(fooSymbol == otherFooSymbol); // false
符号没有字面量语法,这也是它们发挥作用的关键。按照规范,你只要创建Symbol()实例并将其用作对象的新属性,就可以保证它不会覆盖已有的对象属性,无论是符号属性还是字符串属性。
2. 符号的应用场景
利用Symbol来作为对象的属性名,Symbol定义的属性无法通过Object.keys()中的方法和遍历获取,实现属性的私有
var gender = Symbol();
var person = {
name: 'kreme',
age: 12,
[gender]: 'male'
}
Object.keys(person) // ['name', 'age']
for (let p in person) {
console.log(p) // 分别会输出:'name' 和 'age'
}
Object.getOwnPropertyNames(person) // ['name', 'age']
我们可以通过新的api获取
var gender = Symbol();
var person = {
name: 'kreme',
age: 12,
[gender]: 'male'
}
// 使用Object的API
Object.getOwnPropertySymbols(person) // [[gender]]
// 使用新增的反射API
Reflect.ownKeys(person) // [[gender], 'age', 'title']
使用Symbol()来定义常量,利用Symbol()的唯一性来定义常量
const a = Symbol();
const b = Symbol();
const c = Symbol();
定义某个类的私有属性或方法
// 这个是a文件内定义的Login类:
const password = Symbol()
class Login {
constructor(username, password) {
this.username = username
this[password] = password
}
checkPassword(pwd) {
return this[password] === pwd
}
}
export default Login; // 对外暴露了login方法
// 这个是在b文件内调用a文件中的方法:
const login = new Login('admin', '123456')
login.checkPassword('123456') // true
login.password // 无法访问
login[password] // 无法访问
login["password"] // 无法访问
Object类型
ECMAScript中的对象其实就是一组数据和功能的集合。对象通过new操作符后跟对象类型的名称来创建。
开发者可以通过创建Object类型的实例来创建自己的对象,然后再给对象添加属性和方法:
let o = new Object();
let obj=new Object // 不推荐
每个Object实例都有如下属性和方法。
- constructor:用于创建当前对象的函数。在前面的例子中,这个属性的值就是Object()函数。
- hasOwnProperty:用于判断当前对象实例上是否存在给定的属性,要检查的属性名必须是字符串
- isPrototypeOf:用于判断当前对象是否为另一个对象的原型
- propertyIsEnumerable::用于判断给定的属性是否可以使用(本章稍后讨论的)for-in语句枚举
- toLocaleString():返回对象的字符串表示,该字符串反映对象所在的本地化执行环境。
- toString():返回对象的字符串表示。
- valueOf():返回对象对应的字符串、数值或布尔值表示。通常与toString()的返回值相同。
操作符
一元操作符
只操作一个值的操作符叫一元操作符
1. 递增/递减操作符
前缀运算符遵循先变后算,后缀运算符遵循先算后变
int num=10;
++num,num++,--num,num--
递增递减操作符对于其他类型运算的规则如下
- 字符串如果是有效数值,先转换为数值型然后运算。非有效数值直接返回NaN
- bool如果是true先转换为1然后运算,如果是false先转换为0然后运算
- 如果是对象会调用其valueOf然后运算
let obj={
valueOf(){
return -1;
}
}
console.log(obj++); // -1
console.log(obj); // 0
2. 一元加和减
一元加法和减法主要可以用于类型转换
数值
int a=10;
int b=20;
+a // 10
-b // -20
非数值,遵循Number()的转换规律。负号一样
let s1 = "01";
let s2 = "1.1";
let s3 = "z";
let b = false;
let f = 1.1;
let o = {
valueOf() {
return -1;
}
};
s1 = +s1; // 值变成数值1
s2 = +s2; // 值变成数值1.1
s3 = +s3; // 值变成NaN
b = +b; // 值变成数值0
f = +f; // 不变,还是1.1
o = +o; // 值变成数值-1
位操作符
ECMAScript中的所有数值都以IEEE 754 64位格式存储,但位操作并不直接应用到64位表示,而是先把值转换为32位整数,再进行位操作,之后再把结果转换为64位。所以我们只需要考虑32即可
有符号整数使用32位的前31位表示整数值。第32位表示数值的符号,如0表示正,1表示负。这一位称为符号位
正值以真正的二进制格式存储,即31位中的每一位都代表2的幂。第一位(称为第0位)表示20,第二位表示21,依此类推。如果一个位是空的,则以0填充
数值18的二进制格式为00000000000000000000000000010010,或更精简的10010。
负值以一种称为二补数(或补码)的二进制编码存储
- 先计算数值的绝对值,二进制存储
- 然后所有二进制取反(补码)
- 最后一位+1
那么,-18的二进制表示就是11111111111111111111111111101110。要注意的是,在处理有符号整数时,我们无法访问第31位。
特殊值NaN和Infinity在位操作中都会被当成0处理。如果将位操作符应用到非数值,那么首先会使用Number()函数将该值转换为数值
1. 按位非
按位非运算得到的数值要比数值加减运算效率更高,因为这是直接在操作内存
let num1 = 25; // 二进制00000000000000000000000000011001
let num2 = ~num1; // 二进制11111111111111111111111111100110
console.log(num2); // -26
2. 按位与
是将二进制对其比较,都是1返回,否则返回0。计算并返回最终结果
let result = 25 & 3;
console.log(result); // 1
3. 按位或
是将二进制对其比较,只要有一个1就返回1,否则返回0。计算并返回最终结果
let result = 25 | 3;
console.log(result); // 27
4. 按位异或
是将二进制对其比较,只在一位上是1的时候返回1,否则返回0。计算并返回最终结果
let result = 25 ^ 3;
console.log(result); // 26
布尔操作符
1. 逻辑非
无论应用到的是什么数据类型。逻辑非操作符首先将操作数转换为布尔值,然后再对其取反。
- 如果是对象,返回false
- 如果是空字符串,返回true,
- 如果是非空字符串,返回false
- 如果是0,返回true
- 如果是非0,返回false
- 如果是NaN,Null,undefined返回true
console.log(! false); // true
console.log(! "blue"); // false
console.log(!0); // true
console.log(! NaN); // true
console.log(! ""); // true
console.log(!12345); // false
同时使用!!效果和Boolean()一样
console.log(! ! "blue"); // true
console.log(! !0); // false
console.log(! ! NaN); // false
console.log(! ! ""); // false
console.log(! !12345); // true
2. 逻辑与
逻辑与遵循,都真则真,否则为假
如果有操作数不是布尔值,则逻辑与并不一定会返回布尔值,而是遵循如下规则。
- 如果第一个操作数是对象,则返回第二个操作数。
- 如果第二个操作数是对象,则只有第一个操作数求值为true才会返回该对象。
- 如果两个操作数都是对象,则返回第二个操作数。
- 如果有一个操作数是null / NaN / undefined,则返回null / NaN / undefined。
逻辑与操作符是一种短路操作符,意思就是如果第一个操作数决定了结果,那么永远不会对第二个操作数求值。
// 这里因为第一个操作符为true,所以运算到了第二个运算符又因为没有定义所以报错
let found = true;
let result = (found && someUndeclaredVariable); // 这里会出错
console.log(result); // 不会执行这一行
// 这里因为第一个操作符为false,所以结果被确定不再运算第二个操作符
let found = false;
let result = (found && someUndeclaredVariable);
console.log(result); // false
3. 逻辑或
逻辑或遵循,有一个真就为真,否则为假
如果有操作数不是布尔值,则逻辑或并不一定会返回布尔值,而是遵循如下规则。
- 如果第一个操作数是对象,则返回第一个操作数。
- 如果第一个操作数求值为false,则返回第二个操作数。
- 如果两个操作数都是对象,则返回第一个操作数。
- 如果操作数都是null / NaN / undefined,则返回null / NaN / undefined。
逻辑或也有短路的特性
// 这里因为第一个操作符为true,所以结果被确定不再运算第二个操作符
let found = true;
let result = (found && someUndeclaredVariable);
console.log(result); // false
// 这里因为第一个操作符为false,所以运算到了第二个运算符又因为没有定义所以报错
let found = false;
let result = (found && someUndeclaredVariable); // 报错
console.log(result); // 不会执行
乘性操作符
如果乘性操作符有不是数值的操作数,则该操作数会在后台被使用Number()转型函数转换为数值
1. 乘法操作符
乘法操作符遵循如下规则
- 都是数值正常运算
- 不是数值,先Number()转换后继续运算
- 任何一方为NaN,返回NaN
2. 除法操作符
除法操作符遵循如下规则
- 都是数值正常运算
- 如果有任一操作数是NaN,则返回NaN。
- 如果是0除以0,则返回NaN。
- 不是数值,先Number()转换后继续运算
3. 取模操作符
取模操作符遵循如下规则
- 都是数值正常运算
- 不是数值,先Number()转换后继续运算
- 如果被除数是有限值,除数是0,则返回NaN。
指数操作符
console.log(Math.pow(3, 2); // 9
console.log(3 ** 2); // 9
console.log(Math.pow(16, 0.5); // 4
console.log(16** 0.5); // 4
加性操作符
1. 加法操作符
加法操作符遵循以下规则
- 如果有任一操作数是NaN,则返回NaN;
- 如果两个操作数都是数值
- 如果两个操作数都是字符串,则将第二个字符串拼接到第一个字符串后面;
- 如果只有一个操作数是字符串,则将另一个操作数转换为字符串,再将两个字符串拼接在一起。
2. 减法操作符
加法操作符遵循以下规则
- 如果有任一操作数是NaN,则返回NaN;
- 如果两个操作数都是数值
- 如果有任一操作数是字符串、布尔值、null或undefined,则先在后台使用Number()将其转换为数值,然后再根据前面的规则执行数学运算。如果是NaN直接返回
- 如果有任一操作数是对象,则调用其valueOf()方法取得表示它的数值。如果该值是NaN,则减法计算的结果是NaN。如果对象没有valueOf()方法,则调用其toString()方法,然后再将得到的字符串转换为数值。
关系操作符
关系操作符执行比较两个值的操作,包括小于(<)、大于(>)、小于等于(<=)和大于等于(>=),用法跟数学课上学的一样。这几个操作符都返回布尔值。
关系操作符符遵循以下规则
- 如果操作数都是数值,则执行数值比较。
- 如果操作数都是字符串,则逐个比较字符串中对应字符的编码。
- 如果有任一操作数是数值,则将另一个操作数转换为数值,执行数值比较。
- 如果有任一操作数是对象,则调用其valueOf()方法,取得结果后再根据前面的规则执行比较。如果没有valueOf()操作符,则调用toString()方法,取得结果后再根据前面的规则执行比较。
- 如果有任一操作数是布尔值,则将其转换为数值再执行比较。
即任何关系操作符在涉及比较NaN时都返回false
相等操作符
1. 等于和不等于
这两个操作符都会先进行类型转换(通常称为强制类型转换)再确定操作数是否相等。
相等和不相等操作符遵循如下规则。
- 如果任一操作数是布尔值,则将其转换为数值再比较是否相等。false转换为0, true转换为1。
- 如果一个操作数是字符串,另一个操作数是数值,则尝试将字符串转换为数值,再比较是否相等。
- 如果一个操作数是对象,另一个操作数不是,则调用对象的valueOf()方法取得其原始值,再根据前面的规则进行比较。
- null和undefined相等。
- NaN和任何值都不想等
- 对象比较地址
2. 全等和不全等
全等和不全等操作符不存在类型的强制转换,直接是值的比较
由于相等和不相等操作符存在类型转换问题,因此推荐使用全等和不全等操作符。这样有助于在代码中保持数据类型的完整性。
3. 条件操作符
variable = boolean_expression ? true_value : false_value;
赋值操作符
=,+=,-=,…
逗号操作符
let num1 = 1, num2 = 2, num3 = 3;
语句
()中的值会自动用Boolean()转换,根据结果值执行对应语句
if语句
if (i > 25) {
console.log("Greater than 25.");
} else if (i < 0) {
console.log("Less than 0.");
} else {
console.log("Between 0 and 25, inclusive.");
}
while语句
let i = 0;
while (i < 10) {
i += 2;
}
for语句
let count = 10;
for (let i = 0; i < count; i++) {
console.log(i);
}
for-in语句
for-in语句是一种严格的迭代语句,用于枚举对象中的属性
每次执行循环,都会给变量propName赋予一个window对象的属性作为值,直到window的所有属性都被枚举一遍。
ECMAScript中对象的属性是无序的,因此for-in语句不能保证返回对象属性的顺序。换句话说,所有可枚举的属性都会返回一次,但返回的顺序可能会因浏览器而定
如果for-in循环要迭代的变量是null或undefined,则不执行循环体。
for (const propName in window) {
document.write(propName);
}
for-of语句
for-of语句是一种严格的迭代语句,用于枚举对象中的属性值
与for-in用法类型
for (const el of [2,4,6,8]) {
document.write(el);
}
break和continue语句
break跳出临近循环
countinue跳出本次循环
switch语句
必须加break,否则下面代码会以此执行。可以用return替代
default每次匹配都会被执行一次
switch (expression) {
case value1:
statement
break;
case value2:
statement
break;
case value3:
statement
break;
case value4:
statement
break;
default:
statement
}
函数
函数对任何语言来说都是核心组件,因为它们可以封装语句,然后在任何地方、任何时间执行。
function sayHi(name, message) {
console.log("Hello " + name + ", " + message);
}
sayHi("Nicholas", "how are you today? ");
有返回值的函数
只要碰到return语句,函数就会立即停止执行并退出。因此,return语句后面的代码不会被执行
function sum(num1, num2) {
return num1 + num2;
}
const result = sum(5, 10);