JavaScript学习记录
-
引言
一个网页就好像一幢房子,HTML结构就是钢筋混泥土的墙,一幢房子如果没有钢筋混泥土的墙那就是一堆废砖头,也就称不上是房子了。 CSS是装饰材料,是油漆,是用来装饰房子的。CSS如果没有HTML结构那也就什么都不是了,没有了实际使用价值。 而JavaScript就是房屋的开关,用来进行互动,产生动态效果。
前面我们已经记录了本段时间对“钢筋混凝土”HTML和“装饰材料”CSS的学习,接下来将记录的是“房屋开关”JavaScript。
另附:本次记录所使用的IDE为VSCode!
- 目录
1.何为 JavaScript?
JavaScript,就是我们通常所说的JS。这是一种嵌入到HTML页面中的编程语言,由浏览器一边解释一边执行。
HTML用于控制网页的结构,CSS用于控制网页的外观,而JavaScript控制着网页的行为。
单纯只有HTML和CSS的页面一般只供用户浏览,而JavaScript的出现,使得用户可以与页面进行交互(如定义各种鼠标效果),让网页实现更多绚丽的效果。HTML和CSS只是描述性的语言,单纯使用这两个没办法做出那些特效,因此必须用编程的方式来实现,也就是使用JavaScript。
提示: 现在JavaScript再也不是简单的脚本语言了,无论前端还是后台,可以毫不夸张的说,JavaScript都有良好的表现!
运行JavaScript有多种方式,可以直接在浏览器的控制台编写运行;也可以编写一个独立的js文件,然后在Html文件中引入,(这两种方法由浏览器解释执行,是以前唯一的方式)。也可以用编辑软件如Webstrom或VSCode编写独立的js文件,由安装好的Node.js解释执行运行( node-v10.11.0-64位下载)。
因为JavaScript是我们前后端编程的基础,所以下面对JavaScript进行概要介绍
2.JavaScript 基本使用
<script>
标签
在 HTML 中,JavaScript 代码必须位于 <script>
与 </script>
标签之间。
实例
<script>
document.getElementById("demo").innerHTML = "我的第一段 JavaScript";
</script>
注释: 旧的JavaScript 例子也许会使用 type 属性:
<script type="text/javascript">
注释: type 属性不是必需的。JavaScript 是 HTML 中的默认脚本语言。
JavaScript 函数和事件
JavaScript 函数是一种 JavaScript 代码块,它可以在调用时被执行。
例如,当发生事件时调用函数,比如当用户点击按钮时。
提示: 我们将在稍后的章节学到更多有关函数和事件的知识。
<head>
或 <body>
中的 JavaScript
我们能够在 HTML 文档中放置任意数量的脚本。
脚本可被放置与 HTML 页面的 <body>
或 <head>
部分中,或兼而有之。
<head>
中的 JavaScript
在本例中,JavaScript 函数被放置于 HTML 页面的 <head>
部分。
该函数会在按钮被点击时调用:
实例
<!DOCTYPE html>
<html>
<head>
<script>
function myFunction() {
document.getElementById("demo").innerHTML = "段落被更改。";
}
</script>
</head>
<body>
<h1>一张网页</h1>
<p id="demo">一个段落</p>
<button type="button" onclick="myFunction()">试一试</button>
</body>
</html>
<body>
中的 JavaScript
在本例中,JavaScript 函数被放置于 HTML 页面的 <body>
部分。
该函数会在按钮被点击时调用:
实例
<!DOCTYPE html>
<html>
<body>
<h1>A Web Page</h1>
<p id="demo">一个段落</p>
<button type="button" onclick="myFunction()">试一试</button>
<script>
function myFunction() {
document.getElementById("demo").innerHTML = "段落被更改。";
}
</script>
</body>
</html>
提示: 把脚本置于
<body>
元素的底部,可改善显示速度,因为脚本编译会拖慢显示。
外部脚本
脚本可放置与外部文件中:
外部文件:myScript.js
function myFunction() {
document.getElementById("demo").innerHTML = "段落被更改。";
}
外部脚本很实用,如果相同的脚本被用于许多不同的网页。
JavaScript 文件的文件扩展名是 .js。
如需使用外部脚本,请在 <script>
标签的 src
(source) 属性中设置脚本的名称:
实例
<script src="myScript.js"></script>
也可以在 <head>
或 <body>
中放置外部脚本引用。
该脚本的表现与它被置于 <script>
标签中是一样的。
注释: 外部脚本不能包含
<script>
标签。
外部 JavaScript 的优势
在外部文件中放置脚本有如下优势:
- 分离了 HTML 和代码
- 使 HTML 和 JavaScript 更易于阅读和维护
- 已缓存的 JavaScript 文件可加速页面加载
- 如需向一张页面添加多个脚本文件 - 请使用多个 script 标签:
实例
<script src="myScript1.js"></script>
<script src="myScript2.js"></script>
外部引用
可通过完整的 URL 或相对于当前网页的路径引用外部脚本:
本例使用完整的 URL 来链接至脚本:
实例
<script src="https://www.w3school.com.cn/js/myScript1.js"></script>
实例
<script src="/js/myScript1.js"></script>
实例
<script src="myScript1.js"></script>
3.JavaScript 基本语法
-
大小写敏感
-
标识符
所谓标识符,就是指变量、函数、属性的名字,或者函数的参数。标识符可以是按照下列格式规则组合起来的一或多个字符:
第一个字符只能是字母、下划线( _ )或美元符号( $ )之一;
其他字符可以是字母、下划线、美元符号或数字。
按照惯例,ECMAScript(European Computer Manufacturers Association) 标识符采用 驼峰大小写格式,也就是第一个字母小写,剩下的每个单词的首字母大写,如getNameById
-
注释
-
语句
语句后的分号建议添加,但不必须。
-
关键字/保留字
-
变量
ECMAScript 的变量是松散类型的,所谓松散类型就是可以用来保存任何类型(如:
String、Number、Boolean以及Object
等)的数据。换句话说,每个变量仅仅是一个用于保存值的占位符而已。
定义变量时要使用var
操作符,后跟变量名(即一个标识符),如下所示:var message
; 这行代码定义了一个名为message
的变量,该变量可以用来保存任何值。下示代码合法但不推荐:
var message = 'Hi, JavaScript';
console.log(message);
message = 100;
console.log(message);
有一点必须注意,即用
var
操作符定义的变量将成为定义该变量的作用域中的局部变量。也就是说,如果在函数中使用var
定义一个变量,那么这个变量在函数退出后就会被销毁,例如:
function test(){
var message = "hi"; // 局部变量,去掉var即为全局变量
}
test();
alert(message); // 错误!
虽然省略 var 操作符可以定义全局变量,但这也不是我们推荐的做法。因为在局部作用域中定义的全局变量很难维护。
4. JavaScript 操作符
-
一元操作符
++ --
-
布尔操作符
&& || !
除下列值为假外其余皆为真: false、null、undefined、‘’、0、NaN
&&和||
都属于短路操作!
- 算术操作符
+ - * / %
注意以下代码:
var result = 5 + '5'; // 一个数值和一个字符串相加
console.log(result); // '55'
//============================================
var num1 = 5;
var num2 = 10;
var message = "The sum of 5 and 10 is " + num1 + num2;// (num1 + num2),还可使用模板字符串``
console.log(message); // "The sum of 5 and 10 is 510"
- 关系操作符
<> <=>= == === != !==
注意: ===称为全等(值和类型)。
var x = 5;
console.log(x == 5);
console.log(x == '5');
console.log(x === 5);
console.log(x === '5');
- 条件(问号)操作符 ? :
能有效的简洁代码
var max = (num1 > num2) ? num1 : num2;
- 赋值操作符
= += -+ *= /= %=
5.JavaScript 语句
在 HTML 中,JavaScript 语句是由 web 浏览器“执行”的“指令”。
JavaScript 程序
计算机程序是由计算机“执行”的一系列“指令”。
在编程语言中,这些编程指令被称为语句。
JavaScript 程序就是一系列的编程语句。
注释: 在 HTML 中,JavaScript 程序由 web 浏览器执行。
JavaScript 语句
JavaScript 语句由以下构成:
值、运算符、表达式、关键词和注释。
这条语句告诉浏览器在 id=“demo” 的 HTML 元素中输出 “Hello Kitty.”:
实例
document.getElementById("demo").innerHTML = "Hello Kitty.";
大多数 JavaScript 程序都包含许多 JavaScript 语句。
这些语句会按照它们被编写的顺序逐一执行。
注释: JavaScript 程序(以及 JavaScript 语句)常被称为 JavaScript 代码。
分号 ;
分号分隔 JavaScript 语句。
请在每条可执行的语句之后添加分号:
a = 5;
b = 6;
c = a + b;
如果有分号分隔,允许在同一行写多条语句:
a = 5; b = 6; c = a + b;
提示: 以分号结束语句不是必需的,但我们仍然强烈建议您这么做。
JavaScript 空白字符
JavaScript 会忽略多个空格。您可以向脚本添加空格,以增强可读性。
下面这两行是相等的:
var person = "Bill";
var person="Bill";
在运算符旁边( = + - * / )添加空格是个好习惯:
var x = y + z;
JavaScript 行长度和折行
为了达到最佳的可读性,程序员们常常喜欢把代码行控制在 80 个字符以内。
如果 JavaScript 语句太长,对其进行折行的最佳位置是某个运算符:
实例
document.getElementById("demo").innerHTML =
"Hello Kitty.";
JavaScript 代码块
JavaScript 语句可以用花括号({...})
组合在代码块中。
代码块的作用是定义一同执行的语句。
您会在 JavaScript 中看到成块组合在一起的语句:
实例
function myFunction() {
document.getElementById("demo").innerHTML = "Hello Kitty.";
document.getElementById("myDIV").innerHTML = "How are you?";
}
6.函数
函数(function)
对任何语言来说都是一个核心的概念。通过函数可以封装任意多条语句,而且可以在任何地方、任何时候调用执行。以下是一个函数示例:
function sayHi(name, message) {
console.log('Hello ' + name + ',' + message);
}
sayHi('Gridwang', '你好。');
ECMAScript 中的函数在定义时不必指定是否返回值。实际上,任何函数在任何时候都可以通过 return
语句后跟要返回的值来实现返回值。请看下面的例子:
function sum(num1, num2) {
return num1 + num2;
}
var result = sum(3, 2);
console.log(result);
ECMAScript 函数不介意传递进来多少个参数,也不在乎传进来参数是什么数据类型。
也就是说,即便你定义的函数只接收两个参数,在调用这个函数时也未必一定要传递两个参数。可以传递一个、三个甚至不传递参数,而解析器永远不会有什么怨言。
之所以会这样,原因是 ECMAScript 中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组,而不关心数组中包含哪些参数(如果有参数的话)。如果这个数组中不包含任何元素,无所谓;如果包含多个元素,也没有问题。
如果在 ECMAScript中定义了两个名字相同的函数,则该名字只属于后定义的函数。请看下面的例子:
function addSomeNumber(num){
return num + 100;
}
function addSomeNumber(num) {
return num + 200;
}
console.log(addSomeNumber(100)); //300
7. 对象Object
对象 Object
是ECMAScript 中使用最多的一个类型。我们常将数据和方法封装在对象中。
创建对象有如下两种方式,我们常用第二种。
//方式一new
var person = new Object();//生成空对象
person.name = 'Elon Musk';//设置对象的属性
person.age = 46;
person.job = 'SpaceX Rocket';
person.sayName = function(){ //设置对象的方法/函数,注意此处
console.log(this.name);
};
//方式二字面量
var person = {
name: 'Lary Page',
age: 47,
job: 'Software Engineer',
sayName: function(){ //注意此处
console.log(this.name);
}
};
console.log(person.job);
person.sayName();
虽然 Object
构造函数或对象字面量都可以用来创建单个对象,但这些方式有个明显的缺点:使用同一个接口创建很多对象,会产生大量的重复代码。为解决这个问题,人们开始使用工厂模式的一种变体。代码如下:
function createPerson(name, age, job){
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function(){
console.log(this.name);
};
return o;
}
var person1 = createPerson('Steve Jobs',56 , 'Inventor');
var person2 = createPerson('Linus Torvalds', 49, 'Software Engineer');
var person2 = createPerson('Julian Assange', 47, 'Ethical Hacker');
8. 数组Array
除了 Object 之外, Array 类型恐怕是 ECMAScript 中最常用的类型了。
ECMAScript 中的数组与其他多数语言中的数组有着相当大的区别。虽然 ECMAScript 数组与其他语言中的数组都是数据的有序列表,但与其他语言不同的是,ECMAScript 数组的每一项可以保存任何类型的数据(不建议!)。
也就是说,可以用数组的第一个位置来保存字符串,用第二位置来保存数值,用第三个位置来保存对象,以此类推。而且,ECMAScript数组的大小是可以动态调整的,即可以随着数据的添加自动增长以容纳新增数据。
创建数组有以下两种方法,我们常用第二种。
//方式一new
var colors = new Array('red', 'blue', 'green');
//方式二字面量
var colors = ['red', 'blue', 'green']; // 创建一个包含 3 个字符串的数组
console.log(colors[1]);
colors[3] = 'brown';
console.log(colors.length);
var names = []; // 创建一个空数组
var hyBird = [1, 2, 'haha', {firstName: 'Yong', lastName: 'Wang'}]; //不推荐!
console.log(hyBird[3].firstName);
常用的数组方法如下:
- 元素联合
var colors = ['red', 'green', 'blue'];
console.log(colors.join(',')); //red,green,blue
console.log(colors.join('||')); //red||green||blue
- 堆栈方法
栈是一种 **LIFO(Last-In-First-Out,后进先出)**的数据结构,也就是最新添加的项最早被移除。而栈中项的插入(叫做推入)和移除(叫做弹出),只发生在一个位置——栈的顶部。
ECMAScript 为数组专门提供了push() 和 pop()
方法,以便实现类似栈的行为。
var colors = []; // 创建一个数组
var count = colors.push('red', 'green'); // 末尾推入两项
console.log(count); //2
colors.push('black'); // 末尾推入另一项
console.log(colors); //3
var item = colors.pop(); // 末尾弹出最后一项
console.log(item); //'black'
console.log(colors); //2
- 队列方法
栈数据结构的访问规则是 LIFO(后进先出),而队列数据结构的访问规则是 FIFO(First-In-First-Out,先进先出)。队列在列表的末端添加项,从列表的前端移除项。
由于 push() 是向数组末端添加项的方法,因此要模拟队列只需一个从数组前端取得项的方法。实现这一操作的数组方法就是 shift() ,它能够移除数组中的第一个项并返回该项,同时将数组长度减1。
var colors = new Array(); //创建一个数组
colors.push('red', 'green'); //推入两项
console.log(colors); //2
count = colors.push('black'); //推入另一项
console.log(colors); //3
var item = colors.shift(); // 前端弹出第一项
console.log(item); //'red'
console.log(colors);
ECMAScript 还为数组提供了一个unshift()
方法。它能在数组前端添加任意个项并返回新数组的长度。
var colors = new Array(); //创建一个数组
var count = colors.unshift('red', 'green'); // 推入两项
console.log(colors);
count = colors.unshift('black'); // 推入另一项
console.log(colors);
var item = colors.pop(); // 取得最后一项
console.log(item); //'green'
console.log(colors);
总结: 由上可知,
push、pop
操作在数组末,而unshift、shift
操作在数组头;push、unshift
压入而pop、shift
弹出。
- 反转数组项
var values = [1, 2, 3, 4, 5];
values.reverse();
console.log(values); //5,4,3,2,1
- 链接方法
var colors1 = ['red', 'green', 'blue'];
var colors2 = ['yellow', 'black'];
console.log(colors1.concat(colors2));
console.log(colors2.concat(colors1));
console.log(colors2.concat('brown'));
console.log(color2)//注意:concat返回一个新数组,原数组没改变
- 分片方法
slice() ,它能够基于当前数组中的一或多个项创建一个新数组。 slice() 方法可以接受一或两个参数,即要返回项的起始和结束位置。
在只有一个参数的情况下, slice() 方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数,该方法返回起始和结束位置之间的项——但不包括结束位置的项。
注意: slice() 方法不会影响原始数组。
var colors1 = ['red', 'green', 'blue', 'yellow', 'purple'];
var colors2 = colors1.slice(1);
var colors3 = colors1.slice(2, 4);
var colors4 = colors1.slice(2, 2);//结果是什么?
console.log(colors1);
console.log(colors2);
console.log(colors3);
- splice方法
splice() 方法恐怕要算是最强大的数组方法了,它可对数组如下3种操作。
注意: splice() 方法直接更改原始数组。
-
删除: 可以删除任意数量的项,只需指定 2 个参数:要删除的第一项的位置和要删除的项数。 例如, splice(0,2) 会删除数组中的前两项。
-
插入: 可以向指定位置插入任意数量的项,只需提供 3 个参数:起始位置、0(要删除的项数) 和要插入的项。如果要插入多个项,可以再传入第四、第五,以至任意多个项。例如, splice(2,0,‘red’,‘green’) 会从当前数组的位置 2 开始插入字符串 ‘red’ 和 ‘green’ 。
-
替换: 可以向指定位置插入任意数量的项,且同时删除任意数量的项,只需指定 3 个参数:起 始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如, splice (2,1,‘red’,‘green’) 会删除当前数组位置 2 的项,然后再从位置 2 开始插入字符串 ‘red’ 和 ‘green’ 。
var colors = ['red', 'green', 'blue'];
var removed = colors.splice(0,1); // 删除第一项
console.log(colors); // green,blue
console.log(removed); // red,返回的数组中只包含一项
removed = colors.splice(1, 0, 'yellow', 'orange'); // 从位置 1 开始插入两项
console.log(colors); // green,yellow,orange,blue
console.log(removed); // 返回的是一个空数组
removed = colors.splice(1, 1, 'red', 'purple'); // 插入两项,删除一项
console.log(colors); // green,red,purple,orange,blue
console.log(removed); // yellow,返回的数组中只包含一项
9. 链式语法
链式语法已变得非常流行。实际上这是一种非常容易实现的模式。基本上,你只需要让每个函数返回 this代表包含该函数的对象,这样其他函数就可以立即被调用。看看下面的例子。
//链式语法
var bird = {//定义对象字面量
catapult: function() {
console.log( 'Yippeeeeee!' );
return this;//返回bird对象自身
},
destroy: function() {
console.log( "That'll teach you... you dirty pig!" );
return this;
}
};
bird.catapult().destroy();//destroy()后还可以再链接吗?
10. 闭包
闭包是什么?闭包是Closure,这是静态语言所不具有的一个新特性。但是闭包也不是什么复杂到不可理解的东西,简而言之,闭包就是:
函数的局部变量集合,只是这些局部变量在函数返回后会继续存在。
闭包就是就是函数的“堆栈”在函数返回后并不释放,我们也可以理解为这些函数堆栈并不在栈上分配而是在堆上分配
当在一个函数内定义另外一个函数就会产生闭包。如下代码:
function greeting(name) {
var text = 'Hello ' + name; // local variable
// 每次调用时,产生闭包,并返回内部函数对象给调用者
return function() { console.log(text); }//注意该函数无名称,称为匿名函数
}
var sayHello = greeting('Closure');//调用greeting()返回了什么?
sayHello(); // 注意此处的使用方法。通过闭包访问到了局部变量text
上述代码的执行结果是:Hello Closure,因为sayHello指向了greeting函数对象,sayHello()则对其进行调用,greeting函数执行完毕后将返回greeting函数内定义的匿名函数对象,而该匿名函数仍然可以访问到了定义在greeting之内的局部变量text,注意此时我们已从greeting函数中退出了(但请留意,也只有该内部匿名函数能访问,其它任何代码都不能访问)。以下是另外一个例子:
var scope = 'global scope'; //全局变量
function checkScope(){
var scope = 'local scope'; //局部变量
function f(){
return scope;
}
return f;
}
checkScope()(); //注意此处的使用方法。返回值为local scope而非global scope
11.总结
本次对于JavaScript的学习,对于过程而言是十分痛苦的:相比于HTML和CSS,JavaScript的难度完全不是一个等级的。这让在舒适区呆习惯了的我有点措手不及。
但是人总是需要成长的,在通过艰难的匍匐前进后,我对于JavaScript这门技术总算是有一点点了解和能够稍微运用那么一点了。可喜可贺可喜可贺。但是如果仅仅是这样那是远远达不到要求的,无论是老师的要求还是我自己的要求。所以我将继续砥砺前进,争取学出一片自己的天空!
另外,本次学习也使我对于JavaScript的用法有了更加深入的了解,虽然不能说算是能够灵活运用,但是在一定的条件下还是可以进行相对程度上的排版,这也算是一种学习收获吧。
在此特别感谢我的老师王勇,是王勇老师的谆谆教诲使我能够更进一步。
特别鸣谢!
参考网址1:棋哥教学网
参考网址2:W3School教学网
学生:何家豪