[TOC]
# 每日单词
1. `pretty` 可爱
1. `format` 格式化
1. `insert` 插入
1. `upper` 单词大写
1. `lower` 单词小写
1. `Infinity` 无限
# 再谈函数
## 声明后即运行
先声明在调用
```javascript
function hello() {
console.log("hello world");
}
hello();
```
声明及时调用
```javascript
(function hello() {
console.log("hello world");
})();
(function() {
console.log("hello world");
})();
```
## 对象的属性
> 对象只有属性, 当一个对象的属性的内容恰好是函数的时候, 我们把它叫做对象的方法
```javascript
var obj = {
userName: "Xujunhao",
hello: function() {
console.log("hello world");
}
};
obj.hello(); // 调用函数, 输出"hello world"
```
```javascript
var obj = {
userName: "Xujunhao",
hello: function() {
console.log("hello world");
}
};
function loveYou() {
return "I love you";
}
obj.loveYou = loveYou(); // 获取函数的返回值, 赋值给对象的属性
```
```javascript
var obj = {
userName: "Xujunhao",
hello: function() {
console.log("hello world");
}
};
function loveYou() {
return "I love you";
}
obj.loveYou = loveYou; // 把函数的整个内容, 赋值给对象的属性
console.log(obj.loveYou()); // 输出 I love you
```
## 函数进阶
> 函数的返回值, 可以是个函数
```javascript
function hello() {
return hello1;
}
function hello1() {
return hello2;
}
function hello2() {
console.log("hello world");
}
hello()()(); // "hello world"
```
# js 的一行, 和 html 的一行
> js 的一行, 可以理解成整个 js 文件
```javascript
hello(); // 输出hello world, 不会因为先调用而报错
function hello() {
console.log("hello world");
}
```
> html 的一行, 可以理解成一个标签
```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="X-UA-Compatible" content="ie=edge" />
<title>Document</title>
</head>
<body>
<script>
hello(); // 因为调用时, 没有声明hello函数, 所以报错
</script>
<script src="test2.js"></script>
</body>
</html>
```
> test2.js
```javascript
function hello() {
console.log("hello world");
}
```
# 回顾数据类型, 穿插强制类型数据转换
> 注意:js 三种引入方式, 不能混用
## typeof 操作符
typeof 操作符的作用?
> 显示数据类型
typeof 操作符, 可以返回多少类型?
1. undefined —— 如果这个值未定义；
1. boolean —— 如果这个值是布尔值；
1. string —— 如果这个值是字符串；
1. number —— 如果这个值是数值；
1. object —— 如果这个值是对象,arr,null ；
1. function —— 如果这个值是函数。
```javascript
console.log(typeof a); // undefined
console.log(typeof 123); // number
console.log(typeof "123"); // string
console.log(typeof true); // boolean
console.log(typeof false); // boolean
console.log(typeof {}); // object
function hello() {
console.log("hello");
}
console.log(typeof hello); // function
console.log(typeof hello()); // undefined, 函数没有返回值的话, typeof检测为undefined
console.log(typeof []); // array是特殊的object
console.log(typeof undefined); // undefined
console.log(typeof null); // object
```
typeof 的另一种写法
```javascript
console.log(typeof 123); // number
console.log(typeof 123); // number
```
## Undefined 类型
什么是 undefined?
> 变量未定义时返回 undefined
未赋值的变量, 默认值就是 undefined
```javascript
var a;
console.log(typeof a); // undefined
var b = undefined;
console.log(b); // undefined
```
如果未声明会怎样?
```javascript
var a;
console.log(typeof a); // undefined
var b = undefined;
console.log(typeof b); // undefined
console.log(typeof c); // undefined
```
如何区别未声明和未赋值?
```javascript
var userName = "";
var userAge = 0;
// var userObj = {};
console.log(typeof a); // string
console.log(typeof c); // undefined
```
> 初始值的目的, 第一区分未赋值和未定义, 第二监控数据的变化
## Null 类型
什么是 Null 类型
> 空对象
> 如果定义的变量准备在将来用于保存对象，那么最好将该变量初始化为 null 而不是其他值
```javascript
var userName = "";
var userAge = 18;
var userObj = null; // 对象的初始值, 建议null
console.log(Boolean(userObj)); // false
```
## Boolean 类型
什么是 Boolean 类型?
> 真或假 true or false
注意 true 和 True(python)
```javascript
console.log(typeof True); // undefined
console.log(typeof true); // boolean
```
任何其他数据类型,都可以强制类型转换到 Boolean(使用 Boolean())
1. undefined ==> boolean
1. string ==> boolean
1. number ==> boolean
1. object ==> boolean
1. function ==> boolean
```javascript
console.log(Boolean(undefined)); // false
console.log(Boolean(null)); // false
console.log(Boolean("")); // false
console.log(Boolean("hello")); // true
console.log(Boolean(0)); // false
console.log(Boolean(123)); // true
console.log(Boolean(0.0)); // false
console.log(Boolean([])); // true
console.log(Boolean({})); // true
```
不管函数有没有内容, 一律是 true
```javascript
function hello() {
console.log();
}
console.log(Boolean(hello)); // true
```
```javascript
function hello() {}
console.log(Boolean(hello)); // true
```
## Number 类型
什么是数字类型
> 整数和浮点数
> 声明数字类型时的进制问题
```javascript
console.log(123); // 123
console.log(088); // 88
console.log(070); // 56 前面有0, 代表8进制
console.log(0x70); // 112 前面有0x, 代表16进制
```
浮点数的".1"和"1."
保存浮点数值需要的内存空间是保存整数值的两倍, 所以 1.0 会转成 1
```javascript
console.log(1.1); // 1.1
console.log(1.0); // 1
console.log(0.1); // 0.1
console.log(1); // 1
```
如果是一个极小的数(科学计数法)
如果是一个极大的数呢?(科学计数法)
```javascript
console.log(0.00000000000000001); // 1e-17
console.log(0.001); // 0.001
console.log(0.0000001); // 7位会转科学计数法
console.log(1000000000000000000000000000); // 1e+27
console.log(1000000000000000000000); // 21位转科学计数法
```
浮点数的比较问题
不要比较浮点数, 容易出事儿
```javascript
// 0.1+0.2 = 0.3
console.log(0.1 + 0.2); // 0.30000000000000004
console.log(Boolean(0.1 + 0.2 == 0.3)); // false
```
数值范围问题
```javascript
console.log(Number.MAX_VALUE);
console.log(1.7976931348623157e30899); // Infinity
console.log(1.7976931348623157e30899 + 10); // Infinity
console.log(-1.7976931348623157e30899 + 10); // -Infinity
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991
console.log(9007199254740992); // 9007199254740992, 最大安全整数, 保质期
```
什么是 NaN
> 不是数字, js 解释器想要一个数字, 结果没有得到数字的时候, 就会报 NaN
> 除以 0 的问题
```javascript
console.log(1 / 0); // Infinity
console.log(-1 / 0); // -Infinity
console.log(0 / 0); // NaN
```
任何涉及 NaN 的操作（例如 NaN /10）都会返回 NaN
```javascript
console.log(NaN / 0); // NaN
console.log(NaN / NaN); // NaN
console.log(100 / 100); // 1
console.log(10 / NaN); // NaN
console.log(NaN / 10); // NaN
console.log(NaN * 0); // NaN
console.log(NaN * NaN); // NaN
console.log(10 * NaN); // NaN
console.log(NaN * 10); // NaN
console.log(Boolean(100 == 100)); // true
console.log(Boolean(NaN == NaN)); // false
```
NaN 与任何值都不相等，包括 NaN 本身
```javascript
console.log(Boolean(NaN == NaN)); // false
console.log(Boolean(NaN == 10)); // false
```
数字的强制类型转换
有 3 个函数可以把非数值转换为数值： Number() 、 parseInt() 和 parseFloat() 。
Number() 可以用于任何数据类型
另两个函数则专门用于把字符串转换成数值。这 3 个 函数对于同样的输入会有返回不同的结果。
Number()规则
```javascript
console.log(Number("123")); // 123
console.log(Number("123.00")); // 123
console.log(Number("00123")); // 123
console.log(Number("0123")); // 123
console.log(Number("123hello")); // NaN
console.log(Number([])); // 0
console.log(Number({})); // NaN
function hello() {}
console.log(Number(hello)); // NaN
```
```javascript
console.log(Number(true)); //1
console.log(Number(false)); //0
```
1. 如果是 Boolean 值， true 和 false 将分别被转换为 1 和 0。
1. 如果是数字值，只是简单的传入和返回。
1. 如果是 null 值，返回 0。
1. 如果是 undefined ，返回 NaN 。
```javascript
console.log(Number(123)); // 123
console.log(Number(null)); // 0
console.log(Number(undefined)); // NaN
console.log(Number(NaN)); // NaN
```
1. 如果是字符串，遵循下列规则：
1. 如果字符串中只包含数字（包括前面带正号或负号的情况），则将其转换为十进制数值，即 "1" 会变成 1， "123" 会变成 123，而 "011" 会变成 11（注意：前导的零被忽略了）；
1. 如果字符串中包含有效的浮点格式，如 "1.1" ，则将其转换为对应的浮点数值（同样，也会忽略前导零）；
```javascript
console.log(Number(123.333)); // 123.333
console.log(Number(0.1)); // 0.1
```
1. 如果字符串中包含有效的十六进制格式，例如 "0xf" ，则将其转换为相同大小的十进制整数值；
```javascript
console.log(Number("0xf")); // 15
console.log(Number("070")); // 70
```
1. 如果字符串是空的（不包含任何字符），则将其转换为 0；
```javascript
console.log(Number("")); // 0
```
1. 如果字符串中包含除上述格式之外的字符，则将其转换为 NaN 。
```javascript
console.log(Number(070)); // 56
console.log(070); // 56
console.log(Number("070")); // 70
console.log(Number("0x70")); // 112
console.log(Number("12.11")); // 12.11
console.log(Number("012.11")); // 12.11
```
1. 如果是对象，则调用对象的 valueOf()方法，然后依照前面的规则转换返回的值。如果转换的结果是 NaN，则调用的对象的 toString()方法，然后再次依照前面的规则转换返回的字符串值。
转整数, 推荐 parseInt()
```javascript
console.log(parseInt("0123")); // 123
console.log(parseInt("0.123")); // 0
console.log(parseInt("123hello")); // 123
```
转小数, 推荐 parseFloat()
```javascript
console.log(parseFloat("0123")); // 123
console.log(parseFloat("0.123")); // 0.123
console.log(parseFloat("123hello")); // 123
console.log(parseFloat("1.00")); // 1
```
引号与解析变量
关于转义
> 转变含义
\n 换行
```javascript
var a = "I love \n China";
// I love
// China
console.log(a);
```
\t 制表
```javascript
var a = "I love\tChina";
var b = "I love China";
console.log(a); // I love China
console.log(b); // I love China
```
\b 空格(存在兼容性问题)
\r 回车 (windows 里, \r\n 表示一个回车)
\\ 斜杠
```javascript
var a = "I love \\China";
console.log(a); // I love \China
```
\' 单引号（ ' ），在用单引号表示的字符串中使用。例如： 'He said, \'hey.\''
\" 双引号（ " ），在用双引号表示的字符串中使用。
```javascript
var a = "I love China";
var b = "I love 'China'";
var c = 'I love "China"';
var d = 'I love "China"';
console.log(a); // I love China
console.log(b); // I love 'China'
console.log(c); // I love "China"
console.log(d); // I love "China"
```
获取字符的长度
```javascript
var a = [1, 2, 3];
console.log(a.length); //3
var b = "I love China";
console.log(b.length); // 12
var b = "I love\tChina";
console.log(b.length); // 12 \t当成一个
var c = "I love 'China'";
console.log(c.length); // 14
var d = "I love 'China'";
console.log(d.length); // 14 转义当一个字符
```
转字符串
toString(), 几乎每种类型都有, 除了 null 和 undefined
```javascript
var a = 123;
console.log(typeof a.toString()); // string
console.log(a.toString()); // 123
var b = 0xff;
console.log(b.toString()); // 255
console.log(typeof b.toString()); // string
var c = 070;
console.log(c.toString()); // 56
console.log(typeof c.toString()); // string
```
```javascript
var a = null;
console.log(a.toString());
var b;
console.log(b.toString());
```
String()
1. 如果值有 toString() 方法，则调用该方法（没有参数）并返回相应的结果；
1. 如果值是 null ，则返回 "null" ；
1. 如果值是 undefined ，则返回 "undefined" 。
```javascript
var a = null;
console.log(String(a)); // null
console.log(typeof String(a)); // string
var b;
console.log(String(b)); // undefined
console.log(typeof String(b)); // string
```
第三种方法,+""
```javascript
var a = 123;
console.log(typeof (a + "")); // string
console.log(123 + "123hello"); // 123123hello
```
## Object 类型
创建对象和数组的"三种"方式
```javascript
var arr = [];
var arr1 = new Array();
var arr2 = new Array();
console.log(typeof arr); // object
console.log(typeof arr1); // object
console.log(typeof arr2); // object
var obj = {};
var obj1 = new Object();
var obj2 = new Object();
console.log(typeof obj); // object
console.log(typeof obj1); // object
console.log(typeof obj2); // object
```
# 变量作用域
什么是作用域
> 变量的势力范围
某个执行环境中的所有代码执行完毕后，该环境被销毁，保存在其中的所有变量和函数定义也随之销毁
```javascript
var a;
function hello() {
a = "hello";
}
hello();
console.log(a);
```
var 声明局部变量
- 每日单词
- JavaScript 入门
- JavaScript 基础
- JavaScript 基础回顾
- JavaScript 函数
- 匿名函数,多维数组,数据类型转换
- JavaScript 类型转换, 变量作用域
- js 运算符(一)
- js 运算符(二)
- js 流程控制语句
- JavaScript 扫盲日
- JavaScript 牛刀小试(一)
- JavaScript 牛刀小试(二)
- JavaScript 再谈函数
- JavaScript-BOM
- JavaScript-定时器(一)
- JavaScript-定时器(二)
- 番外-轮播图源码
- JavaScript 轮播图和 DOM 简介
- JavaScript-DOM 基础-NODE 接口-属性
- JavaScript-DOM 基础-NODE 接口-方法
- NodeList-接口-HTMLCollection-接口
- Document 节点
- CSS 复习与扩展(一)
- CSS 复习与扩展(二)
- 走进 jQuery 的世界
- 使用 jquery
- 使用 jquery-2
- jquery 中高级
- jquery 备忘清单-1
- jquery 备忘清单-2
- 聊聊 json
- jquery 备忘清单-3