如果想看 面向对象 的内容,请移步JavaScript面向对象基础
01. JavaScript的说明
运行在客户端的脚本语言,不需要编译,直接由js解释器(js引擎)逐行解释执行 由 ECMAScript(JavaScript语法)、DOM(文档对象模型)、BOM(浏览器对象模型) 这三部分组成 区分大小写 简称为JS
02. JS的三种书写位置
(1) 行内式
< input type = " button" value = " 点我试试" onclick = " alert(' Hello World' )" />
(2) 内嵌式
< script>
alert ( 'Hello World!' ) ;
</ script>
(3) 外部式,引用外部js文件
< script src = " my.js" > </ script>
03. 两种打印语句的方式
alert('Hello World');
console.log('Hello World');
04. 注释
4.1 单行注释
// 我是单行注释 (在VSCode下快捷键为:Ctrl + / )
4.2 多行注释
/*
多行注释
多行注释
多行注释
*/ (在VSCode下快捷键为:Ctrl + Shift + / )
05. 特殊的关键字
5.1 标识符
5.2 关键字
5.3 保留字
是预留的 “关键字”,意思是虽然现在还不是关键字,但是未来可能会成为关键字
5.4 字面量
是源代码中一个固定值的表示法,通过字面量的格式特征可以自动的判断数据的类型
种类 字面量 数值字面量 5、9、0.5、9 字符串字面量 ‘饭老板’、“前端开发” 布尔字面量 true、false 数组字面量 [] 对象字面量 {}
06. 代码规范
变量、函数的命名必须要有意义,变量的名称一般用名词、函数的名称一般用动词 操作符的左右两侧各保留一个空格 单行注释前面有一个空格
07. 变量
7.1 概念
变量是程序在内存中申请的一块用于存放数据的空间
变量是用于存放数据的容器,可以通过变量名获取数据、修改数据
7.2 变量的使用
7.2.1 声明变量:JS是弱类型语言,声明变量时不用指定类型
var num;
var num = 10;
var num = 10, age = 15, name = 'wang';
7.2.2 声明变量的特殊情况
情况 说明 结果 console.log(age) 不声明 不赋值 报错 var age; console.log(age); 只声明 不赋值 undefined age = 10; console.log(age); 不声明 直接赋值 赋值成功,该变量为全局变量
7.3 变量命名规范
由 (A-Z)、(a-z)、(0-9)、下划线(_)、美元符号(
)
组
成
,
但
是
由
于
P
H
P
的
特
性
,
不
推
荐
使
用
(
) 组成,但是由于PHP的特性,不推荐使用(
) 组 成 , 但 是 由 于 P H P 的 特 性 , 不 推 荐 使 用 ( ) 不能以数字开头 不能是关键字、保留字 遵守小驼峰命名法
08. 流程控制
8.1 顺序结构(略)
8.2 分支结构
8.2.1 if语句
if () {
}
else if () {
}
else {
}
8.2.2 switch语句
switch(表达式){
case value1: {
break;
}
case value2: {
break;
}
default: {
}
}
8.2.3 三元表达式
表达式1 ? 表达式2 : 表达式3;
8.3 循环结构
8.3.1 for循环
打印九九乘法表
var str = "";
for (var i = 1; i <= 9; i++) {
for (var j = 1; j <= i; j++) {
str += j + " × " + i + " = " + i * j + "\t";
}
str += "\n";
}
console.log(str);
8.3.2 while循环
计算1-100的累加和
var sum = 0, i = 0;
while (++i <= 100) {
sum += i;
}
console.log(sum);
8.3.3 do-while循环
计算100以内的偶数累加和
var sum = 0, i = 0;
do {
if (i % 2 == 0) {
sum += i + " ";
}
} while (++i <= 100);
console.log(sum);
8.3.4 continue、break关键字
continue 跳出本次循环,执行下一次循环 break 直接结束整个循环
09. 数组
关于数组更详细的介绍暂时先占位
9.1 创建数组
1. 利用字面量"[]"
var arr1 = []; // 创建空数组
var arr2 = [5]; // 这里写个5代表有一个元素是5,而不是创建一个长度为5的空数组
var arr3 = ['fan', true, 0.5, null]; // 数组中可以存放任意类型的数据
2. 利用关键字"new"
var arr = new Array(); //创建一个长度为 0 的空数组
var arr = new Array(5); //创建一个长度为 5 的空数组
9.2 使用数组
9.2.1 访问数组元素
如果被访问的位置没有元素 或者 索引值超出范围,返回 undefined
var arr = ['fan', true, 0.5, null];
for (var i = 0; i < arr.lrngth; i ++ ) {
console.log(arr[i]);
}
9.2.2 数组的长度
数组的长度,默认情况下等于元素的个数 当数组中的元素发生变化,length属性也会跟着一起变 如果length属性被修改后大于数组的元素个数,则会在数组末尾出现空白元素; 如果length属性被修改后小于数组的元素个数,则会把超过该值的数组元素删除
var arr1 = ['fan', true, 0.5, null];
arr1.length = 5;
console.log(arr1); // ['fan', true, 0.5, null, 空]
var arr2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
arr2.length = 5;
console.log(arr2); // [0, 1, 2, 3, 4]
9.2.3 添加元素
(1)直接赋值
var arr = ['fan', true, 0.5, null];
arr[99] = 55;
console.log(arr.length); // 100
(2) 巧妙利用数组的长度来增加元素
var arr = [] //arr.length = 0;
for (var i = 1; i <= 10; i ++ ) {
arr[arr.length] = i;
}
console.log(arr);
9.3 数组的冒泡排序
// 数组的冒泡排序,k = 1是正序,其他是倒序
function sort(arr, k) {
if (k == 1) {
for (var i = 0; i < arr.length - 1; i++) {
for (var j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
else {
for (var i = 0; i < arr.length - 1; i++) {
for (var j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
return arr;
}
9.4 数组的函数
9.4.1 push()函数
var arr = [];
arr.push(1);
arr.push(2, 3, 4);
logsole.log(arr); // [1, 2, 3, 4]
9.4.2 pop()函数
var arr = new Array(5);
console.log(arr.length);
arr.pop();
arr.pop();
arr.pop();
console.log(arr.length);
10. 函数
10.1 声明函数、调用函数
10.1.1 function关键字 – 命名函数
function funName() {
console.log("函数体");
}
funName();
10.1.2 函数表达式 — 匿名函数
var varName = function() {
console.log("函数体");
};
varName();
10.1.3 自调用函数 — 匿名函数
(function() {
console.log("函数体");
})();
10.2 函数的参数
10.2.1 形参
函数定义时候,传递的参数 // js中形参的默认值是undefined
10.2.2 实参
函数形参和实参的数量不匹配时
参数个数 说明 实参个数等于形参个数 正常运行 实参个数多于形参个数 只取到形参的个数 实参个数小于形参 多的形参定义为 undefined
function getSum(a, b, c) {
return a + b + c;
}
var n1 = getSum(1, 2); // n1 = 1 + 2 + undefined = NaN
var n2 = getSum(1, 2, 3); // n2 = 1 + 2 + 3 = 6
var n3 = getSum(1, 2, 3, 4); // n3 = 1 + 2 + 3 = 6
10.3 函数的返回值[return]
函数遇到return会停止执行,可以结束当前函数体代码的执行 如果函数有返回值,则返回的是 return 后面的值; 如果函数没有返回值,则返回undefined return a,b,c; // 返回的是 c 的值 return [a, b, c]; // 返回的是一个数组
10.4 arguments的使用
10.4.1 概念
JS中,所有函数都有一个内置对象 ———— arguments arguments 是一个伪数组,存储了所有传入的实参 该伪数组仅用于访问实参列表的值,不支持对其进行更新,故不具有数组的push,pop等方法
10.4.2 实例
function fn() {
for (var i = 0; i < arguments.length; i++) {
console.log(arguments[i]);
}
}
fn(1, 2, 3);
11. 运算符
11.1 算数运算符
运算符 说明 +、-、*、/、% 加、减、乘、除、取模 ++、– 递增、递减 =、+=、-=、*=、/=、%= 赋值
var result = 0.1 + 0.2; // 结果不是0.3 而是:0.30000000000000004
var result = 0.07 * 100;// 结果不是 7 而是:7.000000000000001
在进行算数运算时浮点数值的精确度远远不如整数,所以不要直接判断两个浮点数是否相等!
11.2 比较运算符
运算符 说明 >、<、>=、<= 大于、小于、大于等于、小于等于 ==、!= 等于、不等于(只比较值的内容) === 、 !=== 全等于、全不等与(即比较值,又比较数据类型)
11.3 逻辑运算符
具有短路运算的特点
当有多个表达式时,左边的表达式值可以确定结果时,就不再继续运算右边的表达式的值
12. 数据类型
分为简单数据类型(Number、String、Boolean、Undefined、Null)和复杂数据类型(object)
简单数据类型 说明 默认值 Number 数字型,包含整型值和浮点型值 0 String 字符串型 “” 空字符串 Boolean 布尔值型 false Undefined var a;声明了变量a但是没有赋值,此时a = undefined undefined Null var a = null;声明了变量a为空值 null
12.1 Number数字型
12.1.1 八进制和十六进制
数值前面加 0 表示八进制,数值前面加 0x 表示十六进制
var num1 = 07; // 对应十进制的 7
var num = 0xA; // 对应十进制的 10
12.1.2 特殊的值
特殊的值 说明 Number.MAX_VALUE 数值型可表示的最大值,值为:1.7976931348623157e+308 Number.MIN_VALUE 数值型可表示的最小值,值为:5e-32 Infinity 无穷大 -Infinity 无穷小 NaN 代表一个非数字
12.1.3 isNaN()
12.1.4 数值型与其他类型的计算结果
console.log(11 + true); // 12
console.log(11 + false); // 11
console.log(11 + NaN); // NaN
console.log(11 + undefined); // NaN
console.log(11 + Infinity); // Infinity
console.log(11 + null); // 11
12.2 String字符串型
12.2.1 表示
字符串型可以是引号中的任意文本,语法为 单引号 和 双引号
var name = "fan";
12.2.2 转义符
转义符 说明 \n 换行符(n是 newline 的意思) \ 斜杆 \ ’ 单引号 ’ " 双引号 " \t tab 缩进 \b 空格(b是 blank 的意思)
12.2.3 字符串长度
字符串是由若干字符组成的,这些字符的数量就是字符串的长度
var msg = '我是帅气的饭老板';
console.log(msg.length); // 8
12.2.4 特殊的"+"符号
1. 数字相加
var a = 1;
var b = 1;
alert(a + b); // 2
2. 字符串相连,只要有一个字符串,就是字符串拼接操作
alert('hello' + '- -' + 'world'); // "hello- -world"
alert('11' + 12); // "1112"
12.3 Boolean布尔型
有两个值:true 和 false ,其中 true 表示真,false 表示假 布尔型和数字型相加的时候, true 的值为 1, false 的值为 0
console.log(true + 1); // 2
console.log(false + 1); // 1
12.4 Undefined
一个变量声明后没有赋值会有一个默认值undefined
var variable;
console.log(variable); // undefined
console.log("你好" + variable); // 你好undefined
console.log(11 + variable); // NaN
console.log(true + variable);// NaN
12.5 Null
console.log(11 + null); // 11
console.log(true + null);// 1
console.log(null + null); // 0
console.log(true + undefined); // NaN
12.6 检测变量的数据类型 typeof关键字
var num = 10;
console.log(typeof num)//结果为 number
12.7 数据类型转换
12.7.1 转换为字符串
方式 说明 案例 toString() 转成字符串 var num = 1; alert(typeof num.toString()); String() 强制转换 var num = 1; alert(typeof String(num)); 加号拼接字符串 和字符串拼接的结果都是字符串 var num = 1; alert(typeof (num + “我是字符串”));
12.7.2 转换为数字型
方式 说明 案例 parseInt(String)函数 将string类型转成整数型 parseInt(‘11’) parseFloat(String)函数 将string类型转成浮点型 parseFloat(‘11.2’) Number() 强制转换函数,将string类型强制转换为数值型 Number(‘12’) js隐式转换 ( - * /) 利用算数运算隐式转换为数值型 ‘12’ - 0
12.7.3 转换为布尔型
代表空、否定的值会被转换为false,如’’、0、NaN、null、undefined 代表非空的都会被转换为true
方式 说明 案例 Boolean() 其他类型转换为布尔值 Boolean(‘true’)
13. 作用域分类
13.1 作用域种类
全局作用域:作用于一个页面内的所有script标签内 或者 一个独立的js文件 局部作用域:作用于函数内部的代码环境,因为跟函数有关,所以也被称为函数作用域 块级作用域:块作用域由 {} 包起来,但是JS没有块级作用域
Java中:
if(true){
int num = 123;
System.out.print(num); // 123
}
System.out.print(num); // 报错
以上java代码会报错,因为Java中 {} 是一块作用域,其中声明的变量num,在{}之外不能使用
JS中:
if(true){
var num = 123;
console.log(num); // 123
}
console.log(num);// 123
13.2 变量的作用域
13.2.1 全局变量
在全局作用域下声明的变量(在函数外部定义的变量) 全局变量可以在全局作用域下使用 不使用var声明的变量也是全局变量【不建议使用】
13.2.2 局部变量
在局部作用域下声明的变量(在函数内部定义的变量) 局部变量只能在函数内部使用 函数的形参实际上就是局部变量
13.2.3 全局变量和局部变量的区别
全局变量
在任何一个地方都可以使用 只有在浏览器关闭时才会销毁,因此比较占内存 局部变量
只在函数内部使用 当其所在的代码块被执行时,才会被初始化 当代码块运行结束后,就会被销毁,因此更节省内存空间
13.3 作用域链
根据 内部函数可以访问外部函数变量 的这种机制,用链式查找决定哪些数据能被内部函数访问,就称作作用域链
var a = 1;
function fn1() {
var a = 2;
var b = '22';
fn2();
function fn2() {
var a = 3;
fn3();
function fn3() {
var a = 4;
console.log(a); // a的值 4
console.log(b); // b的值 '22'
}
}
}
fn1();
14. 预解析
14.1 相关概念
JavaScript代码是由浏览器中的JavaScript解析器来执行的,在运行JavaScript代码的时候分为两步
第一步:预解析
在当前作用域下,JS代码在执行之前,浏览器会默认把带有 var 和 function 声明的变量、函数在内存中进行提前声明或定义 第二步:代码执行
预解析会把变量和函数的声明在代码执行之前完成,预解析也叫做变量、函数提升 除了被提升的表达式之外,其余表达式均保留原顺序执行
14.2 变量提升
变量的声明会被提升到 当前作用域 的最上面,变量的赋值不提升
14.3 函数提升
函数的声明会被提升到当前作用域的最上面 函数表达式创建函数,会执行变量提升,但此时函数无法被调用
14.4 预解析案例
注意:在函数中,没有用var声明的变量,当全局变量看
f1();
console.log(c);
console.log(b);
console.log(a);
function f1() {
var a = b = c = 9;
console.log(a);
console.log(b);
console.log(c);
}
相当于
function f1() {
var a;
c = 9;
b = 9;
a = 9;
console.log(a); // 9
console.log(b); // 9
console.log(c); // 9
}
f1();
console.log(c); // 9
console.log(b); // 9
console.log(a); // 报错