[toc]
# 每日单词
1. `property` 属性
1. `defer` 延迟
1. `instance` 实例
# 聊聊昨天的作业(九九乘法表)
```javascript
var array = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var content = "";
for (var index = 0; index < array.length; index++) {
var element = array[index];
var num = 1;
while (num <= element) {
content += element;
content += "*";
content += num;
content += "=";
content += element * num;
content += " ";
num++;
}
console.log(content);
content = "";
}
```
```javascript
for (var i = 1; i <= 9; i++) {
var content = "";
for (var j = 1; j <= i; j++) {
content += i;
content += "*";
content += j;
content += "=";
content += i * j;
if (i != j) {
content += " ";
}
}
console.log(content);
}
```
# 为什么说, js 的引入位置, 会导致问题?
```html
<html>
<head> </head>
<body>
<h1 id="myHeader"><b>这是标题</b></h1>
<p>打开网页会自动弹出标题的HTML代码</p>
<script src="main.js"></script>
</body>
</html>
```
> main.js
```javascript
window.onload = function() {
var x = window.document.getElementById("myHeader");
alert(x.innerHTML);
};
```
## 解决方案一
`defer`
```javascript
<html>
<head>
<script defer="defer" src="main.js" />
</head>
<body>
<h1 id="myHead">
<b>这是一个一级标题</b>
</h1>
<p>当进入页面时, 标题的html代码会弹出</p>
</body>
</html>
```
## 解决方案二
`window.onload`
> main.js
```javascript
window.onload = function() {
var x = window.document.getElementById("myHeader");
alert(x.innerHTML);
};
```
## 顺便再提一下 window 的兼容性问题
> 什么叫兼容性?
同为将网页`加入收藏`
- IE 浏览器: `window.external.AddFavorite(url,title);`
- FireFox 浏览器: `window.sidebar.addPanel(title, url, "");`
# 声明变量名时, 应该避免关键字,保留字
## 什么是关键字?
> 可用于表示控制语句的开始或结束，或者用于执行特定操作等。按照规则，关键字也是语言保留的，不能用作标识符
```
break do instanceof typeof
case else new var
catch finally return void
continue for switch while
debugger* function this with
default if throw
delete in try
```
## 什么是保留字?
```
abstract enum int short
boolean export interface static
byte extends long super
char final native synchronized
class float package throws
const goto private transient
debugger implements protected volatile
double import public
```
## 如何判断关键字,保留字?
1. 会变成红色
1. 会报错
## 只是避免关键字就可以了?
- 一切有冲突可能性的, 都要避免
## 如何避免内置函数?
- 加小括号, 变蓝色
> 根本原则: 不能冲突, ECMAScript 用过的, 你不要再用
# 为什么一个数字和 infinity 取模, 结果还是这个数字本身?
```javascript
console.log(25 % 6); // 1
console.log(25 - parseInt(25 / 6) * 6); //1
console.log(25 - parseInt(25 / Infinity) * Infinity); //25
console.log(25 / Infinity); // 0
console.log(0 * Infinity);
```
一般满足这些性质，这里 a 是有限的实数(123)
`a+Infinity=Infinity`
`a-Infinity=-Infinity`
`Infinity+Infinity=Infinity`
`Infinity*Infinity=Infinity`
`a/Infinity=0`
`a<Infinity`
`a>-Infinity`
`a>0 时 a*Infinity=Infinity`
`a<0 时 a*Infinity=-Infinity`
而 `Infinity-Infinity`、`0*Infinity`、`0/0`、`Infinity/Infinity` 之类的运算一般会返回 NaN（Not a Number）或者-NaN。
```javascript
console.log(26 % 5); // 1
console.log(26 - parseInt(26 / 5) * 5); //1
console.log(26 - parseInt(26 / Infinity) * Infinity); // NaN
console.log(parseInt(26 / Infinity)); // 0
console.log(0 * Infinity); // NaN
console.log(26 % Infinity); // 26
```
# var 声明的是局部变量
> var 操作符定义的变量将成为定义该变量的作用域中的局部变量。也就是说，
> 如果在函数中使用 var 定义一个变量，那么这个变量在函数退出后就会被销毁
- 如果没有 var, 隐式声明全局变量
- 如果在当前作用域中找不到变量, 会逐级往上找
- 函数内的变量, 函数外不能用, 函数外的变量, 函数里可以用
```javascript
function test() {
var message = "hi"; // 局部变量
}
test();
console.log(message); // 错误！
```
```javascript
var var01 = 1;
function funtest() {
console.log(var01);
var var01 = 0;
}
// function funtest() {
// var var01;
// console.log(var01);
// var01 = 0;
// }
funtest();
```
```javascript
var data = 10;
function fn1() {
var data = 100;
console.log(data);
fn2();
console.log(data);
function fn2() {
data = 1000;
fn3();
function fn3() {
data = 10000;
}
}
}
fn1();
console.log(data);
```
```javascript
function fn1() {
data = 100;
console.log(data); // 100
fn2();
console.log(data); // 10000
function fn2() {
data = 1000;
fn3();
function fn3() {
data = 10000;
}
}
}
fn1();
console.log(data); // 10000
```
# 一次声明多个变量, 能否换行?
```javascript
var a = 1,
b = 2,
c = 3;
console.log(a);
console.log(b);
console.log(c);
```
# 为什么`[1,2,3]`使用`toString`会返回`1,2,3`?
```javascript
var arr = [1, 2, 3, 4];
var arr1 = [];
console.log(arr.toString()); // "1,2,3,4"
console.log(arr1.toString()); // ""
```
```javascript
var arr = [1, 2, 3, 4, 5];
var arr_string = "";
for (var index = 0; index < arr.length; index++) {
var element = arr[index];
arr_string += element;
if (index < arr.length - 1) {
arr_string += ",";
}
}
console.log(arr_string);
```
> 如果是空数组...
```javascript
var arr = [];
var arr_string = "";
for (var index = 0; index < arr.length; index++) {
var element = arr[index];
arr_string += element;
if (index < arr.length - 1) {
arr_string += ",";
}
}
console.log(arr_string);
```
# undefined
1. Undefined 类型只有一个值，即特殊的 undefined 。在使用 var 声明变量但未对其加以初始化时， 这个变量的值就是 undefined
1. 可以使用 undefined 值显式初始化了变量 。但我们没有必要这么做，因为未经初始化的值默认就会取得 undefined 值
1. ECMA-262 第 3 版之前的版本中并没有规定这个值。第 3 版引入这个值是为了正式区分空对象指针与未经初始化的变量
# 再谈 NaN
> NaN ，即非数值（Not a Number）是一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）。在其他编程语言中，任何数值除以 0 都会导致错误， 从而停止代码执行。但在 ECMAScript 中，0 除以 0 会返回 NaN，因此不会影响其他代码的执行。
- NaN 本身有两个非同寻常的特点。首先，任何涉及 NaN 的操作（例如 NaN /10）都会返回 NaN ，这个特点在多步计算中有可能导致问题。
- 其次， NaN 与任何值都不相等，包括 NaN 本身。
# 单双引号问题(php)
```php
<?php
$a = "my";
echo "hello{$a}world";
echo "\n";
echo 'hello $a world';
```
# 基本类型和引用类型
变量有两种不同的数据类型：基本类型，引用类型。 1.基本类型
基本的数据类型有：`undefined，boolean，number，string，null`.基本类型的访问是按值访问的，就是说你可以操作保存在变量中的实际的值。
- 值不可变
```javascript
var a = 123;
var b = a;
a = 345;
console.log(b); // 123
```
```javascript
var a = "hello";
console.log(a.toUpperCase()); //HELLO
console.log(a); //hello
var b = 123;
console.log(b.toString()); // "123"
console.log(b); // 123
console.log(typeof b); // number
```
除了上面的基本类型(number,string,boolean,null,undefined)之外就是引用类型了，也可以说是就是对象了。对象是属性和方法的集合。
也就是说引用类型可以拥有属性和方法，属性又可以包含基本类型和引用类型
- 值可变
```javascript
var obj = { sex: "male" };
console.log(obj.sex.toUpperCase()); // "MALE"
console.log(obj.sex); // male
obj.addr = "zhengzhou";
console.log(obj.addr); // "zhengzhou"
console.log(obj); // { sex: 'male', addr: 'zhengzhou' }
```
```javascript
var obj = { sex: "male", obj1: {} };
obj.obj1.addr = "zhengzhou";
console.log(obj); // { sex: "male", obj1: { addr: 'zhengzhou' } }
```
```javascript
var obj = { sex: "male", obj1: {} };
obj.obj1.addr = "zhengzhou";
console.log(obj); // { sex: "male", obj1: { addr: 'zhengzhou' } }
console.log(obj.sex.toUpperCase()); // MALE
console.log(obj); //{ sex: "male", obj1: { addr: 'zhengzhou' } }
```
## 函数传参, 按值传递 ,按引用传递
```javascript
var a = 123;
function addNum(a) {
a += 123;
return a;
}
var res = addNum(a);
console.log(res); // 246
console.log(a); // 123
```
```javascript
var a = 123;
function changeNum(b) {
b++;
}
changeNum(a);
console.log(a);
var obj = { sex: "female" };
function changeObj(a) {
a.age = 123;
}
changeObj(obj);
console.log(obj);
```
```javascript
var a = { age: 17 };
function addAge(a) {
a.age++;
return a.age;
}
var res = addAge(a);
console.log(res); // 18
console.log(a); // { age: 18 }
```
# arguments 问题, 函数的参数个数问题
ECMAScript 函数不介意传递进来多少个参数，也不在乎传进来参数是什么数据类型。也就是说，即便你定义的函数只接收两个参数，在调用这个函数时也未必一定要传递两个参数。可以传递一个、三个甚至不传递参数，而解析器永远不会有什么怨言。之所以会这样，原因是 ECMAScript 中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组，而不关心数组中包含哪些参数（如果有参数的话）。如果这个数组中不包含任何元素，无所谓；如果包含多个元素，也没有问题。实际上，在函数体内可以通过 arguments 对象来访问这个参数数组，从而获取传递给函数的每一个参数。
其实， arguments 对象只是与数组类似（它并不是 Array 的实例），因为可以使用方括号语法访问它的每一个元素（即第一个元素是 arguments[0] ，第二个元素是 argumetns[1] ，以此类推），使用 length 属性来确定传递进来多少个参数。
```javascript
function getNewSum() {
var sum = 0;
for (var index = 0; index < arguments.length; index++) {
sum += arguments[index];
}
return sum;
}
console.log(getNewSum(1, 2, 3, 4, 5, 6, 7)); // 28
```
# typeof 的局限
> typeof 是非常得力的助手，但在检测引用类型的值时，这个操作符的用处不大。通常，我们并不是想知道某个值是对象，而是想知道它是什么类型的对象
```javascript
console.log([] instanceof Array);
console.log({} instanceof Object);
function hello() {}
console.log(hello instanceof Function);
console.log(123 instanceof Number);
```
```javascript
console.log(typeof null); // object
console.log(typeof []); // object
console.log(typeof {}); // object
console.log([] instanceof Array); // true
console.log({} instanceof Object); // true
function hello() {}
console.log(hello instanceof Function); // true
console.log(123 instanceof Number); // false
```
- 每日单词
- 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