再去某个网页拷贝多行代码到script部分
用双重瓜括号括起来，去调用
{{personObj.name}}
vue官网： https://cn.vuejs.org/v2/guide/
_这节内容，我在hellojs的index.html文件尝试了，并成功了，但当前还不懂。完全照搬而已。_
## 四、理解一下，如何拉老师项目的更新
//以下操作在终端进行，我是cmd，需要进入到项目目录下
//配置remote数据源，仅配置一次即可，后面每次不用再配
> git remote add upstream xxxx
//切换至master分支下，我好像不用，因为总是在这个分支
> git checkout master
//取上游数据
> git fetch upstream
//进行主节点与上游节点数据的合并，如果我本地没有更新，则不用吧？
> git merge upstream/master
//假如我确实需要提交，则git push origin master即可，当然我在此之前需要git add 和git commit才行
我的疑问是：为啥不是git pull？
度娘答：
> 将远程存储库中的更改合并到当前分支中。在默认模式下，git pull是git fetch后跟git merge FETCH_HEAD的缩写。
> 更准确地说，git pull使用给定的参数运行git fetch，并调用git merge将检索到的分支头合并到当前分支中。 使用--rebase，它运行git rebase而不是git merge。
================================================
FILE: homework/lesson4/panyong.md
================================================
# 第四节课 小结
首先，谢谢老师，第四节课本应8月24日就关闭，没想到8月27日竟然还可以看到。也发现之前听过一次的内容，竟然全忘了，就算去看PPT也回忆不起讲的内容了。于是，拿起手机边听课，边用电脑做文字笔记。再次听课，收获很大。
这堂课，最大的收获是，通过案例“厨房办一桌酒席工作流程”，理解了编程的思路，这个思路对实际问题到代码的转换有指导意义。
笑来老师说教是最好的学，想象自己将要讲课时，去听课，又体会到了新的收获，发现老师教的非常好。老师教函数时：
1）先聊，实际生活场景中的“调用”：买可乐，理发，打印。
2）再聊，代码中函数的定义与调用：非常简单。
3）最后，演示了实际生活场景到程序代码的映射：报数，厨房办一桌酒席。
一切都变得简单、自然。蕴含的编程思路对解决实际问题有指导意义。不像一般的将函数的课程，就只有语法知识，没有解决问题的编程思路，听了也就只是听了，对运用没有指导意义。
下面是老师课程的教学流程：
## 初学git终端命令使用注意事项
先ls或pwd，知道当前在哪里，确保进入到自己的工作目录。（知道自己在哪儿，知道自己去哪儿，然后再开始工作）
## 函数(function)
### 1、生活中的“调用”讨论
```
我要买瓶可乐。我要理发。我要打印。
“调用”的关键点：
1）明确目标（如：理发）。
2）给予目标必要信息（如：发型要求）。
3）目标处理返回结果。
```
### 2、函数的定义与调用
```
//定义
function counter (num){
num++;
return num;
}
//调用(执行)函数
counter(num);
```
### 3、生活场景映射到代码的思路
#### 报数 - 轮流
```
报数规则：
1）从左往右，轮流报数
2）我说“开始”，执行报数。
映射到代码：
1）报数代码
function personC()
{
console.log('3');
}
2)我说“开始”，执行轮流报数
function startSoundOff(){
personA();personB();personC();......
}
```
#### 报数 - 通知
```
规则：第一个开始报数，第一个报数后通知下一个报数。
映射到代码：
function personB()
{
console.log('2');
personC();
}
function personA()
{
console.log('1');
personB();
}
function startSoundOff(){
personA();
}
```
### 4、厨房的工作流程：办一桌酒席
```
//准备工作
function prepare() {
console.log('磨刀。。。扫地。。。洗碗。。。劳动最光荣！');
return true; //返回值的方式，告诉调用者，我准备工作完成状态。
}
//买菜
function bugFoods() {
console.log('去买菜...');
var foodsList=['egg','fish','meat'];
return foodsList; //买完菜了，返回菜
}
//做菜
function cooking(foodsList) {
console.log('开始做菜');
console.log(foodsList);
var list = ['西红柿炒蛋','红烧肉'];
return list;
}
//startWorkFlow，是做一桌菜的的流程，也是编程的思路，老师讲的非常好，而且例子举的非常可口。
//老师的讲解流程是，先讲解prepare(),buyFoods()等，再在startWorkFlow()中去调用。
//其实，也可以先讲解startWorkFlow()，先理清工作流程，然后再进入到prepare(),buyFoods()等具体实现每一个函数的功能。
function startWorkFlow()
{
//准备
var result = prepare();
if (result) {
//买菜
var foodsList = buyFoods();
//做菜
var list = cooking(foodsList);
//上菜
console.log(list);
}
}
// 干活啦~~
startWorkFlow();
```
#### VUE让数据动起来
以styde/lesson2/my_personal_info_page.html为例，改变网页中的数据。
1、引入vue
```
```
2、vue的使用
```
var app = new Vue({
el: '#app',
data: {
person: xiaoming
}
})
```
vue这一部分，暂时没管，后续再研究。
#### Visual Studio Code 的用法
这要演示了插件的扩展安装(`ctrl+shift+x`)与使用(`ctrl+shift+p`)。
================================================
FILE: homework/lesson4/taobao.md
================================================
# lesson4_theFourthHomework_codingIdea
There no homework about lesson4, but I know I should and must do this.
The goal of this lecture, the prof would like to share the coding idea which is about thinkking code. The most important point is make your thinking in code. If possible, let it satrts with coding thinking and type the code later.
For the two example during the lecture, the first one, instructor gave three sample codes, and explained first two. I 100% understand those two ideas and deep meaning. However, when I saw the sample3.js code. I got one weak part understanding which is about Object and its property. Moreover, I have more deep understanding about var and defination, and I know that practice is the sole criterion for testing truth.
Then when lecture hant out the second example about prepare for one meal. The instructor point me the code thinking and I make connect with my coding before. Before this course, I studied and wrote code in University, I do not know why prof asked us write like that. Maybe I did not pay attention during the course. However, after I type the kitchen-sample.js code, and I replayed the video. I know more than before. I believe my code is more meaningful and clearly.
In conclusion, this lecture help me lots of thinking about code, and it will change my coding write style. I prefer make all logic first on paper or something then type them in code.
---
终于听到直播了，
报数的例子问题不大，对于使用对象进行报数的 sample3.js 看过后已经理解，但是更倾向于 sample1.js 和 sample2.js 的写法，当然相信 sample3.js 的写法也是会有用的，现在没有用到罢了。
做菜的例子上课听的时候，第一反映是懵逼的，后面看代码的时候发现老师的写法让很多东西进行了有效的使用而不是重复的造轮子，之前在校写的时候很多数据我都是复制粘贴，感觉简单易懂，但是面对复杂的情况下，function 使用过多会造成很多的损耗（人力，维护）。
---
1. visaul stiduo 真好用 formate 插件，还有好多插件，之前在用 Atom， 里面也有插件但是从来没用过，教授恨不得让我们用notepad 写代码。
2. 老师上课提到的 扫描没有被使用过的代码的脚本 可以推荐吗？（还不能自己Google 哪个最好）
================================================
FILE: homework/lesson4/xiaochaoge.md
================================================
# 第四课 关于函数与调用
[TOC]
## 函数有啥好的
同样是赋值语句的输出，有函数和没有函数的差异在哪？
我们看一个例子：
```
var startSoundOff = [1,2,3,4,5,6];
for (var i = 0;i < startSoundOff.length; i++){
console.log(startSoundOff[i]);
console.log(\n);
}
```
同样的，我们用函数实现这个过程：
```
function personA() {
console.log(1);
}
function personB() {
console.log(2);
}
function personC() {
console.log(3);
}
function personD() {
console.log(4);
}
function personE() {
console.log(5);
}
function startSoundOff() {
personA();
personB();
personC();
personD();
personE();
}
startSoundOff();
```
单纯来看，除了代码变长之外，没有任何改变，但是真的是这样吗？
> 现在假想一个情况出现了：**程序报错了，你该怎么办？**
对于第一段代码， for 语句循环，如果一处卡死就不执行。你不得不开始重新认真阅读你的每一个变量名、全半角符号以及判断语句，因为任何一种情况都可能出错。但是感谢现在的编辑器，报错提示会明确告诉你卡死在哪一步了，但是故障排除很困难，更可能的情况是，你修改了代码，信心满满的以为，自己的 bug 修复了。最后的结果残酷的告诉你，虽然你解决了一个旧错误，又产生了新错误。现在的代码只有三行，错了可以重新写。如果项目比较大，代码是三千行，你确定要重新写吗？
对于第二段代码，是不是每个数字输出的过程都被“分割”开了，也更容易能根据每个数字确定哪里出错了，更容易找到排出故障，正确的代码不会受到任何影响，你只需要维护和修订对应的“出错函数的区块”，是不是更方便了呢？
如果你是网站的协作者，哪个代码的再编译性、借鉴性更强呢？你会选择用谁的代码与你协作呢？
函数的除了能更快的查错以外，还有第二个特点：**调用更方便**。
同样是这两段代码，如果第一段代码在执行后的第 5000 行，我需要使用变量`startSoundOff`；
同样的情况，如果第二段代码在执行后的第 5000 行，我需要使用变量`startSoundOff`。
> 哪段代码的逻辑更容易出现问题 ？
其实使用函数的好处在于**分块**，一块一块的东西更容易去理解和消化，也更容易去维护。
## 函数自 high 玩法 —— 狠起来自己的脸都打
函数还能怎么玩？
先看看函数的结构吧
```
funcition 变量(){
赋值语句&条件判断；
}
```
这里的条件判断可以是变量本身。坏处是，搞不好，变量调用自己，进入死循环，把自己崩溃掉，用自己高效的特点狠狠的打了自己的脸。
```
var person = 1;
function startSoundOff() {
person = person + 1;
console.log(person);
startSoundOff();
}
startSoundOff();
```
结果数据溢出了，因为执行完`console.log(person)`后，会直接输出一个数字，再循环执行`startSoundOff()`，重新进入函数体再 + 1 ，再输出一个数字，再循环执行`startSoundOff()`，最后从函数体中跳不出来，直到数据崩掉。
那怎么解决呢？让函数自己判断什么时候执行结束，用 if 语句就可以了！
```
var person = 1;
function startSoundOff() {
person = person + 1;
console.log(person);
if (person < 100){
startSoundOff();
}
}
startSoundOff();
```
现在数据执行到第 100 个数字，就会停止执行啦。
## 函数高端玩法 —— 前后调用
创建一个工作流，让函数之间动起来
```
function prepare(){
console.log('磨刀--扫地--洗碗--劳动最光荣');
return true; // 返回一个值说明这件事已经干完了
}
function buyfoods(){
console.log('去买菜');
var foodsList = ['egg','meat','tomato'];
return foodsList; // 买完菜交差
}
function cooking(foodsList){
console.log('开始做菜');
console.log(foodsList);
var list = ['西红柿炒鸡蛋','红烧肉'];
return list; // 炒完菜回来交差
}
function startWorkFlow(){
var result = prepare();
if (result) {
// 如果 result = prepare 为 true ，则执行。
var foodsList2 = buyfoods();
// 如果买完菜，把菜给 foodsList2 去处理
var list = cooking(foodsList2);
// cooking是个函数，它处理的不一定是 foodsList 这个变量，也可以是foodsList2 这个变量
console.log(list);
}
}
startWorkFlow();
```
关键点我都写在注释了，但是最难理解的莫过于：
> cooking 是个函数，它处理的不一定是 foodsList 这个变量，也可以是foodsList2 这个变量。
我给你举个例子好了，还是做饭这件事，今天买的土豆和昨天买的土豆应该是不一样的，但是今天和昨天吃的菜都是炒土豆丝。我们的变量是土豆，而函数就是炒土豆丝的办法，**变量会变，但是对于确定的函数，计算的方法是不会变的。**
## vue 库
其实把各种库，当成别人写好的函数。无论是外部库还是内部的库，都是为了更好的输入、储存和处理。 vue 库也是这样的函数，用这样的函数有什么好处？
如果是赋值语句，一旦一个变量被赋值，这个变量就是确定的，除非你给它重新赋值。但是一个变量程序中又不是只被使用一次，意味着我们需要手动修改掉这个变量的所有值，还要改掉有冲突的值。能不能做到只改一个值，就能做到改掉赋值语句中所有的数值呢？
我以vue 库官方的例子来说吧
html 部分的修改
```
```
JS 部分的修改
```
new Vue({
el: '#app',
data: {
message: 'Hello Vue.js!'
}
})
```
这里例子中，如果我在`JS 部分`修改`message: 'Hello Vue.js!'`，那么`html 部分`的所有含`message`的部分都会修改，那么这如果是新生大学的客户端呢？
我作为用户登陆，相当于给一个函数赋值 ，JS 读取这个值对不对，给出我们对应的 `message` ，你看看，是不是能写出和用户交互的动态网页了呢！当然，别着急，一段段的代码就是逐步成长的脚印。
现在看看这张图，恍然大悟！
-------
小超哥 2017 年 8 月 31 日
================================================
FILE: homework/lesson5/GaoXianfeng.md
================================================
## 第五课总结
### 函数立即返回（在函数中 return 一个结果）
生活中例子映射立即返回函数：
1. 老板打电话给秘书，要求查一下明天早上最早一班从北京飞上海的飞机时间，并嘱咐秘书此事比较着急，不挂电话，马上查询航班信息，查到后将结果告诉他；
2. 秘书收到通知后，马上查询航班信息，将查询到的航班信息告诉老板；
3. 老板与秘书挂断电话。
代码事例：
```
function checkFlightSchedule() {
console.log('开始查询航班信息');
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'shanghai',
};
return scheduleInfo.start; // 立即返回函数结果
}
var startTime = checkFlightSchedule();
console.log(startTime);
```
### 回调函数(间接返回)
生活中例子映射回调函数：
1. 老板打电话给秘书，要求查一下明天早上最早一班从北京飞上海的飞机时间，并嘱咐秘书此事比较着急，不挂电话，马上查询航班信息，查到后将结果通过***微信***发送给他；
2. 秘书收到通知后，马上查询航班信息，将查询到的航班信息通过微信发送给老板；
3. 老板与秘书挂断电话。
代码事例：
```
function checkFlightSchedule(callback) { // callback 这个函数做为参数传入
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'shanghai',
};
callback(flightSchedule.startTime); // 函数内并没有通过 return 将结果直接返回
}
function callback(startTime) {
console.log(startTime);
}
checkFlightSchedule(callback); // callback 是函数结果返回通道，通过此通道获取函数最终结果
```
callback 函数 === 微信 === 间接返回信息的通道。
### 异步
生活中例子映射回调函数：
1. 老板打电话给秘书，要求查一下明天早上最早一班从北京飞上海的飞机时间，查询航班信息，查到后将结果发送给他, 挂掉电话；
2. 秘书收到通知后，查询航班信息，将查询到的航班信息通过微信发送给老板；
代码事例：
```
function checkFlightSchedule(callback) {
setTimeout(function() {
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'shanghai',
};
callback(flightSchedule.startTime);
}, 5000);
}
function callback(startTime) {
console.log(startTime);
}
checkFlightSchedule(callback); // callback 为函数结果返回通道，通过此通道获取函数最终结果
```
setTimeout(); 函数为 JS 内置函数；
运用 setTimeout() 函数模拟老板与秘书通完电话后，双方各自处理自己事情场景，5秒钟后构造 scheduleInfo 变量，并调用 callback 函数获取 startTime 值(60-67行代码)；
### 变量提升简单总结
1. 所有声明都会被提升到作用域顶端；
2. 同一个变量只能声明一次，其他声明会被忽略；
================================================
FILE: homework/lesson5/JayChen.md
================================================
### 代码分析
```Javascript
*1 function output(name){
*2 console.log(name);
*3 }
*4
*5 var name = 'Hello, JS';
*6 output(name);
```
* 第一行的name是定义output函数时设定的参数
* 第五行的name是要把 'Hello, JS'赋值给它的变量
* 第六行的name是调用output函数时喂给它的参数，在这里就是第五行赋值后的name
> 这三者在赋值后值相同，但是含义不同；第一行是在定义函数时设定的参数，是一个通用概念的参数，第五、六行的name分别是被赋值的变量和赋值后喂给函数的参数；他们可以使用同一个名称，或者第一、二行的name指代的参数名称与第五、六行的name赋值的变量名称完全不同，都是可以的。
================================================
FILE: homework/lesson5/Jaykey_Guo.md
================================================
### 基础-第五课
画顺序图，看到顺序图就能翻译出对应的代码。
分步骤来拉取数据。
------
##### 前端的工作，三者之间的关系：
> 1. 用户与HTML的交互
> 2. HTML与JS代码的交互
> 3. JS代码与服务器的交互（数据交互）
##### 函数的调用
输入什么，输出什么，不同函数实现不同的输出。对外界**参数**进行处理。
##### 切分流程，最小的可用单元
用不同的函数来完成最小的工作，组合不同的函数来完成一个较大的任务。小套路的叠加，变成一个大套路。
#### 立刻返回
```javascript
function checkFlightSchedule() {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
return scheduleInfo.start;
}
//---------------------------------------
// 调用立即函数checkFlightSchedule
var startTime = checkFlightSchedule();
console.log(startTime);
```
##### 回调（间接返回）
```javascript
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}
//---------------------------------------
function callback(startTime) {
console.log(startTime);
}
// 调用函数checkFlightSchedule，并塞一个回调函数以获取结果
checkFlightSchedule(callback);
```
通过callback作为返回通道来反馈，不是通过一个函数直接反馈，而是通过一个媒介来反馈。
*函数中的参数，和外界的参数没有关系。*
##### 异步（回调的一种方式）
```javascript
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
setTimeout(function() {
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}, 5000);
}
//---------------------------------------
function callback(startTime) {
console.log('通过反馈通道获得了信息');
console.log(startTime);
}
// 执行查询函数
checkFlightSchedule(callback);
```
对异步调用的个人理解：
```javascript
setTimeout(callback, 5000);
```
上图中的代码块中function的部分其实就是对应上面代码中callback的部分。
主函数是checkFlightSchedule(callback)，辅函数是callback(startTime)。主函数中定义了对应的参数，也调用对应的辅函数，而辅函数调用了主函数中定义的参数，来实现需要的完成功能。
两个函数之间是交叉的关系，一步一步执行。
------
搜索了之后发现，js的异步调用是由于js的单线程的性质，在调用不同地方的参数的时候会出现堵车，所以通过对应的时间控制来等待前面的数据传输，之后再执行后面的操作。
一个生活的场景转换成代码之后，中间的差距在于对应的方法和方式不同，也就是要在其中找到机器如何理解这个事情，简单的一句“你等一下，我准备好告诉你”，在js中就是异步调用的方法。
================================================
FILE: homework/lesson5/LiaoYuemin.md
================================================
## Homework of Lesson 5
### 什么是函数？
我理解的函数就是一个打包的代码块，可以重复使用。
函数的结构：函数由关键词function，函数名，参数（小括号里的变量），函数体（花括号里面的代码）构成，即：
```
function functionname(参数){
函数体
}
```
函数的三要素：参数判断，逻辑处理，返回结果
### 代码分析
```
function output(name) {
console.log(name);
}
var name = 'Hello,JS';
output(name);
```
第一行代码里面的“name”，是名为output的函数的参数。这里的参数就像我们在解方程式时候的X，Y一样，是用来表明函数的逻辑关系的变量，不是实际的值，所以是可以更改的，即为形参。 如将name改成tittle：
```
function output(tittle) {
console.log(tittle);
}
var name = 'Hello,JS';
output(name);
```
整段代码运行的结果依然是“Hello,js”。
形参的作用在于接受调用该函数时传递的参数。
但是需要注意的是，第一行的“name”和第二行里面的“name“，必须有相同的变量。如果这时候我把第二行的”name“ 改成”B“，就会提示B is undefined，代码无法执行。这时因为改成实际的值后，函数将没有可以接收实参的地方，所以在调用函数的时候不会输出实参的值。
第五行代码里面的”name“是新定义的一个变量，并把”Hello,JS“ 赋值给了它。更改赋值会影响代码最终运行的结果，如：
```
function output(name) {
console.log(name);
}
var name = 'Lesson5';
output(name);
```
实际输出的结果变为“Lesson5”了。
第六行代码里面的“name”相当于是是把name这个变量传给output 函数，相对于第一行代码中的“name”这里的“name”是一个实际代入的参数，有确定的值，是实参。
值得注意的是，第五行和第六行的“name”都是是可以更改的，但是必须保证名字一致，如把五六行的“name”改成“tittle”后：
```
function output(name) {
console.log(name);
}
var tittle = 'Hello,JS';
output(tittle);
```
输出结果依然是“Hello,JS”.
假如我将第二行的代码里面的name改成一个实际的值会发生什么呢？
```
function output(name) {
console.log(‘Lesson5’);
}
var name = 'Hello,JS';
output(name);
```
实际输出结果发生了变化，变成Lesson5了。
因为就整段代码而言，实际先执行的应该是最后一行代码，即调用函数output。当第二段代码更改后，函数内部的逻辑发生了变化，这时函数的意思是无论你传入何种参数，都会打印“Lesson5”这个结果。所以即便是第五行代码里面的变量name的赋值并没有发生变化，整段代码的运行结果也会随着函数代码的变化而变化。
### 立即返回
```
function checkFlightSchedule() {
console.log('开始查航班信息');
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
return scheduleInfo.start;
}
// 调用立即函数checkFlightSchedule
var startTime = checkFlightSchedule();
console.log(startTime);
```
立即返回，是指调用一个函数它会立即返回结果。类似于买东西时，我给你钱，你有现货（return）直接给我货，是信息的即时返回。
上面这段代码的意思是调用一个名为scheduleInfo的函数，函数直接将运行返回结果：8/23 8:00
最后两段代码也可以直接写成
> console.log(checkFlightSchedule());
输出的结果是一样的。
需要注意的是，这里的函数需要有return具体的值。如果没有return的值或者return值为空，代码最终执行的结果将是undefined。
### 间接返回
```
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}
function callback(startTime) {
console.log(startTime);
}
checkFlightSchedule(callback);
```
间接返回的意思就是，函数调用者并不是立即拿到结果。类似于买东西时，分店里没有货了，顾客说，那你用顺丰邮寄给我。这里的顺丰就是返回通道，放在上面这段代码里，就是callback这个回调函数。
把一个函数作为实参传入另一个函数内部，并在这个函数内部调用，这个被调用的函数就是回调函数。
这段代码实际运行顺序是：先运行的是最后一行，也就是调用函数checkFightSchedule.然后将callback这个函数作为实参传入函数内部，函数开始运行。先是console.log('开始查航班信息')，然后调用函数callback，并把scheduleInfo.start作为实参传入函数，即代码实际执行的是console.log(schedule.start),即'8/23 8:00'。
### 异步函数
异步是相对同步而言的，同步就是指当一个函数被调用时，它需要把函数内部所有的代码都运行完了，返回调用者需要的值后，下面的代码才能继续运行。
假如函数里面的数据运算非常庞大，同步调用就意味着调用者必须等待很长一段时间，等被调函数全部运行完下一步代码才能执行。
而异步函数就解决了同步函数导致的代码执行效率问题。它相当于是设置了一个函数返回通道，在调用函数时函数内部代码执行完毕后，通过这个通道传回相应的结果。而在函数内部代码执行的时候，调用者不需要等待，代码可以继续执行下去。
```
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
setTimeout(function() {
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}, 5000);
}
function callback(startTime) {
console.log(startTime);
}
checkFlightSchedule(callback);
```
SetTimeout，即定时器。最初看到这个代码的时候很不理解，为什么setTimeout不用定义就可以直接使用，后来查了一下资料大概知道它其实是一种内置方法，不需要声明就可以直接用。这里通过它实现了异步函数调用。
> setTimeout(code,millisec)
> 两个必须的参数：一个调用函数时需要执行的代码串，一个是执行前的等待毫秒数。
上面的代码意思是5s后再执行callback这个回调函数。我们在这段代码下面再增加一段代码，方便理解这个定时器的作用。
```
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
setTimeout(function() {
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}, 5000);
}
function callback(startTime) {
console.log(startTime);
}
checkFlightSchedule(callback);
function setOut() {
console.log('立即出发');
}
setOut();
```
整段代码运行结果如下：
> 开始查航班信息
> 立即出发
> 8/23 8:00
从结果我们可以看到在打印“开始查航班信息”之后，setTimeout中的代码并没有立即执行，而且也不是等待5秒后执行后，再执行prepare()函数。而是先执行了prepare函数，再等待5秒后再执行异步任务。
也就是说**异步任务是会在主函数运行之后再运行**的。本来按照逻辑，应该是先查航班信息，查到出发时间后再立即出发，但是因为setTimeout方法的这个特点，最后输出的结果出现了混乱。因此在用setTimeout的时候需要格外小心。
### 最近学习的感受
最近学得有点吃力。单独拆一下代码好像都懂，但是要自己写就不是一回事儿了。大概还是练习不够。
一直在赶作业，马上第七节课了，现在才在做第五节课的作业，有点担心之后能不能跟得上。
但是老师一直在说第五节就是JS最难的地方，这个搞懂了就搞定了JS，所以有时也会莫名有种自信：不就是一节课的事儿吗？
昨天单位调休，在家敲了一天代码，总算是把做菜流程捋了一遍。主要是函数里面又有函数，看着看着就懵了！下来接着看，接着敲。
在上这门课之前，我一直宣称的是和计算机无缘，对代码毫无兴趣。其实现在也算不上有了兴趣，毕竟还有很多东西没有搞明白，但是我已经坚持学了三周多了，并且现在还没有放弃的打算，这真的是一件神奇的事情。
谢谢老师和同学的陪伴！
继续加油。
================================================
FILE: homework/lesson5/LiuShengsi's homework of lesson5.md
================================================
代码第一行的name是所定义的output函数的形式参数，用来告诉计算机“我这个函数有一个参数，你可要记住了”。
第五行的name则是定义的一个名称是“name”的变量，并且这个变量被赋值为“Hello,JS”。
第六行的name是刚刚定义的“name”变量被当成是output函数要执行需要的实际参数传给了output函数。
定义函数时形参取的名字是否和后来传给函数的实际参数一样都没有关系，只要传给函数的实际参数是已经定义过的就行。
================================================
FILE: homework/lesson5/Risexie.md
================================================
# 第五节课总结
### 代码差异
```js
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
- 第一行的name表示的是`output`这个函数使用了名为name的变量，又因为这个函数的内容是输出name变量的内容。所以从整体来看，`output`函数的作用就是把输入的变量的内容输出出来。无论这个变量的名字是什么。
- 第四行的`name`是内容为“Hello,JS的“一个变量。
- 第五行的`name`是刚刚定义的变量。
```Javascript
1.function output(qwer){
2. console.log(qwer) ;
3.}
4.var qwer = 'Hello,JS';
5.output(qwer);
```
所以执行以上代码的结果，同样是输出Hello,JS。
### 数组对象
Array数组对象是JS对象中的一种，而这个对象中又内置了很多不同的方法。
###### 例如我们创建一个数组
```javascript
var colors = ['yellow','green','blue','red']
```
###### 我们可以通过不同的方法来对这个数组作不同的处理
1. 增加一个字符串"purp"
```javascript
colors.push('purp')
```
2. 删除数组中的最后一个字符串，也就是purp
```javascript
colors.pop('purp')
```
3. 删除数组中的第一个字符串，也就是yellow
```javascript
colors.shift
```
相关的方法还有很多。
### 间接回调
```javascript
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}
//---------------------------------------
function callback(startTime) {
console.log(startTime);
}
```
以上的代码，在最后要输出start，也就是飞机时间的时候。并没有直接使用`console.log`去输出内容，而是调用了一个名叫callback的函数。将这个函数作为代码传输的通道，把(scheduleInfo.start)给它，并通过这个函数，来输出里面的参数。
* 我觉得可以理解为其实就是在checkFlightSchedule，这个函数里面嵌套了callback这个函数，不知道这个理解是否有问题？
### 回调厨房工作流
##### 体现回调
在执行`startwork`函数的时候，可以看到输出的内容。字符串：“事情准备好了，我先去洗个澡”是在“采购完毕”之前输出的，但是在`startwork`函数中，明明该字符串是在函数的最后一行，怎么会先执行呢？
这其实就是回调的体现，当回调函数B嵌套在一个函数A。执行函数A时，可以先把函数A先干完，回头再调用函数B。这代表我们执行A函数的时候，不会因为需要先执行B函数，而把整个函数A给“卡死”。回到老师的例子当中，`startwork`是A函数，`buyFoods`是B函数。
##### 如何回调
```javascript
function a(callback)
{
alert("我是parent函数a！");
alert("调用回调函数");
callback(b);
}
function b(){
alert("我是回调函数b");
```
在函数中使用`callback`这个函数作为参数，并在内容中使用`callback`这就是“callback" 。
================================================
FILE: homework/lesson5/WANG Xuanding.md
================================================
# 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？
```
function output(a){
console.log(a);
}
var name='Hello,js';
output(name);
```
为了区分name我直接将function中的name改成了a。第一行function中的name是一个形式参量，可以是任何形式的字符串。output(什么)，console.log（什么）
第5.6行的name,第5行，name先是起到一个object的作用，赋予name‘hello，js’的字符串形式，第6行，output中的name，我把它理解程未知数，output这个函数是含一个未知数的多项式，（）中的东西就是这个未知数，而这个未知数的赋值是在之前var的时候进行的，而多项式的定义是function。
因此，output（name）就成了求name='Hello,js'时，求值多项式（function值）的问题。
================================================
FILE: homework/lesson5/WuGaoxing.md
================================================
1. function output(name){
2. console.log(name);
3. }
4.
5. var name = 'Hello,JS';
6. output(name);
# 代码理解
### 代码整体理解:
1-3行是一个函数 函数名是output,参数是name
5行是定义一个name变量 类型是string 并赋值 'Hello,JS'
6行是调用函数output，并给函数传入了第5行定义的name
### 代码细分解释：
1-3 行的 两个 name 只是一个标识，标识调用此函数时传入的参数，在函数体内部哪个地方调用，或者怎么使用。可以理解成一个标识。两处 只要一样就行，这里完全可以改成 QQ 等类的 名字。
5行的 name 是定义了一个变量，并赋值，第六行是使用第5行的这个变量，这两处只要一样就行。
================================================
FILE: homework/lesson5/Zhengchao.md
================================================
### JavaScript Lesson5 学习心得
#### 知识点
- css是对html的美容，用来渲染界面
- 相比同时从服务器拿完数据再显示，分步骤拿数据的方法可以较好地减轻卡顿感
- 前端交互的关注点：
用户与html的交互
html与js代码的交互
js代码与服务器的交互
- 复习函数的三要素：目标--函数名／要求--参数／结果--返回值
- 调用函数的顺序图很重要。每一个函数代表了一个功能模块，用一个调度函数将这些模块按照逻辑汇聚在一起，是我们实现大模块功能的基本思路。
- 一个函数的被调用时，完成了‘参数判断’，‘逻辑处理’，‘返回结果’这三个步骤。返回结果分以下三种做介绍：
同步，直接返回（flight_schedule_1.js）
`// 调用立即函数checkFlightSchedule`
`console.log(checkFlightSchedule());`
间接返回通道--回调(flight_schedule_2.js)
对于间接返回通道的理解，我想用以下代码来阐述：
**相比直接返回，间接返回通道的存在，让代码变得更灵活，功能也更多样**
``function checkFlightSchedule(feedbackMethod) {`
console.log('开始查询航班信息')
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
feedbackMethod(scheduleInfo.start);
`}`
`// 秘书这个函数库，不仅能提供查询信息的服务，还自带了多种返回信息方式的函数`
`function weiXin(startTime) {`
console.log('微信传来消息'+startTime);
`}`
`function duanXin(startTime) {`
console.log('短信传来消息'+startTime);
`}`
`function email(startTime) {`
console.log('邮件传来消息'+startTime);
`}`
`// 老板在调用秘书这个函数库时，需要携带信息定义好他想要的信息反馈等方式，其中可选微信，短信，邮件`
``checkFlightSchedule(duanXin);`
异步,属于回调的一种方式(flight_schedule_3.js)
`setTimeout(function() {feedbackMethod(scheduleInfo.start)},5000);`
**在回调的基础上，异步给这个返回通道增加了延时**
#### 作业 对下述代码的理解
- 对name的理解
`function output(name) {`
```markdown
//第一个name是函数output的参数（parameter），它可以任意命名,
//但必须具备可读性，比方说 name1 name2
console,log(name);
//第二个name是函数output的argument（不知道对应的中文怎么说），
//当它和第一个name同名，该函数才有意义
```
`}`
`var name = 'Hello, JS';`
`// 第三个name是一个String变量name，并赋值为'Hello, JS'`
`output(name);`
`// 是函数output的argument，即调用函数output的参数，它的value等效第三个name`
- 对kitchen_workflow_async.js异步函数的理解
**问题：省去函数命名的环节，到底是让函数更易读还是更不易呢？希望老师解答一下～**
`function F2(feast) {`
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++)
{
console.log(feast[i]);
}
`}`
`function F1(foodsList) {`
cooking(foodsList, F2);
`}`
`// 流程控制函数`
`function startWork() {`
var success = prepare();
if (!success) {
console.log('还没准备好');
return;
}
buyFoods(F1);
console.log('事情安排好了，我先去洗个澡');
`}`
`// 干活啦~~`
`startWork();`
**总共定义了6个函数，**分别是采购函数buyFoods（），准备函数prepare（），做菜函数cooking（）和流程控制函数startWork（），还有2个未命名的函数
**未命名的2个函数**分别是buyFoods（）和cooking（）的回调通道,前者用来传回foodsList数组，后者用来传回feast数组，并按照顺序打印
`function (feast) {`
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
`function (foodsList) {`
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
================================================
FILE: homework/lesson5/anjiancai.md
================================================
function output(name) {
console.log(name);
}
var name = "Hello, JS";
output(name)
阐述程序执行过程：
运行上述代码时，读到1-3行的function,放在内存暂不执行；
往下运行至第5行，从右往左开始，把字符串“Hello, JS”赋值给新变量name,这是第5行中的name作为一个新变量出现；
运行至第6行，语句为output(name)函数，此句中的name为用第5行定义的新变量name；
然后再到内存中执行第1-3行定义的output()函数，第1行中的name为函数output的形式参数；而第6行调用函数中的name为实际参数，运行是将调用函数中的实际参数赋值给定义函数的形式参数，即第6行中的name赋值给第1行的name,最后运行函数体中的语句，直到函数体运行完毕，程序结束。
================================================
FILE: homework/lesson5/baoguoqiang.md
================================================
# 懵懵懂懂的函数
## * 感悟
听了几节课的下来，讲解的全是关于函数的调用和处理手法，有些云里雾里的，有些概念暂时还未理解。看到好多同学都交了作业，自己不想落下，中间也有过想放弃的念头，觉得自己理解能力有些跟不上，问问题又不知道怎么问，看到同学们在群里都很积极活跃，也看到了云飞同学的学习热情，看到了老师分享的他的作业，一步一步分析的很是到位，觉得再不跟紧队伍就真的跟不上了，也给了我一个大大的鼓舞，虽然自己的理解还相差甚远，也阻挡不了交作业的欲望（哈哈）
## *作业
>function output(name) {
console.log(name);
}
>var name = 'Hello,JS';
>output(name);
关于上面几个"name"变量的差异：
1. function output(name)中的name是函数名下的一个参数变量；
2. console.log(name)中的name是函数内部中的一个局部变量；对于函数的内部调用有着至关重要的作用
3. var name 中的name是整个函数外部的全局变量；
4. 最后一个是调用函数所需的变量。
## *小结
以上的理解是自己早上刚好看书到那一小结，讲解了这个全局变量和局部变量，就联系到这儿了。
关于函数的异步处理方案，老师讲解的现实中的例子能理解了，就是套用函数的方式，就蒙圈了，看的那些代码环环相套的感觉，似懂非懂的。下来要多练习，多看回放，紧跟大队伍，争取不掉队。
================================================
FILE: homework/lesson5/caijinpeng.md
================================================
# 第五课作业
function output(name){ console.log(name); }
var name = ‘hello,js’; output(name);
第一行的name是一个形式上的参数， 第五行的name是一个变量，这个变量的名字叫name， 第六行的name是实际的参数，
第二行的打印name，就是第一行传入第六行实际的参数name的值，值是第五行变量的hello js。
================================================
FILE: homework/lesson5/caozhen.md
================================================
# 函数的定义与使用
## 函数的定义
```javascript
function output(name) {
console.log(name);
}
```
上面是一个程序开发者对函数**output**的定义：
* 第一个name表示该函数有一个输入参数。
* 第二个name表示该函数的功能是打印出输入的参数。
## 函数的使用
老师课上强调：
> 函数定义了就要使用，否则就是垃圾函数
```javascript
var name = 'xiaoming';
output(name);
```
上面的代码块正是在使用之前定义的函数**output**:
* 第一个name是声明的变量，并将其定义为字符串‘xiaoming’
* 第二个name即函数在使用时，将上一行声明并定义的变量name传入。
## 对课堂上高频问题的思考
老师在讲到此处时，有些同学表示不能理解这四行代码，主要应该是下面这个高频问题：
### 4个name，到底有什么区别？我们懵了。
#### 首先，也是最重要的一点，冷静下来，把4行代码拆成两部分，分别去理解：
* 前两行是**定义**一个函数output
* 后两行是**使用**这个函数output
#### 其次，先看看前两行，定义一个函数（或者说声明一个函数）
* 为什么需要函数定义？是为了告诉计算机（V8引擎）或者其它程序员：
* 函数有几个参数？
* 函数实现什么功能？
* 函数返回什么结果？
* 等等...
* 函数定义是谁的工作？是程序员，设计函数的程序员的工作
* 因此，程序员定义函数时所用到的变量，他爱叫什么就叫什么
* 即name只是一个名词而已，可以把它替换成任意其它名词，比如：
```javascript
function output(inputParameter) {
console.log(inputParameter);
}
```
#### 上面谈到，这个变量爱叫什么就叫什么，它不重要，那什么是重要的呢？
* 定义函数时，以下几个内容很重要：
* 有没有输入参数？
* 如果有参数，有几个参数？
* 如果有参数，这几个参数类型是什么？
* 如果有参数，这几个参数在函数中有什么用？
#### 上面这些真正重要的，需要我们关注的内容，是怎么反映出来的呢？
* 以上几个内容，是通过定义函数时，参数的呈现形式反映出来的。比如以下几个例子：
```javascript
// 没有输入参数
function output1() {
console.log('这个函数没有输入参数');
}
// 一个输入参数，以及它在函数中的用处
function output2(inputParameter1) {
console.log('这个函数有一个输入参数,内容是:' + inputParameter1);
}
// 两个输入参数，以及它们在函数中的用处
function output3(input1，input2) {
console.log('两个输入参数，我们把它们直接连接起来吧: ' + input1 + input2);
}
```
* 因此我们总结，定义函数时，参数的名字不重要，但参数在函数定义中的存在形式很重要。
* 函数定义（声明）中使用的参数，行话称之为**形式参数**，简称形参。
#### 随后，我们来看后两行，函数的使用
* 函数定义了就要使用，定义了不使用就是垃圾函数，那么问题来了，怎么使用？
* 函数的使用方式应该与定义一致，大白话就是：定义了几个参数（形式参数），使用时就应该是几个；
* 因此，output这个函数应该这么用
* 使用时，传入一个参数
* 函数功能是把这个参数在屏幕上打印出来
* 以下展示了几种用法
```javascript
// 用法1
output('xiaoming');
// 用法2
var myName = 'xiaoming';
output(myName);
```
================================================
FILE: homework/lesson5/chenguoqiang.md
================================================
# Lesson5作业Name的区别
函数的定义：
> 说简单点就是“代码块”，具有可重复性。
函数的语法：
> 函数就是包裹在花括号中的代码块，前面是了关键词：function。
>
> 当调用函数时，会执行函数内的代码。
>
> 提示：对大小敏感。关键词function必须小写，并且必须以与函数名称相同的大小写来调用函数。
调用带参数的函数：
> 在调用函数时，您可以向其传递值，这些值被称为参数。
>
> 这些参数可以在函数中使用。
>
> 您可以发送任意多的参数，由逗号(,)分隔。myFunction(argument1,argument2)
>
> 当您声明函数时，请把参数作为变量来声明：
通过上面的概念，我们清楚的知道了，图片第一行的“name”是参数，它也是一个变量，是output这个函数的参数，是用来表面函数逻辑关系的变量，不是实际的值，所以是可以更改的，即为形参。
第五行的name，是新定义的变量，跟上的函数变量没有任何关系，并给它赋值“hello，js’，更改赋值会影响最后的输出结果。
第六行的name，是相当于把第五行name的变量值传递给output函数，相对于第一行的name，这里的name是被赋值的参数，也被称为实参。第五行和第六行的“name”都是可以更改，但是必须保持一致。
================================================
FILE: homework/lesson5/chenrushan.md
================================================
# lesson5 homework
## 几个`name`之间的差异
```js
function output(name){
console.log(name)；
}
var name = ‘Hello，JS’；
output(name);
```
- 第1行的name：是函数output的形参，函数被调用时，会新建一个局部变量name，便把实参的值赋给这个局部变量。
- 第2行的name：函数output接收到的参数值。
- 第5行的name：全局变量name。
- 第6行的name：传给函数output的实参。执行函数时，在当前作用域找到全局变量name，将它的值赋给函数里的局部变量name。
---
## 异步实现kitchen_workflow
### 用`setTimeout(callback, timeout)`模拟延迟
把原本直接return一个值，改成，作为参数传入回调函数。
再用匿名函数`function(){}`把函数体包裹起来，成为setTimeout的callback参数。
```js
function buyFoods(callback){
setTimeout(function(){
// code for buyFoods;
callback(foodList);
}, 3000);
}
```
```js
function cooking(foodList, callback){
setTimeout(function(){
// code for cooking;
callback(feast);
}, 5000);
}
```
Question: 产生疑问，为什么prepare函数不用改成异步呢？
它最后返回的是布尔值，在主控制函数里进行判断，好像都不是其他函数需要的参数。
没想明白...
### 主控制函数startWork
- 先调用`prepare()`, 条件判断产生分岔路:
- 岔路(!success)，没准备好，直接return（起初没写return，函数继续执行❌）；
- 岔路(success)，依次执行buyFoods、cooking。(难点)
难点部分，老师是直接嵌套写:
```js
// 徐帅版
buyFoods(function(foodsList) {
cooking(foodsList, function(feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
```
#### 下面是小白的曲折探索
小白看着有点蒙，小白是想这样写的：
```js
// 小白第一版
function callback (feast){
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
}
let foodList = buyFoods (cooking);
cooking (foodList, callback);
```
结果当然是报错了：`foodList`是`undefined`，传给`cooking`的`callback(feast)` `is not a function`。
问题出在倒数的两行，再改：
```js
// 小白第二版
buyFoods(cooking(foodList, callback));
```
结果当然还是报错了：`foodList is not defined`。`cooking(foodList, callback)`明显也不是个函数。
怎么把foodList作为参数传给cooking...想起上面setTimeout的第一个参数callback，整个匿名函数把cooking包起来，括号参数foodList。
```js
// 小白第三版
buyFoods(function(foodList){
cooking(foodList, callback)
});
```
最后，把callback塞进去。ohhh，跟老师写的一样了。
#### 一点小改动
老师的`console.log('事情安排好了，我先去洗个澡');`是放在`buyFoods(function(foodList){…});`后面的。
执行的时候会出现，去洗澡这句，穿插在了采购食物之间。
```
…
我要开始采购食物啦。。。。
事情安排好了，我先去洗个澡
采购完毕
…
```
我想，是`buyFoods`里有异步代码，里面延迟时，就会先执行与`buyFoods`同一层级的同步代码。
我觉得应该是做完菜才去洗澡，所以想这样改，把洗澡改到`function(feast){}`函数体的最后，也就是打印完菜单就去洗澡。
```js
buyFoods(function(foodsList) {
cooking(foodsList, function(feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
console.log('事情安排好了，我先去洗个澡');// 我想改到这里
});
});
// console.log('事情安排好了，我先去洗个澡'); 老师是写在这里
```
================================================
FILE: homework/lesson5/chenyanxing.md
================================================
分析代码
下面代码中，第1行、第4行、第5行的name变量的差异：
function output(name) { // 定义函数output，output接收一个函数类型的参数name，当执行完动作之后，调用该函数。
console.log(name);
}
var name = 'Hello,JS'; // 定义函数变量name,并且赋值'Hello,JS'
output(name); // 调用函数output，并把函数name当参数传过去
观察代码
1.type_array
数组的样式：['中括号内容并排'];
遍历数据：挨个数组元素查一遍
for (循环开始的初始化变量 var i = 0; 循环条件 i < myLikeColorList.length; 计数器变量更新 i++) {
console.log(myLikeColorsList[i]);
}
2.type_boolean_sample.js
var student = false;
//虽然student是一个boolean类型的变量，但可以调用toString()方法，并输出string类型的值。
console.log(student.toString());
toString() 方法可把一个逻辑值转换为字符串，并返回结果。
返回值：根据原始布尔值或者 booleanObject 对象的值返回字符串 "true" 或 "false"。
3.type_number
https://ws1.sinaimg.cn/large/006tNc79gy1fj3b745f8dj30n307gwfq.jpg
把Number对象转换成字符串，并返回此字符串。
从上图得到的结果可以看出，第一行打印出了 number 类型的变量值，第二行打印出了 number 变量转化成 string 类型后的变量值。
4.type_object
从例子看出，数据类型为对象的变量支持修改、增加和删除对象内变量，同时还支持函数变量。
https://ws2.sinaimg.cn/large/006tNc79gy1fj3brp9ufuj30ei0jdgod.jpg
再一次打印config时，内嵌的run函数变量只是显示 run: [Function] ，赋值的函数表达式不用打印出来❓
{ height: 170,
weight: 120,
sex: 'woman',
bloodType: 'A',
run: [Function] }
5.type_string
https://ws1.sinaimg.cn/large/006tNc79gy1fj3c1r54lej30c00kywgc.jpg
从上图可以看出，根据游标访问字符串的单个字符和通过字符串的长度属性循环访问单个字符，的打印结果虽然是一样的，但是用途却不同。前者更适合调用name的单个字符，而后者是循环访问单个字符。
通过游标切割字符串：
console.log(name.substring(0, 4));
定义与用法：substring() 方法用于提取字符串中介于两个指定下标之间的字符。
注意：语法
stringObject.substring(start,stop)
参数 描述
start 必需。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的位置。
stop 可选。一个非负的整数，比要提取的子串的最后一个字符在 stringObject 中的位置多 1。如果省略该参数，那么返回的子串会一直到字符串的结尾。
说明：substring() 方法返回的子串包括 start 处的字符，但不包括 stop 处的字符。
如果参数 start 与 stop 相等，那么该方法返回的就是一个空串（即长度为 0 的字符串）。如果 start 比 stop 大，那么该方法在提取子串之前会先交换这两个参数。
提示：substring() 不接受负的参数。
indirect_call（最简单的间接返回）
https://ws3.sinaimg.cn/large/006tKfTcgy1fj4f9d10z3j30el0a3wfw.jpg
从上图可以看出，前面function定义的函数都是存到内存去的，执行第14行run(callback);先调用函数run，再间接返回调用callback。
async_function（最简单模拟异步的技巧）
从上图可以看到，使用了setTimeout这个内置的方法，我们可以直接调用它，作用是模拟延时的一种实际场景，第一个参数：callback被调用的代码，第二个参数：时间，5秒。待5秒之后，调用函数callback的结果就打印出来了。
flight_schedule_1（立即返回案例）
https://ws4.sinaimg.cn/large/006tKfTcgy1fj4gawufptj30n60j93zt.jpg
https://ws2.sinaimg.cn/large/006tKfTcgy1fj4g0rjfqwj30b70eo0ug.jpg
老板不挂电话，秘书直接查起飞时间告诉老板。调用立即函数checkFlightSchedule，return一个结果。
flight_schedule_2（间接返回案例）
https://ws1.sinaimg.cn/large/006tKfTcgy1fj4gpu7r9vj30mp0ipabk.jpg
https://ws2.sinaimg.cn/large/006tKfTcgy1fj4hv63x66j30dq0hnju3.jpg
调用函数checkFlightSchedule，通过回调执行callback函数输出航班时间信息。
一开始对定义函数callback那里是有疑问的，为什么又设置了一个变量startTime❓通过老师举的例子，明白了这里函数定义的变量和上面传进去的变量是截然不同的，但值是一样的，scheduleInfo.start把值赋值给了startTime，就算startTime的函数名不同也是可以执行的。老师，这样理解对么？
flight_schedule_3（异步处理案例）
https://ws3.sinaimg.cn/large/006tKfTcgy1fj4zzcnp0vj30k80iw3zp.jpg
https://ws1.sinaimg.cn/large/006tKfTcgy1fj502oazmrj30bi0gsjtj.jpg
从上图可以看出，与上个例子间接返回不用的是老板在调结果的时候，直接安插一个回调的通道，秘书处理完后直接通过通道告诉老板结果，这里使用了setTimeout来模拟这样一个异步情景。
kitchen_workflow_async（异步实现一桌酒席）
可以看到顺序图的强大，老师墙裂推荐把流程用时序图的方式画出来。不止是后面的课程会大量用到，甚至是以后的工作中都会经常用到，get新技能。
让我深刻的是，写函数的步骤其实就类似我们的生活，做事的流程一步一步转化成为代码，我想编程的意义大概就是把我们所想的东西，去学习去掌握怎么结合具体的语法，把它实现出来。
https://ws4.sinaimg.cn/large/006tKfTcgy1fj50hqar7ej30kd0ivwgj.jpg
https://ws3.sinaimg.cn/large/006tNc79gy1fj5espqijoj30ih0zkjtf.jpg
一开始我的思绪是混乱的，觉得老师的顺序打印出来怪怪的，跟组员交流之后，发现是我想错了，没搞懂流程的顺序。理了下思路之后，有恍然大悟的感觉。
厨房做菜流程这里我们首先要学会把任务拆解，把流程分几步，把步分好，前面把函数prepare()、buyFoods()、cooking()给定义好，最后在startWork()函数，我们只需要调这个调那个，把事情搞定就是这样。
分析函数变量【表达式函数定义法】——在 startWork()里用了两层（参考lipeng同学作业）
第一层，买菜，调buyFoods()的时候
buyFoods(function(foodsList) {
cooking(foodsList, function(feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
这里function(){} 当成 buyFood 的回调函数变量:
buyFood(function() {});
给回调函数添加参数 foodList, 目的要把foodList传到下一流程:
buyFood(function(foodList) {});
最后，把买完菜之后要执行的代码，也就是做菜函数，cooking() ， 放在{}花括号里：可以看到，cooking() , 有两个参数，也就是foodList和 回调函数变量。
第二层，做菜，cooking()的回调函数变量
把function(){} 当成 cooking() 的回调函数变量:
cooking(foodList, function(){});
给cooking的回调函数添加参数 feast, 目的要把feast传到下一流程:
cooking(foodsList, function (feast) {});
然后把做好菜之后要执行的代码，也就是console.log('----酒席准备好了----') 和做好的菜式，放在{}花括号里:
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
最后，把第二层构建的做菜代码，放在买菜回调函数花括号里{}
从这样：
buyFood(function(foodList){
cooking(foodList, function(){});
});
变成这样：
buyFoods(function (foodsList) {
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
总结
回调的基本格式：
function caller(callback) {
// do something
var data = XXX;
// pass data to callee
callback(data);
}
function callee(data) {
// do following thing
}
caller(callee);
================================================
FILE: homework/lesson5/chenziwen.md
================================================
# 【第五节课作业】分析代码
作题日期：2017年9月10日
## 【作业题目】
1. 阅读study/lesson5的sample代码，并执行观察结果。
2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
---------
## 【变量差异分析】
1. 第5行的变量name是声明并定义赋值为'Hello,JS';
1. 第6行的变量name是函数output()调用时把函数外部的变量name传递给函数内部;
1. 第1行的变量name是函数接收传递到函数所用的变量;
1. 第5行与第6行的变量是同一个变量,是函数外部定义的变量;
1. 第1行的变量是函数内部的变量;
1. 第1、5、6行的name变量的值是相等的。
**项目目录：study/lesson5 中带有"sample"单词的JS文件共有5个，分别是：**
+ ### [`type_array_sample.js`](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson5/type_array_sample.js) //数组类型变量示例
+ 代码理解：
+ 首行给出Array数组对象的参考链接；
+ 声明定义数组变量`myLikeColorsList`并赋值；
+ 输出打印`myLikeColorsList`，结果：`[ 'blue', 'green', 'black', 'write' ]`;
+ 举例"遍历"数据,使用for语句,第循环一次打印一个当前数组元素;我理解这部分是展示获取值的方法;
+ 最后分部展示操作数组对象的4个方法:
+ .push('red');增加一个元素`'red'`到数组末尾;结果:`[ 'blue', 'green', 'black', 'write', 'red' ]`
+ .pop();删除数组末尾的元素;结果:`[ 'blue', 'green', 'black', 'write' ]`
+ .shift();删除数组最前面的元素;结果:`[ 'green', 'black', 'write' ]`
+ .indexOf('black');找到某个元素在数组中的索引(游标);结果:`1`;//用于定位指定元素方便操作
+ ### [`type_boolean_sample.js`](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson5/type_boolean_sample.js)//布尔值类型变量示例
+ 定义一个布尔值变量`student`并输出打印,输出过程调用toString()方法.
+ >toString() 方法可把一个逻辑值转换为字符串，并返回（字符串）结果。
+ 测试：删除toString() 方法后输出报错，看来console.log()只能输出字符串，调用console.log()方法必须确保参数类型是字符串类型
+ ### [`type_number_sample.js`](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson5/type_number_sample.js)//数字类型变量示例
+ 理解同上;
+ ### [`type_object_sample.js`](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson5/type_object_sample.js)//对象类型变量示例
+ 定义对象变量（变量集合）config；
+ `console.log(config);`输出对象值，所有非文本变量在输出前被自动转换成文本
+ `config.sex = 'woman';`对对象属性赋值，改变值内容
+ `config.bloodType = 'A';`增加对象的属性`bloodType`;
+ `delete config.age;`删除对象属性'age';
+ <<<<<<<<<<
+ 我是分界线
+ <<<<<<<<<<
+ 老师定义了1个变量run()并赋值为函数变量;输出了2行字符串;
+ 新定义了一个`config2`对象,并在对象内部定义了一个函数run()使其成为`config2`的方法,最后调用`config2`的方法;
+ ### [`type_string_sample.js`](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson5/type_string_sample.js)//字符串类型变量示例
+ 首先,定义并赋值一个字符串变量`'xiaoming';
+ 对字符串进行操作:
+ 输出字符串
+ 根据游标访问字符串的单个字符并输出,每行输出一个字符;
+ 字符串有长度属性，通过循环遍历单个字符并输出,也是每行输出一个字符;
+ 通过游标切割字符串:`console.log(name.substring(0, 4));`根据结果"xiao"来猜测,参数`0`设定从第几个游标开始往后计算返回第`4`个字符开始到末尾的值;
+ 查询老师给的参考文档,其描述是:**substring() 方法用于提取字符串中介于两个指定下标之间的字符**
以上是题目的回答
--------------
+ 作完题后我去看看其他同学的作业,caozhen同学的作业乍一看太口语化,我没一下看明白.但他是用了自己提问自己回答的方式思路来思考老师给出的问题,由点带线串起来,对自己的理解进行了一次梳理,这是我觉得要学习的地方.
+ 再看大师兄何伟的作业,厉害呀!他的作业是在研究回调和异步处理了!我要先交作业,回头再来细看!佩服!
+ 再看老师给的"小白典型"王云飞同学(其实我也是小白...)的作业,还是佩服!王云飞同学首先对老师讲的内容进行了回忆总结.再对自己的疑问列举分析,百度查找.再对老师给的代码按自己的思考修改和测试验证自己的想法,动手意愿很强,而我只是运行了老师给的代码而已,何伟也对自己的想法进行了验证,得到了新的理解.我要向他们两位学习这一点.
+ 摘录王云飞同学作业里的一句名人名言:
+ >**每一个人都必须按照他自己的方式去思考；因为他在自己的道路上，就会发现能帮助他度过一生的一条或者一种真理。但是他切不可放任自己；他必须克制自己，光有赤裸裸的本能是不行的。 ——歌德**
================================================
FILE: homework/lesson5/cloudyview.md
================================================
# 第五课作业
## 1. 阅读study/lesson5的sample代码，并执行观察结果。
* ### type_array_sample.js
这个程序主要展示了数组类型数据的操作方式。
首先，如果console.log直接打印一个数组的话，会将“=”右侧的数据完整展示出来。
通过for循环，利用游标可以实现数组数据的遍历。这种方式可以直接抽取数组里面每一个元素来打印。
下面的几段语句实现了对数组的操作。push方法，在数组末尾加入新的元素；pop和shift分别可以将数组最前面和最后面的元素删除；利用indexof()可以查询到某一个元素的游标是多少。
* ### type_boolean_sample.js/type_number_sample.js
布尔类型只有true和false两个值。这两个值可以利用toString()方法，可以转化为字符串类型。利用typeof()方法可以看出，转化后的是字符串类型。数字类型的数据也可以用这个方法来转化为字符串。
## 2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
================================================
FILE: homework/lesson5/cuimiao.md
================================================
#小白cuimiao的第五节课作业（在此期间学习了第九课）
#一.老师的问题是：代码中第1,5,6行的name的差异分别是什么？
第一行的name，是指定义output这个函数时，他的参数是name；
第二行的name，是指运行output这个函数时，打印这个参数name；
第五行的name，是指定义一个变量name，并对这个name赋值为'Hello，JS'，其实恰好这个变量只是拼写成name而已，当然可以改为别的，这样似乎更好理解；
第六航的name，是指运行output这个函数，其参数是name，这个name是刚才第五行定义的变量name；
运行output(name)这个函数的结果，返回值就是'Hello,JS'
#二.这节课的笔记
详见我的云笔记
#三.这节课复习后的收获（特别要感谢我们小组的李朋队长）
1. 问题1：“显示” 这个动作，用代码表现的话， 就是 console.log()，而return虽然有返回值，但如果没有console.log(),就不会显示return的返回值。
2. 问题2（具体结合我的云笔记的截图）：startTime赋值是checkFlightSchedule这个函数，这个函数运行的结果返回值是scheduleinfo.start，所以return的结果就是赋值给了startTime，所以7之后是时间
3. 李朋给我的解释（具体结合我的云笔记的截图）： ()=>{} 就是函数的简写
4. 第五课作业老师要求我们复习代码，第一段代码是立即返回的案例，我试着用老师第九节课的方法，把console.log(1);等都按顺序打好，自己心算一遍顺序，运行代码，和自己心算结果意义，很开心！！！
5. 第二段代码，是间接返回的案例，我心算打印顺序错了，但后来自己理解了。高兴！这段代码要结合我第五课的笔记第19条来看，就能理解callback这个函数定义以及运行callback如何打印出scheduleinfo.start 的值出来。
6. 第三段代码，study lesson 5 中的flight_schedule_3.js 这个代码，是异步处理的案例。我试着用打印顺序，虽然没再犯上一段代码的错误，但还是有个问题，遗忘了5秒延时的事儿（详见我的云笔记及截图）。
================================================
FILE: homework/lesson5/dengxy0907.md
================================================
第五课
=========
> 第一行的name是参数，可以是name，也可以是任意值
>第五行的name是一个变量，也可以是其它名字。
> 第六行的name是一个变量，等于第五行的name，调用了output函数；
题外话
----------------
### 首先祝老师教师节快乐
### 关于编程课的一心里话
> 本来想把作业补完再一起pr的，但是现在看来这点时间不足以做完了，只能先把之前的做的很草率的作业先交了，虽然几次作业在做完后参考了其它同学的作业后有新的见解，但是我还是决定发我最早写的。
>我自己的话对于编程的基础就是大学一个学期的php课，因为我不是计算机专业的，所以几乎注定了学校编程课的水分，但是我可以摸着良心说我尽力了。
>在基础上，我比纯小白走的好一点，甚至8月24日的课我还是在动车上用流量看的，在8月24日之前，虽然因为自己的事情拉下了，但是我其实是不太急的，虽然作业很草率，但是流程我打通了，而且我还看的懂大部分的代码，那个时候函数这一块虽然还有点懵懵懂懂，但是除了小细节外，一些概念在我脑子里是打通了的，在老师的课中，几乎所有我之前写过的不知其然的东西（包括但不限于post和get）似乎都清楚了，甚至现在看游戏中的生死都会想到布尔值。
> 想想挺后悔没有进幼儿园的，最先是觉得我能跟的上，现在群里说的什么几乎都看不懂，因为一直在补课，遇到的比较多的问题还是在代码上，应该算是不好意思问吧，我觉得代码这个总能查的到，还有就是确实目前还没遇到太大的bug，总想着自己先排查一下，还有一个原因就是笑来说的每个人最重要的就是注意力，我自己也能翻墙，条件已经比很多人好太多了，虽然在高考前我有过因为我补课抛出很多问题在一定程度上补充了优秀学生盲点而让他们很愿意帮助我解决问题的经历，但是我还是不愿意在我还有机会自己解决的时候去问，我还是希望我能查得到就先查吧，我还看的懂，我先调试调试再说。
> 这次课程拉下的原因主要还是两点，1、时间没有安排好；2、不愿意去问；前者占90%以上，不想去抱怨太多了，虽然在9月3日后发生了手机摔坏主板等意外让我沉不下心学习，但是确实我在敲代码和解决bug上用的我认为还不够多。
### 补课纪录
>本来想写一篇文档纪录自己补课的过程的，但是后面放弃了，我这里简单回忆一下我自己的这近一个月的经历吧，因为自己没有能力拒绝一些事情导致实际学习的时间不多，因此在作业上主要还是为了打通流程，虽然敲代码这件事依旧是我最爽的事情，但是在学习上我现在认为先打通流程是必要的。
> 1、最开始是软件安装，因为很久之前尝试了新生全栈营的代码，遇到的bug，后来重装系统解决，还有我忘记了的小问题，因为其他同学遇到在新大内提问的到解决，我也顺带着解决了.
> 2、记得第一个md作业，插件是在聊天群里的看到下载的，但是不知道怎么调用，自己是先写了文档，实在老师下一次课说了快捷键后我才知道怎么调用
> 3、在git上就是 .DS 文件的问题，在放弃 －A和用了 －m 后解决，至于html的话确实是为了先打通流程偷懒简单写的。
> 4、在异步上还是需要多写点代码，对看异步代码这件事情还是需要大脑运算一下，时间没有剩下几天了，所以在第六课作业时想的还是打通流程，参考的还是同步，自己话有点多，在打这篇文章上也花了不少时间，现在觉得还是觉得理解并学会异步这件事情比打通流程更重要，但是课程快结束了，我还落下挺多的。
> 5、在写第7课的作业时脑子挺乱的，先是习惯性的想打通流程，代码看的有点乱，因为是在补课，我是第六节课作业写完后才看的第7节课，后来在参考老师代码时被自己第六节课的代码和vue、第三方库弄乱了，在最乱的时候脑子里突然飘过老师说的 在哪里，要往哪里去，所以就重新写代码，然后遇到bug的时候才想起有第三方库这件事情，就又看了回放，刚好看群里有解决方案，然后在npm install后老师的代码可以运行了，自己的也可以了，不知道为什么，jsonFile.readFile就可以，加入jsonfile.wtiteSync就出现了找不到jsonfile模块的bug。而且在尝试代码的时候也遇到了一个不理解的代码执行顺序临时加过来问一下老师吧,因为想先打通流程就没有先google，在遇到后面的bug后自己在烦躁后重启了电脑，打算第7次作业留着从头再来。
> 除了实践不够多之外，确实想不到那么多词汇去具体描述，也想不到有可以通过那么多方面去理解要理解的事情，自己的这份作业更像是一个婴儿在咿咿呀呀的学语，这个是在什么什么，那个是什么什么。这份文档确实说了很多我觉得不应该说的话，但是我还是想纪录下来。
> 最后再次感谢老师为我们这群小白做了这么多。
### 关于这个意外
>可能是由于在尝试代码的时候无意中修改了不该修改的代码，导致同步一个fork时git进入编辑器问我为什么要fork，这个pr是昨天的，但是今天在老师的代码文件里我的作业是没有的，code那一栏的pr里却有我的pr，我意识到出问题了。
> 如果这次pr成功，那就说明我的解决方案是正确的，我删除了我原先fork的项目重新fork了一份，在电脑上重新clone并修改我的作业。
### 突然想加的臭不要脸的话
> 在找代码的时候有点懵，可能犀牛书该看的部分还没看完是一个重要原因，做作业主要还是参考代码＋goole，犀牛书总是被忽略，我想如果犀牛书也加入预习作业可能是一个不错的选择。
> 今天是开学的第一天，这学期有节关于运营的课程，虽然这个课程几乎全是界面操作的，但是在听老师讲解课程的时候就觉得这个课程的技术层次就是js课里用到的啊，而且学校课程是在局域网里的，如果js我早一天做完我甚至可以直接把网页布置到自己的服务器上的。
> 我不是一个好的学习者，作为学生我还有很多缺陷，现在的慌张就是为之前自己挖的坑买单，就不多说了，先pr试试看吧。
================================================
FILE: homework/lesson5/diaozhicong.md
================================================
#第五次课作业
【作业内容】
1. 阅读study/lesson5的sample代码，并执行观察结果。
2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
##
###1.运行结果
+ async_function.js
//启动运行5秒后显示：
**我终于被调用了**
+ indirect_call.js
//启动运行后显示：**�������������������������� **
**我跑完了**
+ flight_schedule_1.js
//启动运行后显示：
**开始查航班信息**
**8/23 8:00**
+ flight_schedule_2.js
//启动运行后显示：
**开始查航班信息**
**8/23 8:00**
+ flight_schedule_3.js
//启动运行后显示：
**开始查航班信息**
//5秒钟后显示：
**通过反馈通道获得了信息**
**8/23 8:00**
###2.分析变量Name的差异
第1行的变量name是函数output的参数；
第5行是定义一个变量name并赋值‘Hello，JS’，这个name与第一行的name本质上没有关系；
第6行的变量name是函数output调用的一个参数，此时调用name就将第5行的name和第1行的name联系起来了。是回调的一个概念。
================================================
FILE: homework/lesson5/donglili.md
================================================
## 代码分析
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);`
上面的代码，其中：
第1行的 name 是 output()这个 function 的参数定义值。是用来接收后面（第5行）的调用函数的值的。这个数可以是任意能使用的，只要他和第2行输出的那个console.log（）中的一致就可以。比如，可以使用a，b，c等等。
第4行的 name 是 一个独立的变量，就是个变量名，我们定义这个变量为"Hello,JS"。
第5行的 name 是 把第4行的变量 name 作为 output()这个函数的参数，送到第1行定义的函数内，运行函数。第4行及第5行的name也可以用其他代替，只要一致就可以。
================================================
FILE: homework/lesson5/fangqingyang.md
================================================
### Lesson5
#### 第一行name
可以是任意一段字符串，指明叫name是因为作者想用这个名字来说明：这段字符串是用来做name的，只是名字与第5行第六行相同，其实他们之间没什么关系。
#### 第五行name
变量的标识名称，指向‘Hello, JS'这个字符串，是’Hello, JS'这个字符串的进一步抽象，方便调用，就像我们每个人有一个名字，那个名字的代表我们这个人。
#### 第六行name
就是指'Hello, JS'这段字符串，将'Hello, JS'这个字符串作为参数（要求）传给output这个函数。
#### 回调
平时都是字符串，数组，数值作为函数参数的，现在函数也作为参数。
异步是回调的一种
类似，老妈早上和儿子说晚上你来煮饭（调用函数），我去上班，儿子到了晚上开始做饭（根据参数晚上），老妈还在上班（同一时间，老妈在上班，儿子在煮饭，异步），老妈回家，儿子煮好饭。（得出结果）
老师说的一个情景，网页，先显示一个LOADING，在用户看着LOADING的同时，浏览器在和服务器做数据交互，各自做各自的，而不是让用户看着空白的页面，以为什么也没发生，等不下去，关了。
================================================
FILE: homework/lesson5/fanliao.md
================================================
# 【作业内容】
## 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
## 谈谈我对这几个‘name’的理解，还请老师看看我对课程的理解是否正确。
1. 第一行和第二行中的两个‘name’必须书写的完全一致，它是函数output的参数；
2. 第五行和第六行中的两个‘name’ 必须命名的完全一致，它是一个新的变量，而且在第五行这个变量已经赋值了‘hello,js’,然后调用函数Output，将这个值通过第六行的‘name’传给函数中的第二行，打印出来；
3. 所以说其实将第一、二行的'name'同时换成'a'，把第五、六行的'name'换成'b'应该对于这段代码的运行毫无影响的，之所以要全用'name'命名，只是考虑到在做大的项目中，这样的命名增强了代码的可读性，所以我们作为初学者也要学习这样的好习惯。
================================================
FILE: homework/lesson5/fanqing.md
================================================
## 作业-1
要求：阅读study/lesson5的sample代码，并执行观察结果。
### 完成情况
逐个sample代码对打执行，对数组中 push/pop/shift/.indexof的用法印象最深，kitchen_workflow_async 耗时最长。
#### 在kitchen_workflow_async代码中：
(1)增加读取随机数结果语句；
(2)增加运行观察节点console.log(1)-console.log(12)，了解：函数中只有return后的内容不再执行，其他还会在调用其它函数后返回继续执行。
#### /----- 代码部分 -----/
function buyFoods(callback) {
console.log('采购原料和菜');
setTimeout(function() {
console.log('采购完毕');
var foodsList = ['fish','egg','meat'];
console.log(1);
callback(foodsList);
console.log(2);
}, 5000);
console.log(3);
}
function prepare() {
console.log('努力磨刀...努力洗碗...努力打扫...劳动最光荣');
//return (Math.random() > 0.5); 原句式，以下为自己修改。
i = Math.random();
console.log(i);
return (i > 0.5);
console.log(4);
}
function cooking(foodsList, callback) {
console.log('开始做菜啦~~~');
setTimeout(function() {
console.log('今天要做这些菜' + foodsList);
console.log('大功告成，上菜');
var feast = ['鸡蛋西红柿','红烧肉','红烧鱼'];
console.log(5);
callback(feast);
console.log(6);
},5000);
console.log(7);
}
function startWork() {
var success = prepare();
console.log(8);
if (!success) {
console.log('还没准备好');
return;
}
console.log(9);
buyFoods(function(foodsList) {
console.log(10);
cooking(foodsList,function(feast) {
console.log('----- 酒席准备好了 -----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
console.log(11);
});
console.log(12);
});
console.log('事情安排好了，我先去洗个澡');
}
startWork();
#### /----- 执行结果1 -----/
an-macprodeMacBook-Pro:Documents kan_macpro$ node JS-L5-kitchen.js
努力磨刀...努力洗碗...努力打扫...劳动最光荣
0.3553369629799288
8
还没准备好
#### /----- 执行结果2 -----/
an-macprodeMacBook-Pro:Documents kan_macpro$ node JS-L5-kitchen.js
努力磨刀...努力洗碗...努力打扫...劳动最光荣
0.7182601417865426
8
9
采购原料和菜
3
事情安排好了，我先去洗个澡
采购完毕
1
10
开始做菜啦~~~
7
12
2
今天要做这些菜fish,egg,meat
大功告成，上菜
5
----- 酒席准备好了 -----
鸡蛋西红柿
红烧肉
红烧鱼
11
6
## 作业-2
要求：图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
### 我的回答
第1行的name是声明函数方法output的参数名称，因在函数内部直接使用到，不能省略。可以是任意名称，内部用名应与其保持一致。
第5行的name是声明的一个新的变量，并定义赋值，第6行的name是对新声明的变量执行output函数方法，第5行的name可以是其他任意变量名，第6行name与其保持一致，运行结果完全相同。
================================================
FILE: homework/lesson5/fengkai.md
================================================
function output(name){
console.log(name);
}
var name = 'Hello, JS';
output(name);
1.第一行的name是 output函数的参数，并且这个参数是个变量；
2.第五行的name是 声明一个变量叫name，并赋予了这个变量一个值；
3.第六行的name是 调用了output函数以及他的变量参数。
================================================
FILE: homework/lesson5/guowei.md
================================================
# 小白JS入门不放弃 lesson5
*Focus Question：回调*
## 又爱又恨的“回调”一桌酒席
### 代码难点
* 函数变量
> 函数变量：在JavaScript中，调用者可以把函数赋值给变量，也可以将其作为参数传递给其他函数。
举例：
在```setTimeout(）```中，```function() {}；```便是函数变量，作为参数传递给```setTimeout(）```函数。
又如：
在```startWork()```中，```function (foodsList) {}；```和```function (feast) {}；```都是```startWork()```的变量。
* 匿名函数
>顾名思义，**匿名函数**就是没有名字的函数，它的作用是为了让代码简单化。
举例：在```setTimeout(）```中，```（function() {}；```便是一个匿名函数。function之前的左圆括号是必需的，因为如果不写这个左圆括号，JavaScript解释器会试图将关键字function解析为函数声明语句。使用圆括号JavaScript解释器才会正确地将其解析为函数定义表达式。
又如：在```startWork()```中，出现两次```（function (foodsList) {}；```和```（function (feast) {}；```都是匿名函数。
* 回调函数 callback
Google给出的解释：
>A callback is a function that is passed as an argument to another function and is executed after its parent function has completed.
在“一桌酒席”里，我被回调搞得一脸懵逼，反复查犀牛书和google，仍然不是特别明白。
参考何伟同学总结的回调格式：
>```
>function a(callback) {
> // do something
> var data = XXX;
> // pass data to b
> callback(data);
>}
>
>funtion b(data) {
> // do following thing
>}
>
>a();
>b();
>```
我目前理解的是：先执行函数a,而且不会等到a完全执行完才执行函数b, 在a的过程中就执行了函数b，b完成后返回执行callback这个函数。
### 问答题：区分同名的变量
老师给出的例子：
>```
>function output(name) {
> console.log(name);
>}
>
>var name = 'Hello, js';
>output(name);
>```
其中第一个```name```、第三个```name```和第四个```name```都是变量：第一个```name```是```output()```这个函数声明语句的参数变量；第三个```name```是字符串变量，并被调用者赋值```'Hello, js'```，第四个```name```是```output()```函数的参数变量。
第二个```name```则是输出的字符串。
================================================
FILE: homework/lesson5/hanwei.md
================================================
## 第五节课作业
第1行的name表示函数用来接收参数的变量，这个变量和第二行的name是一个。相当于声明一个变量，但和一般的声明变量有不同，只有在调用函数的时候才会定义和赋值，用来接收传递过来的参数。而且它的作用范围只在一次调用的函数中，函数执行完成随即失效。
第5行的name则是在这段代码中声明定义并且赋值，在这段代码中它是一个明确的正在使用的变量；不同于第一行的变量只有在调用函数的时候才实际生命定义并使用。
第6行的name，实际上就是第5行的name。它的作用就是调用output函数，并将变量name传递给它。这个过程中，output会在内部生成另一个name来接受它。虽然两者的名字一样，但由于作用的范围并不相同，所以并不冲突。
================================================
FILE: homework/lesson5/haohu.md
================================================
- 第1行的name是函数定义的一部分,是函数的形参;
- 第5行name是自定义的变量名,用来在程序其他地方使用;
- 第6行的name和第5行的name是一样的,是对变量使用.
================================================
FILE: homework/lesson5/hewei.md
================================================
# 第五课作业
## 回调和异步
### flight_schedule_2.js
这个例子简单地介绍了一下回调，以我目前的理解，就是在一个函数内再调用另一个函数。
为什么要这么做呢？因为两个函数之间有交互，我要把一个函数里面处理后产生的结果，传递给另一个函数处理。虽然用最原始的 `return` 这种方法将返回值传递给另一个函数进行处理也是可以的，但是采用回调的方式，能够简化代码，省去了 `return` 的步骤。
但是，因为这个例子只有前端部分的内容，所以只看这个例子的话，对于回调并没有深入的理解。
### flight_schedule_3.js
这个例子，在前一个例子的基础上，加上了人工制造的延迟，是为了模拟前端向后端获取数据、等待数据返回并接收数据的过程。
但是除此之外，和前一个例子没什么区别，所以还是对这个代码理解得不是很好。
为了便于自己理解，将 `checkFlightSchedule()` 函数修改为如下形式：
```
console.log('开始查航班信息');
setTimeout(function() {
// do something
callback(scheduleInfo.start);
}, 5000);
console.log('先去喝口水'); // 自己补充的一行代码
```
这样一来，终端的输出结果就是下面这样子的：
```
开始查航班信息
先去喝口水
通过反馈通道获得了信息
8/23 8:00
```
可以看到，秘书在等待航班信息返回的过程中去喝了口水，回来之后看到了信息。在等待信息返回的过程中，还可以做别的事情，不用干等着。而在默认的情况下，开始查信息之后，如果没有获取到返回的结果，是没法做别的事情的。
补充了上面那一行代码之后，感觉对回调的理解更深刻一点了。
### kitchen_workflow_async.js
这个例子，把之前准备酒席的代码，改成了异步的形式。
因为是初次接触 **回调** 这个概念，所以异步版本的酒席代码，看着还有点儿乱糟糟的。自己手动整理了一下，把代码改成了下面的形式，便于自己分析理解：
```
function buyFoods(callback) {
console.log('start buying...');
setTimeout(function() {
// do shopping
var foodsList = XXX;
callback(foodsList);
}, timeOfShopping);
}
function prepare() { // preparation }
function cooking(foodsList, callback) {
console.log('start cooking');
setTimeout(function() {
// cooking
var feast = XXX;
callback(feast);
}, timeOfCooking);
}
function startWork() {
if (!prepare()) {
console.log('Not ready yet');
return;
}
buyFoods(function(foodsList) {
// when foods were bought to kitchen
// passing foodsList to anonymous function/callback function
// to do the following cooking things
cooking(foodsList, function(feast) {
// cook the foods from buyFoods()
// and deliever the feast to guests
console.log('Let\'s eat!!!');
});
});
console.log('All done, have a rest');
}
// above are all workflow
// the REAL WORK is done here!
startWork();
```
通过自己重新手写这段代码，真的是有了更深的理解！就在二十多分钟前，还对这段代码懵懵懂懂。经过这二十多分钟的重写+分析，理清了整个异步执行的流程，这种攻克难关的感觉太美妙了！！！哈哈。
这二十多分钟，给我带来的宝贵经验就是：不要只是看代码，要去写！一边写一边分析，一遍不行两遍，两遍不行三遍，最后肯定能看懂、看熟、看透代码。成长，就是在这个过程中产生的。
### 自己加餐
读完了老师的代码，感觉还不过瘾，那就自己再写一个吧。
```
...
...
...
```
上面的代码只列出了关键的部分。通过设置 `ajax` 函数中的 `async` 参数，可以分别展示 `同步` 和 `异步` 执行的结果。各自的执行结果如下：
```
// async: false 同步执行
Example started.
888996
Example ended.
// async: true 异步执行
Example started.
Example ended.
888996
```
从上面的执行结果可以看出来：同步执行的时候，必须等待 `ajax` 请求获取到了所返回的结果并进行处理之后，才会执行后面的代码。
而异步执行就不是这样了，发起 `ajax` 请求之后，一边等待结果返回，一边继续做其他的事情。
### 新发现
```
getData(writeData);
console.log('Something else happen');
function getData(callback) {
var timer = setTimeout(function() {
var dataArray = [123, 456, 789];
callback(dataArray);
}, 3000);
}
function writeData(myData) {
console.log(myData);
}
```
上面的代码，会先输出什么呢？是那一句英文。为什么会这样？因为在执行第一行的 `getData` 之后，这个函数在 3 秒钟之后才会给出结果。而代码同时执行到了之后的输出语句，就先把那句英文输出了，然后在 `getData` 的执行时间到达 3 秒钟之后，再输出数组。
前面自己对代码理解的不够透彻，还以为会先输出数组，再输出英文。而经过对这一段代码的剖析，让自己对回调函数的理解又有了进一步的深入。
### 总结
最后，再总结一下回调的基本格式：
```
function caller(callback) {
// do something
var data = XXX;
// pass data to callee
callback(data);
}
funtion callee(data) {
// do following thing
}
caller(callee);
```
## 区分同名的变量
在上图中，第一行代码里的 `name`，表示不管用户传入的是什么参数，都会通过 `output` 这个函数将其打印出来。
而第五行和第六行的 `name`，则是用户所要打印的内容的一个"昵称"。我们用这个昵称来指代用户所要输出的内容，没有这个昵称当然也完全没关系，但是加上这个昵称，能够使函数更容易阅读。比如用户如果要输出一大段文字，把这段文字直接作为参数传给 `output` 函数的话，不管是阅读代码，还是修改代码，都会很不方便。而用昵称来指代这一段文字之后，代码就会清晰很多。
将代码重写一下，下面的形式，应该就更容易理解了：
```
function output(anythingYouWantToOutput) {
console.log(anythingYouWantToOutput);
}
var content = "三国演义全文";
output(content);
```
猜测老师之所以要把代码写成图里的那种形式，就是为了让大家对代码的 `形参` 和 `实参` 有一个更好的理解，因为这个问题迟早要遇到，不如让大家一开始就去思考、去研究。
参考资料：
- [Understanding JavaScript Callbacks](https://closebrace.com/tutorials/2017-01-17/understanding-javascript-callbacks)：通过实例演示，来让读者对回调函数有一个逐步深入的认识。
- [How to format a float in javascript?](https://stackoverflow.com/questions/661562/how-to-format-a-float-in-javascript)：介绍了如何设置小数点的精度。
- [What does setTimeout return?](https://stackoverflow.com/questions/10068981/what-does-settimeout-return)：解释了 `setTimeout()` 函数所返回的整数的含义。
================================================
FILE: homework/lesson5/huangBiLing.md
================================================
## 我的第5课作业
### 第5次作业要求：
#### 题目：
图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
#### 答：
第1行name：是函数的形参变量；作用是在函数结构()的这个地方，作为实参/值/数据的提示，就是让读代码的人了解到这个函数想要调用的实参/值/数据是哪方面的，比如，是“名字”还是“动作”，等等。
第5行name：此处name是刚定义的实参，引用一个字符串类型的值'Hello,JS'。
第6行name：调用函数output，并导入/调用实参name = 'Hello,JS'。
================================================
FILE: homework/lesson5/huangjiashu.md
================================================
### 写在前面
做作业之前我在思考一个问题，那就是 间接返回 。 看直播时对 间接返回和异步 一直搞不清楚。自我感觉模棱两可。故在做作业时有了以下思考。
作业本是七夕下午写的，无奈七夕老板大发慈悲整整提前一个小时允许大家下班，然后被同事拉去吃东西。因为我电脑一直在维修中，所以作业其实是第二天写完了。
七夕当天提了个问题在issue，感谢老师和其他同学的回答。最为感动的是深夜看第六节的回放，看的很感动。因为某些人在我的作业中竟然体会到了我的感受。也感谢老师和同学们的鼓励。我上周非常忙，一个星期的时间我做了一个app1.0版本。现在在赶作业。以后的直播我会尽量赶上的。
### 间接返回和异步的理解
间接返回通道：
什么是间接返回通过：间接返回通道就是在函数中开辟一个通道，用来传递数据。
例子就是：老板打电话给秘书查询航班信息，在挂电话之前把 查到的信息通过微信发回给老板。
```
// 间接返回通道
// 采购食物的函数
function buyFoods(callback) {
console.log('采购原料和菜');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}
// 调用者的代码片段
function callback(foodsList) {
console.log(foodsList);
}
buyFoods(callback);
```
// 直接调用
// 采购食物的函数 注意没有参数
```
function buyFoods() {
console.log('采购原料和菜');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}
// 调用者的代码片段
function callback(foodsList) {
console.log(foodsList);
}
buyFoods()
```
这两个调用结果完全一样。但是调用方式却不同。
那么既然结果完全一样，为什么还要有回调函数，何不直接调用呢？既生瑜何生亮！！！
这是为了解决什么问题呢？
这是个问题，我已经提到[issue](https://github.com/xugy0926/getting-started-with-javascript/issues/407)里了
。因为就快陷入思考的胡同里去了。
> **尽管有些东西可能本身没有什么意义，但是你的思考赋予了他意义。**
> 晚上又复习了下回放，看了一下你的回答，我也理解了一些。似乎这个问题不是那么重要，因为或许本身就没有什么区别，重要的是理解立即返回，和间接返回。这个我倒是理解的。
> 我想了想，其实我写的两个例子应该都是间接返回。所以看上去并无差别。因为他符合间接返回的条件：在外部定义了一个函数（间接返回通道），然后在函数内调用了一下。应该没有什么问题吧。
> 我觉得是一样的，那么问题就在于，是否把这个函数名作为参数进行传递。
> 作为参数的好处就是，他是一个形式参数，不管我外面定义的通道的名字，如何改变，我这个函数的结构都，不用更改，而如果不作为参数，一但我通道名字发生改变，那我就必须改变这个函数。
> 最重要的一点是，**如果我没定义这个参数，就等于我把函数写死了**，我自己使用可能还无所谓，作为一个使用者，没有回调函数肯定是要骂死我的。连传参数都不知道怎么传。从函数的编写者来讲，这是多么失败的函数。
我终于明白了，诸葛亮要比周瑜强很多啊。
> 我想这应该是原因所在吧！这也是深夜看回放的一些启发。
> 至于异步，我觉得把里面的函数名，通过setTimeOut函数调用一下，他应该也是异步函数吧！因为我觉得他符合异步函数的条件。因为它并没有立马执行。
> 老师说，讲间接返回是为了引出异步这个概念。异步就是用了间接返回。举了一个例子，就是调用了setTimeOut。我甚至都没有觉得，间接返回和异步有什么不一样的地方。
> 老师说，获取数据有两个方式，一个是立即返回，一个是callback.称之为回调。而这个callback，我相信指的就是间接返回，而异步就是间接返回的一个应用。与异步相对的概念，就是同步。那么我就可以把间接返回函数，也分为同步函数，和异步函数。我觉得同步与异步的差异，就是在于时间。对于耗时操作，同步间接返回函数，必须等到返回之后才能结束整个函数。那异步返回函数，则无需等待。
> 我在文中有任何理解有偏差的地方，还请老师及时指正，帮助我在错误的道路上渐行渐远。
### 作业
1. 关于函数执行
我在flight_schedule_3更改了代码，在setTimeout函数后面添加了一句，console.log('我执行了');
```
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
setTimeout(function() {
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}, 5000);
console.log('我执行了');
}
//---------------------------------------
function callback(startTime) {
console.log('通过反馈通道获得了信息');
console.log(startTime);
}
// 执行查询函数
checkFlightSchedule(callback);
```
实时证明： checkFlightSchedule 先执行完， 然后 5秒后 才执行的setTimeout 中的匿名函数。这一点证实了异步函数和同步函数的本质区别。
```
node flight_schedule_3
开始查航班信息
我执行了
通过反馈通道获得了信息
8/23 8:00
```
同样的修改之前flight_schedule_2的代码 都是同步函数案例，
```
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
console.log('我执行完了')
}
//---------------------------------------
function callback(startTime) {
console.log(startTime);
for (var i = 0; i < 100000000; i++) {
if (i === 99999999) {
console.log('回调函数执行完了')
}
}
}
// 调用函数checkFlightSchedule，并塞一个回调函数以获取结果
checkFlightSchedule(callback);
```
```
node flight_schedule_2
开始查航班信息
8/23 8:00
回调函数执行完了
我执行完了
```
其结果是等待回调函数执行完毕后才执行的“我执行完了”,由此可见这个间接返回也是个同步函数。
这说明，回调是同步还是异步，取决于函数本身。举例说明就是 示例中的callback 本身就是一个同步函数， 而 setTimeout 本身就是一个异步函数。
同样的 在kitchen_workflow_async.js案例中也证实了这一点，比如这个例子的打印结果是先“我要开始采购食物啦。。。。”
后 “事情安排好了，我先去洗个澡”
kitchen_workflow_async这个例子感觉写的很经典，流程控制函数让整个流程让人看上去很思路很清晰。prepare在这里返回值永远为true，本身并无意义。但写入流程控制函数，就显得很有意义。很明显让我觉得有一个判断过程。而开始做事前的判断很重要。that is to say 思维，逻辑重要。一个好的流程，应当有严谨的逻辑。
2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？
第1行，的name是函数的参数，这个参数在这里是形参，没什么具体意义。
第2行，是函数中，对这个形参的使用。这两个参数是一致的。也只有在调用赋值的时候，这些参数才有意义，才有实际的值。
第5行，是定义了name变量，并赋予了实际的值。
第6行，是调用output函数，将实际的name变量作为参数传给了函数。函数内部会有一个转换过程。也就是简单的赋值操作，name=name
================================================
FILE: homework/lesson5/huyong.md
================================================
#不同“name”的理解
##第一行name我理解是一个参数，这个参数可以指代任何我们需要指代的对象，可以是各种不同的数据类型。
##第五行name根据大犀牛中的定义是一个变量，这个变量是然我们可以给他任意赋值的，我们可以定义这个变量是我们想要的任何值。通过我对第五行和第六行中name变换成不同的字母代替和相同的字母代替得出来的结果来看，我的理解是，第五行中name（以下称为name5）是一个更大的范畴，意思就是这个和第一行中的name（以下称name1）相比，这个name5看作一个集合，name1是其子集，当然这个是在一个函数语句和一个var语句并列的情况下，其他有待实验
##第六行中的name（以下称为name6）我的理解是一个确定的值，这个值完全等于var语句中给出的定义，有确定性和唯一性的属性。
##以上就是我对不同name的个人看法，望老师指点，谢谢。
#执行各种sample的收获
1，立即调用就是直接执行一个函数，并给出信息，间接调用就是通过执行一个函数的过程中再去执行两外一个函数，并通过执行不同的函数得出不同的信息，也就是分步执行
2，分步执行就给出了更为广阔的操作空间，我们可以在不同的函数中加入各种调用，比如老师的延迟执行，比如IF语句等等，这些复杂的操作就是为了能够达到映射现实世界复杂 情况的目的，
3，函数本身即是函数也可以是对象，参数或者变量等等，所以我们在理解函数的时候要树立函数即是执行者的角色还是被执行者的角色，
在理解各代码的过程中我们需要树立调用者的角色定位，这样更易于去理解，而不能是执行者，因为小白是执行者很容易转牛角尖
4，toString()就是万能的输出啊，可以输出甲骨文吧老师？
5,run:[Function]和function（）不理解，function 后面不都是该有funcname吗？还有就是kitchen_workflow_asynct太复杂了 今天搞不定了需要再看。
================================================
FILE: homework/lesson5/jianglin.md
================================================
###姜琳第五次课作业
####作业
第1行的`name`是函数定义中的函数参数，在第2行，函数定义的内部调用对了这个参数`name`。
第5行的`name`是定义的变量，这个变量的名字是"name"。
第6行的`name`是函数output调用变量"name"，值是字符串'Hello,JS'。
总之，第1行和第2行的name指的是参数，二者应该一致。第5行和第6行的name指的是变量，二者应该一致。
####练习笔记
// 采购食物的函数
function buyFoods(callback) {
console.log('我要开始采购食物啦。。。。');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('采购完毕');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}, 5000);
}
// 流程控制函数
function startWork() {
var success = prepare();
if (!success) {
console.log('还没准备好');
return;
}
buyFoods(function(foodsList) {
cooking(foodsList, function(feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
console.log('事情安排好了，我先去洗个澡');
}
这里的callback是形参，可以说是“形式函数参数”，这个名字之所以是callback，是为了表示它的功能。而在整篇代码里，没有明确的定义callback这个函数，而是在调用的时候，直接定义了一个匿名函数，阅后即焚（感谢何伟同学的指导）。
这样做的好处，我自己的理解，一开始是以为能使代码更可读，但是在练习敲了这段代码之后，认为这种方式应该是在定义buyFoods的时候，只是定义了这个函数需要有回调的功能，但是具体怎么回调，在定义的时候不确定，这样就不唯一。然后在调用的时候，可以根据不同的调用需求，定义不同的回调函数。当然如果每次回调方式完全一样的话，那么在定义的时候就把回调函数写清楚，是更方便的选择。
####听课笔记
- 函数定义里的变量和调用的变量完全不是一回事。
`function run(name1){console.log(name1);}`
`var name = 'xugaoyang';`
`run(name);`
name和name1是有区别的。
- callback名字叫做**回调**，但实际上是调用一个函数去处理，和**返回**不同。
**异步**是回调的一种方式。
函数定义在哪里，都是可以使用。和位置没有绝对的关系。
function callback(){
console.log('I finished running')
}
function run(cb){
console.log('run run run run run');
cb();
}
run(callback);
================================================
FILE: homework/lesson5/langjj.md
================================================
下面代码中，第1行、第4行、第5行的name变量都有什么差异？
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
在function定义中的name只是函数output的输入参数，可以是任意名字，只要保持第二行中使用的名字与第一行中一致即可。这是一个局部变量，不会影响到程序的其他部分。
第4行则定义了一个变量，这个变量的名字最好与编程者想要表达的意图相关，必要时用//加注释，以便理解。在给变量取名字时一定要避开JS中已有特定定义的名字，否则会出错。第5行则要求执行函数output，函数的输入值是第4行对变量进行的赋值。这里的变量是适用于整个程序的，因此具有了唯一性。
================================================
FILE: homework/lesson5/lichen.md
================================================
1.重点观察了`kitchen_workflow_async.js`
通过拆解的方式学到了以下知识点：
2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。
这个程序的输出：
`Hello,JS`
第1行的`name`是函数的形参
第5行的`name`是定义的变量
第6行的`name`是调用函数的实参
统一写成`name`是为了便于阅读，和尽可能精简对变量的命名
附注：
形式参数：定义函数时函数名后括号中的变量名
实际参数：调用函数时函数名后括号中的表达式
小小观察：
程序里多定义一个变量，但不调用它，看看结果
```
function output(name) {
console.log(name);
}
var name = 'Hello,JS';
var color = 'blue';
output(name);
```
输出为：
`Hello,JS`
这说明一个变量被定义了但未被使用，这是一种资源的浪费，所以程序需要思考，需要设计，而不是想到哪就写到哪。当然作为小白的我们，趟一趟这些坑也是学习路上必不可少的。
================================================
FILE: homework/lesson5/limu.md
================================================
第一行是声明并定义了一个新的函数，大括号里是函数的内容
第五行是生命并定义了一个变量，并赋予这个变量的值为‘hello，js’
第六行是调用了之前定义的新函数output
由于最近大学开学，一直在准备开学和军训的事情，所以耽误了好久的课程，从山东济南来到广东这边，感觉变化很大，刚来有些水土不服，拉了两天肚子，可算今天没有新生活动参加了，能来敲敲代码了，敲代码让我又有可高三时那股闷着头做导数题的感觉，一转眼几个小时就过去了，很爽。也很开心，自己进入了软件工程卓越计划班，加上暑假跟着老师学了一些编程，开学上课应该会稍微轻松些吧。
================================================
FILE: homework/lesson5/lingxiao.md
================================================
# JavaScript 课程第5次作业
1. 【作业内容】
1. 阅读study/lesson5的sample代码，并执行观察结果。
2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
2. 【解答】
| 代码 | 分析 |
| ---------------------------------------- | ---------------------------------------- |
|  | 第1行是函数的自变量，是一个形参，
可以选择任何字符替换name,
而且此处的形参需要和output函数体内部的参数保持一致；
第5行是定义后的变量，代表“Hello.js”；
第6行的name就是第五行的name，是实参，实际定义的参数。 |
================================================
FILE: homework/lesson5/linxiyao-homework-lesson5.md
================================================
图片中变量名name的差异
1.根据函数表达式：
function functionName （a）{ }
关键字 函数名 形参//形参可以是0或多个
得出function output（name）中的name为函数output的形参，相当于一个空壳子，还没有实际值。
2.根据声明变量，给变量赋值的形式为：
var variableName = "xxxxxx",
得出var name = 'Hello,JS'中的name为一个独立变量名，且这时它被赋了值，值为Hello,JS。
3.根据调用函数的形式：
functionName （ a ）
函数名 实参
得出output（name）中的name为函数output的实参，是已经被var赋过值的，值是Hello,JS 。
ps：代码还没跑，先把容易的作业交了，似乎能减轻点心里压力哈。
================================================
FILE: homework/lesson5/lipeng-学习“异步实现一桌酒席”心得，代码难点分析.md
================================================
## 学习“异步实现一桌酒席”心得，代码难点分析
1 **重点是间接返回**
函数们干的事没变，还是上节课切分的子任务，但buyfood和cooking 用了间接返回。buyFood和coocking 用间接返回，所以，总体上叫**异步实现一桌酒席**。
2 **代码难点- 函数变量（表达式函数定义法）**
setTimeout() 里用了一层，
> 把 `function(){}` 当成setTimeout的第一个参数变量:
>
> ```javascript
> setTimeout(function() {}, 5000);
> ```
>
> 把要延迟执行的代码，放在`{}`花括号里：
>
> ```javascript
> setTimeout(function() {
> console.log('采购完毕');
> var foodsList = ['fish', 'egg', 'meat'];
> callback(foodsList);
> }, 5000);
> ```
在 `startWork()`里用了两层：
第一层，买菜，调`buyFood()`的时候，
> 把`function(){}` 当成 buyFood 的回调函数变量:
>
> ```javascript
> buyFood(function() {});
> ```
>
> 然后，给回调函数添加参数 foodList, 目的要把foodList传到下一流程:
>
> ```javascript
> buyFood(function(foodList) {});
> ```
>
> 最后，把买完菜之后要执行的代码，也就是做菜函数，cooking() ， 放在`{}`花括号里：
>
> ```javascript
> buyFood(function(foodList){
> cooking(foodList, function(){});
> });
> ```
>
> 可以看到，cooking() , 有两个参数，也就是foodList和 回调函数变量.
第二层，做菜，`cooking()`的回调函数变量
> 把`function(){}` 当成 cooking() 的回调函数变量:
>
> ```javascript
> cooking(foodList, function(){});
> ```
>
> 然后，给cooking的回调函数添加参数 feast, 目的要把feast传到下一流程:
>
> ```javascript
> cooking(foodsList, function (feast) {});
> ```
>
> 把做好菜之后要执行的代码，也就是上菜console.log('----酒席准备好了----')，放在`{}`花括号里:
>
> ```javascript
> cooking(foodsList, function (feast) {
> console.log('----酒席准备好了----');
> for (var i = 0; i < feast.length; i++) {
> console.log(feast[i]);
> }
> });
> ```
>
>
最后，把第二层构建的做菜代码，放在买菜回调函数花括号里`{}`
从这样：
```javascript
buyFood(function(foodList){
cooking(foodList, function(){});
});
```
变成这样：
```javascript
buyFoods(function (foodsList) {
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
```
### 3 总结
函数变量，写法比较复杂。我拆了几遍，弄明白了。
“定义一个函数变量（表达式函数定义法）”，是把一个函数的定义代码，function(){} ，直接当成一个变量用。
> 第四课sample代码用了两次：
>
> [使用函数创建对象](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson4/build_a_human.js) `var buildPerson = function(){}`
>
> [士兵对象有报数方法](https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson4/sound_off_3.js) `soundOff:function(){}`
================================================
FILE: homework/lesson5/lipeng.md
================================================
1
```javascript
function output(name){
console.log(name);
}
var name = 'Hello, JS';
output(name);
```
第1行 `name`为 函数output声明的参数变量。
第5行、name 为定义的一个叫做name的字符串变量，并且赋值'Hello, JS'
第6行，name 为第5行定义的 name 字符串变量，在调用output函数时，被当做参数传进去。
================================================
FILE: homework/lesson5/liujuanjuan1984.md
================================================
# JS编程入门Lesson5作业
by刘娟娟
分析这段代码，说明每个地方的name都是什么含义。
'''
function output(name){//定义一个函数，函数名叫output，它需要一个参数，我们以name标记这个参数，用来说明在这个函数里我们如何使唤这个参数
console.log(name);//在这个函数中，我们需要对这个参数name做console.log的处理
}
var name = 'hello,js';//申明一个变量，变量名叫name，并把'hello,js'这个字符串赋值给这个变量name
output(name);//调用函数output，并把上一行变量name的值作为参数传给这个函数，让这个函数去工作
'''
老师这个例子还不够绝的，我拓展下：_步子迈大了，收不回腿了..._
'''
var name = 'liujuanjuan'; //申明一个变量，变量名叫name，把'liujuanjuan'这个字符串赋值给它
var liujuanjuan = { //申明一个对象类型的变量，这个对象名名liujuanjuan
name:'liujuanjuan' //这个对象有一个属性，这个属性叫name，这个属性的值是'liujuanjuan'
};
console.log(name); //打印变量name的值
console.log(liujuanjuan.name); //打印对象liujuanjuan的name属性的值
function liujuanjuan(name){ //定义一个函数，函数名叫liujuanjuan，有一个参数为name
console.log(name)//打印这个参数的值
}
liujuanjuan(name); //调用函数liujuanjuan，参数为第一行变量name的值
liujuanjuan(liujuanjuan.name); //调用函数liujuanjuan，参数对象liujuanjuan的name属性的值
'''
打印出来的结果一定很令人摸不着头脑。改进一下，做个标记：
'''
var name = 'liujuanjuan1'; //申明一个变量，变量名叫name，把'liujuanjuan'这个字符串赋值给它
var liujuanjuan = { //申明一个对象类型的变量，这个对象名名liujuanjuan
name:'liujuanjuan2' //这个对象有一个属性，这个属性叫name，这个属性的值是'liujuanjuan'
};
console.log(name); //打印变量name的值
console.log(liujuanjuan.name); //打印对象liujuanjuan的name属性的值
function liujuanjuanF(name){ //定义一个函数，函数名叫liujuanjuan，有一个参数为name
console.log(name)//打印这个参数的值
}
liujuanjuanF(name); //调用函数liujuanjuan，参数为第一行变量name的值
liujuanjuanF(liujuanjuan.name); //调用函数liujuanjuan，参数对象liujuanjuan的name属性的值
'''
## 这个案例的教训是，对象的名字和函数的名字不要重名。
================================================
FILE: homework/lesson5/liujun.md
================================================
# name变量的差异：
## 第1行name变量：是function output的参数，可以name,name1,或者是空值，都可以。之所以根下面的name一致，是为了代码易读和便于维护。
## 第5行的name变量：是声明了一个叫name的变量，并赋值‘Hello,JS’给了它，它是一个全局变量。可以任意调用。
## 第6行name变量：是把第5行定义的变量的值‘Hello,JS’给到了函数output.
================================================
FILE: homework/lesson5/liuliyuan.md
================================================
##Lesson 5作业
###1. 阅读study/lesson5的sample代码
1. indirect_call.js // 最简单的间接返回
2. async_function.js // 最简单模拟异步的技巧
**3. flight_schedule_1.js // 立即返回案例**
>情景：
>老板：查一下航班时间，不挂电话，查到直接给结果
>秘书：。。
>秘书：明早8点
>老板：好的
转化成代码：
如果老板让你帮查航班时间，一般的流程是先跟老板说我知道啦，开始查，然后查到信息，把起飞时间告诉老板，所以就先定义一个函数，表示一下这个流程，也就是checkFlighSchedule函数；今天就碰到这样的情况，老板打电话给秘书让查航班时间，老板发了一个starttime的需求，你就把这个跟你的函数对应起来，最终得到结果。
**4. flight_schedule_2.js // 间接返回案例**
>情景：
>老板：查航班信息，不挂电话，查到微信给我结果
>秘书：。。
>秘书：（发微信）明早8点
>秘书：老板，微信发给您了。
>老板；好的
转换成代码：
这里多了一个老板要求你用微信发给他，也就是规定了数据返回的一个通道。所以在checkFlightSchedule中，在说我知道了，查到时间结束后，还需要用老板要求的callback的函数发给他。所以就要写出老板定义的那个callback函数。所以，最后执行checkFlightSchedule，代入callback的函数参数。
**5. flight_schedule_3.js // 异步处理案例**
>情景：
>
>老板：查一下航班信息，查到维信告诉我
>
>秘书：。。。
>
>秘书：查完了，喝口水
>
>秘书：发微信（明早8：00）
>
>老板：（维信收到消息）明早八点，现在回去收拾行李
转化成代码：
跟之前不一样的是这里不需要老板在线等着，而是互相各自做不同的事，等秘书回复老板的事后，老板再根据此继续做事情。
站在调用者（老板）的角度，也就是说callback给我反馈之后，我再去看时间，所以对比间接返回，这里多了一行代码，就是console.log('通过反馈通道获得了信息'),这样调用者就可以在调用反馈之前的这段时间做别的事，而不是在线等待。
**6. kitchen_wordflow_async.js // 异步实现一桌酒席**
###2. 下面代码中，第1行、第4行、第5行的name变量都有什么差异？
function output(name) {
console.log(name);
}
var name = 'Hello,JS';
output(name);
第1行中的name是函数output的参数;
第4行是定义一个变量name，并赋值'Hello,JS';
第5行的name是output函数执行时传入的参数名称，4、5行两行可以缩减为output('Hello,JS');
老师作业的目的在于让我们了解定义函数与执行函数时参数的区别，也就是犀牛书中所写的形参和实参的区别。
================================================
FILE: homework/lesson5/liuruyong.md
================================================
# 下面代码1，5，6行name差异
function output(name) {
console.log(name);
}
var name = 'Hello,JS'
output(name)
第1行name，函数的参数名 parameter
第5行name，字符串类型变量
第6行name，给函数的参数赋值，函数参数实际表示的值，argument
================================================
FILE: homework/lesson5/liushengxin.md
================================================
# 第五节课代码分析
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);`
第1行、第4行、第5行的name变量都有什么差异？
第1行的name是异步调用的一个变量或者函数、表示的调用的后面的一个叫name的能满足一定功能的变量或者函数。
第4行的name是一个变量、var语句将Hello,JS这个代码内容赋值给name
第5行的name是将第4行的name变量进行输出操作，也就是输出 Hello,JS
================================================
FILE: homework/lesson5/lixiang.md
================================================
# Ideal's Homework (Lesson5)
标签（空格分隔）： 未分类
像学英语一样，遇到不会的单词就查词典，遇到不会的语法就查语法书。四行代码，学好久。。。
----------
【function】
---------
**什么是函数？**
JavaScript的数据类型分为：
1. **Primitive Type**: 数字、字符串、布尔值、Null、Undefined
2. **Object Type**：Array、**Function**、Other Classes
一言概之：函数是JavaScript中一种重要的特殊对象
---------
- **函数声明(function declaration)**
> - function [name] (parameter) {statements;}
#### 1.function是关键字
#### 2.[name]可以省略，省略后的函数叫做匿名函数（anonymous function）
#### 3.()里可包含0-255个参数（parameter，形参）
#### 4.{}里面的内容叫做函数体（function body）,包含0-多条JavaScript语句，语句的数量不限，每个语句用分号进行分隔 ；花括号是必须的，不可以省略；
#### 5.和var Ideal = "lixiang" 声明一个变量必须以var开头一样，声明一个函数必须以function开头
比如：
```JavaScript
function calculateAdd(x){return x+1;}
//calculateAdd 是函数名；x是形参；return x+1是函数体；
```
- **函数表达式(function expression)**
> - var 变量名 = function [name] (parameter) {statements;}
函数声明和函数表达式的语法很像，但有一个**重要的区别**：
**声明语句**会“被提前”到顶部，也就是可以被在它出现位置之前的代码调用；
而用**表达式方式定义**的函数在被定义之前无法被调用。
PS: 这也是老师在讲函数调用的时候，为什么有一些代码物理位置出现在比较靠后的位置，但是前面的代码需要它的时候依然可以调用。
----------
【output】
---------
根据上一节的内容,第1行的"output"是一个函数的名字，如果省略了则是匿名函数;
第6行的"output"则是函数调用四种办法的第一种：作为函数调用，第6行是调用表达式。由 函数名+括号+传入的实参值（实参的英文是argument）
----------
【name】
---------
```JavaScript
function output(name){
console.log(name)；
}
var name = ‘Hello，JS’；
output(name);
```
#### 第1行的name: 形参
#### 第2行的name: 函数语句，打印函数接收到的值
#### 第4行的name: 定义一个变量 变量名字是name 变量的值是Hello,JS
#### 第5行的name: 调用表达式里面的name是一个实参，接受第四行得到的变量name的值，传入函数，执行，得到最终的结果‘Hello,JS’
================================================
FILE: homework/lesson5/luoruijun.md
================================================
# 第5课作业 分析代码
1. 第一行的变量name是函数output的参数，只是说明此函数需要一个什么参数，定义函数时设计此参数如何参与运算，参数是什么名称（name\name1/myname）都不影响运算情况和结果。
2. 第五行的变量name：定义一个名称为name的变量,并赋值为‘Hello,js’。
3. 第六行调用output函数，此时output()内的参数使用第五行定义的变量name，其值是' Hello,js'，此变量实际进行运算，和第一行、第二行的name是不一样的。
================================================
FILE: homework/lesson5/maggiewong.md
================================================
作业1.代码执行截图
**总结：**作业刚开始做的时候终端运行一直有错误，在网上查了之后也没有解决问题，心态就浮躁了很多，想着欠下很多作业怕赶不上进度。在群里问了之后同学们帮忙看了一下出问题的地方的截图提出了修改建议：
1.文件先保存一下再在终端运行否则容易出问题，文档名字旁边有点说明有改动未保存，可以打开菜单栏里的自动保存。
2.要先打开文件保存的路径，路径写法要规范，斜杠是/而不是\。这里去查了一下绝对路径和相对路径，何伟同学一边操作并截图一边详细讲解举例才搞清楚了概念。想起之前Python的课程里提到过更改文件保存的路径，稀里糊涂没有搞清楚路径的正确写法操作失败，因为老师说不是课程重点了解即可就给自己找借口没有吃透概念，现在被绊倒在同一个地方，深知学习不能糊糊涂涂的，基础的东西一定要吃透，不然还会在别的地方吃亏。
3.路径的问题解决了之后又出现了module not found 和syntax error的问题，排查原因后才发现是因为粗心分别忘了把文件送给node运行和跟着视频打代码时忘了把var改成function。visual studio code用红色波浪线划出了有问题的代码，但是对代码的含义没有吃透的话也难以察觉错误。
遗留问题，代码里跑步的表情不知道怎么调出来的，直接从老师的课件里copy过来了。。。
作业2：
第一行的name变量是做用作参数判断，第五行的name变量是定义一个变量并给它赋值为‘Hello, JS’，第六行的name变量是用作返回结果，第一行和第六行的name变量对应的值是一样的。
================================================
FILE: homework/lesson5/marshalcy.md
================================================
### 作业1
function output(name){
console.log(name);
}
var name = ‘hello,js’;
output(name);
第一行的name是一个形式上的参数，
第五行的name是一个变量，这个变量的名字叫name，
第六行的name是实际的参数，
第二行的打印name，就是第一行传入第六行实际的参数name的值，值是第五行变量的hello js。
================================================
FILE: homework/lesson5/oyanagchun的作业
================================================
================================================
FILE: homework/lesson5/panyong.md
================================================
# 第五次课作业
## 作业
1. 阅读study/lesson5的sample代码
```
sample代码演示了
1、直接调用、间接调用、异步函数的使用
2、string、object、number、boolean、array数据的使用。
```
2. 下面代码中，第1行、第4行、第5行的name变量都有什么差异？
```
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
差异就是，第4行 `var name = 'Hello,JS'` 是定义了一个name变量，后续的代码中都可以使用这个变量。第5行`output(name)`就是在使用第4行定义的name变量。第1行`function output(name) {`这里的name是，函数的参数，只在函数内部有效。
## 听课笔记
课程惊喜：送手环。以github开源为例，说明时间是宝贵，互相帮助是件非常有意义的。
## 浏览器与服务器的顺序图
画图很重要。画图工具: [ProcessOn](www.processon.com)、`Visio`。
## 前端交互实现的关注点
```
1、用户html的交互
2、html与js的交互
3、js与服务器的交互
```
## 函数内部怎么写
上节课主要讲了把生活场景映射为代码的思路，用函数来表达流程（老师重点演示了办一桌酒席的顺序图)。这节课，主要将函数内部如何写。
1、参数判断
2、逻辑处理
3、返回结果
```
立刻返回 / 间接返回
立刻返回： 用return
间接返回： 就是调用函数时，参数中传入另一个函数，用传入的这个函数来间接处理数据。这里的间接返回，也就是callback回掉函数。
```
## 异步
```
setTimeout(callback,5000); // 5秒后，调用callback函数
```
## 小结
很喜欢徐老师的课。我其实是计算机科班出生，学过C/C++/Java，只是没好的机会去工程岗位上锻炼，回老家当了老师。老师的每节课我基本上都听了两遍，一遍是听老师讲了什么，第二遍是听老师如何教的（会对比以前老师是怎么教的，如果是我教呢？）。
跟着徐老师的课，到目前为止最大的收获是git的使用，办一桌酒席案例中蕴含的编程思路，还有js中把函数作为参数传入的用法。一般的编程课，就是在讲语法，讲数组，讲循环...... 老师的课，这些基础语法都没做重点讲，而是在讲真正重要的东西，编程的思路，函数的写法与调用方法。想想，初学编程时能听到这样的课，真的是太幸运了。
由于课程回放有时间限制，后续自己要调整出更多时间来学习来练习，同时，也期待老师后续的课。
================================================
FILE: homework/lesson5/qiujingyu.md
================================================
【作业内容】
1. 阅读study/lesson5的sample代码
2. 下面代码中，第1行、第4行、第5行的name变量都有什么差异？
```
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
【解答】
第1行的name是函数的形参，是函数体的局部变量。
第4行的name是定义的全局变量，是第5行name的值。
第5行的name是第一行函数的实参，第1行的形参name可以变成abc等，不会影响结果。
> 函数调用会为形参提供实参的值。函数使用它们实参的值来计算返回值，成为该函数调用表达式的值。
【体会】
突然蒙了一下，忘了什么是变量，哈哈。
> 变量是一个值的符号名称，可以通过名称来获得对值的引用。变量的工作机制是编程语言的另一个基本特性。
```
console.log(1);
function output(name) {
console.log(2);
console.log(name);
console.log(3)
}
console.log(4);
var name = 'Hello,js';
console.log(5);
output(name);
console.log(6);
```
按照老师说的比较low的方法来调试，得到的结果是
```
1
4
5
2
Hello,js
3
6
```
这样确实比较容易理解。
================================================
FILE: homework/lesson5/readme.md
================================================
今天的间接返回的处理手法理解上会有难度，而这就是js最难的部分。后面的所有课程都是在使用这些技巧来处理代码流程。完全不用担心现在的懵逼状态。
把作业做好。
【作业内容】
1. 阅读study/lesson5的sample代码
2. 下面代码中，第1行、第4行、第5行的name变量都有什么差异？
```
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
【提交方式】
1. 请向getting-started-with-javascript项目发起pull request。
https://github.com/xugy0926/getting-started-with-javascript
3. 提交homework/lesson5目录下。
4. 以自己的名字命名md文件提交。
5.
================================================
FILE: homework/lesson5/shaozhen.md
================================================
### 第一行的name是局部变量，只能在函数内部访问它，只要函数运行完毕，局部变量就会被删除。
### 第五行的name是全局 JavaScript 变量，在任何位置都可以访问。
### 第六行的name是函数的参数，在调用函数时，可以向其传递值
================================================
FILE: homework/lesson5/shenzhili.md
================================================
#第五节课作业：
**代码中第1行、第4行、第5行的name变量有什么差异？**
```javascript
function output(name){
console.log(name);
}
var name = 'Hello, JS';
output(name);
```
第一行的name是function函数中的变量(形参)。调用函数时，函数体用形参进行逻辑处理（计算），之后再将实参传入形参，得出结果。
第四行声明了一个变量，变量名为name，随后赋值给它"Hello,JS"
第五行的name是第四行的变量，此时，name是作为一个实参传给函数去做处理。
**从作用(性质)上来看：**
第一行：函数的变量(名),形参(parameter)
第五行：变量(名)
第六行：变量(名)，作为实参传入函数。
**从值来看：**
第一行：只是形参，内部没有数据，需要被赋值。
第五行：变量值="Hello,JS"
第六行：变量值="Hello,JS"
================================================
FILE: homework/lesson5/sophieQi.md
================================================
代码中第1行、第4行、第5行的name变量有什么差异？
```javascript
function output(name){
console.log(name);
}
var name = 'Hello, JS';
output(name);
```
第4行 变量名为name。
第1行定义函数为name,也可以是其他的名称，比如name1，相应的第二行也要改为name1。
第5行，name为执行对象。输出name的值。
================================================
FILE: homework/lesson5/sunyan.md
================================================
# 作业
声明：按代码从上到下的顺序，分别把三个name称为name1、name2、name3。
1.name1是函数output声明所需要的参数，如果按照老师的“声明 → 定义 → 赋值”三步骤来说的话，此时name1只是被声明了，再结合output函数对name1的用法来看，
此时它可能是任何类型的数据，number、string、object...都可以。
2.name2是声明定义了一个变量，并给它赋予‘Hello,JS’这样一个具体的值。
3.name3就是把name2作为一个参数拿给output函数使用
（即name3其实就是name2，假设name2的命名发生变化“name2 → hello”，那么name3也得跟着变才行“name3 → hello”），
这也相当于给name1定义和赋值，此时name1的值就为name2，数据类型为string。
之后再次调用output函数时，我们还可以给name1赋予不同的值name4、name5...name_x，name1的数据类型也可能随之改变，当然函数的运行结果也会跟着改变。
# 一个疑问
图1——方便理解问题的截图
图2——再次运行，查看到的情况的确是console.log('事情安排好了，我先去洗个澡')这句代码，在那5秒的间隙里先运行了。
【疑问】如果从正确表达“做饭流程”这方面来说，这样的代码算不算有问题？
================================================
FILE: homework/lesson5/tangjianfeng.md
================================================
##Homework of lesson5
第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。
function output(name) {
console.log(name);
}
var name = 'Hello,JS';
output(name);
第一行的name是定义run函数的一个参数，这个参数和第5、6行的name不是同一个东西，第5行的name是被‘Hello,JS'这个字符串赋值的一个变量，然后第6行的name就是把第5行的字符串当参数调进函数output（name）中，这样打印出来的就是‘Hello，JS’
用自己的话说就是function output(name)就是在自定义一个函数，也就是做一个自己的工具，当在name参数的位置放一个变量进去的时候，就会打印出这个变量，第1行的name这个参数就算命名成mingzi也无所谓，只要下面的console.log的括号中的参数也变成mingzi就可以了，即console.log(mingzi);
而第5行的name也可以变成其他的名字，例如myName，只要下面第6行的output中的括号中的内容也写成myName，就可以了。说到底，真正重要的是function output(name)这个函数是怎么定义的，变量名倒不是重点，当然最好能命名得清楚些，例如有些函数的参数必须要数组的，那就把参数变量名写成myArray这种名称，这样就容易让人理解，否则很容易会被人传个字符串或者整数这种不合适的参数传进去，这样就不好了。
================================================
FILE: homework/lesson5/taobao.md
================================================
# lesson5_第五次作业_understandingOfName
```
1 function output (name){
2 console.log(name);
3 }
4
5 var name = "Hello, js";
6 output(name);
```
---
Fidn the "name" different between line 1, 5 and 6.
For the whole code, build the funtion with name "output" and when run function output, it needs get parameter, then the result of function output is print the parameter what it got at beginning. Moreover, for the line 5, it varable name and delimit "Hello, js". In line 5, the "name" is the name of one varable. In line 6, it is run output function and send the parameter which name is "name".
I think this homework is similar with sample code, indirect_call.js.
---
第一行， name 是作为一个接收参数，传入function output() 中，function 将传入的参数打印出来。
第五行， name 是一个变量的名称，即声明变量name ，然后定义。
第六行， name 是一个参数被传入，当运行output() 这个 function 的时候。
================================================
FILE: homework/lesson5/wangchangqing.md
================================================
## 问：图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你名字命名的md文件提交。
第1行的name是一个**“形式变量”**。在这里并没有什么实际的含义，只要和下文中
的“XXX”保持一致即可，都可以传达出“这是一个输入什么，就可以输出什么的函数”这么一个意思。
第5行的name是一个**等待被赋值的变量**。在这里，它被赋值为<'Hello,JS'>。
第6行的name是一个**已经被赋值的“实际变量”**，正在被输入函数output中，经过逻辑处理，获得结果。
**结论：**
在定义函数时，变量叫什么名字不是特别重要，因为这个时候它没有实际的含义，只是一个用来解释“这个函数如何处理数据”的**工具**和**象征**。
当实际调用这个函数时，需要先对函数所需要的变量或者参数赋值，然后将赋值后的变量代入函数之中，以求得最终的结果。这个时候，变量的名字和值就很重要了，因为名字反映了它的用途和意义，而它的值直接决定了我们能否得到想要的结果。
================================================
FILE: homework/lesson5/wangwei.md
================================================
## 1. 阅读study/lesson5的sample代码，并执行观察结果。
> #### 已阅读
## 2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
> 
>> #### 1. 第5行和第6行的`name `是 同一个` name `, 第5行是对 声明 定义一个变量` name `, 并把字符串 `‘Hello,JS’` 赋值给`name`
>> #### 2. 第1行的`name`和 第5行 第6行 不是同一个`name`, 他的 作用域 只在 函数`output()`
里面，在第6行调用函数`output(name)`时， 把第6行`name`的值，赋值给 第1行的`name`, 他是值的一种传递吧。
================================================
FILE: homework/lesson5/wangyunfei.md
================================================
## Lesson 5 关于函数的感悟
### 一、
从第四节课开始，老师陆陆续续引用例子，从“军训报数”，到“做一做酒席”，再到“查询航班信息”，都是为了引出JavaScript中最最最重要的数据类型-----函数。
并通过“不同的查询航班信息案例” 来引出“立刻反回”与“间接反回” ，并最终引出异步函数。
通过案例，确实能够深刻的理解 “立即” “间接” “异步”，这三个中文的名词概念，可是真正引入到JS函数中去，确实一时半会转不过来弯，包括此时此时仍然迷茫。
### 二、
先来说说函数，啥是函数？
经过百度，引用某版主的释义：“函数就是包裹在花括号中的代码块，可以在某事件发生时直接调用函数（比如当用户点击按钮时），并且可由 JavaScript 在任何位置进行调用。”
其实这句话说跟没说一样，我要的是大白话,心碎ing......
创建函数有三种方法？
①、构造函数
var name=new Function（...）
②、函数表达式
var name= Function(...)
虽然版主说，构造函数与函数表达式有区别，并作出了解释，但是实际上，除了少个new，我还是没觉得有啥区别。
③、函数声明法
function name(...){...}
函数声明法，没有声明关键字“var”，也没有“等号”，看上去，有些怪怪的，确实是没有 var name=“小明”，来的直接。
但是确实最常用、最高效的函数创建方法。因为，构造函数和函数表达式存在变量提升的问题。而函数声明不存在这个问题，无论在何处调用都可以。
（其实，我也不懂，啥叫变量提升，查了一圈，也没搞懂....,爱啥啥吧，不管它了。）
### 三、
有了函数声明法的构造，结合构造去了解函数，function name(...){...}。
“function” 这个单词在英文中，就是“函数”的意思，同是“function”也是在“函数声明法”的关键字，“function”后紧跟名字，又叫“函数名”。
函数名后先跟小括号“( ) ”,小括号里的内容是添加参数用的。
小括号后面的花括号{...}，这里面装的就是各种各样的代码块。具体代码块是什么东东，正在研究中....
### 四、
开始研究案例，这个案例同是也是是老师留的Homework，
#### 案例（一）
function output(name){
console.log(name);
}
var name= "小明"
output(name);
短短几行代码，一共出现了4次"name"。
node下运行结果为：“小明”
为啥结果是“小明”呢？ 咋一看，因为 var name=“小明” ,“name” 又被“output” 函数给调用了，所以name输出结果肯定是“小明”。
### 其实不然
继续分析案例，将语句稍作更改。
#### (案例二)
function output(name){
console.log(name+'同学');
}
var name= "小明"
output(name);
在node下运行，得到的结果是 “小明同学”。 可能有很多人蒙圈，确实，我一开始也蒙圈，明明 var name=“小明”，这个定义没变啊，咋就成了“小明同学”了呢？
### 稍等片刻，我将案例再做修改。
#### （案例三）
function output(mingzi){
console.log(mingzi+'同学');
}
var name= "小明"
output(name);
案例总共该了两次。
第一次我将第二行：“console.log（name);”，改成“ console.log(name+'同学')”。
第二次更改，我将“function output(name)，” 改成“function output(mingzi)”。
至此，5行代码中，“name”出现的频率只有两次，分别是 var name= "小明" 与 output(name）。
将第三个案例，再一次运行，结果仍然是 “小明同学”。
## 五、总结
在函数中，一个函数名在定义时，小括号里面输入的参数，是一个虚拟的参数，或者说是一个没有任何值的参数。并非是调用了一个已有的变量，来作为参数。它是个一个“虚拟的参数”。
这个虚拟的参数只有在调用者，调用“别人家的量”时（这个“别人家的量”可以是函数，变量，总之就是一个实际存在的量),。
这个“虚拟的参数”才能接收到“别人家的值”。这个“虚拟参数”也叫做“形式参数”，当“形式参数”收到值后，才能进行一系列的运算，比如：“name+'同学'”。
同理，“别人家的量”，指的是函数、变量、语句等。本文中，指的是 var name= "小明"，这句话中的 “name”。 这个“别人家的量”称之为“实际参数”，简称实参。
#### 再一次回到第一个例子
function output(name){
console.log(name);
}
var name= "小明"
output(name);
这个例子中，如果函数“output”不调用 var name= "小明” 这句话中的name变量，也就是把“output(name);这一语句删掉，
那么 function output(name)与{console.log(name;} ，这一句中的两个“mame”，它俩永远都不知道自己叫“小明”。
output（name）;表示调用“实际参数”，也就是调用 “var name= "小明"”，中的 name 变量。
调用完之后，把“小明”这个值，悄悄的告诉 function output(name){console.log(name+'同学');} 中的两个"name"，
这个两个“name”收到值后，才开始计算，name+'同学'，于是就有了：“小明同学”。
例子中的output(name),name这个单词，就是起到一个接收作用，把这个name改成阿猫、阿狗，只要 var name= "小明"不变化，然后发生函数调用，结果依然是“小明同学”。
## 六、题外话
还是上例子：
function output(name){
console.log(name);
}
var name= "小明"
output(name);
这个例子中，如果把 变量“name”的值发生表更， 即：var name='小李', 其他不变，结果就成了“小李”，因为调用的依然是变量“name”，不管第四行中的name值如何变。
可是如果在函数体内，即花括号内{ }，对name进行变更，结果值就会发生变化。
直接上例子：
function output(name){
var name=“小花”
console.log(name);
}
var name= "小明"
output(name);
再次运行后，发现结果跟小明没关系了。结果是“小花”,因为函数内的“var name” 与函数体外的 "var vame"，他门的作用区域是不相同的，且被调用的顺序也不同。
其实第四、五节课，重点的重点就是同步函数、与异步函数。我不断的尝试更深次的了解它门，并且想总结出自己的理解，但是发现掌握的知识太碎片化，很难串联起来，脑海里很难形成一个成型的同步与异步的概念。
我感觉到，如果想深入了解同步与异步函数，必须要对其基本的知识点掌握透彻，然后不停的修改同步、异步的相关代码，反复执行，然后再看别人的文档，才能有所感悟。
同步函数、与异步函数，确实很烧脑，我正在琢磨中，不知道还要琢磨多久，也许需要很久，但是我愿意去尝试。
就像在在琢磨他们的时候，初步了解了什么叫形参与实参，并且知道他们的差异，与原理。这就是收货。
### 每一个人都必须按照他自己的方式去思考；因为他在自己的道路上，就会发现能帮助他度过一生的一条或者一种真理。但是他切不可放任自己；他必须克制自己，光有赤裸裸的本能是不行的。 ——歌德
================================================
FILE: homework/lesson5/wangzhongbin.md
================================================
###### 题外话
迟来了两周的作业。
上周旅游，周末和周一二都去了外地。
本想着，背电脑去，晚上有时间敲敲代码。
但又想：出去玩，还背电脑，夜里又"啪啪啪"键盘，貌似也不对劲。
结果没带，好后悔。
晚上，看群里讨论得热闹，只能干看，(⊙﹏⊙) b，想敲敲代码，拿着手机很不舒服，于是放弃，觉得自己做错了选择。
教训：电脑外出要背着，不能嫌沉，不能在意别人的眼光，不论走到哪里，都要时刻准备着——敲代码。
Ps:因为作业是听了老师后来讲的，还有周五补的课程，加持了这三节课的威力，我对代码的执行的理解有了质的提升，^^(我感觉)。
---
## 一、lesson5 sample代码的解析
这2周老师，带领我们这群小白，理解函数。
虽然老师讲了那么多，但对异步、直接返回，我依然有些懵，不过也稍微理解了一些。
### 从函数的定义开始
函数是啥，就是你给它一个参数，它经过特殊处理，返回结果的算式。
所以一个函数里面有3个很重要的元素（函数名也很重要）：
1. 参数
2. 表达式（算式）
3. 返回的结果
这三个元素，针对不同情况，就分出来很多不同类型的函数。
**回调函数**
假如，一个函数A的参数B，不是一个值，而是其他的一个函数，即函数A的参数B **是一个函数**。
那么，B是回调函数。
当运行A的时候，运行到了需要用到B时，会跳到B里面，运行B，得出一个结果，再返回到A里面继续运行。
**异步函数和直接返回**
这是针对返回情况，而产生出的两种不同函数。
直接返回的函数是，当你运行到了这个函数时，必须要等待这个函数给出一个结果，它才运行下一行，否则它就会一直卡在那里。
异步函数呢，当电脑运行到了异步函数这一行时，会先跳过它，运行它之后的代码，当异步函数运行完了之后，返回一个结果。电脑不会卡在那一行。
### 作业2 name变量有什么差异？
```
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
第一行的name,是函数output() 的参数，name作为参数变量，并无实际意义，name也可以是a，b，c……
然后，第二行的命令是把参数变量name打印到屏幕上。
此时，都是在定义函数output()。
然后第4行，是声明了一个变量，定义变量名为name,并赋值它name = 'Hello,Js'，是个字符串,此时name是变量，是有意义的;
然后，把name这个变量传给了函数output(),运行output(name);
### 做菜函数解析
粗看之下，老师一直使用callback回调函数，但找了半天也没有找到定义callback函数的语句，试运行了下老师的代码，居然是还没有准备好……后来我又运行了一次，发现又多了一行,后来过了很久，又看时，居然成功了，(⊙﹏⊙)b。
好吧，如果是上周，我傻了，而且束手无策，现在是有些懵，不过幸好是听过了周五的补课，有解决方法。
##### 查找原因
代码的上半截都是定义函数，执行是从调用开始。
```
startWork(); // 是最开始执行的函数,找到它。
// 然后startWrok()执行，
function startWork() {
var success = prepare();
if (!success) {
console.log('还没准备好');
return;
} // 不懂!success是什么意思。
```
只执行到了if语音，因为if函数里面有一个return，也就是直接结束了startWork()函数，所以第一次运行是，运行了if里面的语句，(!success)成立了；
但是第2次运行之后，发现if语句不成立了，(⊙﹏⊙)b，就几秒的时间。
好吧，究其原因，是因为不懂!succsss是什么意思。
一开始不成立，后来又成立了，翻了同学的作业，又百度了一下。
发现，!success 是指 success !== true，即success是false时，就执行if语句。
回看，prepare()函数，里面有一个随机函数。好吧，故而success时而成立，时而不成立。
这个解决后，继续看下去。
##### 第二个难点。
当preapre()函数是ture时，执行了buyFoods()函数。
```
buyFoods(function(foodsList) {
cooking(foodsList, function(feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
```
找到buyFoods()函数，它的变量是一个回调函数:callback();
先执行第一行：
```
function buyFoods(callback) {
console.log('我要开始采购食物啦。。。。');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('采购完毕');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}, 5000);
}
```
接下来是一个setTimeout()函数，是异步函数，跳过它，bufFoods()函数先放一边，先执行其他代码。
执行了53行的代码：
```console.log('事情安排好了，我去洗个澡')```
等待setTimeout生效,执行setTimeout()里面的语句。
* 第7行代码；
* 第8行代码，赋值foodsList;
* 第9行代码，同时执行有参数的回调函数callback(foodsList),找callback()函数的表达式；
* 第44行代码是callback()函数的表达式，是直接写在了buyFoods()函数的括号里面的；
> 一开始我找了好久没有找到callback()的表达式，后来又看了一眼命令行，发现就在buyFoods()函数括号里面，只是没有命名成callback()而已。
* 执行45行，执行cooking()函数，找到定义cooking()的代码，第20行。
* 执行21行。
* 执行24行，又是异步函数setTimeout()，跳过它，但之后没有语句了，等它生效;
* 执行25行。
* 执行26行。
* 执行28行，赋值feast = ['鸡蛋西红柿'，'红烧肉'，'红烧鱼']；
* 执行有了feast参数的29行callback(feast)函数，找到callback()的表达式，又是直接被写在了cooking()函数里面。
* 执行46行。
```console.log('---酒席准备好了----')；```
* 执行47,48行代码，是一个for循环语句，批量打印出feast里面的内容，就是feast = ['鸡蛋西红柿'，'红烧肉'，'红烧鱼']。
然后就结束了。
^^蛮辛苦，好难。
但是很兴奋，执行得蛮顺利，克服了2个困难……给老师比心~
^^
================================================
FILE: homework/lesson5/wengguihua.md
================================================
## 变量差异
第1行变量：作为函数的形参，作用域仅限于函数内部，是局部变量，引用该函数时变量名可以与定义的不一致。
第5行变量：声明了一个变量，并定义了一个变量，同时将Hello，JS这组字符串赋值给变量，这是一个字符串变量，该变量为全局变量。
第6行变量：该变量为第5行所定义的变量作为实参传递给函数。
## 观察代码
重点对厨房工作流的代码进行思考，主要结论为：执行工作流函数后，第一步准备函数开始执行，然后通过条件语句判断是否准备完成，完成后买菜函数开始执行，完成后将结果通过callback函数A传递给做菜函数，同时通过该callback函数A启动执行做菜函数，做菜函执行数完成后将结果通过callback函数B，该callback函数B完成上菜程序。整个工作流为大家开始做准备工作，然后主管安排人买菜，买好菜后通过物流渠道把菜交给做菜的，做菜做好后通过上菜渠道把菜交给上菜的。主管交代完后大家就买菜的就开始干活了，主管也去洗澡了。
================================================
FILE: homework/lesson5/wenliuxin.md
================================================
# 5thHomeworkd
第一行的name是参数，可以把这个name看成收纳盒的盒子，它要装的材料是name这样一个东西（就是性质为name的东西）。
第五行的name是一个参数，它等于Hello,JS，这个name就是一个材料。
第六行的name是输入函数output的数据，也就是材料，这个材料就是第五行的‘name = hello，js’，它虽然和第一行的name位置一样，但是，其实第一行是盒子，也这一行是材料，也可以说是盒子里有了材料。
================================================
FILE: homework/lesson5/wenyunxin.md
================================================
## 三个name变量的差异
### 第一行的name变量
这里的name变量处于函数名后面括号里的位置，是属于这个函数的参数，也是这个函数的参数占位符。它表明这个函数至少需要传入一个参数才能正确被调用。这个name变量在这个函数里未被声明定义或赋值，表明他可以是函数允许传入的任何数据类型。
### 第五行的name变量
这里的name变量是一个全局变量名。它被声明定义并被赋值了'Hello JS'。它在全局的任何位置可以被直接拿来使用。
### 第六行的name变量
这里name变量是指调用函数ouput执行时传入的具体参数对象变量名称。它实际上就等价于'Hello JS'。实际上就是调用函数执行：output('Hello JS')。
================================================
FILE: homework/lesson5/wufan.md
================================================
终端输入：
git checkout master
出现：
$ git checkout master
homework/.DS_Store: needs merge
error: you need to resolve your current index first
#lesson5代码分析
>// 模拟异步处理的手法
// 定义函数callback
function callback() {
console.log('我跑完了');
}
// 定义函数run，run接收一个函数类型的参数，当执行完动作后，调用该函数。
function run(cb) {
console.log('🏃🏃🏃🏃🏃');
cb();
}
// 调用函数run，并把函数callback当参数传过去
run(callback);
// 定义一个函数，函数名为callback
function callback () {
console.log('我终于被调用了');
}
// 5秒钟后调用callback函数
setTimeout(callback, 5000);
> 直接返回结果
function checkFlightSchedule() {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
return scheduleInfo.start;
}
//---------------------------------------
// 调用立即函数checkFlightSchedule
var startTime = checkFlightSchedule();
console.log(startTime);
> 间接回调处理
// checkFlightSchedule函数的定义者设计了一个通过回调的方案。
// 当函数处理完后，通过调用者设置过来的回调
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}
//---------------------------------------
function callback(startTime) {//形参，不具有实际意义。
console.log(startTime);
}
// 调用函数checkFlightSchedule，并塞一个回调函数以获取结果
checkFlightSchedule(callback);
> 模拟一个异步函数
function checkFlightSchedule(callback) {
console.log('开始查航班信息');
setTimeout(function() {
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
callback(scheduleInfo.start);
}, 5000);//构建一个setTimeout函数需要内部参数为一个函数和时间
}
//---------------------------------------
function callback(startTime) {
console.log('通过反馈通道获得了信息');
console.log(startTime);
}
// 执行查询函数
checkFlightSchedule(callback);
> 匿名函数的用法
function run(back){
console.log('跑完用时');
setTimeout(function(){var totaltime='10mins';
back(totaltime);},1000)
}
function back(totaltime){
console.log(totaltime);
}
run(function(){var totaltime='10mins';
back(totaltime);})//这就是一个匿名函数
> 回调异步的用法
// 采购食物的函数
function buyFoods(callback) {
console.log('我要开始采购食物啦。。。。');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('采购完毕');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}, 5000);
}
function callback(foodsList){
console.log(foodsList);
}
// 做准备工作的函数
function prepare() {
console.log('努力磨刀...努力洗碗...努力打扫...劳动最光荣');
return true;
}
// 做菜的函数
function cooking(foodsList, callback) {
console.log('开始做菜啦~~~');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('今天要做这些菜' + foodsList);
console.log('大工告成，上菜');
var feast = ['鸡蛋西红柿', '红烧肉', '红烧鱼'];
callback(feast);
}, 5000);
}
//------------------------------------------------
// 流程控制函数
function startWork() {
var success = prepare();
if (!success) {
console.log('还没准备好');
return;
}
buyFoods(function (foodsList) {
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
console.log('事情安排好了，我先去洗个澡');
}
// 干活啦~~
startWork();
# 代码分析
> 1. function output(name) {
> 2. console.log(name);
> 3. }
>
> 4. var name = 'Hello,JS';
> 5. output(name);
1//name在这里是函数function的参数名，这个参数名是用于接收别人调用时给的参数。按照先声明，定义，赋值的顺序。这里声明一个参数通道，定义它的名字叫name.这个通道可以有各种名命，就像快递的包裹的内容多种多样，书，风扇，手机，接口转换器，等等，最终它们都被快递到目的地。
2//这里的name是输出这个参数通道里的数据。
4//重新定义了一个变量名，这里可以是任意的名称，比如input，name1，等等合法的变量名。就像是快递包裹上名字可以多中多样一样。
5//输出上面定义的那个变量名所带代表的变量数据。快递终于送到目的地。
# 阅读代码的收获
间接返回代码例子：
>function callback () {
>
> console.log('我终于被调用了');
>
>}
>
>// 5秒钟后调用callback函数
>
>setTimeout(callback, 5000)//内置库调用setTimeout()函数，此函数有两个参数，第一个是一个函数返回值的参数，第二个后置时间的参数。
> function callback(){
>
> console.log('我跑完了')；
>
> }
>
> //定义函数run，run接收一个函数类型的参数，当执行完动作后，调用该函数.
>
> function run(e){
>
> console.log('🏃🏃🏃🏃')
>
> e();
>
> }
>
> run(callback);
直接返回的例子：
> function checkFlightSchedule() {
>
> console.log('开始查航班信息');
>
> // 模拟构建航班的时间信息
>
> var scheduleInfo = {
>
> start: '8/23 8:00',
>
> end: '8/23 10:30',
>
> from: 'beijing',
>
> to: 'hangzhou'
>
> };
>
> return scheduleInfo.start;
>
> }//---------------------------------------// 调用立即函数checkFlightSchedule
>
> var startTime = checkFlightSchedule();
>
> console.log(startTime);
================================================
FILE: homework/lesson5/wukuipin.md
================================================
### 第五课作业
代码分析：
```
function output(name) {
console.log(name);
}
var name = 'Hello, JS';
output(name);
```
第一行、第五行、第六行都有变量name。第五行的name是新申明定义的变量（这是一个全局变量），并给它赋值一个字符串‘Hello, JS’;那么，定义一个变量就得使用才行，不然就是垃圾代码，所以第六行代码就来调用第五行定义的变量(name)。同时，第六行也在调用第1~第3行定义的output函数，而output函数内部也有一个变量，恰好名字也是name（也就是第1行的name，这是一个局部变量），真是好巧啊！真所谓无巧不成书嘛！当然，它要是叫什么阿猫阿狗也行的，可偏偏他老爹也喜欢name这个名字，我们现在知道他也叫name，不过要清楚一点，这里的name和第5行的name是两个不同的变量，只是他们恰好叫同样的名字（name）而已。
第6行在调用函数和变量时，name变量的值会赋值给第1行的变量name，函数再把得到的值打印出来。最后结果会得到：Hello, JS
如下图：
================================================
FILE: homework/lesson5/xianengqi.md
================================================
## 【作业内容】
###第1行、第5行、第6行的name变量都有什么差异？
```
function output(name) {
console.log(name);
}
var name = 'xiaohua';
output(name);
> 第一行的'name'可以是一个任意名，它是'形参'。第二行的'name'是把函数output（name）传递给了console.log.第二行的name要与第一行的name保持一致。
> 第五行的'name'可以是一个任意名，声明了一个变量 'name'。 把'xiaohua'这个字符串赋值给了'name' 是'实参'
> 第六行的'name'是被函数output调用了第五行的name，它和第五行一样都是'实参'。
================================================
FILE: homework/lesson5/xiongliyu.md
================================================
# 第五节课作业
## 分析名字的不同之处
function output(name){
console.log(name);
}
var name = 'hello,js';
output(name);
>5：被首先执行。把‘’hello，js‘’赋值给了name。 6：这一行的name调用了第五行的name（因为第五行的name是全局变量）,作为实参，要传入函数名为output的函数中。
第一行的那么是函数output的形参，也是接收器，用于接受实参数据的东西。实参传入后取代形参，
name从未被改变。
### kitchen_workflow_async.js
分析（学习）代码的方法：
我是这样做的：
1. 对着敲代码（读代码），了解每段代码都是干嘛的
2. 找清楚“对象”（比如谁是采购者，谁是厨师、谁是通道）
3. 设置断点调试代码（可以根据我的想法修修改改），通过观察代码的执行顺序（理解整个流程和对象之间的关系）
4. 找关键点，比如callback，结合语法去分析（差语法）
5. 还是搞不懂就画画关系图和时序图
>个人理解：
>1、所有参于调用的函数都必须 除了接受实参以外，还接受一个callback函数（通道）。
> 2、函数中两个setTimeout都是把函数处理过程延迟，其模拟的手段是：延迟5秒再返回结果。
> 3、所有被延迟返回的callback(XX);其中，callback：代表返回通道（微信）。（XX）代表需要被返回的结果。
> 4、函数调用表达式中，以一个函数作为实参,传入后实参并不参与计算，作用：只是告知一个通道，当函数计算完后，callback的返回通道就是当时以实参身份进入的函数。
### flight_schedule_1.js
### flight_schedule_2.js
### flight_schedule_3.js
### indirect.js
================================================
FILE: homework/lesson5/yammy.md
================================================
## 分析代码
```sample.js
function output(name){
console.log(name);
}
var name = "Hello,JS";
output(name);
```
上面的代码，其中：
第1行的 name 是 定义output()这个 function 的参数。
第5行的 name 是 一个独立的变量，赋其值为一个字符串"Hello,JS"。
第6行的 name 是 把第6行的变量 name 作为 output()这个函数的参数，并执行函数。
## 观察代码
1. array
从上图的执行结果可以看出来，第一行是打印出了一个数组，然后是遍历数组并逐个打印，其次是对数组内的元素进行增加或减少，最后是打印出某个元素在数组内的位置索引。
查看了一下 api，发现array 还支持从数组的前面加入元素，比如 `myLikeColorsList.unshift("yellow");`
2. boolean
从上图可以看出，结果是打印出了 boolean 变量转化成 string 的值。
可以推断，js 的 boolean 类型 变量在申明后，允许改变其绑定的数据类型 boolean 成 string，是一种动态语言。
3. number
从上图可以看出，第一行打印出了 number 类型的变量值，第二行打印出了 number 变量转化成 string 类型后的变量值。
4. object
从上图可以看出，数据类型为对象的变量支持修改、增加和删除对象内变量，同时还支持函数变量。
## kitchen_flow 代码越看越有意思
kitchen_workflow_async.js 这里增加了回调函数，起初看不太懂，只感觉函数中套着函数，不过慢慢的发现只要把 callback 分出来，理清楚，就很容易看懂了，真心觉得老师您教的好，以前看不懂的 js代码，现在来看简直容易多了。
```kitchen_workflow_async.js
// 采购食物的函数
function buyFoods(callback) {
console.log('我要开始采购食物啦。。。。');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('采购完毕');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}, 5000);
}
// 做准备工作的函数
function prepare() {
console.log('努力磨刀...努力洗碗...努力打扫...劳动最光荣');
return true;
}
// 做菜的函数
function cooking(foodsList, callback) {
console.log('开始做菜啦~~~');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('今天要做这些菜' + foodsList);
console.log('大工告成，上菜');
var feast = ['鸡蛋西红柿', '红烧肉', '红烧鱼'];
}, 5000);
}
//------------------------------------------------
// 流程控制函数
function startWork() {
var success = prepare();
if (!success) {
console.log('还没准备好');
return;
}
buyFoods(function (foodsList) {
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
console.log('事情安排好了，我先去洗个澡');
}
// 干活啦~~
startWork();
```
看这一段代码的时候，我注意到 cooking 函数中少调用了 callback。
另外感觉安排事情的人和具体按流程做事情的人分开来，可能更容易理解。
================================================
FILE: homework/lesson5/yangchunguang.md
================================================
#第五节课：分析代码
##1.indirect_call.js
```
间接返回，是指第一段先定义出结果“我跑完了”，但是不打印输出。接着再运行“🏃🏃🏃🏃🏃”的代码，最后把定义的结果“我跑完了”通过run回传给“cb”（其实可以是ab，sb等任何字母，只不过为了便于理解和维护，和callback对应，才写了cb），回传之后console.log('🏃🏃🏃🏃🏃'),然后再通过cb（），输出“我跑完了”。
之所以是最简单的返回，就是通过定义callback，然后通过run把callback回传给cb，而不是直接输出结果，所以是间接返回。
```
##2.async_function.js // 最简单模拟异步的技巧
这里其实不是异步，只是时间延迟5秒。异步是并不立即返回结果，而是过了一小段时间后才出结果。
##3.flight_schedule_1.js // 立即返回案例
立即返回：就是发出指令后立即执行，并返回结果。
代码中，先发出查询航班信息指令，接着构建查询航班模型，然后return结果，到最后console.log(heckFlightSchedule);输出结果，中间并没有停滞，所以是立即返回。
##4.flight_schedule_2.js // 间接返回案例
间接返回：就是在直接返回的基础上，增加间接传输渠道。
本案例中，先把航班信息给callback，再通过checkFlightSchedule(callback)回传给callback(scheduleInfo.start);，最后通过console.log(startTime);输出。
##5.flight_schedule_3.js // 异步处理案例
异步：就是发出指令后，该干嘛干嘛，然后由后台执行，执行出结果后，再返回结果。
本案例没有看太明白，看到有5s的延迟，
##6.kitchen_wordflow_async.js // 异步实现一桌酒席
先定义function buyFoods、function prepare、function cooking三个步骤，然后通过流程控制实现做菜的流程，并在流程中增加判断功能，如果某一步骤没有准备好，则return（‘还没准备好’）。过程就是定义函数，确定流程，然后执行。
##代码分析：
第一行和第二行代码为同一个name，第五行和第六行是同一个name，上下两个name可以不一样，但是上下有哪些关系就不清楚了。
================================================
FILE: homework/lesson5/yangtieming.md
================================================
##第1行、第5行、第6行的name变量都有什么差异？
> 1. function output (name) {
> 2. console.log(name)；
> 3. }
> 4.
> 5. var name = 'Hello,JS';
> 6. output(name);
1. 第一行的name,是函数output的参数名称，它可以是任意值。
2. 第五行的name, 是一个被定义的变量，它被赋值成一个叫做'Hello,JS'的字符串。
3. 第六行的name, 也是函数output的参数名称，但此时它已不是任意值，只能是被赋值后的'Hello,JS'这个字符串。
================================================
FILE: homework/lesson5/yangxuewu.md
================================================
## 1. 示例代码分析
**作业示例代码：**
```javascript
function output(name){
console.log(name);
}
var name = 'Hello,JS';
output(name);
```
**分析：**
示例代码中有四个 name ，但四个 name 的含义却是不一样的。
第 1 行的 name ，是函数 `output()` 的参数，表示在调用 `output()` 函数时，需要给这个函数传入一个参数。
第 2 行的 name 就是函数 `output()` 的参数，所以，第 2 行的 name 和第 1 行的 name 是一样的。
第 5 行的 name 是一个变量，它的值是 `Hello,JS` ，这行代码的意思很明显，定义一个变量 name ，并给它赋值。
第 6 行的 name 就是第 5 行定义的变量，因此第 6 行的 name 就是 `Hello,JS` 。
**结论：**
示例代码中，第 1 行的 name 表示函数的参数，在调用前没有具体的值，第 5 、 6 行的name 表示变量，并对这个变量赋予了值。
## 2. 函数回调
老师说这部分是 JS 中最难理解的，我觉得因为突然把一个函数的参数变成了另一个函数，所以理解起来比较难。也就是说在 JS 里，函数的参数不仅可以是各种数据类型，也可以是函数，理解起来自然有点绕，那就用例子来分析。代码示例来自课程项目 `/getting-started-with-javascript/study/lesson5/kitchen_workflow_async.js`
```javascript
// 采购食物的函数
function buyFoods(callback) {
console.log('我要开始采购食物啦。。。。');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('采购完毕');
var foodsList = ['fish', 'egg', 'meat'];
callback(foodsList);
}, 5000);
}
// 做准备工作的函数
function prepare() {
console.log('努力磨刀...努力洗碗...努力打扫...劳动最光荣');
return true;
}
// 做菜的函数
function cooking(foodsList, callback) {
console.log('开始做菜啦~~~');
// 模拟5秒后通过callback返回结果
setTimeout(function() {
console.log('今天要做这些菜' + foodsList);
console.log('大工告成，上菜');
var feast = ['鸡蛋西红柿', '红烧肉', '红烧鱼'];
callback(feast);
}, 5000);
}
//------------------------------------------------
// 流程控制函数
function startWork() {
var success = prepare();
if (!success) {
console.log('还没准备好');
return;
}
buyFoods(function (foodsList) {
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
console.log('事情安排好了，我先去洗个澡');
}
// 干活啦~~
startWork();
```
在这个示例代码中，我认为通过从结果到过程的反向阅读代码的方式，能更好理解回调函数在这个示例中的作用。反向阅读中最重要的一段代码就是 `startWork()` 函数，我把我的分析写成注释，加入这个函数。
```javascript
// 流程控制函数
function startWork() {
var success = prepare();//调用 prepare() 函数，将函数的返回值 true 赋值给 success
if (!success) {//如果 success 没有得到 true 赋值，则执行 if 语句
console.log('还没准备好');
return;//因为 success 值非 true，因此函数终止执行
}
/*
*1. 函数 buyFoods(callback) 有一个 callback 函数，在这里就是 function (foodsList){}
* 因此，在 JS 里，函数不必一定要写成 function functionName(parameters){} 的形式
* 还可以写成 function (parameters){} 的形式，在函数中立即调用
*2. function (foodsList){} 接收一个 foodsList 参数，并将其传递给 cooking(foodsList,callback){}
* 在这里，callback 函数就是 function (feast){}
*3. JS 的回调函数很容易让人绕在里面，
* 一方面回调函数是函数，它被调用了就是要执行的，
* 另一方面回调函数应该看作调用函数的参数，
* 既然是参数，回调函数的执行时机应根据调用函数要求执行
*/
buyFoods(function (foodsList) {
cooking(foodsList, function (feast) {
console.log('----酒席准备好了----');
for (var i = 0; i < feast.length; i++) {
console.log(feast[i]);
}
});
});
console.log('事情安排好了，我先去洗个澡');
}
```
================================================
FILE: homework/lesson5/yanqingmu.md
================================================
# Homework for Lesson 5
## 1.阅读并执行代码
（1）async_fuction.js中```setTime(callback,5000);```是一个内置函数，其中参数```callback```是一个函数名，`5000`表示延迟的时间。这个内置函数的参数形式是已经定义好的，所以`setTime(callback(),5000);`就是不对的。同时，在flight_schedule_3.js中，我们发现可以在setTimeout中直接定义一个函数作为第一个参数，而且不需要函数名。
（2）对于内置函数`console.log()`而言，`()`中是要打印的内容，可以是变量、函数以及具体的值，那么`console.log(startTime);`也可以写成`console.log(checkFlightSchedule());`。
（3）indirect_call.js让我意识到间接调用的强大之处，它可以实现一个功能的整合和拆分。也就是说可以用一个函数来整合其他函数，从而实现更加强大的功能，比如把原来的代码改为如下的形式：
```// 定义函数callback
function teacher() {
console.log('冲刺');
}
function student() {
console.log('Yes, sir!');
}
function run(person1,person2) {
console.log('🏃🏃🏃🏃🏃');
person1();
person2();
}
run(teacher, student);
```
（4）关于kitchen_workflow_async.js有几处没有搞懂。
* 流程控制函数中，先声明了一个success，然后判断`prepare()`是否准备好（其中的if语句，只有当prepare函数的return为false或0的时候，才能被执行，这里只是表达逻辑的完整）。但是并没有调用`prepare()`的语句，但是最后准备函数还是被执行了。所以，我的问题是：为什么声明语句`var success = prepare();`起到了调用函数的作用？
* 流程控制函数中，buyFoods的调用又嵌套了一个cooking调用和两个function定义，这样写的好处是什么？其中foodList是函数buyFoods中的局部变量，为什么可以用在cooking函数中，是否跟这种buyFoods的调用形式有关，`function(foodList){…}`替代了原来的callback使得cooking函数可以使用变量foodList？
* 流程控制函数中，`cnsole.log('事情安排好了，我先去洗个澡');`这条打印明明是最后一条语句，却出现在「采购完毕」的前面，这是否跟延迟5s有关呢？
## 2.一起来找茬
需要找茬的代码是这样的：
```
function output(name){
console.log(name);
}
var name = 'Hello,JS';
output(name);
```
这里一共有4个```name```，它们看起来一个样，但含义却不一样。
（1）我们先来看前两个。
这两个```name```是在一个```function```里的，其中```function```所表达的含义是：你要先给我一个变量作为参数我才运行，运行的结果是把这个变量的值打印出来。
所以前两个```name```是统一的，但这里的```name```只是针对这个```function```所需参数的命名，并不一定需要与5、6行的```name```一致。也就是说代码可以改写成这样：
```
function output(lover){
console.log(lover);
}
var name = 'Hello,JS';
output(name);
```
（2）我们再来看看5、6行的```name```。
第5行中定义了一个string变量，命名为```name```，同时赋值```'Hello,JS'```。第6行是将第5行中定义的name变量作为参数提供给函数output，并执行函数output。所以第5、6行的name是统一的。这里可以把源代码改为如下形式：
```
function output(name){
console.log(name);
}
var girlFriend = 'Hello,JS';
output(girlFriend);
```
================================================
FILE: homework/lesson5/yimiao li 5th.md
================================================
Lesson 5
**最重要的概念就是函数, 立即返回函数， 间接返回函数**
## 函数三要素
假如你要请一个人帮忙做某事，你必须要明确到底请谁（函数名）？告诉他你的要求（参数）是什么，他处理完事情后就会给你一个结果。
functon 函数名（参数）
>参数作用可以一句话总结：在函数执行过程中，完成某些逻辑处理时需要的一些必要的数据。
## 错误记录一（print 函数）
function print(content) {
console.log('hello, JS');
}
print(content);// 是一个错误的结果，因为没有定义content，print后面是一个变量形式，数字、string等，需要加: 'content'
## 错误记录二（关于return 函数）
这是 node 和 浏览器环境的区别。**return函数在浏览器条件下，直接可以执行；但是在node环境下没法执行，必须要console.log才可以**
在使用 return 语句时，函数会停止执行，并返回指定的值。
## 异步函数
setTimeout 是内置函数所以不用定义就可以直接用。
## 变量和函数定义的区别：
> 变量和函数定义的区别：
> **变量：**先定义后使用
> **函数：**无论在哪定义，使用的时候才调用
## 作业部分
function output(name) { //name形参 是一个空壳子
console.log(name); //打印参数name的具体内容
}
var name = 'Hello,JS'; //定义变量name 也是是定义实参
output(name) //调用name这个函数，这是真正赋值的内容
================================================
FILE: homework/lesson5/youshilei.md
================================================
#第五课作业
##作业题目
1. 阅读study/lesson5的sample代码，并执行观察结果。
2. 图片上的代码，第1行、第5行、第6行的name变量都有什么差异？请分析差异提交你的结论。以你命名的md文件提交。
##我的解答
```javascript
function output(name){
console.log(name);
}
var name = 'Hello,JS';
output(name);
```
- 第1行name是自定义函数output用来传递的参数，通过它可以函数外部数值传递给函数内部，也就是第2行里的name。
- 第5行name是新声明的变量，并且给它赋值。
- 第6行name是自定义函数用于计算的变量，它调用的外部第5行name变量的值。
================================================
FILE: homework/lesson5/zhanggaoyang.md
================================================
第五课作业
outpu是一个函数名
function output(name) {
console.log(name);
}
var name = 'Hello,js';
output(name);
output是一个函数变量，var定义了一个值`'Hello,js'`而这个值被传入到`function`函数里，所以`function`是一个按值传递，即虽然参数不同但不影响结果。
所以，函数的`name`和var定义的`name`是不同的。
================================================
FILE: homework/lesson5/zhanglina.md
================================================
---
2017-08-28 第5次作业补交 —-create by zhanglina
---
1. ##### 作业回答：
```javascript
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
```sql
第1行的name:声明一个output的函数，该函数有一个为name的形参
第4行的name:定义了一个叫name的变量，并给其进行赋值操作，或者叫做初始化的操作
第5行的name:将第4行初始化name，传给函数进行调用
```
2. ##### 课程理解：
```
函数的三要素：参数判断，逻辑处理，返回结果
参数判断：主要进行了函数有效性的判断，如果传入的值符合程序的规则，才会执行后续程序，保证了代码的完整性。
逻辑处理：是程序的核心的，该部分是通过程序语言，将PM的需求通过代码的方式实现
返回结果：程序处理完成之后，给出一个执行结束的标致。
```
3. ##### 代码改写：
```javascript
function checkFlightSchedule() {
console.log('开始查航班信息');
// 模拟构建航班的时间信息
var scheduleInfo = {
start: '8/23 8:00',
end: '8/23 10:30',
from: 'beijing',
to: 'hangzhou'
};
return scheduleInfo.start + " "+ scheduleInfo.end + " " + scheduleInfo.from + " " + scheduleInfo.to;
}
//---------------------------------------
// 调用立即函数checkFlightSchedule
var infomation = checkFlightSchedule();
console.log(infomation);
=====================差点没有看懂老师的代码=======================
// 定义函数callback——修改前
function callback() {
console.log('我跑完了');
}
// 定义函数run，run接收一个函数类型的参数，当执行完动作后，调用该函数。
function run(cb) {
console.log('🏃🏃🏃🏃🏃');
cb();
}
// 调用函数run，并把函数callback当参数传过去
run(callback);
// 定义函数callback——修改后
function callback() {
console.log('我跑完了');
}
// 定义函数run，run接收一个函数类型的参数，当执行完动作后，调用该函数。
function run(cb) {
console.log('🏃🏃🏃🏃🏃');
callback();
}
// 调用函数run，并把函数callback当参数传过去
run(1);
代码都执行一遍，还有一个kitchen_workflow_async.js没有看懂呢，回去继续看
```
4. ##### 难点总结：
```JavaScript
1、关于异步的定义：(百度)
在计算机领域，同步就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；异步是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。
2、个人理解：(结合老师的讲解)
老师以老板和秘书之间的交互举例：间接返回、异步处理方式，老师和秘书，都可以各做各的事情，而不是老板傻傻地在线等。待秘书查好航班信息后，可将结果反馈给老板。
3、代码的实现：
由于第一次接触函数传参时，传入的参数同样是一个函数的情况，开始老师讲的这样方式，第一：表示奇怪，第二：理解起来有点弯。直到老师讲到一句话，间接返回，就是定义函数时，不让其直接返回，让其按照某种指定的规则和通道返回，忽然有种打通了任督二脉的感觉。通过课上理解和结合代码的实现，渐渐找到了些为什么要定义间接返回的方式和异步这种的场景的理解。不过我觉得要更深层次的理解，仍需要在实际编程，应用的时候，返回再次来思考，或许能够理解的更透彻。
回调函数，间接返回，异步，这些概念啊，第一次见到他们的时候，十分懵逼。
```
================================================
FILE: homework/lesson5/zhaoxiaoxin.md
================================================
1、作业
function output(name) {
console.log(name);
};
var name = 'Hello,JS';
output(name);
第一行在声明并定义函数output() 此name是函数output()的参数。
第五行在重新声明并定义的一个变量，此name是变量名。
第六行是在调用函数output()，此name是在第五行定义的变量，这里作为参数传给了函数。
2、问题一，什么是匿名函数？
匿名函数，是在微信群里看到的。
我的理解是，匿名，就是没有名字的函数。根据老师的指导，在给出的文件里找到的匿名函数如下
setTimeout(function(){
}
)
这个函数里的function()就是匿名函数。是个函数，但没有取名字。
作用是，参与构建其他的函数，但是很简单，没有名字，只取用它的函数功能。
3、问题二，我们为什么要选择回调函数？
在敲完老师给的几个案例后，关于回调函数怎么使用，已经基本明白了。
但关于为什么使用，还有点不清楚。
学习了报数后，感觉第一种形式里，直接全部调用全部函数，这种方式简单直接。
在学习回调函数的时候，内心一直有个疑问？
为什么要用回调函数呢？为什么不直接返回数值呢？是不是多此一举呢？
老师举了很多例子，证明现实生活中确实有这种情况存在。
比如网购，必须等买家发货邮寄后，才能收到货物。这一点，我可以理解。
还有没有其他的解释呢？
在flight_schedule的三个例子中，
只从编码的角度看，我还是觉得直接输出参数更简便直接，使用callback函数，还是多了一步，有点多此一举的感觉。
关于为什么要多这一步，使用回调函数还有没有其他好处呢？
目前还有一点不清楚。
================================================
FILE: homework/lesson5/zhaoyinan.md
================================================
##关于JS学习最困难的部分##
1.补作业：
在上课时听老师说这部分就是JS最难的一部分，心想如果这就是最难的部分，为何不尝试着去攻克它？让自己JS能有更深入的学习？于是就暗下决心开始了自己的补作业之路。
2.写作业：
在开始劫笔写之前，看了何伟和云飞的作业，都写的非常不错且细致，很是佩服他们认真学习的态度和钻研精神，看来还需要不断努力才是啊。自己一向写文章没有什么基础，没有什么逻辑和思路可言，只能试着不断写，看看能不能接近这些优秀的同学。
3.正式写作业：
代码，第1行、第5行、第6行的name变量都有什么差异？
```
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
这里有必要先提一下关于“形参”和“实参”这两个概念：
形参——只是作为表示符号，其作用范围仅仅在函数表达式之内，并且由于在函数表达式内并未对其进行赋值，因此它并不具有实际意义或实际值，而只能当作是一个传递变量值的载体或工具。代码中的第1行中的name就属于形参。
实参——由于经过了变量赋值，函数变量值代入等2个步骤，第5、6行中的name就具有的实际的参数，因此称为实参。
================================================
FILE: homework/lesson5/zhouqizhou.md
================================================
# 第五课作业
## 第一个name
函数里面的参数，也称形参，主要跟函数内部的中的变量名相对应
## 第二个name
是整体函数定义之后再文件中使用
## 第三个name
获取第二name的值，并传递给函数使用
================================================
FILE: homework/lesson5/zhuningning.md
================================================
```function output(name) {
console.log(name);
}
var name = 'Hello,JS';
output(name);
```
* 第1行、name 为函数output的参数属于局部没有赋值的变量。
* 第5行、name 为声明字符串变量，并赋值'Hello, JS'
* 第6行，name 为第5行定义的 name 字符串变量，在调用output函数时,被当做参数传进去。
================================================
FILE: homework/lesson5/zhutinglesson5.md
================================================
function output(name){
console.log(name);
}
var name = 'Hello.js';
output(name);
第一行： name是函数output的入参，此处只是一个名称，需要调用函数时传入。比如第6行的调用传入的就是Hello.js
第二行：与第一行一样，打印函数入参，调用函数时传入
第五行：name是个变量，并且赋值为 Hello.js
第六行：同第五行，传入变量名，可以理解为一个代号
================================================
FILE: homework/lesson5/zhuyongjin.md
================================================
下面代码中，第1行、第4行、第5行的name变量都有什么差异？
```
1. function output(name) {
2. console.log(name);
3. }
4. var name = 'Hello,JS';
5. output(name);
```
【回答】
针对上面的整个，我是这么理解的。就像是一道数学题。
第一行：建立一个函数 F(x)
第二行；输出这个函数 =x
第五行：告知X的具体值，这里面叫赋值 x=Hello,JS
第六行：输出整个函数f(x)具体值，也就是 Hello，JS
在我看来，第一行Name, 是函数未知变量，可以是某个值，也可以是运行后的值
第四行Name, 是赋值，赋值给第一行Name 的一个具体值
第五行Name, 是输出值，相当于问 F(x)的结果
================================================
FILE: homework/lesson5/谢玉辉.md
================================================
function output(name){ //使用function定义一个函数，函数名叫output，括号里的name为参数。
console.log(name);
}
var name = 'hello,js'; //定义一个名为'name'的字符串变量，并赋值'hello,js'
output(name); //调用'function output(name)'函数并把'name'变量的值 （也就是'hello,js') 作为参数传到这个函数的肚子里面去。
================================================
FILE: homework/lesson6/GaoXianfeng.js
================================================
var fs = require('fs');
var filePath = '../words'; // 该脚本文件在 script 目录下
var outputPath = 'out_put_async.txt';
fs.readdir(filePath, function(err, files) {
if (err) {
console.log('获取文件失败');
return;
}
if (files.length <= 0) {
console.log('没有找到任何文件');
} else {
console.log('开始写入');
fs.writeFile(outputPath, files, function(err) {
if (err) {
console.log('写入文件失败');
} else {
console.log('写入文件成功');
}
});
}
});
================================================
FILE: homework/lesson6/LiuShengsi.js
================================================
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '../../homework/lesson1';
// 定义要写入的文件路径
var outputPathString = './files_name_disposed_by_liushengsi.txt';
// 定义一个read_file_result函数，用于接收读取文件夹内容后的结果
function read_file_result(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
//调用fs的writeFile函数将读取的内容写进目标文件
var fileContent = files
fs.writeFile(outputPathString, fileContent, write_file_result);
} else {
console.log('没有找到任何文件');
}
}
// 定义一个write_file_result函数，用于接收写文件的返回结果
function write_file_result(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//调用fs的readdir函数来读文件夹下的所有文件
fs.readdir(dirPathString, read_file_result);
================================================
FILE: homework/lesson6/Risexie.js
================================================
// 引入fs模块
var fs = require('fs');
//定义读取文件的路径
var dirPathString = '../../../../words-from-the-heart'
//异步方案
//定义一个callback函数，
function callback1(err,files){
if(err){
console.log('读取文件失败');
}
if(files.length > 0) {
//在使用不同的方法获取数据的时候要注意，获取数据的格式是什么
// 例如 fs.writeFile这个方法输出的内容是是一数组。
//所以在下面用了.join这个方法，（.jion）这个方法可以将数组中的所有元素放进一个字符串
//所以输出的file数组，就被.jion方法放进了fileContent。
//.jion这个方法还可以在后面给他指定元素的分隔符，这里用了“\n”。通过空行分割。
//也可以用var = fileContent = files.jion(".")。用.来进行分割
console.log(files);
//把files里面的文件赋值给fileContent
var fileContent = files.join("\n")
//不知道应该如何把files给到fs.writeFile函数，所以在这里卡了很久
//除了把函数嵌套进来之外还有别的方法吗？
fs.writeFile(FilePathString,fileContent,callback2)
} else {
console.log('没有找到文件');
}
}
//调用fs的readdir函数，并输出文档。
//在调用任何函数之前，我们一定要了解清楚函数所需要输入的的参数类型是什么
//例如在下面的函数fs.readdir(path,function(err,files))
//第一个地方是读取文件的路径，第二个是一个回调函数，里面包含错误的信心和files
//也就是读取出来的数组！，一定要注意是数组，这一点非常重要。
//因为我们用写入函数的时候，fs.writeFile这个函数要读取的参数是字符串
//所以我们需要使用别的方法把数组转换成字符串，这样才能被fs.write这个函数使用
fs.readdir(dirPathString,callback1)
//定义要写入的文件路径
var FilePathString = './write_file_asyne.txt';
function callback2(err){
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/WANG_Xuanding.js
================================================
var fs = require('fs');
var dirPathString = 'C:/Users/MSI/my_project/getting-started-with-javascript/words-from-the-heart';
var outputPathString = './quming.txt';
var outPutFileContent = fs.readdirSync(dirPathString);
fs.writeFileSync(outputPathString, outPutFileContent);
var fs = require('fs');
var readPathString = 'C:/Users/MSI/my_project/getting-started-with-javascript/words-from-the-heart';
var writePathString = './quming.txt';
function read_callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
var fileContent = files
fs.writeFile(writePathString, fileContent, write_callback);
} else {
console.log('没有找到任何文件');
}
}
function write_callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(readPathString, read_callback);
================================================
FILE: homework/lesson6/Wei.js
================================================
/*
*第六课作业 Wei
*
*
*/
//同步方案
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '../../../words-from-the-heart';
//指定读取后所写入的文件的存放路径，名称和格式
var outputPathString = './Wei.txt';
//读取内容并赋值给写入文件
var outPutFileContent = fs.readdirSync(dirPathString);
//调用fs的writeFileSync函数来写文件
fs.writeFileSync(outputPathString, outPutFileContent);
//异步方案
var fs = require('fs');
var readPathString = '../../../words-from-the-heart';
var writePathString = './Wei.txt';
// 定义一个read_callback函数，用于接收读取文件夹内容后的结果
function read_callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
//将读取的内容写进目标文件
var fileContent = files
fs.writeFile(writePathString, fileContent, write_callback);
} else {
console.log('没有找到任何文件');
}
}
//定义一个write_callback函数，用于接收写文件的返回结果
function write_callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(readPathString, read_callback);
================================================
FILE: homework/lesson6/WuGaoxing.js
================================================
var fs = require('fs');
fs.writeFileSync((__dirname)+'/fileNameCollection.txt', fs.readdirSync(__dirname));
================================================
FILE: homework/lesson6/anjiancai.js
================================================
//1、同步读写，但不能实现写入的全是json文件
var fs = require('fs');
var dirPathString = '../my_project3/words-from-the-heart';
var outputPathString = '../my_project2/rewrite2.txt';
fs.writeFileSync(outputPathString, fs.readdirSync(dirPathString));
//2、异步读，同步写，可实现写入的全是json文件
var fs = require('fs');
var dirPathString = '../my_project3/words-from-the-heart';
var outputPathString = '../my_project2/rewrite3.txt';
var names =[];
function readcallback(err, files) {
if (err) {
console.log('读取文件失败');
}
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
names.push(files[i]);
}
}
fs.writeFileSync(outputPathString, names);
}
fs.readdir(dirPathString, readcallback);
//3、异步读写，应保证异步读在异步写前完成。
var fs = require('fs');
var dirPathString = '../my_project3/words-from-the-heart';
var filePathString = '../my_project2/rewrite.txt';
var names = [];
function readcallback(err, files) {
if (err) {
console.log('读取文件失败');
}
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
names.push(files[i]);
}
}
fs.writeFile(filePathString, names, writecallback);
}
fs.readdir(dirPathString, readcallback);
function writecallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/babysodme.js
================================================
var fs = require('fs');
var dirPathString = './';
var files = fs.readdir(dirPathString, callbackScanFiles);
//定义一个接收函数，用于接收读取文件夹内容后的结果
function callbackScanFiles(err, files){
if (err){
console.log('------这个文件需要放在所查询文件内------');
console.log('oh,读取文件失败，请检查文件是否放在当前文件内');
console.log('------调整位置，在来一次--------');
}
if (files != undefined){
callbackWriteFiles(files);
}else{
console.log('读取的是空文件');
}
};
//定义一个写文件函数，用于存储读取文件的返回结果
function callbackWriteFiles(files){
if (files != undefined){
var outputPathString = './Write_file_async.txt';
fs.writeFileSync(outputPathString,files);
console.log('写文件成功')
console.log('打开查询文件夹查看.txt文档');
}else{
console.log('写文件失败');
}
};
//点用scanFiles函数来读写文件
console.log('正在检索中...');
callbackScanFiles();
================================================
FILE: homework/lesson6/baoguoqiang.js
================================================
/*
* 同步方案
* 扫描某个文件夹的所有内容
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹
var dirPathString = '../words-from-the-heart';
var files = fs.readdirSync(dirPathString);
console.log(files);
// 定义要写入的文件路径
var outputPathString = '../baoguoqiang.txt';
// 定义文件内容变量fileContent
var fileContent = '.....';
// 调用fs的writeFileSync函数来写文件
fs.writeFileSync(outputPathString,fileContent);
// 异步方案
// 引入fs模块
var fs = require('fs');
//定义要查询的目标文件夹。
var dirPathString = '../words-from-the-heart';
//定义一个callback函数，用于接受读取文件夹内容后的结果
function callback(err,files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
}
// 调用fs的readdir函数读取所有文件
fs.readdir(dirPathString,callback);
// 定义要写入的文件路径
var filePathString = '../baoguoqiang.txt';
// 定义文件内容变量fileContent
var fileContent = '.....';
// 定义一个callback函数，用于接受写文件的返回结果
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//调用fs的writeFile函数来写文件
fs.writeFile(filePathString,fileContent,callback);
================================================
FILE: homework/lesson6/caijinpeng.js
================================================
var fs=require('fs');
var dirPathString='./';
var files=fs.readdirSync(dirPathString);
var outputPathString = './write_file_sync.txt';
var fileContent =files;
fs.writeFileSync(outputPathString, fileContent);
================================================
FILE: homework/lesson6/caozhen.js
================================================
// 引入FileSystem
var fs = require('fs');
// 定义要读取的路径
var readDirPath = '../../../words-from-the-heart/';
// 下面分别使用同步和异步两种方式读取并写入homework/lesson6文件夹
// 方案1:同步读取 同步写入
console.log('方案1-开始');
var writeFilePath1 = './fileNameOfSchema1_caozhen.txt';
if (!fs.existsSync(readDirPath)) {
console.log('读取路径不存在！请检查读取路径是否正确')
} else {
var files1 = fs.readdirSync(readDirPath);
if (files1.length == 0) {
console.log('读取路径中没有找到任何文件！请检查读取路径是否正确');
} else {
for (var index = 0; index < files1.length; index++) {
if (!fs.statSync(readDirPath + files1[index]).isFile()) {
console.log('[Warning] ' + files1[index]+ ' 不是文件,跳过');
}
else if (files1[index].match('\.json$') == null ) {
console.log('[Warning] ' + files1[index]+ ' 不是json,跳过')
}
else {
fs.writeFileSync(writeFilePath1, files1[index]+'\n', {flag: 'a'});
}
}
console.log('方案1-写入完成!');
}
}
// 方案2:异步读取，异步写入
console.log('方案2-开始');
var writeFilePath2 = './fileNameOfSchema2_caozhen.txt';
function readCallback(err, files2) {
if (err) {
console.log('读取路径失败，请检查读取路径是否正确');
return;
} else {
if (files2.length == 0) {
console.log('读取路径中没有找到任何文件，请检查读取路径是否正确');
}
else {
for (var index = 0; index < files2.length; index++) {
if (!fs.statSync(readDirPath + files2[index]).isFile()) {
console.log('[Warning] ' + files2[index]+ ' 不是文件,跳过');
}
else if (files2[index].match('\.json$') == null ) {
console.log('[Warning] ' + files2[index]+ ' 不是json,跳过')
}
else {
fs.writeFile(writeFilePath2, files2[index]+'\n', {flag: 'a'}, writeCallback);
}
}
console.log('方案2-写入完成');
}
}
}
function writeCallback(err) {
if (err) {
console.log('写文件时出错啦');
}
}
fs.readdir(readDirPath, readCallback);
================================================
FILE: homework/lesson6/caozhen.md
================================================
# 提高代码兼容性&可读性的操作实践
本文是完成lesson6作业后，对作业过程的思路总结；希望能帮助到代码经验较少的小白同学们。
## 通过模仿sample代码完成基本功能
徐老师给了我们四段sample代码，分别实现了同步／异步读取文件路径，以及同步／异步向文件写入内容。
通过模仿，我们可以完成lesson6作业的基本要求。下面分别给出两个代码示例：
### 同步读取+同步写入
```javascript
// 引入FileSystem
var fs = require('fs');
// 定义要读取的路径
var readDirPath = '../../../words-from-the-heart/';
// 方案1:同步读取 同步写入
var writeFilePath = './fileNameOfSchema1_caozhen.txt';
var files = fs.readdirSync(readDirPath);
fs.writeFileSync(writeFilePath, files);
```
### 异步读取+异步写入
```javascript
// 引入FileSystem
var fs = require('fs');
// 定义要读取的路径
var readDirPath = '../../../words-from-the-heart/';
// 方案2:异步读取 异步写入
var writeFilePath = './fileNameOfSchema2_caozhen.txt';
// 定义读取时的回调函数
function readCallback(err, files) {
if (err) {
console.log('读取路径失败');
return;
} else {
if (files.length > 0) {
// 异步写入
fs.writeFile(writeFilePath, files, writeCallback);
} else {
console.log('没有找到任何文件');
}
}
}
// 定义写入时的回调函数
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(readDirPath, readCallback);
```
### 得到的结果
上面两个方案输出的txt文件内容是这样的：
### 观察结果后的思考
重点来了，我们得到的结果是老师想要的么？上图显示的结果至少有以下几个问题：
- 发现输出结果中有隐藏文件，比如`.git`
- 发现输出结果中有文件夹，比如`script`
- 发现输出结果中有非json文件，比如`xx.json.txt`
- 一大堆结果挤在一起，看着好丑
除此之外，还有哪些地方存在问题？或者说，老师的这个作业中给我们预留了多少坑等我们去踩呢？
## 分析到底有哪些地方存在问题（坑）？
**思考这个问题的关键在于，把自己代入成使用者，即**：如果我现在正使用这段代码，我可能会进行哪些操作？遇到什么问题？
- 可能给出了一个根本不存在的路径
- 可能给出了一个路径，但里面没有文件
- 可能给出了一个路径，里面不仅有文件，还有文件夹（而文件夹并不是我们想要的）
- 可能给出了一个路径，里面存在一些不满足要求的文件（即不是.json的文件，也不是我们想要的）
以上问题（坑），都是我们在代码开发时需要关注并处理的。
即老师上课时提到的：**通过异常处理，提高代码的兼容性**
此外，针对上面提到的“一大堆结果挤在一起，看着好丑“，怎么改善呢？
- 我们更希望每个文件名一行，整齐排列
即：**提高代码执行结果的可读性**
## 如何解决这些问题？
### 基本思路
- 先踩一下坑看看，会导致什么结果
- 思考解决问题的方案，以及可能需要用到的功能
- 在库中寻找这个功能对应的函数，及其定义
- 模仿&实现在我们的代码中
### 下面举几个实操案例
#### 案例1-处理不存在路径
**先踩一下坑看看，会导致什么结果**
我们给出一个不存在路径，比如
```javascript
var readDirPath = '~/test'; //备注：该路径不存在
```
运行一下，出现错误
**思考解决问题的方案及可能需要用到的功能**
思考：如果我们在代码中判断一下路径是否存在，问题就解决了嘛！即老师课上提到的**参数检查**。
**在库中寻找这个功能对应的函数及其定义**
上面提到的关键功能是**判断路径是否存在**，我们去库里找一找，有没有函数可以实现这个功能？
在nodejs documentation中搜索关键词`exist`,看！找到了！
看一下文档描述，学习一下用法，就可以模仿着在自己的代码中实现了。
**模仿&实现在自己的代码中**
```javascript
var readDirPath = '~/test/'; // 故意给一个不存在的路径
if (!fs.existsSync(readDirPath)) {
console.log('读取路径不存在！请检查读取路径是否正确')
} else {
xxx xxx // 执行后续代码
}
```
下面再举一例
#### 案例2-处理文件夹
**我们已经知道运行结果了，直接来思考怎么办，此步骤省略**
**思考解决问题的方案及可能需要用到的功能**
思考：
- 我们得到的`files`是一个object，里面有很多文件名，需要一一判断 —— **要用到循环语句for**
- 判断是文件还是文件夹 —— **要去库中找找用什么方法实现**
- 如果不是文件就不输出了，是文件才输出到txt —— **要用到条件语句if**
- 如果文件名不是json格式，也不满足条件不输出 —— **同样要去找找怎么实现**
**在库中寻找上述功能对应的函数及其定义**
我们去库里找一找，有没有函数可以实现`判断是文件还是文件夹`这个功能？
搜索关键词`isfile`试试，我们找到了以下内容！
根据描述，我们发现它是从`fs.stat()`中来的，再去看看
----------分界线---------
（此处只是给出一种实现方式，如果感觉陌生请跳过，并不影响后续内容的理解）
如何判断文件名是否是.json结尾呢？我们可以使用`正则表达式`
```
维基百科：正则表达式，（英语：Regular Expression，在代码中常简写为regex、regexp或RE），是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。
```
Google搜索“javascript中的正则表达式用法”，去模仿一下用法即可。
----------分界线结束----------
**模仿&实现在自己的代码中**
```javascript
for (var index = 0; index < files.length; index++) {
if (!fs.statSync(readDirPath + files[index]).isFile()) {
console.log('[Warning] ' + files[index]+ ' 不是文件,跳过');
}
else if (files2[index].match('\.json$') == null ) {
console.log('[Warning] ' + files[index]+ ' 不是json,跳过')
}
else {
fs.writeFileSync(writeFilePath, files[index]+'\n');
}
}
```
执行一下，成功！
再看看输出txt文件，诶，有问题！
奇怪，为什么txt中只有一个文件名？如果再运行几次，得到的结果一样；再仔细观察，发现是最后一个文件名。思考一下原因：
- 很可能是在for循环中，每次执行`fs.writeFileSync`都会清空之前的数据，重新写入
- 所以每写入一个新名称，前面的内容都被清除了，最终只能留下最后一个名称
怎么解决？还是要去文档中找答案！我们仔细看看`fs.writeFileSync`的说明：
发现里面还有一个`option`参数，默认取值是`w`，在文档中搜搜看这表示什么意思？我们搜到了如下结果：
通过学习我们发现，`a`是可以追加写入的，因此我们把参数进行修改
```javascript
fs.writeFileSync(writeFilePath, files[index]+'\n', {flag: 'a'});
```
终于大功告成啦！
### 总结
由于平时工作任务较多，本文零零散散竟然写了三天，惭愧！
写此文的目的是，很多同学以前没有写过代码，面对vscode这个黑窗口可能大脑一片空白，不知道应该如何整理思绪。
这次刚好以lesson6作业代码为主题，把自己完成作业时的所思所想梳理成文字，希望能从以下方面对小白同学有所帮助：
- 遇到问题很正常，踩的坑越多提高才越快
- 遇到问题不要懵，要学会下面的思维方式
- 完成思考解决方案-搜索可用功能-模仿官方文档-写出可用代码的全过程
- 通过实战不断提高
欢迎到lesson6文件夹查看我的最终代码`caozhen.js`，指出错误，共同进步！
================================================
FILE: homework/lesson6/chenrushan.js
================================================
const fs = require('fs');
const dirPathString = '../../../words-from-the-heart/words';
const filePathString = '../../../test-code/write_file_async.txt';
fs.readdir(dirPathString, function (err, files) {
if (err) {
console.error('读取文件失败');
return;
}
if (files.length > 0) {
fs.writeFile(filePathString, files, function (err) {
if (err){
console.error('写文件失败');
} else {
console.log('写文件成功');
}
});
} else {
console.log('没有找到任何文件');
}
});
================================================
FILE: homework/lesson6/chenyanxing.js
================================================
/*
*第六课作业 陈燕杏
*
*异步方案
*/
//引入fs模块
var fs = require('fs');
//定义要查询的目标文件夹。
var dirPathString = '../../../words-from-the-heart';
//定义要写入的文件路径
var filePathString = './write_file_async_cyx.txt';
//定义一个callback函数，用于接收读取文件夹内容的结果
function read_callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
//调用fs的writeFile函数,将读取的内容写进目标文件（这个地方的修改参考Wei同学的作业，实在太cool了!）
var fileContent = files
fs.writeFile(filePathString, fileContent, write_callback);
} else {
console.log('没有找到任何文件');
}
}
//定义一个write_callback函数，用于收写文件的返回结果
function write_callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(dirPathString, read_callback);
/*使用异步方案中，参考同学的作业，发现自己写的漏洞随即改了过来：
1.读取文件和收写文件两次callback命名不能用没有意义的名字，比如：函数名+数字1，2。
2.参考老师的教材，原封不动把‘’读取文件‘’和‘’收写文件‘’，单独两部分写在json里，虽然终端可以跑起来，但是却只得到两句话“写文件成功‘’，显然是不合适的，也没有达到作业的目的。
*/
/*
*同步方案
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '../../../words-from-the-heart';
//指定读取后所写入的文件的存放路径，名称和格式
var outputPathString = './write_file_sync_cyx.txt';
//读取内容并赋值给写入文件
var outPutFileContent = fs.readdirSync(dirPathString);
//调用fs的writeFileSync函数来写文件
fs.writeFileSync(outputPathString, outPutFileContent);
================================================
FILE: homework/lesson6/chenziwen.js
================================================
// # 扫描某个文件夹的所有内容 #
/* =====================================同步方案Start */
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '../../../words-from-the-heart';
// 调用fs.readdirSync()方法读取目录内容，并把结果赋值给files，打印files
var files = fs.readdirSync(dirPathString);
console.log(files);
/* =====================================将内容写入到文件中 */
// 定义要写入的文件路径
var outputPathString = './write_file_sync.txt';
// 定义文件内容变量fileContent
var fileContent = files;
//调用fs的writeFileSync函数来写文件
fs.writeFileSync(outputPathString, fileContent);
/* =====================================同步方案End */
================================================
FILE: homework/lesson6/cloudyview.js
================================================
//引入fs模块
const fs = require('fs');
//定义reddir需要的path
var dirPathString = '../../../words-from-the-heart';
// var dirPathString = './';//调试用的路径
// var dirPathString = '../../homework/lesson1';//调试用的路径2
//定义写入的文件路径和文件名
var filePathString = './cloudyview_file_writing.txt';
//定义函数将信息写入这个函数的files变量里面
function callback(err , files) {
if (err) {
console.log('读取文件失败');
}
//希望格式上能够好一些，加入分行的符号，结果发现用appendFile会更好些。对格式有强迫症，没办法。。。
//我本来希望能够起2个函数，其中一个函数能够单纯是写文件的。但是没找到将数据通过回调函数输出给写函数的办法。
if (files.length > 0) {
console.log('有文件啊！！！')
for (i = 0 ; i < files.length ; i++ ) {
// fs.writeFile(filePathString , files[i] , writeCallback); //这样会不断重写文件。
var fileDate = i + '.\n' + files[i] + ',' + '\r\n' ;
fs.appendFile(filePathString , fileDate , writeCallback);
}
}else{
console.log('没有文件存在！');
}
}
function writeCallback(err) {
if (err) {
console.log('writing files faild!');
} else {
console.log('succeed! you just done!');
}
}
//定义回调函数
function fileListCallback(files) {
console.log('writing file');
console.log(files);
}
//执行查询的函数
fs.readdir(dirPathString , callback);
//调用fs的写函数来写入文件
================================================
FILE: homework/lesson6/cuimiao.js
================================================
//第6课 小白cuimiao的作业
//引入fs模块
var fs =require('fs');
//定义查询文件的目标文件夹
var dirPathString = '../../../words-from-the-heart';
//定义一个callback函数，用于接受读取文件的返回结果
function callback(err,files){
if (err){
console.log('文件读取失败');
return;
}
if(files.length>0){
console.log(files);
}else {
console.log('没找到任何文件');
}
}
//用fs的readdir函数读取全部文件
fs.readdir(dirPathString,callback);
//将读取到的文件名称写到txt文件中
var filePathString = './cmwrite_async.txt';
//定义文件夹内容变量
var fileCount = fs.readdirSync(dirPathString);
//定义一个callback函数用于接受写文件的返回结果
function writecallback(err) {
if (err) {
console.log('文件写入失败');
} else {
console.log('文件写入成功');
}
}
//调用fs的writeFile函数来写入文件
fs.writeFile(filePathString,fileCount,writecallback);
//总结
//1.函数如果是自己定义的，要什么参数，自己要弄明白；如果是第三方库提供函数，则要看明白函数的定义，每个参数是做什么的，调用时怎么用参数
//2.参数的名称有时会一样，主要是为了少起名字
//3.有时要加入容错机制，比如作业以及老师课后的代码文档里，当出现err的时候，返回的文字内容，都是容错机制。
//4.老师鼓励我们改代码，都试一试，反正没损失。我这次做作业就尝试了一下，感觉还不错。
//5.内置库我们目前学了 console setTimeout typeof
//6.file system 是nodejs环境的内置库
//7.搜索nodejs.api 第一个英文的文档是要阅读的，左侧的就是内置库，比如fs是我们重点学习的并做了作业
//8.犀牛书的前七章是基础，第八九章最重要，要认真反复阅读。
================================================
FILE: homework/lesson6/cuiyuwei.js
================================================
/*同步读取、写入文件，参考曹振同学的作业,感觉看nodejs documentation有点困难*/
// 引入FileSystem
var fs = require('fs');
// 定义要读取的路径
var readDirPath = '/Users/Administrator/learningjs/words-from-the-heart/';
//写入读取回来符合要求的文件的txt文件路径
var writeFilePath = '/Users/Administrator/learningjs/fileNameOfwordsheart_cuiyuwei.txt';
//判断读取路径是否存在，不存在做出警告
if(!fs.existsSync(readDirPath)){
console.log('读取路径不存在，请填写正确路径');
}
else{
var files = fs.readdirSync(readDirPath);
}
/*对读取回来的结果进行处理*/
for (var i = 0; i < files.length; i++) {
if (!fs.statSync(readDirPath + files[i]).isFile()) {
console.log('[Warning] ' + files[i]+ ' 不是文件');
}
else if (files[i].match('\.json$') == null ) {
console.log('[Warning] ' + files[i]+ ' 不是json')
}
else {
fs.writeFileSync(writeFilePath, files[i]+'\n',{flag:'a'});
}
}
/*异步读取、写入文件，参考曹振同学的作业*/
// 引入FileSystem
var fs = require('fs');
// 定义要读取的路径
var readDirPath = '/Users/Administrator/learningjs/words-from-the-heart/';
// 方案2:异步读取 异步写入
var writeFilePath = '/Users/Administrator/learningjs/fileNameOfwordsheart2_cuiyuwei.txt';
// 定义读取时的回调函数
function readCallback(err, files) {
if (err) {
console.log('读取路径失败');
}
else {
if (files.length > 0) {
for (var i = 0; i < files.length; i++) {
if (!fs.statSync(readDirPath + files[i]).isFile()) {
console.log('[Warning] ' + files[i]+ ' 不是文件');
}
else if(files[i].match('\.json$') == null ) {
console.log('[Warning] ' + files[i]+ ' 不是json')
}
else{
fs.writeFile(writeFilePath,files[i]+'\n',{flag:'a'},writeCallback);
}
}
}
else {
console.log('没有找到任何文件');
}
}
}
// 定义写入时的回调函数
function writeCallback(err) {
if (err) {
console.log('write error');
} else {
console.log('write success');
}
}
fs.readdir(readDirPath, readCallback);
================================================
FILE: homework/lesson6/dangfeipeng.js
================================================
var fs = require('fs');
// 最简单的实现，为了确保正确执行，应将此文件放在 words-from-the-heart 项目的 script 文件夹下（编码约定）
var dirPathString = '../words';
var filePathString = './words_file_names.txt';
var fileNames = fs.readdirSync(dirPathString);
if (fileNames.length > 0) {
// 异步写入返回值 err 可以明确判定写入是否成功，而同步写入只返回了 undefined，意义不明，所以采用异步写入
fs.writeFile(filePathString, fileNames, function (err) {
if (err) {
console.log('文件写入失败');
} else {
console.log('文件写入成功');
}
});
} else {
console.log('读取文件失败');
}
================================================
FILE: homework/lesson6/dengxy0907.js
================================================
var fs =require('fs');//引入fs模块
var dirPathString = '../paixu/WORDS-FROM-THE-HEART';//定义要查询的文件夹
var files =fs.readdirSync(dirPathString);
var needFiles= [];
(function filesContent(){
for(i=0;i 0) {
var fileContent = files;
fs.writeFile(filePathString, fileContent, callback1);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, callback);
var filePathString = './write_file_async.txt';
function callback1(err) {
if (err) {
console.log("写文件失败");
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/fangqingyang.js
================================================
var fs = require('fs');//导入这个模块
var outputPathString = './name.txt';//要写入名字的文件，如果没有则自动创建一个
var inputPathString = '../../homework/lesson1';//这里是要导入的文件名的位置
var files = fs.readdirSync(inputPathString);
//让写入的名字分行
if(files.length > 0){
for(var i = 0;i < files.length; i++){
files[i] = files[i] + '\n';
}
}
//回调函数，作用是告诉调用者，写文件的结果
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFile(outputPathString,files,callback);
================================================
FILE: homework/lesson6/fanliao.js
================================================
var fs = require('fs');
var dirPathString = './';
function callback(err, files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
var filePathString = '../xlh.txt';
var fileContent = files.join("\n");
fs.writeFile(filePathString, fileContent, call);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, callback);
function call(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/fengkai.js
================================================
/* 同步方案 */
// 读取
var fs = require('fs');
var dirPathString = './words-from-the-heart';
var files = fs.readdirSync(dirPathString);
console.log(files);
// 写入
var outputPathString = './worksFromTheHeart.txt';
var fileContent = files;
fs.writeFileSync(outputPathString, fileContent);
/* 异步方案 */
//读取
var fs = require('fs');
var dirPathString = './words-from-the-heart';
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, callback);
//写入
var filePathString = './wordsFromTheHeart01';
var fileContent = fs.readdirSync(dirPathString);
function callbackforwrite(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFile(filePathString, fileContent, callbackforwrite);
================================================
FILE: homework/lesson6/hanwei.js
================================================
/*
* 异步方案
*
* 扫描'words-from-the-heart'文件夹的所有内容
*并将内容写入到上机目录test文件中
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '../../../words-from-the-heart';
// 定义要写入的文件路径
var filePathString = '../../../test.txt';
// -----------------------------------
// 异步方案
// 定义一个read函数，用于接收读取文件夹内容后的结果
function read(err, files) {
if (err) {
console.log('读取文件失败！')
return;
}
if (files.length > 0) {
console.log(files);
// 调用fs的writeFile函数来写文件
fs.writeFile(filePathString, files, write);
} else {
console.log('没有找到任何文件！')
}
}
// 定义一个write函数，用于接收写文件的返回结果
function write(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//调用fs的readdir函数读取所有文件
fs.readdir(dirPathString, read);
================================================
FILE: homework/lesson6/haohu.js
================================================
var fs = require('fs')
var dirPathString = '../lesson1'
var txtPathString = './haohu.txt'
function readCallback(err, files) {
if (err) {
console.log('读取文件失败')
return
}
if (files.length > 0) {
writeToTxtFile(files)
} else {
console.log('没有找到文件')
}
}
function writeCallback(err) {
if (err) {
console.log('写入文件失败')
} else {
console.log('写入文件成功')
}
}
function writeToTxtFile(filesArray) {
fs.writeFile( txtPathString, filesArray.join("\n"), writeCallback )
}
fs.readdir( dirPathString, readCallback )
================================================
FILE: homework/lesson6/hewei.js
================================================
var fs = require('fs');
var path = require('path');
/* 定义徐老师的 words-from-the-heart 项目在本地硬盘上相对于本 js 文件的位置
最初定义的路径是相对于本 js 的相对路径，但是在后面的执行过程中发现
如果在终端中分别从项目根目录执行本 js 文件，和从 js 所在目录执行本 js 文件
得到的结果是不同的，由于 js 文件位于 homework/lesson6 目录下
从项目根目录执行本 js 文件的话，js 获取到的 words-from-the-heart 项目的路径是错的
研究了接近一个小时，最终才找到了解决办法
用 fs.realpathSync 获取到本 js 文件的绝对路径后，再用 path.join 结合 ./../../words
就可得到 words-from-the-heart 的绝对路径 */
var directoryString = path.join(fs.realpathSync(__dirname), '../../../words');
/* 设置输出文件的路径，这也是个坑！
如果设置路径为 ./json_path.txt，并且执行本 js 文件时的当前路径不同的话
这个文本文件的保存路径也会变化
所以也是用 __dirname 获取当前文件绝对路径，以保证生成的 txt 文件的路径不会变 */
var txtPathString = path.join(__dirname, 'json_path.txt');
// 用于保存 json 文件名的字符串变量
var jsonFileName = '';
// Node.js API: Readline 读取用户输入
// https://nodejs.org/api/readline.html
function processJsonFileNames() {
var prompt =
'\nWhich method do you like?\n\n' +
'1. Use native JS\n' +
'2. Use npm module - glob\n' +
'3. Use native JS with recurvise method\n';
console.log(prompt);
var readline = readline || require('readline');
var rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
/* 这里是回调，所以取到用户的输入之后，在回调里执行后续的函数 */
rl.on('line', function (choice) {
console.log('You have chosen: ' + choice);
getJsonFileNamesFromDirectory(choice);
rl.close();
});
}
processJsonFileNames();
function getJsonFileNamesFromDirectory(userChoice) {
switch (parseInt(userChoice)) {
case 1:
searchCurrentDirectory();
break;
case 2:
searchWithGlob();
break;
case 3:
searchRecursive(directoryString);
break;
default:
console.log('Please make the right choice');
break;
}
if (parseInt(userChoice) != '2') {
writeToFile();
}
}
function writeToFile() {
if (jsonFileName.length == 0) {
console.log('No json files found, is it right?');
return;
}
fs.writeFile(txtPathString, jsonFileName, function (err) {
if (err) {
console.log('Writing failed');
} else {
console.log('File written');
}
});
}
/* json 文件查找方法一
只查找当前目录下的 json，不查找子文件夹里的 json
这个需求，直接用 fs.readdirSync() 就能实现了 */
function searchCurrentDirectory() {
/* 如果采用异步方法，需要用回调，否则文件列表还没获取完
就会执行后面的代码，这时文件列表还是空的，肯定不行 */
var files = fs.readdirSync(directoryString);
jsonFileName = '';
for (var i = 0; i < files.length; i++) {
var currentFilePathPath = path.join(directoryString, files[i]);
var stats = fs.statSync(currentFilePathPath);
if (!stats.isDirectory() && files[i].endsWith('json')) {
jsonFileName += files[i] + '\n';
}
}
// 上面的拼接方式会让字符串最后多出一个空行，要删掉
jsonFileName = jsonFileName.trim();
}
/* json 文件查找方法二
直接用 npm 中现成的模块 glob，遍历当前文件夹及所有子文件夹 */
function searchWithGlob() {
// glob 只在该方法中用到
// 所以就不放在文件的开头进行声明了
var glob = require('glob');
// 定义文件类型，设置完整搜索路径
var fileType = '**/*.json';
// 依然采用 path.join 生成完整路径，避免因系统不同导致手动设置路径出错
var fullSearchPath = path.join(directoryString, fileType);
jsonFileName = '';
/* 注意：glob 方法获取到的文件路径是完整的绝对路径
而且 glob 是通过回调返回结果的，所以写入文件的函数必须在回调中调用 */
glob(fullSearchPath, function (err, files) {
if (!err) {
if (files.length === 0) {
console.log('No json found');
return;
}
for (var i = 0; i < files.length; i++) {
var stats = fs.statSync(files[i]);
if (!stats.isDirectory() && files[i].endsWith('json')) {
jsonFileName += path.basename(files[i]) + '\n';
}
}
// 上面的拼接方式会让字符串最后多出一个空行，要删掉
jsonFileName = jsonFileName.trim();
// 然后将结果写入文件
writeToFile();
} else {
console.log('Unable to write file');
}
});
}
/* 在工作中有时候可以像方法二那样，找到能搞定问题的解决方案就行
但是在学习的时候，还是应当攻克每一个难关，这样才有进步
如果只是一味地复制 Google、StackOverFlow 上的代码
那么不管有多少年工作经验，都是不会有什么成长的 */
/* 在终端里查看 words-from-the-heart 这个仓库
会发现仓库里不只是有 json 文件，还有其他扩展名的文件
而且还有文件夹，而 fs.readdirSync() 只扫描根目录下的文件
对于子文件夹里的文件，这个方法是不会去扫描的
所以，就需要用递归调用的方法，来遍历整个仓库里的所有文件夹
这样才能找到所有的 json 文件 */
/* json 文件查找方法三
遍历当前目录及所有子文件夹 */
function searchRecursive(pathString) {
jsonFileName = traverse(directoryString);
var json = '';
for (var p in jsonFileName) {
if (jsonFileName[p]) {
json += jsonFileName[p] + '\n';
}
}
jsonFileName = json;
}
function traverse(dir) {
var files = fs.readdirSync(dir);
// 如果定义该变量为字符串，并用 result += file + '\n' 的形式拼接文件名
// 最后输出的txt文件是每个字母一行的，而不是像方法一那样每个文件名占一行
// 目前还没想出来是什么原因
var result = [];
//
files.reduce(function (files, file) {
fs.statSync(path.join(dir, file)).isDirectory() ?
traverse(path.join(dir, file)) :
(file.endsWith('.json') ?
result.push(file) :
null)
});
return result;
}
================================================
FILE: homework/lesson6/hitchhacker.js
================================================
var fs = require('fs');
//同步方案
var dirPathString = './';
var files = fs.readdirSync(dirPathString);
console.log(files);
var outputPathString = './write_file_sync.txt';
fs.writeFileSync(outputPathString, files);
//异步方案
outputPathString = './write_file_async.txt';
// 定义一个callback函数，用于接收读取文件夹内容后的结果
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
//读完后写文件
fs.writeFile(outputPathString, files, callback2);
} else {
console.log('没有找到任何文件');
}
}
// 定义一个callback2函数，用于接收写文件的返回结果
function callback2(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//异步回调之实现
setTimeout(function(){
fs.readdir(dirPathString, callback);
},3000)
console.log("hahaha");
================================================
FILE: homework/lesson6/huangjiashu.js
================================================
fs = require('fs')//引入头文件
/**
* 获取指定路径下文件列表
* 使用的是异步函数，因此不能使用立即返回，用callback传递数据
* @param {*} dirPath 文件路径
*/
function readFileList(dirPath,writeToFile){
// 对传入参数进行判断
if (!dirPath) {
console.log('路径不能为空')
return null;
}
if(typeof writeToFile != 'function'){
console.log('%s is not a function',writeToFile);
return;
}
//读取文件列表
fs.readdir(dirPath,function(err,files){
//处理错误
if (err){
console.log('读取文件列表失败：%s',err)
return;
}
//处理文件列表为0的情况
if (files.length === 0){
console.log('未找到任何文件');
return;
}
console.log("+++++++++++++++++++")
//处理找到的文件
filesStr = files.join(',')
console.log(filesStr)
writeToFile('realHeatFileName.txt',filesStr.toString())
})
}
/**
*
* @param {*文件内容} contents
* @param {*文件路径} filePath
*/
function writeToFile(filePath,contents) {
if (!filePath || !contents || contents.length === 0) {
console.log('路径不能为空或内容不能为空')
return;
}
//写文件操作
fs.writeFile(filePath,contents,function(err){
if (err){
console.log('文件写入失败:%s',err)
} else {
console.log('文件写入成功')
}
})
}
//执行函数
var dirPath = '../../homework/lesson1'
readFileList(dirPath,writeToFile)
/**
* 此文件在作业第六次的作业目录下，可以直接运行。生成的文件默认也存储在此作业目录下。
* 很遗憾的一点是 每个函数都应该尽可能独立，而我写的函数readFileList 本来是只负责读取文件列表的。
* 然后要写文件 需要使用 回调。 这本身没什么问题。
* 问题是我的writeFile 需要一个文件路径参数。因为单独作为一个写文件函数，这个参数是必要的。
* 但在回调时 没法给这个参数 所以我只能写死了，那么这个函数其实就很烂了。
* 我要是把路径作为参数传递给readFileList，然后在传递给writeFile，那就不符合readFileList的本意了，
* 读取文件列表这个函数不需要一个写入路径参数。
*
*/
================================================
FILE: homework/lesson6/huyong.js
================================================
var fs = require('fs');
var dirPathString = '../../lesson6/words-from-the-heart';
var files = fs.readdirSync(dirPathString);
console.log(files);
var fs = require('fs');
var outputPathString = './write_file_sync.txt';
var fileContent = fs.readdirSync(dirPathString);
fs.writeFileSync(outputPathString, fileContent);
/*今天的作业作业我的理解就是一个填空题，按照老师给的同步异步代码，换上不同的路径和文件夹进行操作，
我们唯一要做的就是对于两段代码的连接，这是最难的，对吧老师？
我想老师的答案应该有四种结果，分别是
同步扫描对异步写入，
同步扫描对同步写入，
异步扫描对同步写入，异步扫描对异步写入，
最复杂的应该是两个都是异步，因为两个都是异步才是最难的，也最接近现实生活场景的代码解决方案，
老师我理解的对不对啊？☺今天异步对异步我还是没搞明白如何操作，我想我对于异步和值还有变量并没有完全理解清楚，
我的作业给出了最简单的答案，老师给点评下哦。
下面是我对真个课程的学习框架总结，后面慢慢写入细节，框架按照我学习到的东西进行分类
1，git操作，
2，如何在github上完成项目建立，如何协作，
3，js在前端和后端的运行框架，
4，两种交互
5，函数的理解
6，.......
老师我写的框架有没有少的啊？ */
================================================
FILE: homework/lesson6/jaykeyGuo.js
================================================
//引入FileSystem
var fs = require('fs');
//定义读取路径
var dirPathString = '../../../words-from-the-heart/words';
//定义写出路径
var filePathString = "../write_words_async.txt"
//定义写出回调函数
function callbackForWrite(err) {
//检查
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//定义读取路径
function callbackForRead(err, files){
//检查读取路径
if (err){
console.log("读取文件失败");
return;
}
if (files.length > 0) {
//调用写入
fs.writeFile(filePathString, files, callbackForWrite);
} else {
console.log("没有找到任何文件");
}
}
fs.readdir(dirPathString, callbackForRead);
================================================
FILE: homework/lesson6/jaykeyGuo.md
================================================
### 基础-第六课
```Javascript
//引入FileSystem
var fs = require('fs');
//定义读取路径
var dirPathString = '../../../words-from-the-heart/words';
//定义写出路径git revert HEAD
var filePathString = "../write_words_async.txt"
//定义写出回调函数
function callbackForWrite(err) {
//检查
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//定义读取路径
function callbackForRead(err, files){
//检查读取路径
if (err){
console.log("读取文件失败");
return;
}
if (files.length > 0) {
//调用写入
fs.writeFile(filePathString, files, callbackForWrite);
} else {
console.log("没有找到任何文件");
}
}
fs.readdir(dirPathString, callbackForRead);
```
今早收到的鼓励。
前两天在忙毕业论文的事情，这两天回归学习的主线，目标前端！
先回顾一下之前的内容：
对上述代码调用顺序的整理：
> 1. 引入 fs
> 2. 调用 fs.readdir
> 3. callbackForRead，读取对应的files
> 4. 调用 fs.writeFile
> 5. callbackForWrite
**这个部分还是有不少的疑惑，问题在于对应的fs的引入之后，写入和读取的调用顺序，我的理解是，先读取，后写入。**
------
小结：
做作业的时候，知道读取的函数能够遍历整个目录，于是就将对应的写入的部分放在读取的下级，在每一次读取的时候能够进行写入，引入的fs，不是很懂原理，单从结果来看达到了目的。
***留下的疑问，fs两个函数的嵌套是如何执行的？***
================================================
FILE: homework/lesson6/jianglin.js
================================================
//引入fs模块
var fs = require('fs');
//要查询的文件夹
var dirPathString = 'words-from-the-heart';
//要写入的文件
var outputPathString = 'jianglin.txt';
var fileContent = new Array();
//查询回调函数。看了别的同学作业结合老师说的原则和推理，才改明白。原来在fs.readdir里的第二个函数参数里，必须要把查询到的内容调出去。也就是说，如果不直接输出的话，得在callback里用一个函数或者别的对象把得到的内容传出去，否则callback没意义。
function dirCallback(err,files){
if(err){
console.log('There is an error in reading.');
return;
}else{
if(files.length > 0){
console.log('Reading is OK.');
//想添加换行符号，但是没有成功，只是加了空格
/*for(var i=0;i 0) {
fs.writeFile(writePath, files, writeCallback)
} else {
console.log('没有找到任何文件');
}
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
};
};
fs.readdir(readPath, readCallback);
//相比上面同步的方法，fs.readdir()这里括号里面的参数有点变化
//同步里面只需要写入路径即可，就可以直接返回结果，而异步并不是直接返回结果，因此它有两个参数，一个是路径，一个是回调函数
//callback函数的参数(err,files 这些)可以有多个，网上说通常第一个参数保留给异常。
//其实意思就是在读取数据的时候首先应该考虑到异常情况处理。那么问题来了，既然都需要考虑异常情况，那同步拿来有什么用？
//以上代码也可以直接把函数声明写到参数里面
var fs = require('fs');
fs.readdir('./', function (err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
fs.writeFile("./test.txt", files, function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
});
});
//筛选json文件
//想筛选出json文件的名字，那肯定需要将所有的文件每个都甄别一遍，遍历数组，需要for循环语句。
//然后筛选，肯定是要判断条件，如果满足什么什么条件就怎么怎么地，嗯，要用if语句，先写出来
for (var i = 0; i < files.length; i++) {
if (文件名以.json结尾为true) {
那么就把它写进test.txt
}
}
//很痛苦的地方就在这里，怎么用代码描述“文件名以.json结尾”呢？
//先想到的是去nodejs API的中文网上去搜。但是搜啥关键字呢，试了filter，search都没有找到合适的，也百度了还是没有头绪
//后来听群里的小伙伴说可以用endWith，就搜了一下endWith的用法，好像真的行。（老师可不可以分享一下搜索关键字的一些技巧？要不是同学提到endwith我都搜不出来）
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
那么就把它写进test.txt
}
}
//接着就是中括号里面的内容了。相对之前的异步，其实就是多了筛选那部分，那么把这筛选的部分加进去后面接着写就好了嘛：
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
fs.writeFile('./test.txt', files[i], writeCallback);
}
}
//到这里我就蒙圈了，fs.writeFile括号里的第二个参数我是写files[i]和files呢？
//这里就要先知道files和files[i]到底是什么？
//在之前异步的代码里的files，是fs.writeFile的一个参数，指代的是写入的内容，很明显它是一个由多个文件名组成的数组，每一个文件名就是数组里面的元素。
//而files[i]就是files这个数组里面索引值为i的元素，类似arr = [1,2,3], arr[1]就是2。
//如果这里我写成files[i],从语法来讲，其实写入的是一个数据，并不是全部。最终我得到的结果是在test.txt里面写入了一个莫名其妙的值zhuyongjin.jsonnononn（我还没有想通为什么是这个值）
//而其实我是想写出读出的整个数组，所以这时候其实应该用files才对。
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
fs.writeFile('./test.txt', files, writeCallback);
}
}
//但是这样又不对了呀，这时候files是全部的数据，也就是没有筛选的全部文件名。所以给筛选的出来的结果再给个名字比如jsonFile,这样就行了吧？
//这时候我又犯了难，通过for循环和if语句筛选出来的是一个一个值，而我想定义的是一个数组，要怎么表达这个数组和一个个元素的关系呢?
//脑子里想的是jsonFile = [file[i],file[i+1],file[i+1+1],........],但是这样很明显不能用啊。
//然后我去看第七课的代码，才知道是可以定义空数组的。我先定义一个空数组，然后把通过for循环和if语句得到的一个个元素往里面添加,这样不就可以得到一个只有json文件名的数组了吗？
var jsonFile = [];
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
jsonFile.push(file[i]);//这里也费了一些功夫，刚开始看到第七课的代码时，还以为跟writerFile一样是个新的API呢，后来发现这不就是之前的课件里面数组增删改查的功能吗。。。默念“学以致用”三遍
fs.writeFile('./test.txt', jsonFile, writeCallback);
}
}
//把这个弄好了，再把之前的异步代码套上，运行。2017年9月4日7点43分，发现居然成功了！老泪纵横！
var fs = require('fs');
function readCallback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
var jsonFile = [];
if (files.length > 0) {
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
jsonFile.push(files[i]);
}
fs.writeFile('./test.txt', jsonFile, writeCallback);
}
} else {
console.log('没有找到任何文件');
}
}
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir("./", readCallback);
//总算是把所有json文件的名字写到目标文件里了，但是有个问题，就是运行代码的时候会打印很多次“写文件成功”。
//仔细一看，原来是因为我把fs.writeFile('./test.txt',jsonFile,writeCallback)写到循环里面去了，把它挪出来：
var fs = require('fs');
function readCallback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
var jsonFile = [];
if (files.length > 0) {
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
jsonFile.push(files[i]);
}
}
fs.writeFile('./test.txt', jsonFile, writeCallback);
} else {
console.log('没有找到任何文件');
}
}
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir("./", readCallback);
//这样就只会打印一次“写文件成功”
//谈一谈最近学习的感受：
//还是那句话：越来越吃力啦。以前可能花个周末还能完成作业，现在感觉得花双倍时间。
//大群里面讨论的很多东西都看不懂了，幼儿园群似乎不是很活跃，我们的成长幼稚园群很热闹。
//这个群的名字是我取的，大家投票决定的。云飞还很不喜欢，感觉没有“屌丝逆袭学霸队”霸气，哈哈。
//取这个名字的时候，我就在想我们到底是为了什么聚集在一起的？当然，或许我们都抱着要变成学霸，要成为优秀的程序员的梦想，但对于小小小白来讲，对我们来说最重要的是什么？
//我觉得是成长，自我的成长。人有时很容易跟别人相比较，然后自惭形秽，然后停滞不前，要不然为什么连问题都不敢问呢？
//其实我们真正需要的不是跟别人比较后“我还不错”的那种优越感，而是今天的我跟昨天的我相比是不是进步多了一点？
//离课程结束的时间不多了，这个月后我也要从上海回到成都，工作生活可能都会有很大的变化，但是学习还会继续。
//最开始学这门课，可能并没有像其他同学那样的雄心壮志，只是碰巧知道编程很重要，碰巧在情绪最不好的时候，碰巧看到了这门课，碰巧报了名而已。
//想来都是巧合，结果却令人意外。
//你如果问我学到了什么？我不会告诉你我知道了JS的运行环境框架，知道了同步函数异步函数，学会了一些电脑端的命令，会简单写几行代码，我会告诉你这门课教给我最重要的事情是：把学习当作一种习惯。
//现在在我们的幼稚园里，大家每天在群里打卡学习，相互答疑解惑，每天都有收获的感觉实在是太好了！
//谢谢老师和同学们的陪伴！
//继续加油！
================================================
FILE: homework/lesson6/lichen_async.js
================================================
/**
* 异步方案
*/
//引入 file system 模块
var fs = require('fs');
//定义要扫描查询的路径
var dirPathString = '../../../words-from-the-heart';
//定义要写入txt文件路径
var writePathString = '../../homework/lesson6/write_name.txt';
//定义一个 callbackScan 函数，用于接收读取文件结果
function callbackScan(err, files) {
if (err) {
console.log('Caution: 读取文件失败!');
return;
}
if (files.length > 0) {
var fileContent = fileArrayToString(files);
fs.writeFile(writePathString, fileContent, callbackWrite);
} else {
console.log('Alert: 没有找到任何文件!');
}
}
//定义一个 fileArray 函数，用于将 files 转为逐行打印的字符串
function fileArrayToString(files) {
var returnString = [];
// var returnString = '';
for (var i = 0; i < files.length; i++){
returnString += i + 1 + '. ' + files[i] + '\n';
}
return returnString;
}
//定义一个 callbackWrite 函数，用于接收写入文件结果
function callbackWrite(err) {
if (err) {
console.log('Caution: 写入文件失败!');
}
else{
console.log('Success: 写入文件成功!');
console.log('文件路径：' + writePathString);
}
}
// 第一步一定是先读取dirPathString下的所有文件，将内容返回给callbackScan
fs.readdir(dirPathString, callbackScan);
================================================
FILE: homework/lesson6/lichen_sync.js
================================================
/*
* 同步方案
*
* 扫描某个文件夹的所有内容
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../../words-from-the-heart';
// 定义要写入的文件路径
var writePathString = '../../homework/lesson6/write_name.txt';
var files = fs.readdirSync(dirPathString);
function fileArrayToString(files) {
var returnString = [];
// var returnString = '';
for (var i = 0; i < files.length; i++){
returnString += i + 1 + '. ' + files[i] + '\n';
}
return returnString;
}
// ---------------------------------
// 同步方案
//调用fs的writeFileSync函数来写文件
fs.writeFileSync(writePathString, fileArrayToString(files));
console.log('Success: 写入文件成功!');
console.log('文件路径：' + writePathString);
================================================
FILE: homework/lesson6/limingxing.js
================================================
/*
* 扫描某个文件夹的内容,并将内容写入txt文件中
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹
var dirPathString = '../../../words-from-the-heart';
// 调用fs的readdirSync函数来读取文件
var files = fs.readdirSync(dirPathString);
console.log(files);
// 定义要写入的文件路径
var filePathString = './wish_filename.txt';
// 定义文件内容变量
var fileContent = fs.readdirSync(dirPathString);
// 定义一个callback函数，用于接收写文件的返回结果
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
// 调用fs的writeFile函数来写文件
fs.writeFile(filePathString,fileContent,callback);
================================================
FILE: homework/lesson6/lingxiao.js
================================================
/*
*扫描某个文件夹的所有内容,并将文件中文档名字打印输出
*下面用同步和异步两种方式输出
*/
// 同步方案
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../homework/lesson1';
console.log(dirPathString );
var files = fs.readdirSync(dirPathString);
console.log(files);
// 定义要写入的文件路径
var outputPathString = './lingxiaoSync.txt';
// 定义文件内容变量fileContent
var fileContent = files;
//调用fs的writeFileSync函数来写文件
fs.writeFileSync(outputPathString, fileContent);
// 异步方案
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../homework/lesson1';
// 定义一个callback函数，用于接收读取文件夹内容后的结果
function read_callback(err,files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
console.log(files);
var filePathString = './lingxiaoAsync.txt';
var fileContent = files;
fs.writeFile(filePathString, fileContent, write_callback);
console.log(files.length);
//console.log(Buffer);
} else {
console.log('没有找到任何文件');
}
}
//调用fs的readdir函数读取所有文件
fs.readdir(dirPathString,read_callback);
// 定义一个callback函数，用于接收写文件的返回结果
function write_callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/lipeng.js
================================================
/*
* 第6课作业 李朋
*
* 异步方案
*/
// 引入fs模块
var fs = require('fs');
// 定义要读取的文件夹路径
var dirPathString = '../../../words-from-the-heart/';
// 定义要写入的文件路径
var outputFilePathString = './persons.txt'
// 定义回调函数，用来处理扫描文件夹的结果
function readCallback(err, files){
if(err){
console.log('读取文件夹失败');
}
if(files.length >0){
// 调用fs的writeFile函数写文件
fs.writeFile(outputFilePathString,files,writeCallback);
}else{
console.log('没有找到任何文件');
}
}
// 定义回调函数，处理写文件返回结果
function writeCallback(err){
if(err){
console.log('写文件失败');
}else{
console.log('写文件成功');
}
}
// 调用fs的readdir函数来读取文件夹
fs.readdir(dirPathString,readCallback);
================================================
FILE: homework/lesson6/liujuanjuan1984.js
================================================
/*
第6课的作业：
需求：写一个整理文件名的js脚本，即扫描文件夹，把读到的文件名写入到一个txt文件。
要求：该js脚本以自己名字来命名
*/
//调用fs这个服务
var fs = require('fs')
//扫描目录地址，扫描结果写入文件；
//这个文件即便不存在也会自动创建；如果已存在会被覆盖。
//交作业时的地址
var scanPathString = '../lesson2';
var writePathString = './files-results.txt';
/*
//我在本地调试的地址
var scanPathString = '../sample';
var writePathString = './files-results.txt';
*/
function scanCallback(err, files){
//出错提醒；我故意设置了一个不存在的文件夹为扫描路径，会触发这个报错
if(err){
console.log('扫描文件报错了');
return;
}
//空文件夹提醒，readdir的结果存在files这个参数里，是个数组
if(files.length > 0 ){
//本行仅是显示屏打印，读取其实是js.readdir做的工作。所以也可以不打印到终端。
//console.log('正在扫描\n'+files);
//创建一个数组，用来存储结果；实际上这个callback本身就会存储在files这个参数里。
var filesList = []
for (var i = 0; i < files.length; i++) {
filesList.push(files[i]);
//console.log(files[i])
}
//console.log(filesList);
//把files这个数组内容，逐个写入文件。
//但输出结果很奇怪。没有逐行写入，而且会写不完整。但循环确实完成了指定次数。
//但这至少解释了一点，files如何从读取函数跑到写入函数那里。
//用writeFile同步方式，会有乱七八糟的效果
//而用异步方式则只剩下最后一个，因为被覆盖了
fs.writeFile(writePathString,filesList,writeCallback)
//fs.writeFileSync(writePathString,filesList)
//for (var i = 0; i < files.length; i++) {
//fs.writeFileSync(writePathString,files[i],writeCallback)
//}
}else{
console.log("这个目录下没有任何文件");
}
}
//定义一个写入文件的反馈函数
function writeCallback(err,files){
if(err){
console.log("写文件报错")
}else{
console.log("写文件成功")
}
}
fs.readdir(scanPathString,scanCallback);
//疑问：fs是什么，require fs就成功了， 这叫什么？
//疑问：readdir是什么，fs.readdir就直接调用了，这叫什么？
//readdir有2个参数，分别有什么要求？
//定义了callback函数，但调用它的时候并没有给它参数，怎么回事？
//这个脚本运行后，结果只有一个undefined，不知道为什么。
/*
作业过程中产生的疑问与答案：
1、
最初我用了fs.readdir，写入文件的结果是undefined；查看刘胜新的作业，改成fs.readdirSync就成功了。
不知道为什么。
带Sync的是同步处理。不带，是异步。
猜测是：
fs.readdir的返回值，是未定义。
fs.readdirSync的返回值，居然正确？
2、
我把scanCallback的err参数及对应代码去掉，结果报错了，说files.length无法找到。
不知道为什么。
3、
//向刘胜新学习用fs.readdirSync并移除下面这个回调的调用。代码是能跑通的，但逻辑有缺口。
//刘胜新用fs.readdirSync没有scanCallback回调，而我b回调也能跑，但实际上没调用这块代码。可能是可选参数。
//
//测试下如何把一个函数的运行结果赋值给一个变量
function test(){
console.log('text for log');
return "back for back"
}
var doc = test();
console.log(doc);
//结论是，把没有return的函数赋值给变量，打印变量就是undefined
*/
================================================
FILE: homework/lesson6/liujun.js
================================================
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart';
var filePathString = './info.txt';
function readCallback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
var fileContent = files;
fs.writeFile(filePathString,fileContent,writeCallback)
} else {
console.log('没有找到任何文件');
}
}
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(dirPathString, readCallback);
================================================
FILE: homework/lesson6/liuliyuan.js
================================================
//异步
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart';
function scan_callback(err,files) {
if (err) {
console.log('读取文件失败');
}
if(files.length > 0) {
console.log(files);
var filePathString = './liuliyuanAsync.txt';
var fileContent = files.join("\n");
fs.writeFile(filePathString, fileContent, write_callback);
console.log(files.length);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString,scan_callback);
function write_callback (err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/liuliyuan.md
================================================
#JS 第六节 2017.08.26
**心理建设：**
刚开始听说要做这个，觉得好难啊，自己还没有独立写过代码，有点怵的慌。但是大早上起来也无所事事，我就想先看老师study/lesson6中的代码吧，肯定有给提示的。
于是就开始做了，打开看了下是四个文件，分别是scan和write的文件，分别有两个，一个是同步，一个是异步。看了一下，分别运行了一下代码，觉得这不就是把两个代码放在一起就可以了嘛，一个扫描，一个放在txt格式的文件中。
这时觉得自己so clever，于是就喜滋滋开始做了。开始在一个新的js文件中一行行抄老师的代码。其中有几个让自己把之前so clever的想法全盘抛弃的节点，下面总结出来，让自己明白：熟能生巧，不是你不能巧，而是还不熟。
##异步
###问题1、定义要查询的目标文件夹
dirPathString使用的是相对路径的方式找到要读取的文件夹的。也就是说你现在运行的这个JS代码的文件夹才是坐标的原点，你要根据这个文件的坐标去找你要读取的文件夹的位置。
比如我们的作业中，我们的作业JS代码按要求是要放在homework下的lesson6中的，而我们要读取的是words-from-the-heart的文件夹，那么你需要退回到homework，然后退回到getting-started-with-javascript,再退回到my_project中，你才能在这个文件夹中打开words-from-the-heart的文件夹，于是代码就是：
> '../../../words-from-the-heart
**Notice**：刚开始搞不懂可以一直试，运行后下面报错就是我们学习的最好资料。反正电脑也不会崩，怕啥（当然，觉得自己有点蠢，那也没关系，人生难得几回蠢）。
###问题2、fileContent
write文件中与scan程序类似，运行老师的代码，就会发现会出现一个TXT格式的文件，里面写着“Hello，JS”。这是因为fileContent变量被定义赋值为'Hello，JS'。我们的目的是让之前扫描文件夹中的文件名被写入txt文件中，因为扫描打印的是files，所以：
>var fileContent = files；
###问题3、换行
代码写好后，运行，看到homework/lesson6中出现一个txt的文件，里面有62个文件（没有更新的情况下），但是所有的名字都在一行，完全懵，没法看。就想着怎么可以换行，做到一个文件夹名一行？
去网上搜索查到了换行符号(“\n”)，就打在了files的后面，但是发现files不是函数，直接在后面打括号，那肯定要报错的，于是运行了一下，果然是。
继续查找，在别人的代码中发现join()，然后在网上查到用法：
>join方法用于把数组中的所有元素放入一个字符串,元素是通过指定的分隔符进行分隔的。
那用join（"\n")的方法应该可以，遂运行，成功（因为是要对内容修改，所以这是写在fileContent后面的，对问题2的补充。
代码：
>var fileContent = files.join("\n");
##同步
做完了异步，同步就很简单了，没有什么问题。
---
做完了同步和异步，比较两者的代码，会发现同步的代码很简单，而异步的代码比较繁琐。其实还没有达到可以选择什么时候用同步，什么时候用异步的程度，只能照猫画虎。
还需要加强理解，现在的状态是只能看着例子，想着实际生活理解，还不能熟练，接下来一周的任务就是巩固之前的知识，开始认真看书的第二遍（第一遍太囫囵吞枣）；跟上听课，完成作业（不计划做太多的课外拓展）。
================================================
FILE: homework/lesson6/liushengxin.js
================================================
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '/Users/jackmac/getting-started-with-javascript/homework/lesson5';
// 定义要写入的文件路径
var filePathString = '/Users/jackmac/getting-started-with-javascript/homework/lesson6/liushengxin_file_async.txt';
// 定义文件内容变量fileContent
var fileContent = fs.readdirSync(dirPathString);
// 定义一个callback函数，用于接收写文件的返回结果
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//调用fs的writeFile函数来写文件
fs.writeFile(filePathString, fileContent, callback);
================================================
FILE: homework/lesson6/lixiang.js
================================================
var fs = require('fs'); //引入fs模块
var dirPathString = './'; // 定义要查询的目标文件夹为当前文件
var outputPathString = './lixiang.txt'; // 定义写入文件夹的路径和文件名
var names = []; // 这一步研究了两个小时，到底如何把读取出来的数组文件，转换为字符串写入新文件
// ---------------- 分割线以上 引入模块 及 定义变量，分割线以下定义函数
// 定义一个回调函数，筛选只有json后缀名的文件，这一步也花了差不多2小时
// 这里的callback (err,files)完全就是照搬模板，目前无法做到知其所以然，只知道这是一个回调函数，有两个参数
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
for (var i=0; i 0) {
console.log(files);
fs.writeFile(filePathString, files, callback1);
} else {
console.log('没有找到任何文件');
}
}
function callback1(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
function scanAndWriteFiles_async(callback){
fs.readdir(dirPathString, callback);
}
scanAndWriteFiles_async(callback);
================================================
FILE: homework/lesson6/mindongquan.js
================================================
/*
* 第6课作业，同步方案
*
* 扫描某个文件夹的所有内容并写入一份txt文件
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果想查其他文件夹的内容，就修改下面路径字符串。
var dirPathString = '../../../words-from-the-heart';
// 定义要写入的文件路径
var writeFilePath = './write_file_sync.txt';
// 检查所查询的目标文件夹是否存在，返回的true值作为workFlow的参数
function dirPathTest(dirPathString) {
if(!dirPathString) {
console.log('参数错误!');
return false;
}else if(!fs.existsSync(dirPathString)) {
console.log('所查询的目录不存在！');
return false;
}else {
return true;
}
}
//先将查询到的内容赋给filesName变量，再将其中的.json对象输出到目标文件
function collectJsonFilesNameToTxt(dirPathString) {
var filesName = fs.readdirSync(dirPathString);
// console.log('filesName的数据类型是 ' + typeof filesName);
var jsonFileName = [];
if(filesName.length === 0) {
console.log('该目录为空！');
}else {
for(index = 0; index < filesName.length; index++) {
if(filesName[index].endsWith('.json')) {
jsonFileName += filesName[index] + '\n';
}
}
// 最后一次循环导致末尾多一次换行，修掉
jsonFileName = jsonFileName.trim();
fs.writeFileSync(writeFilePath,jsonFileName);
}
}
// 按老师课上提到的思路——将整体过程按步骤分到各函数，再用workFlow控制
function workFlow() {
if(!dirPathTest(dirPathString)){
return false;
}else{
collectJsonFilesNameToTxt(dirPathString);
console.log('内容写入完毕，请打开write_file_sync.txt查看。');
}
}
workFlow();
/* 向老师提问
1. 第26行
}else {
return true;
}
除了return true 以外，还需不需要加别的内容？
2. 第54行
if(!dirPathTest(dirPathString)){
return false;
if 在判断时，是否会执行dirPathTest函数的全部内容？
我在编写过程中，出现过不加!会执行，增加!后就不执行了。但是按照以上的编写内容，即使我故意制造dirPathTest中的几种错误，也会执行并console.log。
所以我疑问的核心就是究竟何时会执行一次函数？还是只要有dirPathTest(dirPathString的地方就执行一次？有没有只需要取它的return，而不用再执行一遍的方法？
*/
================================================
FILE: homework/lesson6/ouyangchun.js
================================================
//ͬfsģ
var fs = require('fs');
//ҪѯĿļС
var dirPathString = '../words-from-the-heart';
var filePathString = '../js.txt';
var files = fs.readdirSync(dirPathString);
fs.writeFileSync(filePathString,files);
//첽
var fs = require('fs');//FSģ
var dirfile = '../words-from-the-heart';//Ҫѯļ·
var xierufile = '../js.txt';//Ҫдļ·
function callback(err,files){
if (err){
console.log('ȡļʧ');
return false;//˳ǰѭ
}
if(files.length>0){
console.log(files);
} else{
console.log('ûҵļ');
}
};//ص
fs.readdir(dirfile,callback)//FSģ
var files = fs.readdirSync(dirfile)
function writecallback(err){
if(err){
console.log('дļʧ');
}else{
console.log('дļɹ');
}
};
fs.writeFile(xierufile,files,writecallback);
================================================
FILE: homework/lesson6/panyong.js
================================================
// ---------------------------------
// 同步方案
function scan_write_files_sync(dirPathString,outputPathString)
{
// 引入fs模块
var fs = require('fs');
// 读文件名
var files = fs.readdirSync(dirPathString);
// 写文件名
fs.writeFileSync(outputPathString,files);
}
scan_write_files_sync('../../../words-from-the-heart','./write_sync.txt');
// ---------------------------------
// 异步方案
// 引入fs模块
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart';
var filePathString = './write_async.txt';
var name="panyong";
function write_callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
function read_callback(err,files){
if(err){
console.log('读取文件失败');
return err;
}
if (files.length > 0) {
fs.writeFile(filePathString, files, write_callback);
} else {
console.log('没有找到任何文件');
}
}
//调用fs的readdir函数读取所有文件
fs.readdir(dirPathString, read_callback);
console.log(name);
================================================
FILE: homework/lesson6/qiujingyu.js
================================================
//同步方案
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart/';
var files = fs.readdirSync(dirPathString);
var outputPathString = './write_file_sync.txt';
fs.writeFileSync(outputPathString, files);
//异步方案
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart/';
var filePathString = './write_file_async.txt';
function callback(err, files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
console.log(files);
fs.writeFile(filePathString, files.join("\n"), callback2);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, callback);
function callback2(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/readme.md
================================================
【第六节课作业】帮我整理数据
在words-from-the-heart项目中收到了很多同学的心声。我想把这些json的文件名整理到一个txt文件中。但苦于文件里太多。请帮我写个整理文件名的脚本代码。
请参考study/lesson6的的代码，共4个文件。
关于相对路径的理解请参考：https://github.com/xugy0926/getting-started-with-javascript/blob/master/topics/%E7%9B%B8%E5%AF%B9%E8%B7%AF%E5%BE%84.md
【作业内容】
1. 以自己的名字命名一个js文件。
2.先扫描文件夹，再把读到的文件名写入到某个txt文件。
【特别注意】
只提交一个你命名的js文件即可，我只要代码。不要给我txt结果文件。
【提交方式】
1. 请向getting-started-with-javascript项目发起pull request。
https://github.com/xugy0926/getting-started-with-javascript
2. 提交homework/lesson6目录下。
================================================
FILE: homework/lesson6/shaozhen.js
================================================
/*
第六课作业
*/
//同步方案
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '../../../words-from-the-heart';
//指定读取后所写入的文件的存放路径，名称和格式
var outputPathString = './wordsFromTheHeartName.txt';
//读取内容并赋值给写入文件
var outPutFileContent = fs.readdirSync(dirPathString);
//调用fs的writeFileSync函数来写文件
fs.writeFileSync(outputPathString, outPutFileContent);
//异步方案
var fs = require('fs');
var readPathString = '../../../words-from-the-heart';
var writePathString = './wordsFromTheHeartName2.txt';
// 定义一个read_callback函数，用于接收读取文件夹内容后的结果
function read_callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
//将读取的内容写进目标文件
var fileContent = files
fs.writeFile(writePathString, fileContent, write_callback);
} else {
console.log('没有找到任何文件');
}
}
//定义一个write_callback函数，用于接收写文件的返回结果
function write_callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(readPathString, read_callback);
================================================
FILE: homework/lesson6/shenzhili.js
================================================
/*
* 尝试用同步读取文件名，用异步的方式写入文件名
* 此js文件放在words-from-the-heart文件夹下
*/
var fs = require('fs');
var dirPathString = './';
var filePathString = './words-from-the-heart.txt';
var fileContent = fs.readdirSync(dirPathString);
fs.writeFile(filePathString, fileContent,function(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
);
================================================
FILE: homework/lesson6/sunyan.js
================================================
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹
var dirPathString = './words-from-the-heart-master';
/*
* 同步方案
*/
// 定义要写入的文件路径
var outputPathString = './write_file_sync.txt';
var files = fs.readdirSync(dirPathString);
fs.writeFileSync(outputPathString, files);
/*
* 异步方案
*/
// 定义要写入的文件路径
var filePathString = './write_file_async.txt';
//调用fs的readdir函数读取所有文件
fs.readdir(dirPathString, function (err, files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
console.log('读取文件成功');
var fileContent = files;
//调用fs的writeFile函数来写文件
fs.writeFile(filePathString, fileContent, function callback_write(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
});
} else {
console.log('没有找到任何文件');
}
});
================================================
FILE: homework/lesson6/tangjianfeng.js
================================================
var fs = require('fs');
var dirPathString = '../../homework/lesson1';
var outputPathString = './write_lesson1_sync.txt';
var files = fs.readdirSync('../../homework/lesson1')
function callback(err, files) {
if (err) {
console.log('读取文件失败');
}
else if (files.length >0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
}
function callbackwrite(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(dirPathString, callback);
fs.writeFileSync(outputPathString,files,callbackwrite() );
================================================
FILE: homework/lesson6/taobao.js
================================================
// 引用内置库
const fs = require("fs");
const path = require("path");
// 定义要查询的目标文件夹。
const scanPathString = path.join(__dirname, "../../../words-from-the-heart");
// 定义输出的目标文件及其路径。
const writePathString = path.join(__dirname, "./homework3.txt");
// 保存的文件Striing;
let saveScanFileString = "";
// 搜索的文件类型;
let findFileType = ".json";
//写入文件function;
function writeFile() {
function callback(err) {
if (err) {
console.log("Failwriting");
} else {
console.log("Sucesswriting");
}
}
fs.writeFile(writePathString, saveScanFileString, callback);
}
//扫描文件function;
//提供：扫描 total 文件个数，扫描目标类型文件个数，文件夹个数和非目标文件个数;
function scanFile() {
function callback(err, files) {
if (err) {
console.log("Scan Fail");
return;
}
if (files.length != 0) {
console.log("Find some files and folders");
var j = 0;
var k = 0;
var l = 0;
var m = 0;
for (var i = 0; i < files.length; i++) {
var eachFilesPath = path.join(scanPathString, files[i]);
var checkDirectry = fs.lstatSync(eachFilesPath).isDirectory();
if (checkDirectry == true) {
l = l + 1;
}
if (files[i].endsWith(findFileType)) {
saveScanFileString = saveScanFileString + files[i] + "\n";
j = j + 1;
} else {
k = k + 1;
}
}
m = i - l;
console.log("Total Find : " + i);
console.log("There is/are " + l + " Directiory(ies)");
console.log("Total files : " + m);
console.log(findFileType + " type files : " + j);
console.log(k - l + "file(s) is/are not " + findFileType + " files.");
saveScanFileString = saveScanFileString.trim();
writeFile();
} else {
console.log("There is not any files.");
}
}
fs.readdir(scanPathString, callback);
}
//写入代码嵌套在扫描代码中，不知到怎么做call back 来调取；
scanFile();
/*
Below this line, you can put in markdown to read it.
--------------------------------------------------------
#lesson6_第六次作业_scanAndWrite
This time homework, I spent almost 4 days on it. No matter how busy I was, I should done this 20 days ago. I will talk about something about lesson6 first, and later I will talk about me.
---
lesson6
1. var, let, and const;
At the beginning of study javascript, the prof from university, instructor Mr.Xu and most of textbook in the web, all of those teach with "var" at the beginning. However, this time when I read the node.js API, I found that some code not use "var", they prefer to use "const" and "let".
```
const fs = require('fs');
fs.unlink('/tmp/hello', (err) => {
if (err) throw err;
console.log('successfully deleted /tmp/hello');
});
```
Maybe Mr.Xu taught in later lecture or he already mentioned this point and I missed it. I got some idea from internet. I have some questions and I will out at the end of this article.
2. how important for flow chart;
When I write the version 2, I stop there for half of one day. Then later I try to draw the picture to slove the problem. I also felt happy while I typeing the version 3 homework3.js. I believed that I git the feeling as same as you coding in lesson 4. If everything follow my picture, I belive I can fly in coding.
3. relative and absolute path;
I did not know the difference between relative and absolute path in node.js becasue I even did not know
```
1. node lesson6\sample.js
2. node sample.js
```
that I can run sample.js by line 1 way. I always cd dir to the folder and run it like line 2.
I tried to solve this problem with one whole day. The reason I can find this problem beacsue I go to saw Hewei's homework, I did three different version homework, and if you want you can find them in [lesson6 study](https://github.com/tiandimeihua/xinshengdaxue_javascript/tree/master/study/lesson6).
After I finish the version 2 which is homework2.js, I do not know how to use callback make scan function and write function toghter, then I go to see hewei's howmwork. I found the proeblem with the path. I used the similar idead with him, but there have difference in code.
4. add some other task;
After I read the code from hewei, he use three different ways to slove the problem in two versions. However, I only come out with one. Moreover, I add different features with him. I found the diffence between he and I. He can think more bigger than me. In the other word, he stands more higher than me now. In his code, I see some new I never see before. Maybe I need to finish reading the textbook. Yep, I must read it.
---
Questions:
1. Can I use "const" and "let" to instead of "var" ?
2. How can I find what I need in the whole API ? Sometimes I do not know where to find it. For example,
```
.endsWith()
```
---
没有及时的听课，自己的经历还少，精力不够，没有在8月底的时候把课程跟上，5以后直播也很少去看，还好14那天去看了直播，远在重洋，网络好差，坚持了20分钟，我放弃了。 刚刚看lesson6的时候，有好多话想和老师说，但是后来写作业的时候想想算了。谢谢老师。
---
1. 老师上次批改我的作业说 形参和实参 可以点明以下么？ 谢谢。
2. 微信群压了2000+的消息，因为没有及时的听课，怕被剧透，所以没有去看，要现在去看吗？
---
老师辛苦了。
--------------------------------------------------------
*/
================================================
FILE: homework/lesson6/tuyilang.js
================================================
/*
* 异步方案
*
* 扫描某个文件夹的所有内容
*
* 将扫描的内容写入到文件中
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹，如果你想查询其他文件夹的内容，就修改下面的字符串。
var fileReadPathString = '../../../words-from-the-heart';
// 定义要写入的文件路径
var fileWritePathString = '../../../words-from-the-heart/file_list_async.txt';
//----------------------------------------------------
// 异步方案
// 定义一个read_Callback函数，用于接收读取文件夹内容再将其写入txt文件后的结果
function readCallback(err, files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
fs.writeFile(fileWritePathString, files, writeCallback);
} else {
console.log('没有找到任何文件');
}
}
// 定义一个writeCallback函数，用于接收写文件的返回结果
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
// 调用fs的readdir函数读取所有文件
fs.readdir(fileReadPathString, readCallback);
/*
for (var i = 0, j = 0; i < files.length; i++) {
var index = files[i].lastIndexOf('.');
var extend = files[i].substring(index + 1);
var fileContent = [];
if (extend == 'jason') {
fileContent[j] = files[i];
fileContent[j++] = "\n";
j++;
}
}
*/
================================================
FILE: homework/lesson6/wangchangqing.js
================================================
//同步方案
var fs = require("fs");
var dirpathString = '../../../words-from-the-heart';
var files = fs.readdirSync(dirpathString);
var outputPathString = '../../../words-from-the-heart/write_file-sync.txt';
fs.writeFileSync(outputPathString, files);
//异步方案
var fs = require("fs");
var dirpathString = '../../../words-from-the-heart';
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
}
var filePathString = '../../../words-from-the-heart/write_file-async.txt';
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFile(filePathString, files, callback);
//输出倒是成功了，但是结果有点乱。
//想实现每个文件名之后自动换行，还有过滤掉所有非json文件，那样应该会美观很多。
//好像有的同学已经实现了这样的技术。比如“liuliyuan”的作业就成功实现了自动换行的技术。
//我模仿她的代码，加入var fileContent = files.join("\n");但是依然没有成功，不太清楚原因是什么。
//而且她的代码中似乎没有定义files，也依然成功输出了结果。我尝试了一下在自己的代码中不对files做赋值和定义，但是运行的时候报错了——not defined。这一点也不太清楚原因是什么。
//读了何伟同学的代码，好复杂！！几乎完全看不懂。膜拜大神
//老师挖的坑好多，不过感觉自己已经慢慢知道老师的套路了哈哈哈——“改”、“删”、“换”，陷阱多多，必须多加小心才行。
================================================
FILE: homework/lesson6/wangganzy.js
================================================
var fs = require('fs');
var readDir = fs.readdirSync('./');
var filePathString = './write_file_async.txt ';
function weixin(err){
if(err){
console.log('写文件失败');
}
else {
console.log('写文件成功');
}
}
fs.writeFile(filePathString,readDir,weixin);
================================================
FILE: homework/lesson6/wangshasha.js
================================================
var fs = require('fs');
var files = fs.readdirSync("../../../words-from-the-heart");
console.log(files);
function callback(err, files) {
if (err) {
console.log('文件写入失败');
} else {
console.log('成功');
}
}
var OutPutPathString = './write_file_sync.txt'
fs.writeFile(OutPutPathString, files, callback)
================================================
FILE: homework/lesson6/wangwei.js
================================================
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart';
var files = fs.readdirSync(dirPathString);
for(var i=0; i < files.length; i++) {
var filesContent = filesContent + files[i] + '\n\n';
}
var outputPathString ='../../../write_file.txt';
fs.writeFileSync(outputPathString, filesContent);
================================================
FILE: homework/lesson6/wangyunfei.js
================================================
// lesson 6 作业，整理“同学们的心里话” ---王云飞
// 按着老师的作业思路，方案有两个，一个是同步的方案，一个是异步的方案。
// 同步方案
var fs =require('fs');
var dirPathString='C:/Users/Administrator/my_project/words-from-the-heart';
var outputPathString='C:/Users/Administrator/desktop/zy5.txt';
var fileCount=fs.readdirSync(dirPathString)
//console.log(fileCount);
fs.writeFileSync(outputPathString,fileCount);
// 先说说，同步方案，剔除掉 “打印日志”，一共5行代码，5行语句，从第一行，到第五行，按顺序执行。
//一、首先说说 "var fs=require('fs)",这是一个什么鬼东西。
// require('fs')的意思就是：“调出 “fs”模块这个功能, var fs 意思是用 fs 来作为他们的“代号”。
// "fs"是什么？ fs 就是一个功能模块，它提供了文件的读取、写入、更名、删除、遍历目录等功能。并被封装在Node.js 文件系统中。
//二、值得注意的是：fs 模块中提供了“异步”和“同步“两个版本。
// 例如：读取目录：异步函数形式为：fs.readdir() ，同步为 fs.readdirSync()。
//三、fs 同步函数中，fs.writeFileSync(),括弧中，必须包含两个参数，一个是“待写入的文件名” 另一个是“内容”。
// 翻译一下：fs.writeFileSync(filename,date). filename,date必须是要是真是存在的 “实参” ，否则操作无效。
// 废话不多说，直接上 “异步方案”
var fs =require('fs');
var dirPathString='C:/Users/Administrator/my_project/words-from-the-heart'
var outputPathString='C:/Users/Administrator/desktop/zy3.txt';
function readcallback(err,files){
if(err){
console.log('读取文件失败');
return;
}
if(files.length>0){
fs.writeFile(outputPathString,files,writecallback);
} else{
console.log('没有找到任何文件');
}
}
function writecallback(err){
if(err){
console.log('写入失败');
}else{
console.log('写入成功');
}
}
fs.readdir(dirPathString,readcallback);
// 一、如果你是小白，你一定感觉这个异步案例很烧脑，恭喜你，你的感觉是对的。因为，我的感觉跟你是一样的。
// 烧脑怎么破，听我慢慢道来。
// 二、 首先，有几个点，我们必须搞清楚，本文中谁是 “fs” 异步函数，谁又是普通的异步函数，否则，就没法混了。
// 谁是fs异步函数呢，当然是 fs.readdir(..); ,fs.writeFile(...),因为他俩都前缀了“fs”。
// 那谁有是普通函数呢? 当然是： readcallback(err,files) 和writecallback(err)。 为什么呢，因为地球人都知道，如果你不知道，我有理由怀疑你是火星人。
// 三、整个异步方案就是围绕这4个函数，调来调去。这里最关键的一点就是最后一个语句：“fs.readdir(dirPathString,readcallback); ”
// 正是因为这个语句，整个方案才开始动起来，你的计算机“内存”才开始真正”干活“。 一开始的那些语句别看都在前面，其实都被挂了起来，并没有动起来。
// 计算机最后一榔头干的活，则是打印writecallback(err)中的一个日志。
// 四、fs.feaddir（dirPathString,readcallback); 正是这个函数的调用，瞬间激发了readcallback(...)函数。、
// fs.readdir(dirPathString,readcallback); 这个fs函数的意思是，读取文件目录。fs.readdir（...）,这个括弧里必须包含两个参数（A,B）,否则fs没法干活。
// fs.readdir（A,B）; “A” 指的是“path”， 中文叫“路径”，“B"指的是“callback（err，files）”，中文叫“回调函数”。
// 五、重点来了：当fs函数读取了"A"中的内容后，会迅速把”读取结果“，给到”B“,注意了，我说的是读取结果，而不是一个值。
// 为什么读取了"A"后要给到“B”, "B"又为什么要接收呢？ 因为他们都得听 "fs"的，这是fs"的规定，他们必须的干。
// 这个读取结果包括两项：一个是读取”是否成功“ ,二个是成功后“读取的值” ，这两个信息，分别赋予给了 “ readcallback”函数中的“err与files”。
//
// 六、好了，说到这里，山路十八弯，已经过了一大半了，后面细节我就不一一啰嗦了，加油，童鞋们....
================================================
FILE: homework/lesson6/wangzhongbin.js
================================================
/**
目的：把words-from-the-heart项目中的jason文件名，扫描一下，再写入到一个txt文件中。
初步思考：
1. 先获取words-from-the-heart项目的路径，进入到jason文件夹里面。
2. 扫描文件，然后把jason文件名录下来(需要做判定，是否是jason文件)。
3. 再生成一个txt文件，然后把录下来的jason文件名写进去。
**/
// 引入fs模块
var fs = require('fs');
// 获取需要浏览的jason文件夹的路径
var scanPathString = '../../../words-from-the-heart'; // 有一个问题，就是这是一个相对路径，如果项目的文件夹不是这个目录的话，就获取不到路径了。
// 浏览目标文件夹内容,返回一个数组
var outContent = fs.readdirSync(scanPathString);
// 定义一个要写入到文件夹的数组writeContent;
// 筛选outContent的内容,把不含有.json的文件从数组中剔除出去，并加入到要写入的内容数组writeContent。
var writeContent = [];
for (var i = 0; i < outContent.length; i++) {
if (outContent[i].indexOf('.json') > -1) {// 判定outContent的元素是否包含有'.json'字符串，如果没有就说明不是.json文件。
outContent[i] = '(' + outContent[i] + ')'; // 百度和google了好久，都没有找到在txt里面，进行分段的符号，就加了一个括号，好辨认一些。
writeContent.push(outContent[i]); // 在writeContent里面加入筛选后确定是json文件的元素。
}
}
// 开始生成目标文件，并写入筛选好的内容
// 定义要写入的文件路径
var writFilePath = './write_file_name.txt';
// 调用fs的writeFileSync函数来写入文件
fs.writeFileSync(writFilePath,writeContent);
/*
// 感想
这可能是我第一次真正写代码，从设计到撰写。
刚拿到题目的时候，流汗……(⊙﹏⊙)b。
幸好还是之后老师补了节函数课，又翻了几遍同学的作业，晕眩之后，心里面稍定。
于是先理理思路，先把流程想清楚了。
但对怎么用函数还是不懂。
后来想起来老师让读nodejs api里面的东西，就赶快去网上找了，去读。
然而看到前几行：
conset fs = requre('fs')……以及后面的 throw err。
诸如：冒泡，抛出……
我的天……
讲得什么黑话，每个词都见过，但就是不知道说的啥。
一头雾水。
放弃，心塞。
就去看了老师第6节的示例代码，然而，还是老师写的代码比较容易懂，比心。
实验了一遍，迅速搞懂了fs怎么用。
但不甘心读不懂nodejs api 里面的文档，弄懂了老师的代码后，
又对照着去读nodejs api 里面关于fs reddir的部分。
这一次有如神助，莫名奇妙地就读懂了开头。
继续读，虽然还是不太清楚，但对throw 有理解了，类似是return。
如果throw err, 函数就停止了。
但接下来再读就又不懂了，对url，buffer之类的，感觉超出了理解能力。
放弃，还是先把作业搞定吧。
跟着老师的步子走，得到了文件夹的名字。
之后遇见了2个难题。
1. 如何筛选出.json文件,搞了好久。
一开始不清楚fs.reddirSync返回的outContent内容是数组还是一串字符串，就打印了outContent
发现是数组。
就用for 函数进行outContent每个元素的检查。
百度了如何检查字符串里面，是否包含有某个字符串，是用indexOf(这个函数区分大小写)，就使用了。
这里有一个大乌龙。
我百度了好久，都说indexOf是可以检查字符串里面是否有包含一个指定的字符串。
但我用的时候，一直没有检查出来，
接下来更新outContent内容时，一直包含有不是.json的内容，几乎浪费了2小时。
后来，在关键代码的每一行打入了console.log(1),console.log(2)进行检查……
然后发现，那个22行的if函数，一直没有执行，然而虽然没有执行，但也没有报错。
最后，发现居然是"json"写错了，我写成了"jason"……
哭……(⊙﹏⊙)b。
改了之后，顺畅好多。
之后轻松搞完了。
2. 搞完后，发现txt的内容都是没有分行的。
后来看同学的作业，发现有同学是能分行的。
我也希望做成那样的，然后就抄袭了一下，但发现我的搞不成。ㄒoㄒ。
之后我又运行了一下同学们的文件，发现在我的win7的环境下，他们生成的txt文件也是不行的。
好吧，百度……
百度的结果是只要在字符串后面加上'\n'或'\r'或'^p'就能进行分行。
但我试了之后，都不行。
期间，也百度如何给字符串加一些内容的，就是直接+ 就成了。
虽然一开始我百度的是用.join()函数来进行，不过一直报错，后来看了liuliyuan同学的作业，
发现她是通过“+”来进行的，就用了，成功！^^
不过依然不能在txt中分段。
就决定先放下去，有机会问下老师，如何进行分段。
不过为了美观，我在每个元素的前后，都加了一个双括号。
打印了之后，还是很美观的。
超有成就感。
做完之后，就迫不及待地噼里啪啦，打了很多字。
之后努力读懂api文档。
*/
================================================
FILE: homework/lesson6/weiyang.js
================================================
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../../words-from-the-heart';
// ---------------------------------
// 同步方案
var files = fs.readdirSync(dirPathString);
// console.log(files);
fs.open('words-from-the-heart', 'w+', function (err, fd) {
for (i in files) {
// console.log(files[i]);
if (files[i].indexOf('json') != -1)
fs.writeSync(fd, files[i] + '\n');
}
})
//fs.writeFileSync('words-from-the-heart', files);
================================================
FILE: homework/lesson6/wengguihua.js
================================================
/*
* 异步方案
*
* 扫描某个文件夹的所有内容
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查哪个文件夹的内容，就修改下面路径字符串。
var dirPathString = '../../homework/lesson2';
// 定义要写入的文件路径
var filePathString = './wengguihua_async.txt';
// 定义一个callback函数，用于接收读取文件夹内容后的结果
function readCallback(err,files){
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
var fileContent = files; // 定义文件内容变量fileContent
fs.writeFile(filePathString, fileContent, writeCallback); //调用fs的writeFile函数来写文件
} else {
console.log('没有找到任何文件');
}
}
// 定义一个callback函数，用于接收写文件的返回结果
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
// 调用fs的readdir函数来读取文件夹
fs.readdir(dirPathString,readCallback);
================================================
FILE: homework/lesson6/wenliuxin.js
================================================
var fs = require('fs');
var dirPathString = 'getting-started-with-javascript/homework/lesson1';
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, callback);
var stringContent = fs.readdir(dirPathString, callback);
var filePathString = 'write_file_async.txt';
var fileContent = fs.readdirSync(dirPathString);
console.log(fileContent);
function callback_writing(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFile(filePathString, fileContent, callback_writing);
/*
同步扫描and写文件方案
var fs = require('fs');
var dirPathString = 'getting-started-with-javascript/homework/lesson1';
var files = fs.readdirSync(dirPathString);
console.log(files);
var outputPathString = 'write_file_async.txt'
var fileContent = files;
fs.writeFileSync(outputPathString, fileContent);
*/
================================================
FILE: homework/lesson6/wenyunxin.js
================================================
fs = require('fs');
var readfile = ('./words-from-the-heart');
var writefile = ('./words-from-the-heart.txt');
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
fs.writeFileSync(writefile, files);
} else {
console.log('没有找到任何文件');
}
}
//调用fs的readdir函数读取所有文件
fs.readdir(readfile, callback);
================================================
FILE: homework/lesson6/wufan.js
================================================
/*看了好多同学的作业，我收获很大，这次作业交地时间晚，
一方面是学习节奏没跟上，另一方面看到那么多好作品，所以自己不愿意将就写。
无奈水平有限，只能临摹一个自己还能接受的版本吧。*/
//同步读写
var fs = require('fs');//引入nodejs API文件使用
var writeDirPath = './wufan.txt';//声明定义写入的目录路径，当前的文件位置
var readDirPath = '../myproject/words-from-the-heart/';//声明定义读取的目录路径，一定是相对路径
var files = fs.readdirSync(readDirPath);
var fileData = [];
for (var i = 0; i < files.length; i++) {
if (!fs.statSync(readDirPath + files[i]).isFile()) {
console.log('[Warning] ' + files[i] + ' 不是文件跳过');
} else if (files[i].match('\.json$') == null) {
console.log('[Warning] ' + files[i] + ' 不是json跳过')
} else {
fileData[i] =files[i] + '\n';
}
}
fs.writeFileSync(writeDirPath, fileData);
//-----------------------------------------
//异步读写
var fs = require('fs');//引入nodejs API文件使用
var writeDirPath = './wufan.txt';//声明定义写入的目录路径，当前的文件位置
var readDirPath = '../myproject/words-from-the-heart/';//声明定义读取的目录路径，一定是相对路径
function readCallback(err, files) {//读取的回调函数，按照API文档的语法规则去写
if (err) {
console.log('写文件失败');
}
if (files.length > 0) {//第一次出来都是大堆拥挤在一起，分d行写入好看多了,曹振写的很好。
console.log(files);
var fileData = [];
for (var i = 0; i < files.length; i++) {
fileData[i] = files[i]+',\n';
}
fs.writeFile(writePath, fileData, write);
} else {
console.log('没有找到任何文件');
}
}
function writeCallback(err) {//写入的回调函数
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(readDirPath, readCallback);
//---------------------------------------------
/*以下的代码输出的txt里面是undefined，到底哪里出了问题？
就在该使用回调函数的时候，用了直接函数，因为调用的异步读取书写函数，
所以应该使用回调函数的*/
//---------------------------------------------
var fs = require('fs');//引用API文件
var readPath = '../myproject/words-from-the-heart';//声明读取文件的相对路径
var writePath = './write_files.txt';//声明写入文件的相对路径
function read(err, files) {//定义读取文件的函数read
if (err) {
console.log('什么时候才能输出这个句子呢？程序出错时看到了。。。');
}
if (files.length > 0) {
console.log(files);
fs.writeFile(writePath, files, write);//错误版本没有的内容,这是回调read函数时会执行的.
} else {
console.log('这里没有你要的文件');
}
}
function write(err) {//定义写入文件的函数write
if (err) {
console.log('写入失败！');
} else {
console.log('写入成功！');
}
}
fs.readdir(readPath, read);//执行文件
/*错误版本中，这样写就成了直接调用函数，而不是回调了。
var files = fs.readdir(readPath, read);
console.log(files);
fs.writeFile(writePath, files, write);*/
//----------------------------------------------
/*我的疑惑是，如何把txt文件列表中的","消除，在添加序号的时候
/fileData[i] =i + 1 +files[i]+',\n';/这句出来的结果也不是按照123的顺序出来，因为开头中间又不是json文件的。
编程需要很多思考，思考的时间占据了80%的编程时间。*/
================================================
FILE: homework/lesson6/wukuipin.js
================================================
var fs = require('fs');
var filePathString = '../write_filename_from_project_words-from-the-heart.txt';
var dirPathString = '../words-from-the-heart/';
function callbackRead(err, files) {
if (err) {
fileContent(err);
}
if (files.length > 0) {
console.log(files);
var fileData = [];
for (var i = 0; i < files.length; i++) {
fileData[i] = i + 1 + '.'+files[i]+',\n';
}
fileContent(fileData);
} else {
fileContent('没有找到任何文件');
}
}
function callbackWrite(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
function fileContent(fileContent) {
fs.writeFile(filePathString, fileContent, callbackWrite);
}
fs.readdir(dirPathString, callbackRead);
// 这是第五版，使用不同的参数多次回调函数。哈哈哈，这是老师留的 bug，处理错误忘记return或回调，大部分的新手对这个问题视若无睹，我就是其中一位。现在对这个问题有一点点概念，我离高手又近了一步！
================================================
FILE: homework/lesson6/xianengqi.js
================================================
/*
*
*
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。
var dirPathString = '/Users/Administrator/my_project/words-from-the-heart';
// 定义要写入的文件路径
var filePathString = './qi.txt';
// 定义一个name_callback函数，用于接收读取文件夹内容后的结果
function name_callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
var fileContent = files.join('\n');
fs.writeFile(filePathString, fileContent.toLowerCase(), nameCallback);
} else {
console.log('写文件成功');
}
}
// 定义一个函数用于接收读取写内容后的结果
function nameCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
// 调用fs的readdir函数读取所有的文件
fs.readdir(dirPathString, name_callback);
================================================
FILE: homework/lesson6/xiongliyu.js
================================================
//引入fs模板
var fs = require('fs');
//确认读取文件的相对路径
var dirPathString = '../../my_project/words-from-the-heart';
//确认文件写入的路径
var filePathString = './xiongliyu.txt';
//什么一个变量、一个空盒子来装文件名
var fileList = [];
//建立一个callback用于接受读取的信息结果.调用readdir函数
fs.readdir(dirPathString,function read_callback(err,files){
//错误第一原则，判断异步是否有错
if(err) {
console.log('文件读取路径错误:' + err);
return;
}
if(files === 0) {
console.log('没有文件 err！！');
return;
}
console.log('找到指定文件，开始筛选所需文件：')
//筛选非“.json”文件，并把文件复制到 fileList 中
for(var i = 0; i < files.length; i++) {
if(files[i].indexOf('.json') != -1) {
fileList.push(files[i] );
console.log(files);
}
}
});
//调用writeFile函数，建立callback
fs.writeFile(filePathString, fileList,function write_callback(err) {
if(err) {
console.log('文件写入失败:' + err);
return;
}else {
console.log('文件写入成功');
}
});
================================================
FILE: homework/lesson6/yammy.js
================================================
// 引入文件系统模组
var fs = require('fs');
// 定义扫描的目标文件夹所在路径
var scan_dir_path_string = "../words-from-the-heart";
// 定义指定的写入文件所在路径
var write_file_path_string = "../achivement.md";
// 调用 fs 的 readdir函数来扫描指定文件夹，读取文件名
fs.readdir(scan_dir_path_string, function(err, files) {
// 如果扫描有错误，打印错误，运行结束
if (err) {
console.log("scanning failed\n" + err);
return;
}
// 提示扫描成功
console.log("scanning successfully");
// 如果扫描文件中无文件，打印无文件，运行结束
if (files.length === 0) {
console.log("oops, no files exist!")
return;
}
// 过滤出以 .json 结尾的json文件，并把数据存在 jsonFilesList 数组中
var jsonFilesList = [];
for (var i = 0; i < files.length; i++) {
if (files[i].slice(-5) === '.json') {
jsonFilesList.push(files[i]);
}
}
// 把收集到的 json 文件名 list，整理出字符串，方便一会儿写入文件
var file_content_string = jsonFilesList.join('\n');
fs.writeFile(write_file_path_string, file_content_string, function(err) {
if (err) {
console.log("write failed\n" + err);
} else {
console.log("write successfully");
}
});
});
================================================
FILE: homework/lesson6/yangtieming.js
================================================
//A 同步方案
//引入第三方的file system文件系统函数模块
var fs = require('fs');
//指定需要读取的目标文件夹路径
var readPathString = "./words-from-the-heart";
//指定读取后所写入的文件的存放路径，名称和格式
var writePathString = "./heartWordsList.txt";
//读取内容并赋值给filesContent这个变量
var filesContent = fs.readdirSync(readPathString);
//将filesContent变量的内容写入指定目录下的文本文件中
fs.writeFileSync(writePathString,filesContent);
//B 异步方案
//引入第三方的file system文件系统函数模块
var fs = require('fs');
//指定需要读取的目标文件夹路径
var readPathString = "./words-from-the-heart";
//指定读取后所写入的文件的存放路径，名称和格式
var writePathString = "./heartWordsList2.txt";
// 自定义一个文件读取函数rend.
function read(err,files){
if (err) {
console.log('读取文件失败');
}
if(files.length > 0){
console.log(files);
fs.writeFile(writePathString,filesContent,write);
} else {
console.log('没有找到任何文件');
}
}
//将读取的内容赋值给变量filesContent
var filesContent = fs.readdir(readPathString, read);
//自定义一个write函数，用于返回写入内容这个动作的结果
function write(err){
if(err){
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/yangxuewu.js
================================================
/**
* 异步方案
*/
//引入 file system 模块
var fs = require('fs');
//定义要查询的路径
var dirPathString = '../../../words-from-the-heart/';
//定义要写入txt文件路径
var writePathString = '../../homework/lesson6/file_name.txt';
//定义一个 callback_read 函数，用于接收读取文件结果
function callback_read(err, files) {
if (err) {
console.log('------读取文件失败------');
return;
}
if (files.length > 0) {
var fileName = fileArray(files);
fs.writeFile(writePathString, fileName, callback_write);
}
}
//定义一个 fileArray 函数，用于将 files 转为逐行打印的字符串
function fileArray(files) {
var returnString='';
for (var i = 0; i < files.length; i++){
returnString += files[i] + '\n';
}
return returnString;
}
//定义一个 callback_write 函数，用于接收写入文件结果
function callback_write(err) {
if (err) {
console.log('------写入文件失败------');
}
else{
console.log('------写入文件成功------');
console.log('文件路径：' + writePathString);
}
}
fs.readdir(dirPathString, callback_read);
================================================
FILE: homework/lesson6/yanqingmu.js
================================================
var fs = require('fs');
var readPath = './words-from-the-heart';
var writePath = './write_files.txt';
function write(err){
if (err){
console.log('写入失败！');
} else {
console.log('写入成功！');
}
}
var files = fs.readdirSync(readPath);
console.log(files);
fs.writeFile(writePath, files, write);
/*
尝试默写代码：
用异步的方式完成作业。
以下的代码输出的txt里面是undefined，到底哪里出了问题？
//先声明fs，从而调用内部函数的功能
var fs = require('fs');
//声明读取文件的相对路径
var readPath = './words-from-the-heart';
//声明写入文件的相对路径
var writePath = './write_files.txt';
//定义读取文件的函数read
function read(err, files){
if (err){
console.log('什么时候才能输出这个句子呢？程序出错时看到了。。。');
}
if (files.length > 0){
console.log(files);
} else {
console.log('这里没有你要的文件');
}
}
//定义写入文件的函数write
function write(err){
if (err){
console.log('写入失败！');
} else {
console.log('写入成功！');
}
}
//执行文件
var files = fs.readdir(readPath, read);
console.log(files);
fs.writeFile(writePath, files, write);
*/
================================================
FILE: homework/lesson6/yimiao.js
================================================
// 同步方案
var fs = require('fs');
var files = fs.readdirSync('./');
var outputPathString = './yimiao.txt';
fs.writeFileSync(outputPathString,files);
// 异步方案
var fs = require('fs');
var dirPathString = '../../homework/lesson6';
// ------
function callback(err, files) {
if (err) {
console.log('fail to read the document');
return;
}
if (files.length > 0) {
console.log(files);
} else {
console.log('can not find any');
}
}
// writh 部分
fs.readdir(dirPathString, callback);
var filePathString = '.ym_async.txt';
var fileContent = callback();
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFile(filePathString, fileContent, callback);
================================================
FILE: homework/lesson6/youshilei.js
================================================
/*
* 【第六节课作业】帮我整理数据
* 在words-from-the-heart项目中收到了很多同学的心声。我想把这些json的文件名整理到一个txt文件中。但苦于文件里太多。请帮我写个整理文件名的脚本代码。
* 请参考study/lesson6的的代码，共4个文件。
* 关于相对路径的理解请参考：https://github.com/xugy0926/getting-started-with-javascript/blob/master/topics/%E7%9B%B8%E5%AF%B9%E8%B7%AF%E5%BE%84.md
* 【作业内容】
* 以自己的名字命名一个js文件。 2.先扫描文件夹，再把读到的文件名写入到某个txt文件。
* 【特别注意】 只提交一个你命名的js文件即可，我只要代码。不要给我txt结果文件。
* 【提交方式】
* 请向getting-started-with-javascript项目发起pull request。
https://github.com/xugy0926/getting-started-with-javascript
* 提交homework/lesson6目录下。
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../../words-from-the-heart';
// 定义要写入的文件路径
var filePathString = './words-from-the-heart.txt';
// 定义一个read_callback函数，用于接收读取文件夹内容并写入txt文件后的结果
function read_callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
var fileContent = files;
fs.writeFile(filePathString, fileContent, wirte_callback2);
} else {
console.log('没有找到任何文件');
}
}
// 定义一个wirte_callback2函数，用于接收写文件的返回结果
function wirte_callback2(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.readdir(dirPathString,read_callback);
================================================
FILE: homework/lesson6/zhanggaoyang.js
================================================
//同步方案
var fs = require('fs')
var dirPathStiring = '../my_project/words-from-the-heart';
var files = fs.readdirSync(dirPathStiring);
console.log(files)
var outputPathString = './zhanggaoyang.txt';
var fileContent = files
fs.writeFileSync(outputPathString, fileContent);
//异步方案
var fs = require('fs');
var dirPathString = '../words-from-the-heart/'
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
var fileContent = files
fs.writeFile(filePathString, fileContent, callback2);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, callback);
var filePathString = './write_file_async.txt';
function callback2(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//在观察同学们的作业时
//发现在一个简单的“扫描文件，写入文件”的代码上，根据编程水平的不同，每个人看到的问题，遇到的坑也不同。
//小白们往往是照搬模仿成功就已经‘谢天谢地’了。
//高手则能够看到各种细节。还能找出不同的方法应对。
//作为小白，应该学习那些‘高手’们在各种细节上下功夫的态度。
================================================
FILE: homework/lesson6/zhanglina.js
================================================
/*
* 作者：张丽娜
* 时间：2017-08-30
* 版本：version1
* 功能：异步方案:
* 1、扫描words-from-the-heart文件夹下的的所有内容
* 2、将其写入到指定路径的文件下
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹
var dirPathString = '/Users/zhanglina/ZLNdocument/my_project/words-from-the-heart';
// -----------------------------------
// 异步方案
// 定义一个callback函数，用于接收读取文件夹内容后的结果
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
} else {
console.log('没有找到任何文件');
}
}
//定义一个变量，用于将读取到的文件存放在一个变量中
var files = fs.readdirSync(dirPathString,callback);
//定义一个写文件的路径
var outputPathString = '/Users/zhanglina/Downloads/write.txt'
// 定义一个callback函数，用于接收写文件的返回结果
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFileSync(outputPathString,files,callback)
/*
* 作者：张丽娜
* 时间：2017-08-30
* 版本：version2
* 功能：同步方案
* 1、扫描words-from-the-heart文件夹下的的所有内容
* 2、将其写入到指定路径的文件下
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹
var dirPathString = '/Users/zhanglina/ZLNdocument/my_project/words-from-the-heart';
//定义一个变量，用于将读取到的文件存放在一个变量中
var files = fs.readdirSync(dirPathString);
//定义一个写文件的路径
var outputPathString = '/Users/zhanglina/Downloads/write1.txt';
fs.writeFileSync(outputPathString,files,callback);
console.log(files);
================================================
FILE: homework/lesson6/zhanglina.md
================================================
---
2017-08-30 --create-by:zhanglina 补交第6次作业
---
- ##### 关于if(var)值的笔记
> ```javascript
> javascript是弱变量类型语言,通俗地就是没有数据类型。任意值都有逻辑值（真或假）：
> 非真值：null undefined '' 0 false
> 真值：任意对象、任意非0数字、任意非空字符串、true
> if(a){}表示如果a为真值就执行。
> ```
- ##### 作业部分代码提交
> ```javascript
> /*
> * 作者：张丽娜
> * 时间：2017-08-30
> * 版本：version1
> * 功能：异步方案:
> * 1、扫描words-from-the-heart文件夹下的的所有内容
> * 2、将其写入到指定路径的文件下
> */
>
> // 引入fs模块
> var fs = require('fs');
>
> // 定义要查询的目标文件夹
> var dirPathString = '/Users/zhanglina/ZLNdocument/my_project/words-from-the-heart';
>
> // -----------------------------------
> // 异步方案
>
> // 定义一个callback函数，用于接收读取文件夹内容后的结果
> function callback(err, files) {
> if (err) {
> console.log('读取文件失败');
> return;
> }
>
> if (files.length > 0) {
> console.log(files);
> } else {
> console.log('没有找到任何文件');
> }
> }
>
> //定义一个变量，用于将读取到的文件存放在一个变量中
> var files = fs.readdirSync(dirPathString,callback);
> //定义一个写文件的路径
> var outputPathString = '/Users/zhanglina/Downloads/write.txt'
>
> // 定义一个callback函数，用于接收写文件的返回结果
> function callback(err) {
> if (err) {
> console.log('写文件失败');
> } else {
> console.log('写文件成功');
> }
> }
>
> fs.writeFileSync(outputPathString,files,callback)
> ```
>
> ```javascript
> /*
> * 作者：张丽娜
> * 时间：2017-08-30
> * 版本：version2
> * 功能：同步方案:
> * 1、扫描words-from-the-heart文件夹下的的所有内容
> * 2、将其写入到指定路径的文件下
> */
>
>
> // 引入fs模块
> var fs = require('fs');
>
> // 定义要查询的目标文件夹
> var dirPathString = '/Users/zhanglina/ZLNdocument/my_project/words-from-the-heart';
>
>
> //定义一个变量，用于将读取到的文件存放在一个变量中
> var files = fs.readdirSync(dirPathString);
> //定义一个写文件的路径
> var outputPathString = '/Users/zhanglina/Downloads/write1.txt';
>
> fs.writeFileSync(outputPathString,files,callback);
> console.log(files);
> ```
>
>
================================================
FILE: homework/lesson6/zhaokaili.js
================================================
/*
异步
*/
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart';
var filePathString = './zhaokailiAsync.txt';
fs.readdir(dirPathString, function(err, files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
for (var index = 0; index < files.length; index++) {
if (files[index].indexOf(".json") != files[index].length-5 ) {
files.splice(index,1);
};
}
fs.writeFile(filePathString, files.join(" \r\n "), function(err){
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
);
console.log(files.length);
} else {
console.log('没有找到任何文件');
}
}
);
================================================
FILE: homework/lesson6/zhaoxiaoxin.js
================================================
var fs = require('fs');
var dirPathString = '../../../words-from-the-heart';
function callback1(err,files){
if(err){
console.log('读取文件失败');
return;
};
if(files.length>0){
console.log(files);
}else{
console.log('没有文件');
};
};
var outputPathString = './zhaoxiaoxin.txt';
var files = fs.readdirSync(dirPathString);
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
fs.writeFile(outputPathString,files,callback)
================================================
FILE: homework/lesson6/zhaoxiaoxin.md
================================================
很开心利用JS进行实际操作了。
描述好像不是很准确，很开心能用JS做与工作比较相关的内容了。
今天的作业感觉不是很难，毕竟老师把文件扫描和文件写入的代码都给我们了。而且每个步骤都给了两种方法。只需要拼接一下就好了。
我感觉这次作业的难点在于相对路径这个概念的理解。
既然是相对，就涉及到两个内容.下面是我的理解。希望老师点评。
已网上的一个例子为说明，假设现在有一个页面index.htm,在这个页面中联接有一张图片photo.jpg。他们的绝对路径如下：
c:/website/index.htm
c:/website/img/photo.jpg
已知页面index.htm的路径，如何用相对路径来找到图片photo.jpg呢？
一个原则是：两者重复的路径都可以省略。
一个自己领悟的重点是：所为当前目录也好，上级目录也好，上上级目录也好，这些都是针对已知的那个内容来说的。比如例子中的index.htm.
自己总结的三步：
1、比较已知内容与需表示的内容的路径，找出相同的路径，然后忽略。比如例子中的c:/website/
2、查看剩余内容，需表示的内容用来作为查找对象，比如例子中的img/photo.jpg；
3、查看剩余内容，已知内容的剩余部分用来表示路径。比如例子中，已知内容的剩余部分为index.htm 。则说明两者在同一个文件夹下。
最后相对路径为：img/photo.jpg
相同的方法
c:/website/web/index.htm
c:/website/img/photo.jpg
步骤3，已知内容的剩余部分为web/index.htm ，说明index.htm 的上一级目录和photo.jpg相同。
photo.jpg的相对路径可以表示为：../img/photo.jpg
c:/website/web/xz/index.htm
c:/website/img/images/photo.jpg
步骤2，需表示的内容剩余部分为img/images/photo.jpg；
步骤3，已知内容的剩余部分为web/xz/index.htm ，说明index.htm 的上一级上一级目录和photo.jpg相同。
photo.jpg的相对路径可以表示为：../../img/images/photo.jpg
c:/website/web/xz/index.htm
c:/website/web/img/photo.jpg
photo.jpg的相对路径可以表示为：../img/photo.jpg
回到老师的作业
在myproject中clone了项目words-from-the-heart；
代码文件作为作业保存的路径为已知路径，为
myproject/getting-started-with-javascript/homework/lesson6/zhaoxiaoxin.js
需要表示的路径为
myproject/words-from-the-heart/xx.json
words-from-the-heart文件的相对路径可以表示为：../../../words-from-the-heart
（1）增加了callback函数，相对于增加了一个对结果的判断，根据每一种反应给出一个反馈。
运行错误，也能得到反馈，让整个代码更具包容性。
也让代码对各种情况都有了一个反馈性。
这里的callback,感觉相当于老师讲的程序三步骤里的，参数验证，起这个作用
（2）写代码的过程中，突然有个疑问，什么时候函数名要加括号？
在异步写入时，callback是作为参数使用的，我写的时候加了括号。
什么时候加括号？
我的理解是，函数执行的时候需要加括号。函数作为参数引入别的函数时，不用加括号。
（3）老师给的scan-files-async.js里，貌似漏了files的定义。
但好像没有影响代码的执行。
================================================
FILE: homework/lesson6/zhaoyinan.js
================================================
//引入file system函数
var fs = require('fs');
//定义读取、输出地址
var dirPathString = '../../../words-from-the-heart';
var outputPathString = './titleInfo.txt';
//定义读取、反馈结果函数
function readCallback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log('已读取文件内容');
//调用写入函数，将files读取的用容传递给它
fs.writeFile(outputPathString, files, writeCallback);
} else {
console.log('没有找到任何文件');
}
}
//定义写入、反馈结果函数
function writeCallback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
// 调用fs的readdir函数来读取文件夹
fs.readdir(dirPathString, readCallback);
================================================
FILE: homework/lesson6/zhengchao.js
================================================
// 引入fs模块
var fs = require('fs')
//定义要查询的目标文件
var dirPathString = '../../../words-from-the-heart';
//定义要写入的文件路径
var filePathString = './write_file_async.txt';
// 定义一个函数用于接收读取目标的结果和读取到的内容
function readOutcome(err, files) {
if (err) {
console.log('读取文件失败');
}
if (files.length > 0) {
var fileContent = files.join('\n');
fs.writeFile(filePathString, fileContent.toLowerCase(), writeOutcome);
} else {
console.log('没有找到任何文件');
}
}
// 定义一个函数用于接收写入目标的结果
function writeOutcome(err) {
if (err) {
console.log('写入文件失败');
} else {
console.log('写入文件成功');
}
}
// 调用fs的readdir函数读取所有文件
fs.readdir(dirPathString, readOutcome);
================================================
FILE: homework/lesson6/zhengchao.md
================================================
### Lesson6作业思路
- 作业需求：读取指定路径的文件内容，并将其名称写入到指定路径的TXT文件中
- 异步思路：首先需要调用fs模块的两个子函数，一个是readdir()，一个是writeFile()。
相比同步函数readdirSync()，异步readdir()可以构建一个callback用于接收读取指定路径得到的内容和结果；
相比同步函数writeFileSync（），异步writeFile()可以判断写入的结果。
最初本来是想着按照做菜的思路，构建一个读函数，一个写函数和一个调度函数。但实操过程发现很麻烦，不如在函数末尾直接调用`fs.readdir(dirPathString, readOutcome);`来的清晰。
- 感想
真正去构建函数时，才发现思路真的很重要，也很难。知道的函数库足够多，才能实现更多的功能，在需要的时候才能知道去哪里找出自己需要用到的模块。就好比在代码成功运行第一次之后，发现TXT文件是一大长串，借鉴了一下LiuLiyuan同学的作业，才找到了把每个名字回车的办法。我自己也添加了一个小的method，用来把字符串统一改成小写格式，能更美观一些。
- 期待
想要在将来能实现更多的功能：
比方说阅读readdir() 这个模块的介绍时，看到fs.readdir(path[, options], callback)path还可以是URL（网址），如果这样，是不是就可以把path改成网址保证每次写入的文件都是最新最全的呢？
比方说如何把TXT里边的系统文件如：'.git' / '.gitignore'给屏蔽掉呢？
================================================
FILE: homework/lesson6/zhuting.js
================================================
//引入
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '/JavaScriptzt/GitHubxgy/getting-started-with-javascript/homework/lesson1';
//定义写入文件
var filePathString = 'heart.txt';
// -----------------------------------
// 异步方案
// 定义一个callback函数，用于接收读取文件夹内容后的结果
function callback1(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log(files);
//将读取的文件写入
fs.writeFile(filePathString, files, callback);
} else {
console.log('没有找到任何文件');
}
}
//调用fs的readdir函数读取所有文件
fs.readdir(dirPathString, callback1);
// 定义一个callback函数，用于接收写文件的返回结果
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
================================================
FILE: homework/lesson6/zouhainan.js
================================================
var fs = require('fs');
var dirPathString = '../files/my_project/words_from_the_heart/words-from-the-heart';
var outputPathString = './fileNames_async.txt';
fs.readdir(dirPathString, function (err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
console.log('到这里都没有问题');
console.log(files);
fs.writeFile(outputPathString, files, function (err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
});
}
else {
console.log('没有找到任何文件');
}
});
================================================
FILE: homework/lesson6/谢玉辉六课作业.js
================================================
/*
* 同步方案
*异步我是思考了几个小时一直搞不定。。。然后看了同学的作业才搞明白。多思考多测试，搞不定再看同学的作业可以立马恍然大悟。
*/
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../homework/lesson1';
var outputPathString = './write_file_sync.txt';
// ---------------------------------
// 同步方案
var fileContent = fs.readdirSync(dirPathString);
fs.writeFileSync(outputPathString, fileContent);
//--------------------------------------------------------------------------
//异步处理
//.................................................................//////
// 引入fs模块
var fs = require('fs');
// 定义要查询的目标文件夹。如果你想查lesson2的内容，就修改下面路径字符串。
var dirPathString = '../../homework/lesson1';
var filePathString = './write_file_async.txt';
// -----------------------------------
// 异步方案
// 定义一个callback函数，用于接收读取文件夹内容后的结果
function c(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
var fileContent = files
fs.writeFile(filePathString, fileContent, callback);
} else {
console.log('没有找到任何文件');
}
}
function callback(err) {
if (err) {
console.log('写文件失败');
} else {
console.log('写文件成功');
}
}
//调用fs的readdir函数读取所有文件
fs.readdir(dirPathString, c);
================================================
FILE: homework/lesson7/GaoXianfeng.md
================================================
## 第七课总结
### 项目地址代码
https://github.com/ruoshuigao/lesson7_homework
### 心里话地址：
https://ruoshuigao.github.io/lesson7_homework/
### 作业与课程内容总结
1. 课程内容部分：自己断断续续的学习了很长时间 JavaScript，但是每当在工作中遇到需要写 JS 时才意识到自学的 JS 又都还回去了，每次的工作任务还是上网查资料和文档完成，因为工作中写的少，自己平时也没有动手做一些额外的项目来巩固所学内容，所以每次学习的知识不久之后就又会忘掉，这次学习中，以前学习的内容慢慢涌现出来了。例如：课堂中老师讲授的函数定义与函数表达式。
2. 作业部分：参考了老师的实例，但是主要是自己思考思路、在 GitHub 中查阅 jsonfile 官方实例完成作业中数据读取功能。至于 html 文件，直接拷贝老师源代码。此次作业共用时4.5个小时，个人感觉作业完成的并不轻松。
================================================
FILE: homework/lesson7/anjiancai.md
================================================
项目地址：https://github.com/jiancaian/testwordsfromtheheart
网页地址：https://jiancaian.github.io/testwordsfromtheheart/
操作顺序：
1、在words-from-the-heart文件夹下新建一个test文件夹，在文件夹下新建一个package.json文件（一开始自己错误的命名成.js），然后在编写的package.json文件下打开集成终端，cd到test后，输入npm install,自动安装package.json文件中的jsonfile第三方包，此时在test文件下有node_modules文件夹生成，即安装的jsonfile包。
2、在test文件夹下新建一个index.js文件，copy徐老师的homework_sample.js文件内容。徐老师已经提示有bug,自己共修改三处：一是修改第八行中目标文件夹路径，即var pathString = '../../my_project3/words-from-the-heart/'，看到微信群中说到用../../向上返回文件夹，与终端中用cd ..类似；二是第26行中筛选文件夹中的json文件，应为files[i].includes('.json')这样表示；三是第38行读取json文件内容并写入至jsonList,应是jsonList.push(content)。运行index.js文件，正常下生成all_words和error_data的json文件。
以上两步实现了把内容读取至一个json文件中。接下来重点是把json文件内容展示到html中。
3、在test文件夹下新建一个index.html文件，同样copy徐老师的index.html，并复制粘贴包含style.css和vue.min.js的public文件夹。然后修饰index.html文件，一共更改了两处，一是在标题JavaScript编程入门下加入文本信息，授课老师：徐高阳
授课时间：20170808--20170914 每周二和周四晚上8:00--9:00
网页制作：安建才 20170910--23:00
二是把汇总到all_words.json文件中内容全选复制，赋值给index.html文件第56行中变量wordsList。完成以上操作，即可用点击index.html文件查看效果。
4、部署到github上。
新建一个库testwordsfromtheheart,生成一个地址https://github.com/jiancaian/testwordsfromtheheart.git，然后用终端cd words-from-the-heart，git clone 上述地址，此时在words-from-the-heart文件夹下生产一个testwordsfromtheheart文件夹，将通过上述1、2、3步在test文件下的内容全选并复制，粘贴至testwordsfromtheheart文件夹下。此时在终端依次执行git status, git add -A,
git commit -m "the first html", git push origin master,完成从本地仓库上传至远程仓库。
接下来就是生产一个网页文件的地址，在testwordsfromtheheart仓库中点击setting,然后下来找到GitHub Pages 的 Source,选择master branch ，然后点击save保存，稍等片刻，GitHub就会给你生产一个网址，即https://github.com/jiancaian/testwordsfromtheheart，点击网址就能看到部署的网页。
总结：以上步骤基本都是抄的，只对其中的很小一部分进行修改，通过完成以上步骤，对建立网页 有了初步的认识。接下来就是优化网页，让网页好看一些。
在操作前心理一直畏惧，感觉好复杂啊，自己搞不定。实操一遍，觉得还可以，重点是思路要清晰，完成后幸福感满满。
【项目背景】
前期收集了同学们的心里话，我想把这些内容整理到一个页面上展示。
【技术要求】
1. 使用filejson这个库，把同学们的json文件汇总到一个json文件中。
2. 用vue实现一个html，把json文件的内容展示出来。
【提示】
1. 先扫出所有的文件名。
2. 过滤掉非json的名字，得出一个结果全部是json的文件名。
3. 利用jsonfile的方法循环读取内容到一个json的数组变量中。
4. 将内容写入到一个json文件中。
5. 把最终得到的json文件的内容反映到html上，请参考github_index/index.html
6. 修饰一下你的html效果。
7. 部署到你github项目的页面上。
我给出了一个homework_sample.js供你参考。为了不让你直接抄，我里面设置了2个bug，可能需要你调试才能找出bug。
================================================
FILE: homework/lesson7/chenguoqiang.md
================================================
# 学编程一小步，人生一大步
参加了新生大学的编程入门课，最主要的原因就是便宜。之所以会想到学点编程，笑来老师建议每个人都要学点编程，想着学不下来也不会有很大损失。
课程总共有13节课，目前已经上完了12节课。前5节课并没有难度，都是一些基础的知识点，只要花些时间，不懂的地方多重复几遍。如果说有难度的话，没有接触编程的未知，会让你有恐惧感。你明明知道老师说的是中国话，就是不明白什么意思。仅仅过了十几天，回头看当时的课程内容，它们变得有点亲切。
出差的缘故，从第五节课开始，没有看直播课程，整个学习节奏就乱了，作业没能及时交。看课程回放，第一遍像是听天书，第二遍、第三遍··· ···，时不时的要拉回某个点再听一遍。作业并不是很顺利，就卡那里近一个小时动弹不得，你问老师，也没有发现问题，流程和命令都对，作业老师也会给出范本。就在你绝望的顶点，不经意的瞬间发现是命令拼写错了。
这个课程特色，老师不教编程语法，这些语法部分自学。直接做项目，做一个自己的网站。前面几节课的作业，都是为网站项目做铺垫。编程的知识，会用才算学到，学到了不会用，那就白白浪费了时间。网站的作业是第七课的作业，尽管之前有所铺垫，看着作业，不知道怎么下手，老师给预留了比较长的时候，利用这些时间又去看了前面课程内容，看完后依然不知道怎么下手。
有很多同学都提交了作业，心理更着急了，还是不知道从哪开始。偷偷观摩同学做好的作业，知道了老师设置的两个bug的位置，然后按照老师给的范例，顺利迈出了第一步。后面一切都按部就班，当看到自己网站建好的样子，很有成就感，完成了自己想都不敢想的事情。
一个月的编程学习的收获：碰到的问题并不需要都整明白，可以选择夸过去，项目先跑起来，而不是困在原地。就像写作，不能因为写不好而不写，正是因为写不好，所以才更要写。有些问题回头去看也许就不存在了。
人也需要盲目的自信，下辈子这个世界上就多了一个著名程序员。
网页地址：[https://chenguoqiang007.github.io/My-page/](https://chenguoqiang007.github.io/My-page/)
================================================
FILE: homework/lesson7/chenrushan.md
================================================
# homework lesson7
## 仓库地址
[words-in-hearts](https://github.com/Rushan-Chen/words-in-hearts)
## 网页地址
[words-in-hearts](https://rushan-chen.github.io/words-in-hearts/)
================================================
FILE: homework/lesson7/chenyanxing.md
================================================
JavaScript编程入门_lesson7
网页地址: https://pingcha.github.io/words_collection/
项目地址：https://github.com/pingcha/words_collection
碰到的问题
创建好项目，打开本地制作的网页，发现心里话这里没有显示出来：
回去重新对照老师教材的代码，花了一天去对照代码都没想明白是怎么回事，然后我点看本地页面的检查，发现这里说Vue没有定义
我重新认真的回去看了老师教材Vue的定义：https://github.com/xugy0926/getting-started-with-javascript/blob/master/study/lesson7/github_index/easy_vue.html
找到了问题的所在：
前面学习了如何引入第三方模块并执行后产生全局对象的js文件，没有写到html文件里面，所以报错‘没有引入vue模块’。所以事实上是我对如何引入第三方库的概念不清，还一直以为问题是出在引用的函数名上，参考同学的作业然后一直不停修改，也还是搞不明白。
未解决的问题：
1.导出数据到json文件里面，发现data挤在一堆，易读性差也不美观，还好有老师的提点：在vscode中，快捷键 alt + shift + F ，一键格式化代码。
2.对于某些函数片段的理解还不够，周末要多花点功夫研究。
3.教材代码：
把含有“json”字符的文件名过滤出来(需要一一判断—要用到循环语句for)
var jsonFilesList = [];
for (var i = 0; i < files.length; i++) {
if (files[i].slice(-5) === '.json') {
jsonFilesList.push(files[i]);
}
}
try…catch捕获错误的方法，直接用了，还木有研究
for (var i = 0; i < jsonFilesList.length; i++) {
// 同步读取文件如果发生错误，用try...catch捕获该错误
try {
// 读取json文件内容（文件路径+文件名）,并存在jsonList数组内
var contentJson = jsonfile.readFileSync(readDirPath + jsonFilesList[i]);
jsonList.push(contentJson);
} catch (err) {
// 如果读取错误就把错误的文件名写入到errorFiles数组内
errorFiles.push(jsonFilesList[i]);
}
}
作业心得
1.看到同学作业做得又快又好，我要更加用心才行。
2.一碰到不懂，觉得难，在以前我是很容易放弃的，没有想到的是跟着老师的脚步一步步加深认识JavaScript后，越觉得是门很有趣的语言，作业因为之前搬家而耽误了一段时间，但是不会拖延着不做，反而做的时候挺带劲的，特别是做出来后，那种攻克后的小成就感，让心情特别好呢！虽然还做不到不借鉴同学作业独自想明白然后完成作业，不过，适时向高手请教，帮助你上手，才不至于死磕一个“难点”未果把耐心给磨没了，很可能会导致放弃。
================================================
FILE: homework/lesson7/chenziwen.md
================================================
# 第七课作业——展示同学们的心里话
## 项目地址
> https://github.com/WindBlewSails/myFirst-repository
## 心里话展示页面地址
> https://windblewsails.github.io/myFirst-repository/
## 学习感受
这节课老师教了我们用Bootstrap来套用CSS表现，用VUE来展示数据，用JSONFILE第三方库来读取JSON文件内容。
完成这个作业用了我挺多时间的，先是解决老师设置的2个BUG，理清代码运行的过程。然后是搞清楚Bootstrap怎么套用，搞清楚VUE怎么把数据展现出来。最花时间而又没有成果的是想把头像和名字组合成一个正方形，心里话全部放到顶部的固定的位置，鼠标悬浮在哪位同学的头像上，顶部就会出现那位同学的心里话。或者是心里话就悬浮在头像的旁边。
But no Results。
CSS 和 VUE没有搞明白，只能按老师演示的完成了最基础的功能。
这又是眼高手低了呀。
================================================
FILE: homework/lesson7/cloudyview.md
================================================
#Lesson 7 HomeWork
## [页面链接]( http://daijun.info/lesson7-homework/)
## [GITHUB项目网址](https://github.com/cloudyview/lesson7-homework)
通过调试徐老师的程序，完成了作业，CSS方面也自己尝试了BOOTSTRAP的强大力量，VUE初步体验，感觉很爽。
这次作业，我总感觉要是还要手动去吧JSON文件里面的数据COPY一次到HTML里面，太罗嗦，就尝试用三段HTML代码来组合成一个HTML文件。美其名曰：动态。
具体做法：
1. 首先将index.html拆成两部分，分别是开头和结尾。中间的数据部分就删除。
2. 然后在老师的例程基础上做修改和调试，先读入开头，然后用fs.writeFileSync()函数创建一个index.html.由于这个函数每次执行都会将内容清零，然后再写入，所以相当于每次执行都在创建index.html。
在写入的时候，用了同步函数，是发现如果用异步，会出现写入顺序错误的问题。暂时还不清楚具体原因。估计是因为JSON读写的那段，用了同步，那么系统会首先执行同步的那些代码，所以，虽然我创建Index.html的函数先执行，结果还是会后出。
3. 然后是JSON文件读取，写入的部分，就直接用fs.appendFile（）函数来添加到index.hmtl的后面。 4、然后再后面再添加一段结尾的部分，至此，完成！
这个方法的好处是，我每次只需要执行我的JS文件，就能读取最新的“心里话”实现更新。
我考虑是否利用fs.Watch()函数，自动来监控。不过这样就需要做成后台自己运行的程序，或者要用web页面来发起请求，这些技巧目前都还不掌握，以后再考虑。
当前要解决的是乱码的问题，还在调试。功课先交，慢慢优化。
## 学习心得
1. 只需要调用一次的函数，就直接在要用的地方执行。在CALLBACK的位置，实在是好方便的说。
2. 用括号的时候，必须成对打出，否则很容易就多了或者少了。即使是VSCODE帮你，也不要贪图这个方便，只打一边。为这个括号，花费了我超多时间来调试程序。
3. 同步与异步，还需要多多理解。
4. 编码的问题在中文世界里真的很重要，目前还有好多好多乱码在文件里，应该是读取的时候就出问题了，现在在考虑如何解决，学习中。
================================================
FILE: homework/lesson7/cuiyuwei.md
================================================
作业地址：
团队
https://fengkaiwater.github.io/Beijing-Olympics/
================================================
FILE: homework/lesson7/dangfeipeng.md
================================================
https://dangfp.github.io/words_from_heart/index.html
================================================
FILE: homework/lesson7/dengxy0907.md
================================================
第七课作业
==========
> 项目地址：https://dengxy0907.github.io/myFirstJavascriptProject/
> 项目仓库: https://github.com/dengxy0907/myFirstJavascriptProject
心得(更像我情绪的描述)
---
> 因为自己生活中的意外和自己付出的时间不够多，导致课落下了，在急于完成作业的焦虑中一直在填自己给自己挖的坑。说实话，我这点小困难在其他同学面前不值一提
>虽然在敲代码时整体上很静，但是事实上还是有点着急的。我在哪里，我要什么，真的很重要，只有我脑子清楚了，代码才会跟着我走，而不是一心为了完成作业跟上进度而被代码带着思绪走
>这次依旧是最小可用品，之后再完善，感觉这个项目我可以像舍友反复打单机剧情一样反复啃了。
> 关于套路，我自己是很喜欢套路的，而去罗胖也说套路就是非正式的知识(大概是这个意思，原话忘记了)，因为没有什么经历，所以只能拿游戏举例了，套路让我最快的了解了这个游戏且在我的套路里能打败实力高过我的玩家，但是我毫无进步，一直都是在舒适区里。
> 之前的php是真的不知道该做什么几乎停止了学习，加上忙于shadowsock的事情就把php放下了，然后就遇到了这门课，我真的挺幸运的。我的js学习也能开始了，我是电子商务专业，今年大三了，之前学校的课程真的很水，今年终于上了专业课了，真的，感觉大部分课程要做的就是这次js课的内容，这种感觉很棒。
### 记录的错误汇总(因为屈指可数，就不分先后了)
>先安装库，遇到问题，package.json包在test文件夹下，npm安装应该在test下安装
>vue找不到，搜索了很多，也安装了Vue.js devtools 。最后在才在检查中发现我把Vue打成了vue,当然找不到了。
>找不到jsonfile－－－－－－>最后在微信聊天记录找到解决 npm install --save jsonfile ;不理解安装第三方库和插入第三方库有什么区别
>说jsonfile.writeFileSync 不是一个function；这两行我复制了其他同学的代码，但是代码是一样的，我的就不行，我也是英文输入法啊，不知道为什么，有空调试一下，是不是我哪里用了中文的输入法或者是其他原因
!(问题图)[https://ws2.sinaimg.cn/large/006tKfTcgy1fji1y2p22hj31b018ggvp.jpg]
> 哇，这里不知道又发生了什么，界面最左边出了一条绿线，然后这个图就。。。
### 成功汇总文件时想说的话
> 1、到这里的心里话，在我这次重新再来的时候收到了老师的回信，感谢老师对我们的付出
> 2、确实之前有点着急，除了一眼看出的扫描文件处的错误之外就没有注意其他的了，过于着急想打通流程，完全违背了初衷
> 3、直到晚上的课才隐约明白为什么pr“没有”成功了，是不是因为现在的pr要老师看完才算成功
> 4、之所以我觉得是不是pr出错是因为太久没有同步fork了，然后是先git到自己的git上才同步fork，git调用了我的编辑器让我说明为什么这次同步是必要的
> 5、强行关闭会提示打断git vi的运行，之后在的重新fork后，因为好奇，又同步了一次，出现了同样的界面（刚fork就同步fork）
> 6、因为我看pr里依旧是显示这个pr可以通过的（大致意思），所以就没有去注意
> 7、至于编程，虽然一直出错，但是我没有厌烦过，只是着急于课程落下了，不知道具体的应该去哪里找，敲代码时，我整个人都宁静了，很舒服，感觉每时每刻都在心流中
> 8、今晚的课上完我才知道我的php课不只是学了一点代码，我的php老师也让我完成了大半的入门，虽然是垫底的二本，但是很幸运遇到了这么多好老师
================================================
FILE: homework/lesson7/diaozhicong.md
================================================
#第七次课作业
##
【网页部署】
https://sam-tiao.github.io/Diaozhicong/
【作业地址】
https://github.com/Sam-Tiao/Diaozhicong
##
学到的关键知识点：
1.用后端jsonFile第三方库的方法读取众多文档写入一个Json文档；
2.初次用前端vue库的锚点方法将后端数据引入前端。
思考点：
本次作业，不知能否实现汇总的Json文档地址直接在前端vue的引用中实现直接挂钩（而不用拷贝进文档中），后面Json有更新，web端直接更新？ 如果能实现，该如何实现？需要那方面的知识？
================================================
FILE: homework/lesson7/fangqingyang.md
================================================
### 静态页面地址
### https://vfongv.github.io/LetMeTry/
### 项目地址
### https://github.com/vFONGv/LetMeTry
### 要解决的问题
* 网页加载太慢
* 页面排版，巨幕的背景图片，页面的背景图片
### 体会
1 走路的时候，总能想到点东西。
2 看文档是必须的。
3 抄，抄完后要看得明白。
4 重复敲代码是必须的。
================================================
FILE: homework/lesson7/fengkai.md
================================================
1.编程方法论
a.
声明 -> 变量
定义 -> 内存
赋值 -> 变量
b.
顺序
选择（分支） if ...
循环 for 、while ...
c.
封装;
调用服务,使用黑箱进行快速学习，适用初阶、中阶;
d.
编程世界里有一种机制，把不相关或低相关度的两件或者多件事产生联系;
e.
模仿是最好的初级训练
f.
对于编程语言的理解方法：把一句话拆成若干个单词，拿每个单词去执行，然后组合起来，整句话也就理解了；机器语言也是语言。
下断点 ／ console.log
g.
在项目中成长
h.
编程的过程就是把数据传来传去
i.
减法比加法好
j.
好的程序员 = [写文档, 项目管理, PPT, 简洁的代码, ... ]
2. 作业地址：
个人
https://fengkaiwater.github.io/myPage/indexHeart.html
团队
https://fengkaiwater.github.io/Beijing-Olympics/
================================================
FILE: homework/lesson7/guowei.md
================================================
# JS小白入门不放弃 homework_lesson7
### 提交作业
项目地址：https://github.com/Wei02320/words_collection
网站地址：https://wei02320.github.io/words_collection/
## 反思
### 学习最怕的不是不懂，而是傲慢。
这几天不管是在看回放还是做作业上都有些懈怠，反思一下：作业难度增加，完成没之前那么顺利，正向反馈减低，花时间变得更少，更难完成，走进死循环。一看日期，明天便是最后一节课，想起第一次课的JS小白不放弃里所说，放下傲慢。拿起键盘就是干！
### 作业要点和难点
* 使用filejson这个库，把同学们的json文件汇总到一个json文件中。
* 用vue实现一个html，把json文件的内容展示出来。
### 思路
其实老师在作业里都有留下sample，我们需要对代码进行修改和调试，大大地降低了难度。做的时候我也在想，不参考代码我能不能写出来。
**不过，不花时间还想一步登天，做梦呢！**
1.在github上新建一个项目：words_collection
2.先使用filejson这个库，安装package.json，引入第三方库。在这里犯了一个大错误，将*npm install*输成*npm install package.json*，以致于下一步一直报错。好在英俊潇洒的徐老师及时指出错误，并丢过来一个问题：
>为什么*npm install package.json*也可以执行？
*npm install*可以命令根据这个配置文件，自动下载所需的模块，也就是配置项目所需的运行和开发环境。而package.json文件本质上是一个对象，*npm install package.json*相当于单独安装package.json，所以报错？
3.把同学们的json文件汇总到一个json文件中。代码偷懒参考老师的sample：
需要注意的是，有三处需要修改哦！
```
var pathString = '../words-from-the-heart/';
```
```
var jsonFiles = [];
for (var i = 0; i < files.length; i++) {
if (files[i].includes('.md')) {
jsonFiles.push(files[i]);
}
}
```
```
var jsonList = [];
var errorFiles = [];
for (var i = 0; i < jsonFiles.length; i++) {
try {
// 读取json文件
var content = jsonfile.readFileSync(pathString + jsonFiles[i]);
jsonList.push(jsonFiles[i]);
} catch (err) {
// 如果读取错误就把错误的文件名写入到errorFiles数组内
errorFiles.push(jsonFiles[i]);
}
}
```
请开动脑筋找出来！
4.之后便是用vue实现一个html，然后把读取的json数据展示到网页上。新建index.html文件，copy徐老师的index.html（下一步想加一些新的东西玩玩，装修一下网页），并复制粘贴包含style.css和vue.min.js的public文件夹。
5.部署到自己的github项目的页面上。
*大功告成！明天结课前我要完成第9课，不多写了，看回放去了！*
================================================
FILE: homework/lesson7/hanwei.md
================================================
### 主页网址
https://freedomsky11.github.io/JScouser-homework-7/
### 代码网址
https://github.com/freedomsky11/JScouser-homework-7
================================================
FILE: homework/lesson7/hewei.md
================================================
# 第七课作业
## 团队概况
- 何伟：[https://github.com/Dream4ever/](https://github.com/Dream4ever/)
- 王颖：[https://github.com/MaggieWong27/](https://github.com/MaggieWong27/)
- 王沙沙：[https://github.com/shashawang](https://github.com/shashawang/)
- 谢泓升：[https://github.com/Risexie/](https://github.com/Risexie/)
## 作业地址
- 仓库地址：[https://github.com/Dream4ever/JavaScript](https://github.com/Dream4ever/JavaScript/)
- 网页地址：[https://dream4ever.github.io/JavaScript/lesson7.html](https://dream4ever.github.io/JavaScript/lesson7.html)
## 整体思路
最开始是想做一个里程碑式的效果，来展示大家的心里话，就是类似下图的这种效果。
但是在后面做网页的过程中，发现大家的心里话字数不一致，想要做出来预期中的效果，就要对原来的设计方案进行更改。而且工作和生活上的事情也不少，没有足够的时间来做出自己希望中的效果，只好作罢。
作业的基本内容倒是完成了，但是离自己期望中的样子还差很远，还要付出更多的努力才行。看着身边的同学一个个进步神速，自己心里那个焦虑啊。
下面就来讲讲本次作业的整体流程和遇到的问题。
### 一、后台读取 `json` 文件内容
后台读取各个 `json` 文件内容的基本流程如下：
> 1. 先用 `fs.existPath()` 检查保存心里话的文件夹路径是否正确，正确则继续，否则就中止程序。
> 1. 接着用 `fs.readdir()` 读取文件夹中的所有文件及文件夹至 `files` 这个数组中。
> 1. 在读取完成之后，只保留其中的 `json` 文件，删除所有扩展名不是 `json` 的文件以及所有文件夹。并且将 `files` 数组中的每个元素，由原来只是保存 `json` 文件名，改为保存各 `json` 文件的完整路径。
> 1. 用同步读取的方式 - `fs.readdirSync()` - 将每个 `json` 文件的内容读取至 `fileContent` 数组中，并将读取失败的文件名保存至 `errorFiles` 数组中。
> 1. 最后，将成功读取到的所有 `json` 文件的内容保存到 `content.json` 文件中，并将所有读取失败的文件名保存至 `error.json` 文件中。
### 二、前台读取 `json` 内容
前台读取 `json` 文件内容的方法很简单，因为用的都是现成的库的功能，所以几行代码就搞定了，也没遇到什么问题。
> 1. 在第一阶段，已经把大家的心里话都保存到了 `content.json` 文件中，然后在终端中将该文件上传至 GitHub 的仓库里：[content.json](https://raw.githubusercontent.com/Dream4ever/JavaScript/master/public/lesson7/content.json)。这样就可以用 `ajax` 请求来获取仓库上的内容，从而开始最基本的前后端交互。
> 1. 在 `main.js` 文件中，采用 `ajax` 请求来获取上面的 `content.json` 文件的内容。如果读取成功，则用 `JSON.parse(data)` 来解析返回的数据，并将解析后的数据与 `Vue` 实例 `vm` 中的数据项 `words` 进行绑定。这样，就可以在前端页面中使用读取到的内容了。
### 三、浏览器页面渲染数据
在获取到数据之后，就要开始对数据的渲染了。因为有了 `Vue` 这个强大的前端框架，以前很多需要用 `jQuery` 来手动操作的部分，现在都不需要考虑了，只要把主要精力集中在页面样式和业务逻辑上就可以了。说一下在做这个简单页面过程中的几个关键点。
> 1. 如何让大家的心里话依次在左边和右边进行展示？这里当然要用数组，将下标为偶数的元素 0、2、4…… 在左侧显示，将下标为奇数的元素 1、3、5…… 在右侧显示。那么如何能够获取到数组的下标呢？这就需要稍微深挖一下 `Vue` 中的 `v-for` 这个指令了。`v-for` 这个指令的第二个参数用来表示当前项的索引，这刚好就是我们所需要的。在前端页面中，用 `v-for="(word, key) in words"` 这条指令，来获取每一个元素 `word` 及其索引 `key`。这样就可以根据每个元素的索引值，来决定是让它在左边显示还是在右边显示了。
> 1. 在获取到元素及其索引之后，就需要为左侧和右侧的元素分别设置不同的样式了。经过一番研究，发现可以用 `Vue` 中的条件渲染来实现这个需求：对于索引分别为偶数和奇数的元素，利用 `Vue` 中的条件渲染这个功能，用 `v-if="key % 2 == 0"` 这个条件进行判断，然后分别用 `` 元素进行包装，这样就方便我们为不同的元素设置不同的样式了。
> 1. 接下来，就可以用 Bootstrap 的栅格系统来实现基础的布局，结合 `col-md-X` 和 `col-md-offset-X`，便可让元素在指定的位置显示了。
### 存在问题
虽然页面的基本效果做出来了，但是在这个过程中，发现了两点问题。
> 将屏幕分辨率设置为 `1280 x 800` 时，通过 Bootstrap 的栅格系统设置的样式发生了错位（见下方第一张图）。一方面，可以从图片的位置看出来，奇数行最右侧图片的右边缘，与偶数行最左侧图片的左边缘已经交叉了。而将分辨率设置为 `1440 x 900` 时，这种现象就消失了。另一方面还可以看到，偶数行的文字，全都跑到了下一行，似乎是因为偶数行最左侧的图片占据了过多的宽度。
↑发生错位的情况
↑正常显示的情况
下面就尝试着分析一下问题的原因：
在 `1280 x 800` 分辨率下，对于每一行来说，不包括边距的宽度为 `1168.8px`，那么其一半的宽度就是 `584.4px`。
奇数行的文本占据 5 列，含边距的总宽度为 `456.984 + 30 = 486.984px`。
奇数行的图片占据 1 列，宽度为 `style.css` 中指定的 `100px`。
这样奇数行左侧的内容占据的总宽度就为：`486.984 + 100 = 586.984px`，这个宽度已经超过父元素的半宽 `584.4px` 了。
再来看偶数行。
偶数行图片左侧的 `col-md-offset-6` 占据的宽度为 `584.391px`，这个宽度没有超过父元素的半宽，说明 Bootstrap 本身的栅格系统是没问题的。
偶数行的图片占据 1 列，宽度为 `style.css` 中指定的 `100px`。
这样偶数行图片右侧的位置为 `584.391 + 100 = 684.391px`。这个宽度是否超过了 Bootstrap 栅格系统 7 列的宽度呢？我们来计算一下 7 列的宽度：`1168.8 / 12 * 7 = 681.8px`，这个宽度是小于偶数行图片右侧的距离的。
经过上面的计算，问题的根源已经找出来了：在 `style.css` 中设置图片的尺寸为 `100px * 100px`，而之前显示器的分辨率设置为 `1440 x 900`，这个时候，`100px` 的宽度不会超过 Bootstrap 栅格系统一列的宽度，所以当时没有看出来问题。而这次把显示器分辨率调低之后，`100px` 这个宽度已经超过了 Bootstrap 栅格系统中一列的宽度了，所以出现了错位问题。既然这样，就不能用 `px` 来指定图片的尺寸了，用 `bootstrap responsive image max size` 作为关键字进行 Google，发现应当设置图片的 `max-height` 属性的值为 `100%`，这样不管怎样更改分辨率，都不会出现错位的问题了。
但是在查看页面的时候，发现对于 `img` 地址错误的元素，其高度坍缩成 0 了。而当初正是为了让这样的元素也能占据和普通图片元素相同的宽高，才设置的 `px` 值。这样一来，虽然解决了新问题，但是老问题又回来了，哈哈，真是辛辛苦苦三十年，一夜回到解放前呐。
嗯，这个问题先记录下来，后面再慢慢解决吧，作业都布置了一个多星期了，还没交上呢，焦虑啊！
参考资料：
[Constraining image height with bootstrap responsive image?](https://stackoverflow.com/a/21859493/2667665)
================================================
FILE: homework/lesson7/hitchhacker.md
================================================
# hitchhacker-homework7
---
## 队伍：志翀小分队
## 提取JSON文件的代码
```
// 引入fs模块
var fs = require('fs');
// 引入file json库
var jsonfile = require('jsonfile');
// 定义要扫描的目标文件夹
var pathString = './words-from-the-heart/';
// 文件全地址
var fileString
// 获取文件列表
var files = fs.readdirSync(pathString);
// 用于存放所有心里话
var writePathString = './all_words.json';
// 用于存放格式不正确的json文件名
var errorPathString = './error_data.json';
//得到jsonFiles
var jsonFiles = [];
for (var i = 0; i < files.length; i++) {
if (files[i].includes('.json')) {
jsonFiles.push(files[i]);
}
}
//console.log(jsonFiles);
//循环读取json文件的内容，并都存在jsonList数组内。读取出错的文件名存在errorFiles数组内。
var jsonList = [];
var errorFiles = [];
var content=new Array();
// 文件读取
for (var i=0;i var content = jsonfile.readFileSync(pathString + jsonFiles[i]);
通过pwd得到的路径/Users/chaoshengluchi/JS/words-from-the-heart，我直接拷进去了，然后怎么都得不到想要的结果。检查了很多遍，才发现路径后面少了个“／”。就因为这个“／”，差不多多花了一半的时间。深刻感受到代码的严谨性，只是微小的错误都能导致整个代码都不能正常运行。
另外还有一个地方我纠结了很久的，就是我一直以为像readFileSync这种方法是nodejs本身就有的方法，所以一直想不明白第三方库引用有啥用。虽然我知道第三方库是一个可以直接拿过来用的代码块，但是是怎么实现的完全是懵的。后来自信看了说明文档，才知道这个库就相当于定义了一种方法，如果我不引入这个库，我就不能使用readFileSync这个方法来读文件内容。想明白的那一刻真的是又气愤又高兴，气愤的是这么简单的东西居然想了那么久才想明白，高兴的是总算想明白了，哈哈。
### Vue
这个东东困扰了我好久。我真的想不明白vue是个啥。
比如老师说“设置一个锚点，好让初始化vue的时候来依据这个锚点构建映射关系”，这句话真的不是普通小白能听懂的。首先我就在想什么是锚点？其次初始化vue是什么意思？构建映射关系又是什么意思？只是一句话我就有三个问题。
老师在视频里还详细地讲了怎么用vue来实现数据更新，但是听完我也是懵的，因为我知道一个步骤但是却不知道为什么要这样做，也就是说依葫芦画瓢可以，但是让我自己写的话会完全不知道从哪里下手。
然后反复看视频，反复看代码，反复查资料，才终于明白了vue的作用。。。。
讲一下我对vue的理解。就是你有很长一段代码的时候，你想更改其中的一部分内容，直接去改很容易出错，vue要做的事情就相当于把你需要更改的部分框起来（在div后面加上id="app"，id名字和vue的el参数保持一致），标明这部分是我可以控制的。然后需要vue来完成更新的部分，需要打个标记（ {{ item.name }}），要不然vue怎么知道要更新哪些数据呢？两个瓜括号里面的内容对应vue里面的data参数。遇到需要做数据更新的时候，就不需要所有的代码都check一遍再去更改，只需要更改vue里面的data的内容就可以了。这就好比一个机器的一个零件坏掉了，不需要把整个机器拆了再来修，而是直接修这个零件，只要你告诉它在哪儿（定义ID），然后告诉它那个东西是什么（{{ item.name }}），vue就可以帮你把它修好，并且完全不影响你整个代码的运行。
顺便说下，这段时间做梦都是在写代码，vue就是在做梦后想通的。。。也是醉了。
页面上那首诗也是想用vue的，但是发现变量是一个简单的字符串好办，但是如果设计到换行排版又不会做了。。。
这个下来还要再研究研究
### Bootstrap
还不是很明白，只是明白它是一个CSS框架，就是用他可以实现很多页面布局效果。不过还不太会用
### 其他
搞明白jsonfile和vue后，要做一个网页，发现html／css的知识必不可少。之前利用业余时间在网上也看了一点相关的课程，这次为了这个作业又把剩下的课程看完了，了解了一个大概。感觉老师的课程就是这样，给你画个框，然后内容要自己填。不会填怎么办？去学。而在学一个知识点的过程中又发现需要其他知识。感觉就是养树的过程，最开始只是一根小苗，然后慢慢长出很多枝桠，最后变成参天大树.
div真的快把我弄疯了，div太多了，有时改也不知道多删了个还是少删了个，然后运行后就发现各种错乱，网页都是东拼西凑凑出来的。。。。。
有疑问的地方：
1. 页面左右两边留白各1格，中间6+4格，居中，container应该也有居中的效果，但是还没想明白，目前使用的的新加一个空白格的笨办法。。。。
2. 中间4格区域想分成上下两个模块，目前使用的是百度出来的方法，还不是很明白，勉强实现了。
### 学习感受
快歇菜了！好难啊，没有愁过工作，天天就愁JS作业怎么做。还要给自己加油打气，生怕一时偷懒放弃了。
切实感受到老师说的“课程结束才是真正的开始”的含义。开始上课那会儿，同事让我出去玩儿啥的，我都是说的“等我课程结束再约你”，现在的感觉是我约不约你跟课程有没有结束没有关系，反正不做作业我就没兴致约。。。
虽然很困难，很着急，很心累，但是还是要熬个鸡汤。群里的小伙伴一直都有在打卡学习，好几个同学之前进度掉一大截的都赶上来了。别人行没道理自己不行。我只是从开始到顿悟有点慢，并非不能学会。
谢谢老师和同学们的陪伴。
继续加油！
================================================
FILE: homework/lesson7/lingxiao.md
================================================
# 凌晓的第七次作业
[静态网页地址](https://lydialing.github.io/JSlearning/)
[项目地址](https://github.com/LydiaLing/my-getting-started-with-javascript/tree/master/homework/lesson7)
这次作业在讲bootstrap之前就完成了，但是本地json文件到html传输是采用的“复制-粘贴”，就想着怎么样能够实现自动获取，整了两个小时没搞定，就去休息了，后面停了bootstrap的课程，又觉得自己的页面太简单了，想把页面布置的华丽一点，可觉得内容好多啊，内心充满深深地焦虑...然后一直焦虑着，然后看着好多同学的作业，把我能想到的都实现了，我没有想到的也实现了，然后我还是很焦虑，然后就没有然后了...
一直拖到今天，想着一口吃不成大胖子，还是一步一步来吧，想太多没用，还是要去做...所以先把作业完成，后面再优化吧...
================================================
FILE: homework/lesson7/lipeng.md
================================================
这是李朋的第7次作业.
https://5haydn.github.io/JS-Startup/
**技术要点：**
1. json数据放在 dataEngin.js里了。
2. dataEngine.js, 放在public 文件夹下面，与vue.min.js 一同在 index.html 的 `` 引用。
3. 参考老师的文档：[《函数 - 定义完就执行》](https://github.com/xugy0926/getting-started-with-javascript/blob/master/topics/%E5%87%BD%E6%95%B0%20-%20%E5%AE%9A%E4%B9%89%E5%AE%8C%E5%B0%B1%E6%89%A7%E8%A1%8C.md)
================================================
FILE: homework/lesson7/liujun.md
================================================
JavaScript编程入门7课作业
网页地址: https://liujun009.github.io/liujun/
项目地址：https://github.com/liujun009/liujun
对于自己的作业还有许多不满意的地方，比如：心里话是粘贴过去的，代码因此显得很繁琐，后来要学会更高级一点的方法。
作业由于自己的原因，落后了许多，我会一点一点的赶上的。
================================================
FILE: homework/lesson7/liuliyuan.md
================================================
刘丽媛的第七次作业
网页请戳： 项目地址：[https://zjutszl.github.io/Vue_word/](https://zjutszl.github.io/Vue_word/)
> 仓库地址：[https://github.com/zjutszl/Vue_word](https://github.com/zjutszl/Vue_word)
这次的作业工程庞大，花了很多时间才完成。期间踩了不少坑。找时间把爬坑的经验传到仓库里。
================================================
FILE: homework/lesson7/taobao.md
================================================
# lesson7_第七次作业_read_and_write
---
老师你好，这次的作业我想先用中文写出来，给您节省点时间。
---
[网页地址](https://tiandimeihua.github.io/xinshengdaxue_javascript/)
[javascript 扫描文件读取内容写入新地址](https://github.com/tiandimeihua/xinshengdaxue_javascript/blob/master/study/lesson7/read_and_write.js)
---
问题：~~(问问题的顺序会有点乱)~~
1. var, let 和const，可以尝试使用 let 和const 代替var 吗？还是说只有自在var 有bug 的时候替换？
2. 如何找到自己想要功能，（内置库和第三方库），以第7课程为例，如何找到扫描json内容的api?
3. github 上看到好的项目如何收藏？star 还是fork ？
4. 老师的easy_work 上，想提交一些关于编程环境的准备教程，之前在国内windows + the Great Wall 里面存在好多坑，不知道会不会偏离主题？
---
这次的作业没有什么难点，之前安装第三方库的时候有点小麻烦，全局安装失败，谷哥后变成本地安装了。但是也没有加什么装饰，先把课程都看过的。
代码整体按照老师的思路做的，我重复扫描了2次所有json文件内容，没有去仔细看老师的Bug，写完大致看下是变量的一个坑，function 使用的时候一个坑。（没有仔细去看）。
读完了3000+的微信，老师最帅啦 !!!
---
English is an interesting language for me becasue most of people who are around of me, they know hwo to speak but dislike to use it. Sometimes, I know if I put it in the special place, I can talk more what I never say in real world. Maybe one day, someone will find it. I really want to talk all thing happen in my daily life by updating code, and hit them in it. I just finish my problem in university, and keep studying. I realized that how fast time passes every second. I will try my best on coding and move more forward.
================================================
FILE: homework/lesson7/wangwei.md
================================================
## 王炜wayneWong(新生大学:朱春雷,我老婆)作业项目地址
> [项目地址:https://github.com/lightww/words-collection-lesson7-homework](https://github.com/lightww/words-collection-lesson7-homework)
> [主页地址:https://lightww.github.io/words-collection-lesson7-homework/index.html](https://lightww.github.io/words-collection-lesson7-homework/index.html)
### 问题:
有的文件名称,内容好像没有问题,怎么也扫不出来,属于err了呢.
比如 我自己的 json文件 **wayneWong.json** 内容如下:
```
{
"avatar": "https://raw.githubusercontent.com/wiki/lightww/words-from-the-heart/avatar.png",
"name": "wayneWong 王炜",
"words": "之前学过一点 html和css， 还比较好理解，
但是JS 就更偏向于 编程和代码了，所以想和名师系统的学一下"
}
```
这个文件就没有扫出来,写入了 **error_data.json** 文件中. 还有好多文件,看着都正常的,也写入了 **error_data.json** 的文件中.
================================================
FILE: homework/lesson7/wangyunfei.md
================================================
## Lesson7 Homework 王云飞
### 一、
很快js语言，入门课程接近尾声，逐渐进入项目实战状态。本次作业可以说是，将之前讲的函数调用、循环语句，fs模块、相对路径，等知识发挥的淋漓尽致。并且引入了一些新的知识点，比如： jsonfile第三方库，内置push函数、includes方法、try..catch语句、等。
讲真，这些知识点同时混合在一篇代码中，对于小白来说，短时间内彻底通透领悟，实属不易，我也是琢磨的许久才悟了个大概。想必那些还在补课的同学们，在制作本次作业时，内心也是异常的煎熬。不过没关系，试错的次数只要足够多，总能行得通。
如何将读出的“心里话”内容写出来，并写到json格式的文件里。关于具体代码部分，这里不做详述。
这里有一个最最重要的地方，也算是我的心得吧。“要筛选“json”格式的“心里话”，并用json写出来，最最最重要的一点，就是提前要安装好“jsonfile”这个第三方库，也叫第三方包。 “var jsonfile = require('jsonfile')” 这一步不叫安装，叫引入。 如果没有提前安装好，引入是无效的。”
如何安装 “jsonfile” 第三方库，可以参考老师的步骤，也可以去网上搜，简单几步，半分钟搞定，谁用谁知道.......
安装好 “jsonfile”库以后，会出现一个”node_modules 包“，“js工作文件” 一定要与这个“node_modules包”处于同一目录下，否则，“js工作文件” 是引入不到 jsonfile模块的。 安装，并使用 “jsonfile”库，其实老师在直播中有讲到，但是很多人可能都会忽略细节。
掌握了这个关键步骤点以后，后面的如何筛选“json格式心里话” 并写入到“json文件中”这些都不在话下。
话不多说，直接进入作业的重点。
### 二、
将“心里话内容"写到一个"json格式“文件以后，并没有结束。前边的工作，只是做铺垫。真正的重头戏，在后边："将得到的 json格式心里话内容，反映到HTML上"。讲通俗一点，就是把“心里话内容”给挂到网页上，而且一定要是其他人能访问的一个互联网网页，不能是一个本地网页，这才是重头戏。
从某种程度上来讲，这就是一个实战，虽然工程量不大，严格来讲，都算不上工程。但是对于像我这样的小白来说，简直就是“大工程”。 首先，我对html一窍不通，更不要说把内容放到html上，放到HTML之后，又如何挂到互联网上呢? 问题多多......
困难再多，但是，办法总归比困难多。老师的授课方式有自己的独特之处，他不去讲“html知识”，直接就开讲“vue". vue是个啥，难道vue就可以制作网页？
其实不然，网页=html，虽然这种说法不严谨，但是对于小白来说，没问题的。 vue其实就是个第三方库，说白了就是个工具， 仅作用在html里面的一个工具。vue这个工具的目的是：“通过尽可能简单的手法，来实现html里的数据绑定与更新。 ” 说白了，vue就是给html“打工的”。 没有vue，html也可以找其他的人来代替vue。
那么为什么偏偏选中vue这个工具呢？ 因为vue 相较于其他类似的工具，比如:jquery,vue显得更轻，更高效。更重要的时，vue更适合初学者。所以老师一上来，就直接放大招，直接就上vue。不过说真的，因为我也没学过其他的第三方工具，vue我也确实没感觉到简单，心碎....
说完了vue，再回到html里，因为要把“json心里话”挂到html里，始终绕不过html。直到开始做今天的作业，我才明白js语言，跟前端有啥关系。原来js代码应用在html页面里面，然后通过浏览器内核引擎执行，代码的执行效果，就会出现在屏幕上。这就是典型的js语言应用在前端。
html文档，说白了就是一个网页。html文档里包含了各种各样的标签，通常标签都是成对出现（有些标签确实是单个的）。html就是靠这些标签，来描述网页。 标签里面的内容称为元素，这些元素由浏览器内核来执行并显示。当然了，web网页是不会显示标签本身的。
关于html标签，像：< html > < /html > 、< body > < /body >、 < h1 > < /h1 >、< p > 、< /p > 等很多标签， 这里就不一一叙述。
大多数HTML标签内的元素，都拥有自己的属性。而这些属性非常重要，只有掌握了这些属性，才能熟练的掌握html。比如“link标签” ，“link标签”就拥有charset属性、hreflang属性、href属性、type属性等属性....
关于更多的html知识，课参考http://www.w3school.com.cn 教程，里面把html相关的基础知识，介绍的很是详尽，且可以在线实操。
说起html知识，我觉得，html跟js函数比起来，可以用“小巫见大巫”来形容。虽然html也算是一门独立的学问，如果想掌握的很牛逼，也确实不容易。但是总体上来说，html学习起来，还是稍微比学习js函数，轻松那么一小丢丢。而学习js函数，更多的可能是思考，且深度的思考，这也是老师花那么多时间讲js函数的原因...
了解了大致的html知识点，我们就可以制作本课作业。当然，我们小白自己完全独立制作，撰写html代码，不太现实，毕竟需要一个过程，甚至这个过程很长，但是这没关系。本课作业，我们可以直接借鉴老师、以及同学的范文。 前提是必须了解一些html的基本知识，否则我们真的看不懂，而且是一点也看不懂。
我们“抄作业”规“抄作业”，但最起码我们抄完后，要能看懂每一行代码的意思，比如：“ < link rel="stylesheet" href="./style.css">”，这行语句。
其实弄懂这行语句，只需查询一些基本的link标签知识，就能搞懂，如果不去查询，就算抄10遍，也搞不懂是什么意思。搞不懂，这是一个与外部文件进行连接的标签。
在借鉴老师html代码的同时，有些地方要特别注意。尤其是第三方库的调用。比如：< link rel="stylesheet" href="./public/style.css">，其实这行语句，本质上就是调用第三方包，调用style.css文件，但是这个链接发起的是一个相对路径，如果自己的本地里没有这一个style.css这个文件。那么我们抄完老师的代码后，最终html页面一定是混乱的。因为页面他找不到了style.css文件，没法执行这个样式。同理，vue这个工具也是个相对路径。 同样需要我们去下载，我们直接从本地电脑里，去老师的github文件study里，去复制就ok。
等自己本地html页面做好后，就要把它放到互联网上了，否则别人远程是看不到的，最简单的方法放在github项目上，利用github平台来展示.当然，再把自己的html推送到github时，不要忘记把相关的包一并推送上去、且自己的html文件命名为index。不要问为什么， github他就是这么“傻”，你改成其他名字，它就不认识它了，只显示“404”，他就是这么“傻”。
基本上，这些步骤，就可以把童鞋们的“心里话”，展示在互联网上了。当你在互联网上打开自己制作的“心里话”网页时，那一瞬间，是不是感觉自己很牛逼，反正我是.....
虽然网页效果比较LOW，但是，万里长征，也算走出了第一步。
### 三、
说起html知识，我觉得，html跟js函数比起来，可以用“小巫见大巫”来形容。虽然html也算是一门独立的学科，想掌握的很牛逼，也确实不容易。但是总体上来说，html学习起来，还是稍微比学习js函数，轻松那么一小丢丢。而学习js函数，更多的可能是思考，且是深度的思考，这也是老师花那么多时间讲js函数的原因...
老师的课程毕竟有限，只能在保证大方向的基础上，将最重要的知识点来讲，重要的点与点之间，散落的其他的知识点，只能靠我们自己去学习，去思考。但是请相信，老师所讲授的一定是最精华的，老师所没有讲授的，一定是相信大家，通过自学可以搞定的。
就像老师说的：“我要是花大量时间给你们讲html，css，那我这门课就白瞎了......
本次作业，将js语言的用处，生动的展现出来。直到今天，我才明白，原来js语言用来就是干这个的，其实js语言不仅仅是应用在前端html上，同样也应用在后天服务器上，还记得很早之前，老师说的“node js，现在运行时”吗？ node，js就是典型的在后端的应用。 那么他是如何在后端执行的呢，老一套，代码还是js代码，函数还是那个js函数，只不过从浏览器运行环境，换到了node，js运行环境了，前面就跑后面了。
说道这里，是不是觉得js语言很牛逼，的确，它是很牛逼。
可是，如果我的js没有学好，js函数，还在懵逼咋办？ 其实我在js函数这块，也在懵逼。但是我会一直前行下去，所有的问题，在发展的道路上，都能找到解决的办法。有些问题点，暂时搞不明白，就放一放，学习的进度，一定不能长时间停滞。该少许加快点速度，就要加速。 js函数基础坑坑洼洼，也一样可以做出来一个项目，虽然很low，但是也算是个项目，在做项目时，碰到js函数难题，再回头去深思考，深学习，把js函数也搞懂了，项目也搞出来了.....
顺便附上我的作业地址：虽然很low，请老师过目：https://yunfei1988.github.io/newtest-0814/
================================================
FILE: homework/lesson7/wangzhongbin.js
================================================
/*
目标：把同学们的心里话，扫描到同一个json文件里面。
步骤：
1. 进入到目标路径words-from-the-heart
2. 筛选出所有的json文件，并把这些json文件名写入一个需要扫描的目标json文件里面。
3. 定义一个要输出的json文件名和路径。
4. 遍历这些json文件，依次把里面的内容，写入到要输出的json文件里面。
（需要判断，哪些json文件写入失败了，并把写入失败的json文件名写入到err的里面）
*/
// 引入fs库和jsonfile库
var fs = require('fs');
var jsonfile = require('jsonfile');
// 定义要扫描的目标文件夹
var dirPathString = 'D:/my_project/words-from-the-heart';
// 定义存放大家心里话的js文件路径
var ourHeartWords = './ourHeartWords.json';
// 定义扫描错误的json文件路径
var errFilesPath = './errHeartWords.json';
// 扫描出需要扫描的json文件名，先筛选，再把它们存放到jsonScanFilesNames文件里面。
var files = fs.readdirSync(dirPathString,function (err,files) {
if (err) {
console.log('读取文件失败');
return;
}
})
//把.json文件过滤出来，并把内容存放到jsonScanFilesNames里面。
var jsonScanFilesNames = [];
for (var i = 0; i < files.length; i++) {
if (files[i].includes('.json')) {
jsonScanFilesNames.push(files[i]);
}
}
// __________________________________________________
// 循环读取jsonScanFilesNames文件的内容，并把内容输出到一个数组jsonContent。
var jsonContent = [];
var errFiles = [];
for (var i = 0; i < jsonScanFilesNames.length; i++) {
try{
var content = jsonfile.readFileSync(dirPathString + '\\' + jsonScanFilesNames[i]);
jsonContent.push(content);
} catch (err) {
// 把读取文件错误的文件名写入到errFiles中去。
errFiles.push(jsonScanFilesNames[i]);
}
}
// 把收集到的数据写入到相应的文件中去
jsonfile.writeFileSync(ourHeartWords, jsonContent);
jsonfile.writeFileSync(errFilesPath, errFiles);
/* 总结
一开始顺着老师的方法走，先定了思路和流程，做得很顺。
然而，依然有坑，搞了很多乌龙。（解决了后，回过头来看，感觉自己简直是zz……）
这次写代码最大收获是，你认为错的地方，不一定错了。
反而是那些没考虑过的地方，错了。
还有就是，一定要相信cmd反馈回来的信息，它们能帮你找到错误。
最后！！也记得去群里面问一下，我每次遇到问题时，满脑子想的是百度或google，居然忘记截图去群里面问了。
(这次出错的地方很弱智，如果去群里面问了，反而可能会立刻解决)
事情是这样的……(⊙﹏⊙)b，记录一下。
这一次代码一开始我觉得，做得满顺利的，运行时，修复了一些问题。
但就卡在最后一步，一直出错，不论怎么改，都是出现：
PS D:\my_project\my_article> node wangzhongbin.js
D:\my_project\my_article\wangzhongbin.js:81
});
^
SyntaxError: Unexpected token )
at createScript (vm.js:74:10)
at Object.runInThisContext (vm.js:116:10)
at Module._compile (module.js:533:28)
at Object.Module._extensions..js (module.js:580:10)
at Module.load (module.js:503:32)
at tryModuleLoad (module.js:466:12)
at Function.Module._load (module.js:458:3)
at Function.Module.runMain (module.js:605:10)
at startup (bootstrap_node.js:158:16)
at bootstrap_node.js:575:3
当时我怀疑是不是电脑的nodejs出问题了，因为我的代码只有80行，
但它居然说我81行有问题……
我调整了很多语句，但执行后，一直说是（我写的代码行数+1）的那一行出错了（即永远是你没写到的那一行有问题），
且永远是“})”错了，语法错误。
然而我都找不到这两个代码……
无语。
我怀疑jsfile库安装不正确。
就又重新敲了一遍 npm install --save jsfile。
果然看到 err ，我觉得应该是jsfile有问题了。（然而我错了）
就百度，如何重装第三方库。
通过npm cache clean --force 强制删除。
后来重装。
但是，重装后，运行代码，依然错！还是同样的错误。
抓狂，继续想，是不是我的jsonfile名写错了？
因为老师后来在read_a_json和另一个文件里的jsfile引用，一开始是写成了jsonFile的，区分大小写。
老师是不是挖了坑……（虽然理智告诉我，不太可能，但万一呢……之前老师说埋了2个bug呢。）
以防万一，我改了，然而依然还是最开始屏幕的话……好吧，再改回。
不过这时的我，依然满脑子认为，是jsonfile库装错了，
因为我用的是sublime编辑器，
然后最开始两行，引用jsonfile库的时候，jsonfile的字体颜色是黄色的，但引用fs时，颜色是白色的……
我猜，这是不是有区别……(⊙﹏⊙)b（好吧，我的脑回路是有些清奇）
就一直在百度，想确认jsonfile是不是装成功了。
直到我百度到用npm ls，来查看装的modules，看到了有jsonfile库之后，我才开始明白：
哦，原来它装对了。
但到底哪里错了呢……
于是通过把一段段代码变成注释，
确定出，就是for语句之后出错了。
然而我实在是想不出，哪一行错了。
后来，我表哥来电话了，就和他聊了十几分钟。
回来后，开始莫名其妙地开始数for语句的挂括号了……
一数之下，
我发现……
我少写了一个花括号！！！！
！！！
我的for语句，是抄袭了老师的那一段，因为是抄袭老师的，就潜意识以为，应该不会出错吧，
应该不会出错吧？！！
是的，老师木有错，
然而我错了！！！！
我少抄了一个花括号！！
也许是，我删代码时多删了一个！
总之，就是少了一个花括号！！
然后我又加了一个，再运行，居然成功了！！
喜极而泣……
现在一想，感觉这个错误好弱智，不应该出错的，/(ㄒoㄒ)/~~。
不过cmd返回的反馈，也是让我有些懵，因为出错的行数，我根本就没写到那里。
虽然它的意思是，让我在那一行补上一个括号，但这种反馈很容易造成误导，因为是整个模块的错误。
这也让我判断错误，（好吧，我在为错误找借口）
不过简而言之，还是有些收获的……至少完成了作业。
*/
================================================
FILE: homework/lesson7/wangzhongbin.md
================================================
网页地址：https://wangzhong2014.github.io/javascript/
项目主页：https://github.com/WangZhong2014/javascript
## 第7次作业总结
第七次的作业是分为2部分。
一部分是用js，把同学们的心里话筛选出来，放到json文件里面。
然后再把这一部分的json内容更新到自己的主页上。
#### 第一部分
第一部分做得很顺，如果不是自己一开始搞得乌龙的话，真得是不用几小时就做出来了。
然而，搞了一个乌龙，浪费了一天。（解决后，回过头来看，感觉自己简直是zz……）
**这次写代码最大收获是，你认为错的地方，不一定错了。
反而是那些没考虑过的地方，错了。**
其次，一定要相信cmd反馈回来的信息，它们能帮你找到错误。
最后，要敢于问，善于问，如果真得遇到了自己解决很困难的问题， 就勇敢地去提问。
我总是担心浪费别人的时间，每次遇到问题时，满脑子想的是百度或google，很少会截图去群里面问。
(但这次出错的地方并不是很难的，如果去群里面问了，反而可能会立刻解决)
事情是这样的……(⊙﹏⊙)b，记录一下。
这一次代码一开始我觉得，做得满顺利的，运行时，修复了一些问题。
但就卡在最后一步，一直出错，不论怎么改，都是出现：
```
PS D:\my_project\my_article> node wangzhongbin.js
D:\my_project\my_article\wangzhongbin.js:81
});
^
SyntaxError: Unexpected token )
at createScript (vm.js:74:10)
at Object.runInThisContext (vm.js:116:10)
at Module._compile (module.js:533:28)
at Object.Module._extensions..js (module.js:580:10)
at Module.load (module.js:503:32)
at tryModuleLoad (module.js:466:12)
at Function.Module._load (module.js:458:3)
at Function.Module.runMain (module.js:605:10)
at startup (bootstrap_node.js:158:16)
at bootstrap_node.js:575:3
```
我当时怀疑是不是电脑的nodejs出问题了，因为我的代码只有80行，
但它居然说我81行有问题……
我调整了很多语句，但执行后，一直说是（我写的代码行数+1）的那一行出错了
> 即永远是你没写到的那一行有问题，且永远是“})”错了，语法错误。
然而我都找不到这两个代码……
无语。
我怀疑jsfile库安装不正确。
就又重新敲了一遍 npm install --save jsfile。
果然看到 err ，我觉得应该是jsfile有问题了。*（然而我错了）*
就百度如何重装第三方库。
通过npm cache clean --force 强制删除。
后来重装。
但是，重装后，运行代码，依然错！还是同样的错误。
抓狂，继续想，是不是我的jsonfile名写错了？
因为老师后来在read_a_json和另一个文件里的jsfile引用，一开始是写成了jsonFile的，区分大小写。
老师是不是挖了坑……*（虽然理智告诉我，不太可能，但万一呢……之前老师说埋了2个bug呢。）*
以防万一，我改了，然而依然还是最开始屏幕的话……好吧，再改回。
不过这时我，依然坚定地认为，是jsonfile库装错了。
因为我用的是sublime编辑器，
然后最开始两行，引用jsonfile库的时候，jsonfile的字体颜色是黄色的，但引用fs时，颜色是白色的……
我猜，这是不是有区别……(⊙﹏⊙)b（好吧，我的脑回路是有些清奇）
就一直在百度，想确认jsonfile是不是装成功了。
直到我百度到用npm ls，来查看装的modules，看到了有jsonfile库之后，我才开始明白：
>哦，原来它装对了。
>但到底哪里错了呢……
于是采用笨方法，先把一段段代码变成注释，然后逐步运行。
确定出，就是for语句之后出错了。
然而我实在是想不出，哪一行错了。
后来，我表哥来电话了，就和他聊了十几分钟。
回来后，开始莫名其妙地开始数for语句的括号了……
一数之下，
我发现……
我少写了一个花括号！！！！
！！！
我的for语句，是抄袭了老师的那一段，因为是抄袭老师的，就潜意识以为，应该不会出错吧，
应该不会出错吧？！！
然而我错了！！！！
我少抄了一个花括号！！
也许是，我删代码时多删了一个！
总之，就是少了一个花括号！！
然后我又加了一个，再运行，居然成功了！！
喜极而泣……
现在一想，感觉这个错误好弱智，不应该出错的，/(ㄒoㄒ)/~~。
不过cmd返回的反馈，也是让我有些懵，因为出错的行数，我根本就没写到那里。
虽然它的意思是，让我在那一行补上一个括号，但这种反馈很容易造成误导，因为是整个模块的错误。
这也让我判断错误，（好吧，我在为错误找借口）
不过简而言之，还是有些收获的……至少完成了作业。
#### 第二部分
第二部分是把json的内容更新到网站上。
我一开始想的是，如何把我筛选好的json文件里面的同学们的心里话，写入到html文件里面。
但这里有两个难点：
1. 如何把json文件里面的内容写入到html中，我查了是通过jquery，但具体的还不是很清楚，估计要花很大的功夫。
2. 心里话写入到html中，是放到了```用这个去渲染 里面的内容
4. 在 var object ={
el:''[el里面指的是具体内容的锚点，div去设置，因为下面的data只会渲染锚点里面的东西]
data:{
}
}
5. vue就是JS在浏览器环境中使用的第三方库。
6. jsonfile.readFileSync 意思是读取文件内容并立即返回
7. var content = jsonfile.readFileSync(pathString + jsonFiles[i]);其中=是赋值；jsonfile.readFileSync是方法。
### 遇到的大坑
1. 相对路径： 本地测试第一遍的时候，只有没更新的网站，是因为我没有修改本地引入vue的相对路径和css的相对路径，看了2遍Topic的内容，重新做，测试成果。
2. 在本地测试成功的基础上，上传到我的github里，网页还是不能正常显示，倒腾了半天，刚开始以为要把相对路径写成必须是网站的地址，后面发现不用；其实我没有把public文件夹上传到我的rouor repo，所以vue得引用和css都不成功。就这个内容折腾了一下午。但是我忍住没有在群里问。当时的心路历程是这样的：好焦虑怎么办做不出来——要在群里问——但是，转念想，昨天最后一节课，徐老师还说了要在编代码之前多想，**想清楚再下手，而不是不停的不动脑子的去做。**因此，我调整了一下焦虑的心——用逻辑分析一下——本地显示正常，git显示不出来vue和css的原因只可能是出在路径上——重新检查，把public文件夹上传。——bingo!
3. 因此学到了解决bug，最重要的是先冷静下来，根据逻辑课里学到的知识做逻辑的分类思考，然后分别去检查。
================================================
FILE: homework/lesson7/yinzhibao.md
================================================
## JavaScript编程入门_lesson7
网页地址:https://babysodme.github.io/homework_lesson7/
项目地址：https://github.com/babysodme/homework_lesson7.git
## 自我感觉网页的小亮点
1.照片每次刷新会随机排序。
2.配色风格延续新大主站色调。
## 作业心得
1.复制粘贴就是干。太多编程知识需要去开拓。
2.当听到老师讲我们学完课程后完全可以找份前端工作做着，第一反应我是怀疑的；啥都不会儿呢咋整。可是通过这次作业按照老师讲的在bootstrap上找组件，看到好看的网站就把样式拿过来，网页从上到下逐一完成导航、巨幕、面板、缩略图、内容填充、页脚。每个细节都会遇到一箩筐的问题，想起老师说过我们遇到的问题肯定别人都解决了去搜索去github上找就好，问题就这样一个个的解决掉，兴奋的20个小时没睡觉把网页搭建出来，对html文件引用css、js文件也有了更多的认知。
3.javascript函数对前端好比摄影中的光影；太太重要了，似乎体会到为什么老师花这么多时间来讲函数。
## 新见识的代码听老师讲随时存上以后可以拿来直接用
1.数组随机排序方法：
arr.sort(function(){return Math.random()-0.5;})
网上很多前辈认为这个方法不是正真的随机，这个问题留着以后进阶了回来看。
2.将一个数组平均分为若干个数组的小方法：。
function split_array(arr, len) {
arr.sort(function(){return Math.random()-0.5;});
var a_len = arr.length;
var result = [];
for (var i = 0; i < a_len; i += len) {
result.push(arr.slice(i, i + len));
}
return result;
}
3.瀑布流bootstrap缩略图+Masonry插件
## 待解决问题
1.想让每个缩略图有阴影效果，这样立体感更强，同时鼠标放上去有悬浮效果。
2.网站需要增加登录系统。
3.划分精品区域根据点赞+评论数排序。
4.按钮上可以显示点赞数和评论数。
5.按钮根据点击次数提示不同信息。
这几个问题留着进阶后回头来搞
6.强化javascript函数方法的理解及使用。
6.新大主页和登录页会动的背景视频一定要“偷”出来用。
7.隔壁队伍的队长那晚说去抽根烟到底是去做了、想了什么？
================================================
FILE: homework/lesson7/youshilei.md
================================================
## 第七课作业
【技术要求】
1. 使用filejson这个库，把同学们的json文件汇总到一个json文件中。
2. 用vue实现一个html，把json文件的内容展示出来。
【提示】
1. 先扫出所有的文件名。
2. 过滤掉非json的名字，得出一个结果全部是json的文件名。
3. 利用jsonfile的方法循环读取内容到一个json的数组变量中。
4. 将内容写入到一个json文件中。
5. 把最终得到的json文件的内容反映到html上，请参考github_index/index.html
6. 修饰一下你的html效果。
7. 部署到你github项目的页面上。
---
### 我的操作步骤：
1. 先是学习老师的几个例子，观察jsonfile.readFileSync， jsonfile.writeFileSync，jsonFile.readFile，jsonFile.writeFile几个函数的用法和区别。只有jsonfile.readFileSync是有直接返回值。
2. 发现老师例子里的两个坑：
- 过滤json文件名时的`.md`:
```javascript
//把含有"json"字符的文件名过滤出来,把所有文件保存在jsonFiles数组中
var jsonFiles = [];
for (var i = 0; i < files.length; i++) {
if (files[i].includes('.md')) {
jsonFiles.push(files[i]);
}
}
```
- 读取心里话是的`jsonFiles.push(files[i]);`:
```javascript
// 读取json文件
var content = jsonfile.readFileSync(pathString + jsonFiles[i]);
jsonList.push(jsonFiles[i]);
```
3. 在形成index.html的时候卡了很久，不知道如何将json文件中的内容在html中显示。看了老师的index.html也没明白，最后查看其他同学的作业，发现罗陆军同学的作业步骤，是先把数据内容放在js文件里，然后通过head里调用js文件来实现。照猫画虎，完成html。
4. 以下是最终的HTML。
[新生大学javascript学习心里话](https://yousl.github.io/allwords/)
================================================
FILE: homework/lesson7/zhanglina.md
================================================
- ##### 第一：作业提交
[（个人网页）](https://zhanglinalove.github.io/MyPage/)
- ##### 第二：心得体会
> 1、完成第7次课程，再重新看自己以前做的网页，顿时觉得丑爆了，可是当时也折腾了半天，还是不能解决布局的问题，直到老师手把手的教我们布局这块，一个bootstraps引入，再加div的class属性col-md-n的设置，一个简单的设置就解决了困扰我之前网页搭建痛苦了好久的布局。多么痛的领悟啊，做一个事情，知道怎么做，远比盲目的傻做效率要高太多倍啊！难怪老师反复强调自己教编程的思想，而不是上来就从枯燥地语法开始，教会了我们做事情的方法，浩瀚的JS的星辰大海，需要我们自己去探索。
>
>
>
> 2、GIT HUB:在接触JS课程之前，我之前对于GitHub只停留在听别人说过一次，至于自己用，完全觉得不可能，当时觉得这个东西完全就是深不可测的东西。在JS课程开始以后，因为需提交作业，从git下载、安装、上传遇到冲突解决、到现在几乎成为了每天必备的工具，那些开始记不住的命令，仿佛和打字一样成为了习惯。这个感觉真心是超棒，我试图把这个东西推荐给我的同事，不过他觉得没有意思，就没有用。或许只有用，且经常用的人才知道有多爽！对了，老师之前让我学习写md的文档，完全没有听过是什么鬼？现在我的笔记全部都是md，也不过半个月的时间，哈哈哈，人的适应和学习能力都是很有潜力的。
>
>
>
> 3、JS群里每天都有各种各样的问题，恐怕这个群，目前是我手里最活跃的一个了，没有之一！老师、童鞋们对于回答、解决问题的热情都非常的高。高手太多，总是让我这种小白有着强烈的危机感。因为怕做出来的东西太水，太菜。可现实是总是要从小白开始，然后一点一点的进阶。希望我这小白菜童鞋也能给大家提供到帮助呢。技术还是要分享的，这句老师的话，我记住了，接下来，就是好好践行。
>
>
- ##### 第三：Coding部分
```javascript
// 引入fs模块
var fs = require('fs');
// 引入file json库
var jsonfile = require('jsonfile');
// 定义要扫描的目标文件夹
var pathString = '/Users/zhanglina/ZLNdocument/my_project/words-from-the-heart';
// 用于存放所有心里话
var writePathString = '/Users/zhanglina/ZLNdocument/my_project/jsonInfo/all_words.json';
// 用于存放格式不正确的json文件名
var errorPathString = '/Users/zhanglina/ZLNdocument/my_project/jsonInfo/error_data.json';
// 调用fs的readdir函数读取所有文件
fs.readdir(pathString, function(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
//把含有"json"字符的文件名过滤出来,把所有文件保存在jsonFiles数组中
var jsonFiles = [];
for (var i = 0; i < files.length; i++) {
if (files[i].includes('.json')) {
jsonFiles.push(files[i]);
}
}
//循环读取json文件的内容，并都存在jsonList数组内。读取出错的文件名存在errorFiles数组内。
var jsonList = [];
var errorFiles = [];
for (var i = 0; i < jsonFiles.length; i++) {
try {
// 读取json文件
console.log(pathString + jsonFiles[i]);
var content = jsonfile.readFileSync(pathString + "/"+jsonFiles[i]);
jsonList.push(content);
console.log(jsonList);
} catch (err) {
// 如果读取错误就把错误的文件名写入到errorFiles数组内
errorFiles.push(jsonFiles[i]);
}
}
// 将收集到的数据写入到一个json文件中
jsonfile.writeFileSync(writePathString, jsonList);
// 将收集到的错误文件写入到一个json文件中
jsonfile.writeFileSync(errorPathString, errorFiles);
// 假如收集到的内容（json文件）格式乱怎么办？可以使用visual studio code的代码格式化插件自动调整格式，就会得出你想要的格式想过。
});
```
#####
================================================
FILE: homework/lesson7/zhaokaili.md
================================================
网页地址
https://luckary.github.io/Lesson7/
================================================
FILE: homework/lesson7/zhaoxiaoxin.md
================================================
第七次作业
2017-9-8
近期都有快要放弃的感觉。前面的作业一直没有交，然后任务越堆越多，最后感觉都不想上课了。
昨天的课上，看到老师做出了自己的服务器，做出了自己的页面，感觉又看到了一个新的世界，里面有无限可能。
是啊，都走到这里了，成功安装过很多闻所未闻的软件，成功的完成了老师的各种四五次作业，对自己充满了信心，觉得好像没有什么难事了一样，前几天，自己甚至上网找到并成功安装了打印机驱动，成就感爆棚。
没什么难事了，大不了抄别人的作业嘛！抄也要完成，抄也是一种学习的方法啊。这样安慰着自己，开始了完成作业的过程。
扫描并写入文件，第6课的作业已经完成了。
只是扫描的时候，没有采用异步，采用同步实现的。
从同学们第7课的作业看起，边看边记录着自己不太懂的地方。
直到看到有个同学说，他修改了老师的代码、、、、啊啊啊啊，我怎么忘记了！！！老师课后都会留练习并给出作业提示的！！！有种山重水复疑无路，柳暗花明又一村的感觉。
根据老师的提示，继续前进。
------------------------------------------
2017-9-15
后悔没有把完成的作业及时提交，错过了老师的奖品。。。
先把第七课的作业完成，然后再补后面的课程和作业吧。
目前的进展是：
1、根据同学作业的提示，找到了老师埋藏的一个bug，成功把内容输入到json文件。
2、成功给vue灌入了数据！成就感爆棚！憋了两天，根据老师的提示，自己想明白了！（几次想借鉴别的同学的作业，发现很多都没有用老师给的方法，定义完就执行）
3、怎么把网页布局到github上，想找以前的作业，发现找不到了。。。然后想到git push 本地内容，在项目setting里找到了网页链接，打开，成功！
https://ziqi319.github.io/test/
-----------------------------------------
================================================
FILE: homework/lesson7/zhaoyinan.md
================================================
赵一楠第7次课作业：
1、准备
写作业之前，把自己比较模糊的概念整理了一便：
jsonfile是个什么鬼？它是nodeJS运行环境中的第3方库，跟据github相关页面上的介绍“Easy write read/write json files”，可以了解到它简化了json文件的内容读取和写入的复杂、繁琐流程。
2、作业
课上老师并没有靠诉我们如何调用jsonfile的API，而只是教了如何引入jsonfile，不过学了这么多节课，这点自学能力应该是有的，打开github中jsonfile的页面，所有API都写的清清楚楚。
把老师在作业描述中的相关说明进行整理：
A. 使用filejson这个库，把同学们的json文件汇总到一个json文件中。
1）先扫出所有的文件名。
2）过滤掉非json的名字，得出一个结果全部是json的文件名。
3）利用jsonfile的方法循环读取内容到一个json的数组变量中。
4）将内容写入到一个json文件中。
B. 用vue实现一个html，把json文件的内容展示出来。
1）把最终得到的json文件的内容反映到html上，请参考github_index/index.html
2）修饰一下你的html效果。
3） 部署到你github项目的页面上。
按照上述步骤一步一步的实施，经过多番调试，终于成功，最终创建的人个页面的网址如下：
https://zhaoyn7.github.io/My-first-webpage/
================================================
FILE: homework/lesson7/zhengchao.js
================================================
var fs = require('fs')
var jsonfile = require('jsonfile');
var dirPathString = '../../words-from-the-heart/';
var writePath = './write.json';
arrJson = [];
function readOutcome(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
if (files.length > 0) {
var fileContent = files;
for (var i = 0; i < fileContent.length; i++) {
if (fileContent[i].endsWith('.json')) {
fileContent[i] = dirPathString + fileContent[i];
console.log(fileContent[i]);
jsonfile.readFile(fileContent[i], function(err, obj) {
if (err) {
console.log('err');
return;
} else {
arrJson.push(obj);
//console.log(arrJson);
jsonfile.writeFile(writePath, arrJson, function(err) {
if (err) {
console.log('写入失败');
}
})
}
})
}
}
setTimeout(function() { console.log(arrJson) }, 10000);
} else {
console.log('没有找到任何文件');
}
}
fs.readdir(dirPathString, readOutcome);
================================================
FILE: homework/lesson7/zhengchao.md
================================================
## Lesson7 学习心得
### 第七课学习到的技能：怎么快速搭建网页布局
##### 零散知识点：
- ###### 空白的画布竖向切分为12块
- ###### 板块之间的间距
- ###### 网页的自动适配功能
- ###### BootStrap
- ###### CDN加速
##### 作业思路：
- 关键字v-for，解决把json数组里的内容依次显示到网页的问题；
- jsonfile第三方库解决读取json文件内部的内容，读和写的问题；
- fs内置库解决读取到所有json文件的存放路径的问题
##### 深坑：打印写好了的json文件时，结果总是空的数组【】，直到昨天老师提到异步处理需要时间，而根据js“边编译边执行”的性格，console.log这条代码执行完了callback的内容估计还没传回来呢。今天给console.log加了个延时，总算是能实现打印结果了。虽然没有这个打印并不影响json的写入，但是在调试代码时不谨记异步函数这个特性，真的很容易迷失。
##### 布置完网页的感觉：从一开始布置网页，就陷入一种恐慌之中。参照bootstrap时，被各种效果所吸引，但是对于各种关键字的含义，摆放位置，优先级关系，真的是一头雾水。复制粘贴每个小效果的代码，很容易理解；但是想拼凑到一起，就很让人抓狂。索性浏览了一下HTML Tutorial里的内容，做到对每个关键字有个大致感觉，和对整个页面有个理解。为了实现tab功能，发现复制范例上的代码居然没办法让页面之间互动。好在‘抄’bootstrap内置精美网页时发现了下边一行代码，用上居然有奇效！虽说目前还是看不懂，但是还是很开心。就像在小组群（杨学武跑男群）里大家说的那样，了解html的基本知识和语法，才能抄的有模有样。
``
[心里话网页地址]( https://tal170809.github.io/JSNote/)
================================================
FILE: homework/lesson9/GaoXianfeng.md
================================================
## 第九课内容总结
### 作业部分
后进生，作业中的接口已经无法调用，好在平时工作中会给前端同事写接口，所以对接口调用并不陌生。根据 axios 官方说明，完成作业中 post 请求接口调用。
### 课程内容部分
1. 两个函数异步调用，发生结果嵌套时，第二个异步调用需放置在第一个异步调用中，已防止意外情况，因为第二个异步处理开始时无法确保第一个异步处理已完成。
```
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
names.push(files[i]);
}
}
}
fs.readdir(dirPathString, callback);
fs.writeFile(outputPathString, names, callback2);
```
正确写法
```
function callback(err, files) {
if (err) {
console.log('读取文件失败');
return;
}
for (var i = 0; i < files.length; i++) {
if (files[i].endsWith('.json')) {
names.push(files[i]);
}
}
fs.writeFile(outputPathString, names, callback2);
}
fs.readdir(dirPathString, callback);
```
================================================
FILE: homework/lesson9/dengxy0907.md
================================================
### 静态网页
> https://dengxy0907.github.io/JSlesson9/
### 项目地址
> https://github.com/dengxy0907/JSlesson9
### 过程
> 依旧是最小可用品，axios我用postman试了get，不知道该怎么说，课程的话还要再看看，这几天感觉主要要解决的是Vue。
axios的链式结构我没有遇到error，response下倒是修改了一些，可能受到之前PHP的