这篇笔记介绍了JavaScript的基础知识，包括如何在HTML中和外部文件中使用JavaScript，以及变量、数据类型、字符串、数组、对象、条件判断和循环等核心概念。还提到了ES6的新特性如Map和Set，并强调了变量声明和作用域的重要性。
这篇笔记是跟着廖雪峰老师的博客写的,有需要的可以去看廖雪峰老师的博客
- JavaScript 放在Html中
通常我们都把JavaScript代码放到<head>中
由<script>...</script>包含的代码就是JavaScript代码，它将直接被浏览器执行
- 放在JS文件中
把JavaScript代码放到一个单独的.js文件，然后在HTML中通过<script src="..."></script>引入这个文件
可以在页面中多次编写<script> js代码... </script>，浏览器按照顺序依次执行
<script type="text/javascript">...</script>
//默认的`type`就是JavaScript，所以不必显式地把`type`指定为JavaScript
请注意，JavaScript严格区分大小写，如果弄错了大小写，程序将报错或者运行不正常。
调试程序可以用console.log()和alert(),使用console.log()代替alert()的好处是可以避免弹出烦人的对话框,通过F12可以查看console.log()的内容。
- 快速入门
JavaScript不区分整数和浮点数，统一用Number表示，以下都是合法的Number类型
123; // 整数123
0.456; // 浮点数0.456
1.2345e3; // 科学计数法表示1.2345x1000，等同于1234.5
-99; // 负数
NaN; // NaN表示Not a Number，当无法计算结果时用NaN表示
Infinity; // Infinity表示无限大，当数值超过了JavaScript的Number所能表示的最大值时，就表示为Infinity
与大多数语言相同 都用 " "或者 ’ ’ 包含,引号本身不包括
如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：
'I\'m \"OK\"!'; // I'm "ok"!
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，\\表示的字符就是\
ASCII字符可以以\x##形式的十六进制表示,\u####表示一个Unicode字符：
'\x41'; // 完全等同于 'A'
'\u4e2d\u6587'; // 完全等同于 '中文'
由于多行字符串用\n写起来比较费事，所以最新的ES6标准新增了一种多行字符串的表示方法，用反引号...表示：
`这是一个
多行
字符串`;
要把多个字符串连接起来，可以用+号连接：
ES6新增了一种模板字符串 可以用${变量名}, 注意用反引号`
var name = '小明';
var age = 20;
var message = '你好, ' + name + ', 你今年' + age + '岁了!';
var message1 = `你好, ${name}, 你今年${age}岁了!`
一些常用字符串操作:
需要特别注意的是，字符串是不可变的，如果对字符串的某个索引赋值，不会有任何错误，但是，也没有任何效果
var s = 'Hello';
s.length; //获取长度 5
s[0]; //H
s[0] = 'T';//不会报错但是也没有效果
s;//Hello
s.toUpperCase(); // 大写返回'HELLO' 同理toLowerCase
s.indexOf('e');// 获取查找字符串的首位下标 1
s.indexOf('llo');// 2 如果没有返回 -1
s.subString(1); //返回指定索引位置字符串 从1到结束 ello
s.subString(1,3); // el
布尔值和布尔代数的表示完全一致，一个布尔值只有true、false两种值，要么是true，要么是false，可以直接用true、false表示布尔值，也可以通过布尔运算计算出来：&&与运算 ||或运算 ! 非运算
比较运算会得到布尔值
JavaScript允许对任意数据类型做比较：
false == 0; // true
false === 0; // false
第一种是==比较，它会自动转换数据类型再比较，很多时候，会得到非常诡异的结果；
第二种是===比较，它不会自动转换数据类型，如果数据类型不一致，返回false，如果一致，再比较。
由于JavaScript这个设计缺陷，不要使用==比较，始终坚持使用===比较。
另一个例外是NaN这个特殊的Number与所有其他值都不相等，包括它自己：
唯一能判断NaN的方法是通过isNaN()函数：
NaN === NaN; // false
isNaN(NaN); // true
null 表示为空 undefined表示为未定义
多数情况下用null , 一般在undefined仅仅在判断函数参数是否传递的情况下有用。
数组是一组按顺序排列的集合，集合的每个值称为元素。
JavaScript的数组可以包括任意数据类型, 用 [ ] 表示数组, 元素之间用, 分割
数组可以通过下标访问,同样 下标从0开始
[1, 2, 3.14, 'Hello', null, true];
另一种创建数组的方法是通过Array()函数实现：
new Array(1, 2, 3); // 创建了数组[1, 2, 3]
为了可读性,强烈推荐用[]
数组常用操作:
var arr = [1, 2, 3];
arr.length; // 3
arr.length = 6; //直接给Array的length赋一个新的值会导致Array大小的变化
arr; // arr变为[1, 2, 3, undefined, undefined, undefined]
arr[5] = 'x';//如果通过索引赋值时，索引超过了范围，同样会引起Array大小的变化：
arr; // arr变为[1, 2, 3, undefined, undefined, 'x']
因为数组越界不会报错,所以使用数组要注意检查数组索引
// 与String类似，Array也可以通过indexOf()来搜索一个指定的元素的位置：
var arr = [10, 20, '30', 'xyz'];
arr.indexOf(20); // 元素20的索引为1
arr.indexOf(30); // 元素30没有找到，返回-1
arr.indexOf('30'); // 元素'30'的索引为2
//slice()就是对应String的substring()版本，它截取Array的部分元素，然后返回一个新的Array
var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.slice(0, 3); // 从索引0开始，到索引3结束，但不包括索引3: ['A', 'B', 'C']
arr.slice(3); // 从索引3开始到结束: ['D', 'E', 'F', 'G']
push()向Array的末尾添加若干元素，pop()则把Array的最后一个元素删除掉
var arr = [1, 2];
arr.push('A', 'B'); // 返回Array新的长度: 4
arr; // [1, 2, 'A', 'B']
arr.pop(); // pop()返回'B'
arr; // [1, 2, 'A']
arr.pop(); arr.pop(); arr.pop(); // 连续pop 3次
arr; // []
arr.pop(); // 空数组继续pop不会报错，而是返回undefined
arr; // []
如果要往Array的头部添加若干元素，使用unshift()方法，shift()方法则把Array的第一个元素删掉：
var arr = [1, 2];
arr.unshift('A', 'B'); // 返回Array新的长度: 4
arr; // ['A', 'B', 1, 2]
arr.shift(); // 'A'
arr; // ['B', 1, 2]
arr.shift(); arr.shift(); arr.shift(); // 连续shift 3次
arr; // []
arr.shift(); // 空数组继续shift不会报错，而是返回undefined
arr;
sort()可以对当前Array进行排序 reverse()把整个Array反转：
var arr = ['B', 'C', 'A'];
arr.sort();
arr; // ['A', 'B', 'C']
arr.reverse();
arr; // ['A', 'B', 'C']
splice()方法是修改Array的“万能方法”，它可以从指定的索引开始删除若干元素，然后再从该位置添加若干元素：
var arr = ['A', 'B', 'C', 'D', 'E', 'F'];
// 从索引2开始删除3个元素,然后再添加两个元素:
arr.splice(2, 3, '1', '2'); // 返回删除的元素 ['C', 'D', 'E']
arr; // ['A', 'B', '1', '2', 'F']
// 只删除,不添加:
arr.splice(2, 2); // ['C', 'D']
arr; // ['A', 'B', 'E', 'F']
// 只添加,不删除:
arr.splice(2, 0, '1', '2'); // 返回[],因为没有删除任何元素
arr; // ['A', 'B', '1', '2', 'C', 'D', 'E', 'F']
concat()方法把当前的Array和另一个Array连接起来，并返回一个新的Array,不会修改原来的Array
var arr = ['A', 'B', 'C'];
var added = arr.concat([1, 2, 3]);
added; // ['A', 'B', 'C', 1, 2, 3]
join()方法是一个非常实用的方法，它把当前Array的每个元素都用指定的字符串连接起来，然后返回连接后的字符串：
如果Array的元素不是字符串，将自动转换为字符串后再连接。
var arr = ['A', 'B', 'C'];
arr.join('-'); // 'A-B-C'
多维数组
var arr = [[1, 2, 3], [400, 500, 600], '-'];
var x = arr[1][1]; //500
来个题 请排序后显示：欢迎XXX，XXX，XXX和XXX同学！
var arr = ['小明', '小红', '大军', '阿黄'];
arr.sort();
console.log(`欢迎${arr[0]}，${arr[1]}，${arr[2]}和${arr[3]}同学！`);
console.log(`欢迎${arr.sort().splice(0,arr.length-1).join(',')}和${arr[arr.length-1]}同学！`)
JavaScript的对象是一组由键-值组成的无序集合，键都是字符串类型,值可以是任意类型,每个键称为对象的属性 ,每个键值对用,分开 最后一对不需要,
JavaScript规定，访问不存在的属性不报错，而是返回undefined
var person = {
name: 'Bob',
age: 20,
tags: ['js', 'web', 'mobile'],
city: 'Beijing',
hasCar: true,
zipcode: null
};
//获取属性值 对象变量名.属性值
person.name// Bob
person[name] //Bob 也可以这么活得,但是这样不推荐
由于JavaScript的对象是动态类型，你可以自由地给一个对象添加或删除属性：
var xiaoming = {
name: '小明'
};
xiaoming.age; // undefined
xiaoming.age = 18; // 新增一个age属性
xiaoming.age; // 18
delete xiaoming.age; // 删除age属性
xiaoming.age; // undefined
delete xiaoming['name']; // 删除name属性
xiaoming.name; // undefined
delete xiaoming.school; // 删除一个不存在的school属性也不会报错
不过要小心，如果in判断一个属性存在，这个属性不一定是xiaoming的，它可能是xiaoming继承得到的：
因为toString定义在object对象中，而所有对象最终都会在原型链上指向object，所以xiaoming也拥有toString属性。
要判断一个属性是否是xiaoming自身拥有的，而不是继承得到的，可以用hasOwnProperty()方法：
var xiaoming = {
name: '小明'
};
'name' in xiaoming; // true
'toString' in xiaoming; // true
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false
如果if 和 else 后面只有一句话是可以不加{}的, 但是后面如果想添加内容会失去if else的意义
希望大家可以像java代码规范一样 保持自己的代码规范 一行也加上{}
var age = 20;
if (age >= 18)
alert('adult');
else
console.log('age < 18'); // 添加一行日志
alert('teenager'); // <- 这行语句已经不在else的控制范围了
多个条件判断可以用else if 但是要注意判断是从上至下的 注意顺序
JavaScript把null、undefined、0、NaN和空字符串''视为false，其他值一概视为true，因此上述代码条件判断的结果是true。
for 循环
for循环的3个条件都是可以省略的，如果没有退出循环的判断条件，就必须使用break语句退出循环，否则就是死循环
var x = 0;
var i;
for (i=1; i<=10000; i++) {
x = x + i;
}
var x = 0; //
for (;;) { // 将无限循环下去
if (x > 100) {
break; // 通过if判断来退出循环
}
x ++;
}
for循环的一个变体是for ... in循环，它可以把一个对象的所有属性依次循环出来
var o = {
name: 'Jack',
age: 20,
city: 'Beijing'
};
for (var key in o) {
//要过滤掉对象继承的属性，用hasOwnProperty()来实现
console.log(key); // 'name', 'age', 'city'
}
由于Array也是对象，而它的每个元素的索引被视为对象的属性，因此，for ... in循环可以直接循环出Array的索引：
var a = ['A', 'B', 'C'];
for (var i in a) {
console.log(i); // '0', '1', '2'
console.log(a[i]); // 'A', 'B', 'C'
}
while循环
while循环只有一个判断条件，条件满足，就不断循环，条件不满足时则退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：
var n = 99;
while (n > 0) {
n = n - 2;
}
最后一种循环是do { ... } while()循环，它和while循环的唯一区别在于，不是在每次循环开始的时候判断条件，而是在每次循环完成的时候判断条件;
var n = 0;
do {
n = n + 1;
} while (n < 100);
n; // 100
最新的ES6规范引入了新的数据类型Map。要测试你的浏览器是否支持ES6规范，请执行以下代码，如果浏览器报ReferenceError错误，那么你需要换一个支持ES6的浏览器:
'use strict';
var m = new Map();
var s = new Set();
console.log('你的浏览器支持Map和Set！');
//使用
var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);
m.get('Michael'); // 95
初始化Map需要一个二维数组，或者直接初始化一个空Map。Map具有以下方法：
var m = new Map(); // 空Map
m.set('Adam', 67); // 添加新的key-value
m.set('Bob', 59);
m.has('Adam'); // 是否存在key 'Adam': true
m.get('Adam'); // 67
m.delete('Adam'); // 删除key 'Adam'
m.get('Adam'); // undefined
Set和Map类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在Set中，没有重复的key。
要创建一个Set，需要提供一个Array作为输入，或者直接创建一个空Set：
重复元素在Set中会自动被过滤,
通过add(key)方法可以添加元素到Set中，可以重复添加，但不会有效果,
通过delete(key)方法可以删除元素
var s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3, 3]); // 含1, 2, 3
var s = new Set([1, 2, 3]);
s.delete(3);
s; // Set {1, 2}
map和set用后面的iterable进行循环
变量就是方程中的x,y 的意思,Javas中变量名是大小写英文、数字、$和_的组合，且不能用数字开头。
申明一个变量统一使用 var
var a; // 申明了变量a，此时a的值为undefined
var $b = 1; // 申明了变量$b，同时给$b赋值，此时$b的值为1
var s_007 = '007'; // s_007是一个字符串
var Answer = true; // Answer是一个布尔值true
var t = null; // t的值是null
//同一变量可以反复用 = 赋值, 但是只能用var 定义一次
var a = 1;//错误 上面已经申明
a = 1; //正确
strict模式: 即严格模式,Javascript设计之初不强制用var声明变量, 但是没有用var会被识别为全局变量
i = 10; //现在是全局变量
如果同一页面的不同Javascript代码都使用了 i ,就会出现冲突,出现难以调试的结果
使用了var定义的变量只会在限定的作用域内使用
所以强烈建议开启"strict模式":只用在JavaScript文件第一行加上;
'use strict'
遍历Array可以采用下标循环，遍历Map和Set就无法使用下标。为了统一集合类型，ES6标准引入了新的iterable类型，Array、Map和Set都属于iterable类型。
```javascript
var a = ['A', 'B', 'C'];
var s = new Set(['A', 'B', 'C']);
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
for (var x of a) { // 遍历Array
console.log(x);
}
for (var x of s) { // 遍历Set
console.log(x);
}
for (var x of m) { // 遍历Map
console.log(x[0] + '=' + x[1]);
}
```
for...of与for...int区别;
for ... in循环由于历史遗留问题，它遍历的实际上是对象的属性名称。一个Array数组实际上也是一个对象，它的每个元素的索引被视为一个属性。
手动添加一个属性后,for ... in循环将把name包括在内，但Array的length属性却不包括在内。
for ... of循环则完全修复了这些问题，它只循环集合本身的元素：
```javascript
var a = ['A', 'B', 'C'];
a.name = 'Hello';
for (var x in a) {
console.log(x); // '0', '1', '2', 'name'
}
for (var x of a) {
console.log(x); // 'A', 'B', 'C'
}
```
还可以使用iterable的内置方法forEach:它接收一个函数，每次迭代就自动回调该函数。以Array为例
```javascript
var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {
// element: 指向当前元素的值
// index: 指向当前索引
// array: 指向Array对象本身
console.log(element + ', index = ' + index);
});
//A, index = 1,B, index = 1,C, index = 2
```
Set与Array类似，但Set没有索引，因此回调函数的前两个参数都是元素本身：
```javascript
var s = new Set(['A', 'B', 'C']);
s.forEach(function (element, sameElement, set) {
console.log(element);
console.log(sameElement);
});// A A B B C C
```
Map的回调函数参数依次为value、key和map本身:
```javascript
var m = new Map([[1, 'x'], [2, 'y'], [3, 'z']]);
m.forEach(function (value, key, map) {
console.log(value);
});
```
如果对某些参数不感兴趣，由于JavaScript的函数调用不要求参数必须一致，因此可以忽略它们。例如，只需要获得Array的element：
```javascript
var a = ['A', 'B', 'C'];
a.forEach(function (element) {
console.log(element);
});
```
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
