Showing preview only (2,028K chars total). Download the full file or copy to clipboard to get everything.
Repository: xugy0926/getting-started-with-javascript
Branch: master
Commit: 5eb1b97442ba
Files: 684
Total size: 1.2 MB
Directory structure:
gitextract_7orgddh0/
├── .gitignore
├── README.md
├── _config.yml
├── homework/
│ ├── lesson1/
│ │ ├── Autumn.md
│ │ ├── ElizabethZhouli.md
│ │ ├── GaoXianfeng.md
│ │ ├── Huang_Biling.md
│ │ ├── Jaykey.md
│ │ ├── Learner-Chen.md
│ │ ├── LiaoYuemin.md
│ │ ├── Liuzhengchun.md
│ │ ├── Rachel.md
│ │ ├── Risexie.md
│ │ ├── SunBo.md
│ │ ├── WangChangQing.md
│ │ ├── Wei.md
│ │ ├── WuGaoxing.md
│ │ ├── XGunn-lesson01.md
│ │ ├── ZhengChao.md
│ │ ├── anjiancai.md
│ │ ├── baoguoqiang.md
│ │ ├── caijinpeng.md
│ │ ├── caozhen.md
│ │ ├── chaigaoping.md
│ │ ├── chengjun.md
│ │ ├── chenlingmin.md
│ │ ├── chenqiong.md
│ │ ├── chenrushan.md
│ │ ├── chenyanxing.md
│ │ ├── chenzidong.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuimeng.md
│ │ ├── cuimiao.md
│ │ ├── dangfeipeng.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── donglili.md
│ │ ├── duhongxia.md
│ │ ├── fangqingyang.md
│ │ ├── fanliao.md
│ │ ├── fanqing.md
│ │ ├── feixiguang.md
│ │ ├── fengkai.md
│ │ ├── hanmeng.md
│ │ ├── hanwei.md
│ │ ├── haohu.md
│ │ ├── hewei.md
│ │ ├── huangjiashu.md
│ │ ├── huangqi.md
│ │ ├── huangxiaohui.md
│ │ ├── huangzhihua.md
│ │ ├── huxiaodan.md
│ │ ├── huyong.md
│ │ ├── ianyang.md
│ │ ├── jaychen.md
│ │ ├── jianglin.md
│ │ ├── langjianjun.md
│ │ ├── leizhen.md
│ │ ├── lichen.md
│ │ ├── linchunlong.md
│ │ ├── lingxiao.md
│ │ ├── linxiyao.md
│ │ ├── lipeng.md
│ │ ├── lipengyu.md
│ │ ├── litao.md
│ │ ├── liujuanjuan1984.md
│ │ ├── liujun-sh.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── liuqing.md
│ │ ├── liuruyong.md
│ │ ├── liushengsi.md
│ │ ├── liushengxin.md
│ │ ├── liuxiaohaohao.md
│ │ ├── lixiang.md
│ │ ├── lixiaoxin.md
│ │ ├── liyihang.md
│ │ ├── luoruijun.md
│ │ ├── maggiewong.md
│ │ ├── panqi.md
│ │ ├── panyong.md
│ │ ├── qiujingyu.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── sophieQi.md
│ │ ├── sunxl.md
│ │ ├── tangjianfeng.md
│ │ ├── taobao.md
│ │ ├── tuyilang.md
│ │ ├── wangmeiling.md
│ │ ├── wangshasha.md
│ │ ├── wangwei.md
│ │ ├── wangxuanding.md
│ │ ├── wangyuliang.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.md
│ │ ├── wenliuxin.md
│ │ ├── wenyunxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi.md
│ │ ├── xiaochaoge.md
│ │ ├── xieyuhui.md
│ │ ├── xiongliyu.md
│ │ ├── xugang.md
│ │ ├── xugaoyang.md
│ │ ├── xuli.md
│ │ ├── xuluchun.md
│ │ ├── xumin.md
│ │ ├── yammy.md
│ │ ├── yangchunguang.md
│ │ ├── yanglovewo.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yangyepeng.md
│ │ ├── yanqingmu.md
│ │ ├── yimiao.md
│ │ ├── yongfei.md
│ │ ├── youshilei.md
│ │ ├── yueruiqi.md
│ │ ├── yujianke.md
│ │ ├── zhanggaoyang.md
│ │ ├── zhanghuanyuan.md
│ │ ├── zhanghy.md
│ │ ├── zhanglina.md
│ │ ├── zhangqian.md
│ │ ├── zhangruirui.md
│ │ ├── zhangxuedong.md
│ │ ├── zhaokaili.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhouhong.md
│ │ ├── zhouqizhou.md
│ │ ├── zhouziqi.md
│ │ ├── zhuningning.md
│ │ ├── zhuting.md
│ │ ├── zhuxiaoping.md
│ │ └── zhuyongjin.md
│ ├── lesson2/
│ │ ├── Autumnchou.md
│ │ ├── GaoXianfeng.md
│ │ ├── JayChen.md
│ │ ├── Jaykey_Guo.md
│ │ ├── LiaoYuemin.md
│ │ ├── Liuzhengchun.md
│ │ ├── Rachel.md
│ │ ├── Risexie.md
│ │ ├── SunBo.md
│ │ ├── WANG XUANDING.md
│ │ ├── WangChangQing.md
│ │ ├── WuGaoxing.md
│ │ ├── Zhengchao.md
│ │ ├── baoguoqiang.md
│ │ ├── caozhen.md
│ │ ├── chengjun.md
│ │ ├── chenguoqiang.md
│ │ ├── chenqiong.md
│ │ ├── chenrushan.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuimiao.md
│ │ ├── dangfeipeng.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── duhongxia.md
│ │ ├── fangqingyang.md
│ │ ├── fanqing.md
│ │ ├── fengkai.md
│ │ ├── guowei.md
│ │ ├── hanmeng.md
│ │ ├── hanwei.md
│ │ ├── haohu.md
│ │ ├── hewei.md
│ │ ├── huangjiashu.md
│ │ ├── huangqi.md
│ │ ├── huangzhihua.md
│ │ ├── huyong.md
│ │ ├── jianglin.md
│ │ ├── langjianjun.md
│ │ ├── leizhen.md
│ │ ├── lichen.md
│ │ ├── lingxiao.md
│ │ ├── linxiyao.md
│ │ ├── lipeng.md
│ │ ├── litao.md
│ │ ├── liujuanjuan.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── liuqing.md
│ │ ├── liuruyong.md
│ │ ├── liushengsi.md
│ │ ├── liushengxin.md
│ │ ├── liuxiaohaohao.md
│ │ ├── lixiang.md
│ │ ├── liyihang.md
│ │ ├── luoruijun.md
│ │ ├── marshalcy.md
│ │ ├── panqi.md
│ │ ├── panyong.md
│ │ ├── qiujingyu.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── sophieQi.md
│ │ ├── tangjianfeng.md
│ │ ├── taobao.md
│ │ ├── tuyilang.md
│ │ ├── wangshasha.md
│ │ ├── wangwei.md
│ │ ├── wangying.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.md
│ │ ├── wenliuxin.md
│ │ ├── wenyunxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi.md
│ │ ├── xiongliyu.md
│ │ ├── xugaoyang.md
│ │ ├── xuli.md
│ │ ├── xuluchun.md
│ │ ├── xumin.md
│ │ ├── yammy.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yangyepeng.md
│ │ ├── yanqingmu.md
│ │ ├── yimiao.md
│ │ ├── yongfei.md
│ │ ├── youshilei.md
│ │ ├── yueruiqi.md
│ │ ├── yujianke.md
│ │ ├── zhanggaoyang.md
│ │ ├── zhanglina.md
│ │ ├── zhangqian.md
│ │ ├── zhangxuedong.md
│ │ ├── zhaokaili.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhengchengyan.md
│ │ ├── zhouhong.md
│ │ ├── zhouwenming.md
│ │ ├── zhuningning.md
│ │ ├── zhuting.md
│ │ ├── zhuxiaoping.md
│ │ ├── zhuyongjin.md
│ │ ├── zongjie-fanliao.md
│ │ ├── 第二次作业.md
│ │ ├── 第二次课程总结.html
│ │ └── 第二次课程总结.md
│ ├── lesson3/
│ │ ├── GaoXianfeng.md
│ │ ├── Jaykey_Guo.md
│ │ ├── LiaoYuemin.md
│ │ ├── Risexie.md
│ │ ├── WangChangQing.md
│ │ ├── caijinpeng.md
│ │ ├── cloudyview.md
│ │ ├── cuimiao.md
│ │ ├── dengxy0907.md
│ │ ├── fangqingyang.md
│ │ ├── guowei.md
│ │ ├── hanwei.md
│ │ ├── hewei.md
│ │ ├── huangBiLing.md
│ │ ├── jianglin.md
│ │ ├── leizhen.md
│ │ ├── lichen.md
│ │ ├── lipeng.md
│ │ ├── liujuanjuan1984.md
│ │ ├── liuxiaohaohao.md
│ │ ├── panqi.md
│ │ ├── sophieQi.md
│ │ ├── taobao.md
│ │ ├── wangwei.md
│ │ ├── wangyunfei_zongjie.md
│ │ ├── wenliuxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi3.md
│ │ ├── xiaochaoge.md
│ │ ├── xiaoyi.md
│ │ ├── xiongliyu.md
│ │ ├── xugaoyang.md
│ │ ├── yammy.md
│ │ ├── yanqingmu.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── 第三次作业 交互图.md
│ │ └── 谢玉辉.md.md
│ ├── lesson4/
│ │ ├── Jaykey.md
│ │ ├── Risexie.md
│ │ ├── WuGaoxing.md
│ │ ├── jianglin.md
│ │ ├── liujuanjuan1984.md
│ │ ├── panyong.md
│ │ ├── taobao.md
│ │ └── xiaochaoge.md
│ ├── lesson5/
│ │ ├── GaoXianfeng.md
│ │ ├── JayChen.md
│ │ ├── Jaykey_Guo.md
│ │ ├── LiaoYuemin.md
│ │ ├── LiuShengsi's homework of lesson5.md
│ │ ├── Risexie.md
│ │ ├── WANG Xuanding.md
│ │ ├── WuGaoxing.md
│ │ ├── Zhengchao.md
│ │ ├── anjiancai.md
│ │ ├── baoguoqiang.md
│ │ ├── caijinpeng.md
│ │ ├── caozhen.md
│ │ ├── chenguoqiang.md
│ │ ├── chenrushan.md
│ │ ├── chenyanxing.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuimiao.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── donglili.md
│ │ ├── fangqingyang.md
│ │ ├── fanliao.md
│ │ ├── fanqing.md
│ │ ├── fengkai.md
│ │ ├── guowei.md
│ │ ├── hanwei.md
│ │ ├── haohu.md
│ │ ├── hewei.md
│ │ ├── huangBiLing.md
│ │ ├── huangjiashu.md
│ │ ├── huyong.md
│ │ ├── jianglin.md
│ │ ├── langjj.md
│ │ ├── lichen.md
│ │ ├── limu.md
│ │ ├── lingxiao.md
│ │ ├── linxiyao-homework-lesson5.md
│ │ ├── lipeng-学习“异步实现一桌酒席”心得，代码难点分析.md
│ │ ├── lipeng.md
│ │ ├── liujuanjuan1984.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── liuruyong.md
│ │ ├── liushengxin.md
│ │ ├── lixiang.md
│ │ ├── luoruijun.md
│ │ ├── maggiewong.md
│ │ ├── marshalcy.md
│ │ ├── oyanagchun的作业
│ │ ├── panyong.md
│ │ ├── qiujingyu.md
│ │ ├── readme.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── sophieQi.md
│ │ ├── sunyan.md
│ │ ├── tangjianfeng.md
│ │ ├── taobao.md
│ │ ├── wangchangqing.md
│ │ ├── wangwei.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.md
│ │ ├── wengguihua.md
│ │ ├── wenliuxin.md
│ │ ├── wenyunxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi.md
│ │ ├── xiongliyu.md
│ │ ├── yammy.md
│ │ ├── yangchunguang.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yanqingmu.md
│ │ ├── yimiao li 5th.md
│ │ ├── youshilei.md
│ │ ├── zhanggaoyang.md
│ │ ├── zhanglina.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhouqizhou.md
│ │ ├── zhuningning.md
│ │ ├── zhutinglesson5.md
│ │ ├── zhuyongjin.md
│ │ └── 谢玉辉.md
│ ├── lesson6/
│ │ ├── GaoXianfeng.js
│ │ ├── LiuShengsi.js
│ │ ├── Risexie.js
│ │ ├── WANG_Xuanding.js
│ │ ├── Wei.js
│ │ ├── WuGaoxing.js
│ │ ├── anjiancai.js
│ │ ├── babysodme.js
│ │ ├── baoguoqiang.js
│ │ ├── caijinpeng.js
│ │ ├── caozhen.js
│ │ ├── caozhen.md
│ │ ├── chenrushan.js
│ │ ├── chenyanxing.js
│ │ ├── chenziwen.js
│ │ ├── cloudyview.js
│ │ ├── cuimiao.js
│ │ ├── cuiyuwei.js
│ │ ├── dangfeipeng.js
│ │ ├── dengxy0907.js
│ │ ├── diaozhicong.js
│ │ ├── donglili.js
│ │ ├── fangqingyang.js
│ │ ├── fanliao.js
│ │ ├── fengkai.js
│ │ ├── hanwei.js
│ │ ├── haohu.js
│ │ ├── hewei.js
│ │ ├── hitchhacker.js
│ │ ├── huangjiashu.js
│ │ ├── huyong.js
│ │ ├── jaykeyGuo.js
│ │ ├── jaykeyGuo.md
│ │ ├── jianglin.js
│ │ ├── langjianjun.js
│ │ ├── lesson9.md
│ │ ├── lianghf.js
│ │ ├── liaoyuemin.js
│ │ ├── lichen_async.js
│ │ ├── lichen_sync.js
│ │ ├── limingxing.js
│ │ ├── lingxiao.js
│ │ ├── lipeng.js
│ │ ├── liujuanjuan1984.js
│ │ ├── liujun.js
│ │ ├── liuliyuan.js
│ │ ├── liuliyuan.md
│ │ ├── liushengxin.js
│ │ ├── lixiang.js
│ │ ├── lixiang.md
│ │ ├── luoruijun.js
│ │ ├── mindongquan.js
│ │ ├── ouyangchun.js
│ │ ├── panyong.js
│ │ ├── qiujingyu.js
│ │ ├── readme.md
│ │ ├── shaozhen.js
│ │ ├── shenzhili.js
│ │ ├── sunyan.js
│ │ ├── tangjianfeng.js
│ │ ├── taobao.js
│ │ ├── tuyilang.js
│ │ ├── wangchangqing.js
│ │ ├── wangganzy.js
│ │ ├── wangshasha.js
│ │ ├── wangwei.js
│ │ ├── wangyunfei.js
│ │ ├── wangzhongbin.js
│ │ ├── weiyang.js
│ │ ├── wengguihua.js
│ │ ├── wenliuxin.js
│ │ ├── wenyunxin.js
│ │ ├── wufan.js
│ │ ├── wukuipin.js
│ │ ├── xianengqi.js
│ │ ├── xiongliyu.js
│ │ ├── yammy.js
│ │ ├── yangtieming.js
│ │ ├── yangxuewu.js
│ │ ├── yanqingmu.js
│ │ ├── yimiao.js
│ │ ├── youshilei.js
│ │ ├── zhanggaoyang.js
│ │ ├── zhanglina.js
│ │ ├── zhanglina.md
│ │ ├── zhaokaili.js
│ │ ├── zhaoxiaoxin.js
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.js
│ │ ├── zhengchao.js
│ │ ├── zhengchao.md
│ │ ├── zhuting.js
│ │ ├── zouhainan.js
│ │ └── 谢玉辉六课作业.js
│ ├── lesson7/
│ │ ├── GaoXianfeng.md
│ │ ├── anjiancai.md
│ │ ├── chenguoqiang.md
│ │ ├── chenrushan.md
│ │ ├── chenyanxing.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuiyuwei.md
│ │ ├── dangfeipeng.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── fangqingyang.md
│ │ ├── fengkai.md
│ │ ├── guowei.md
│ │ ├── hanwei.md
│ │ ├── hewei.md
│ │ ├── hitchhacker.md
│ │ ├── huangBiLing.md
│ │ ├── huangjiashu.md
│ │ ├── jaykeyGuoJian.md
│ │ ├── liaoyuemin.md
│ │ ├── lingxiao.md
│ │ ├── lipeng.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── lixiang.js
│ │ ├── lixiang.md
│ │ ├── luoruijun.md
│ │ ├── qiujingyu.md
│ │ ├── readme.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── taobao.md
│ │ ├── wangwei.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.js
│ │ ├── wangzhongbin.md
│ │ ├── weiyang.js
│ │ ├── wengguihua.md
│ │ ├── wenyunxin.md
│ │ ├── wukuipin.js
│ │ ├── wukuipin.md
│ │ ├── xieyuhui.md
│ │ ├── yammy.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yanqingmu.md
│ │ ├── yimiaoli.md
│ │ ├── yinzhibao.md
│ │ ├── youshilei.md
│ │ ├── zhanglina.md
│ │ ├── zhaokaili.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhengchao.js
│ │ └── zhengchao.md
│ └── lesson9/
│ ├── GaoXianfeng.md
│ ├── dengxy0907.md
│ ├── fangqingyang.md
│ ├── guowei.md
│ ├── liujun.md
│ ├── wayne.md
│ ├── weiyang.html
│ ├── wukuipin.md
│ ├── yammy.md
│ └── yinzhibao.md
├── public/
│ ├── libs/
│ │ └── bootstrap-3.3.7-dist/
│ │ ├── css/
│ │ │ ├── bootstrap-theme.css
│ │ │ └── bootstrap.css
│ │ └── js/
│ │ ├── bootstrap.js
│ │ └── npm.js
│ └── style.css
├── script/
│ ├── checkHomework.js
│ ├── checkMyFile.js
│ ├── clean.js
│ ├── fs.js
│ ├── package.json
│ ├── run.js
│ ├── scan.js
│ ├── start.js
│ └── updateTeam.js
├── study/
│ ├── lesson10/
│ │ ├── first-web-app/
│ │ │ ├── app.js
│ │ │ ├── bin/
│ │ │ │ └── www
│ │ │ ├── package.json
│ │ │ ├── public/
│ │ │ │ ├── style.css
│ │ │ │ ├── stylesheets/
│ │ │ │ │ └── style.css
│ │ │ │ └── words.js
│ │ │ ├── routes/
│ │ │ │ ├── index.js
│ │ │ │ └── users.js
│ │ │ └── views/
│ │ │ ├── error.ejs
│ │ │ └── index.ejs
│ │ └── github_index/
│ │ ├── index.html
│ │ └── public/
│ │ └── style.css
│ ├── lesson2/
│ │ ├── github_index/
│ │ │ ├── index.html
│ │ │ └── public/
│ │ │ └── style.css
│ │ ├── my_personal_info_page.html
│ │ ├── sample1.html
│ │ ├── sample2.html
│ │ ├── sample3.html
│ │ └── sample_code.js
│ ├── lesson3/
│ │ ├── name_style.js
│ │ └── statement.js
│ ├── lesson4/
│ │ ├── build_a_human.js
│ │ ├── kitchen_workflow.js
│ │ ├── object.js
│ │ ├── readme.md
│ │ ├── sound_off.js
│ │ ├── sound_off_2.js
│ │ ├── sound_off_3.js
│ │ └── vue/
│ │ └── index.html
│ ├── lesson5/
│ │ ├── async_function.js
│ │ ├── flight_schedule_1.js
│ │ ├── flight_schedule_2.js
│ │ ├── flight_schedule_3.js
│ │ ├── indirect.js
│ │ ├── indirect_call.js
│ │ ├── kitchen_workflow_async.js
│ │ ├── readme.md
│ │ ├── type_array_sample.js
│ │ ├── type_boolean_sample.js
│ │ ├── type_number_sample.js
│ │ ├── type_object_sample.js
│ │ └── type_string_sample.js
│ ├── lesson6/
│ │ ├── scan_files_async.js
│ │ ├── scan_files_sync.js
│ │ ├── write_file_async.js
│ │ └── write_file_sync.js
│ ├── lesson7/
│ │ ├── all_words.json
│ │ ├── error_data.json
│ │ ├── github_index/
│ │ │ ├── easy_vue.html
│ │ │ ├── index.html
│ │ │ └── public/
│ │ │ └── style.css
│ │ ├── homework_readme.md
│ │ ├── homework_sample.js
│ │ ├── package.json
│ │ ├── read_a_json_file.js
│ │ ├── readme.md
│ │ ├── sound_off.js
│ │ ├── test_data/
│ │ │ └── data.json
│ │ └── write_a_json_file.js
│ └── lesson9/
│ ├── chain_function_call.js
│ ├── github_index/
│ │ ├── index.html
│ │ └── public/
│ │ └── style.css
│ └── readme.md
├── topics/
│ ├── Git实战笔记.md
│ ├── JS函数.md
│ ├── JavaScript的语法学习指引.md
│ ├── MAC-Terminal-command-list.md
│ ├── Win-Command-list.md
│ ├── callback函数的设计学.md
│ ├── js重要语句.md
│ ├── 两种定义函数方式的差异.md
│ ├── 了不起的axios(http).md
│ ├── 代码就是由这些组成的.md
│ ├── 作品征集.md
│ ├── 函数 - 定义完就执行.md
│ ├── 匿名函数使用技巧.md
│ ├── 变量命名简明技巧.md
│ ├── 同步函数的两种返回结果的方式.md
│ ├── 图床教程.md
│ ├── 在Heroku上快速部署自己的JS项目.md
│ ├── 如何从主项目更新fork的项目.md
│ ├── 如何在终端执行代码.md
│ ├── 如何查看git push和pr的提交结果.md
│ ├── 安装nvm.md
│ ├── 定义变量.md
│ ├── 相对路径.md
│ ├── 第一个webapp.md
│ ├── 第一次pull-request.md
│ ├── 第一次pull-request错误汇总.md
│ ├── 第一次使用Git.md
│ ├── 第一次使用JSON.md
│ └── 让github-wiki变成图床.md
└── webapp/
├── package.json
├── src/
│ ├── app.js
│ ├── bin/
│ │ └── www
│ ├── config/
│ │ ├── index.dev.js
│ │ ├── index.js
│ │ └── index.pro.js
│ ├── middleware/
│ │ └── courseInfo.js
│ ├── public/
│ │ ├── libs/
│ │ │ └── bootstrap-3.3.7-dist/
│ │ │ ├── css/
│ │ │ │ ├── bootstrap-theme.css
│ │ │ │ └── bootstrap.css
│ │ │ └── js/
│ │ │ ├── bootstrap.js
│ │ │ └── npm.js
│ │ └── stylesheets/
│ │ ├── anim.css
│ │ ├── github-markdown.css
│ │ └── style.css
│ ├── request.js
│ ├── routes/
│ │ ├── homework.js
│ │ ├── index.js
│ │ ├── sayToTeacher.js
│ │ ├── studentWorks.js
│ │ ├── topics.js
│ │ └── words.js
│ └── views/
│ ├── _head.ejs
│ ├── _header.ejs
│ ├── _nav.ejs
│ ├── _slider.ejs
│ ├── error.ejs
│ ├── homework.ejs
│ ├── homeworkList.ejs
│ ├── index.ejs
│ ├── sayToTeacher.ejs
│ ├── sayToTeacher2.ejs
│ ├── studentWorks.ejs
│ ├── topics.ejs
│ └── words.ejs
└── test/
├── routes_api.test.js
└── routes_page.test.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# Ignore Mac OS desktop services store
.DS_Store
package-lock.json
node_modules
dist
.vscode
script/result
script/teams.md
================================================
FILE: README.md
================================================
## 美好的回忆
该项目记录了一群小白学习js的过程，现封存该项目供所有人回忆。
感谢大家的努力
请[点这里](https://js.7xinsheng.com/)访问我们的家！
================================================
FILE: _config.yml
================================================
theme: jekyll-theme-hacker
================================================
FILE: homework/lesson1/Autumn.md
================================================
第一节课老师运用银行开户的类比帮助我们理解JS（或者说是理解编程）。
###### 1.银行（内部服务➕核心服务）—> 运行环境（内置库➕V8引擎） ; 客户—> 代码
开户的环境是银行，在这个环境中客户可以得到内部服务以及核心服务，通过这两种服务客户可以成功开户。
同样的，对于代码来说，其在运行环境中可以运用内置库的服务、V8引擎服务处理代码，最终让代码被成功执行。在JS中有两类运行环境，分别是浏览器环境和Nodejs环境。这两种环境的内置库、第三方库不同，在写程序时一定要明确自己处于哪种环境，不要弄混。
###### 2.核心服务（预处理➕执行）—> V8引擎 （=编译器／解释器）
为了给客户开户，银行工作人员需要对开户信息进行预处理（审核信息准确性）与执行（审查信度）。为了执行代码，V8引擎做的就是让代码被识别被执行。客户开户不必考虑工作人员如何审核信息，小白程序员写代码也不必考虑V8引擎内部如何运行。
编程语言分为编译型语言与解释型语言：
编译型语言将所有信息都预处理后再执行，运行效率高（电脑）开发效率低（程序员）
解释型语言预处理一条信息执行一条信息，运行效率低开发效率高
JS属于解释型语言
###### 3.内部服务（复印、拍照、查询逾期）—> 内置库 ；第三方服务（公安部门信用鉴定)—> 第三方库
客户开户之前需要做许多准备工作，在银行之内可以复印、拍照、查询预期…在银行之外需要去公安部门开具信用证书…只有运用这些服务做好准备工作才能进行开户。写代码也需要环境内、环境外的内置库、第三方库提供多种多样的服务，这样代码运行时才能种种功能。
在理解了JS的大致框架后老师提供了学习的方向。因为小白程序员不必深究V8引擎内部如何运行，所以在学习的过程中只需要把精力放在如何运用编程语言以及内置库、第三方库写出代码即可。
* 一开始要练习编程语言，熟练语法。
* 之后要熟悉内置库、第三方库的各种服务，让代码能有更多样的功能。
* 最后要不断比较各类服务，找到实现各类功能的最优解决方法。
这个进阶路径很像准备考试的过程，一开始熟练基本概念定理，然后在题海中习得多种解题方法，最后化繁为简总结类型题的最佳解法。
================================================
FILE: homework/lesson1/ElizabethZhouli.md
================================================
**#** **learning-javascript lesson 1**
**1. 类比代码执行流程**
方式：用“银行为用户开户这一”具象业务架构“一对一抽象成“JS运行环境框架“，框架包含：JS运行环境［浏览器运行环境（v8引擎＋内置环境）＋Nodejs运行环境（v8引擎＋内置环境）］——第三方库——JS代码
**2. 运行环境**
包含浏览器运行环境和Nodejs运行环境
**3. V8引擎**
核心：用来执行代码
**4. 编译器/解释（执行）器**
是V8引擎的组成部分，用来处理和解析代码
**5. 内置库**
是运行环境所提供的一组服务，用来实现代码的功能
**6. 第三方库**
付费或开源的各类服务于JS的工具库
**7. 学习JS的方向**
有难度：变化快＋无边界，但也有套路从小白到高手： "掌握编程语言，用编程方式调用服务来完成你的需求"—— “了解和掌握重要的服务能力，使其能服务你的业务”—— “善于比较服务／技术之间的差异性，用最好的方式实现自己的业务”。
加油！
================================================
FILE: homework/lesson1/GaoXianfeng.md
================================================
## JavaScript 第一课总结
### 现实生活场景举例类比 JS 代码执行流程及相关概念
客户去银行办理业务，在正式办理业务前填写相关资料，随后将填写好的资料提交给银行办理业务工作人员，工作人员对已填写好的材料进行审核，然后将办理结果提交给客户，银行根据客户自身情况将客户划分为不同等级，如：普通客户、VIP客户等。银行为更好的服务客户，在银行内部提供相关服务，如：身份证复印等。工作人员审核客户提交资料时除审核资料格式填写准确性外，有可能通过调用外部系统检查客户身份合法性等。
以上客户在银行办理业务流程即可理解为 JS 代码的执行流程。即客户填写资料（编写代码），将资料提交给银行工作人员（编辑器与解释器），银行工作人员对材料进行审核（编辑器与解释器解析执行代码），将办理结果返回给客户（返回代码结果）。
银行不为同等级客户办理业务可映射为 JS 运行环境，为普通客户办理业务（浏览器运行环境）、为VIP客户办理业务（Nodejs 运行环境），每一种业务（运行环境）均包括银行内部的服务（内置库）与办理业务（V8引擎，进行预处理与代码执行）。
银行工作人员调用外部系统核实用户身份合法性，即可视为 JS 调用第三方库完成相应功能。
### 学习 JS 方向
#### 1. JS 学习困难原因：变化快、无边际
#### 2. 学习上升途径
初学阶段：***掌握编程语言***，用编程方式调用服务来完成你的需求；
提高阶段：***了解与掌握重要的服务能力***，使其能服务你的业务（了解内置库与第三方库使用）；
进阶阶段：擅于比较服务/技术之间的差异性，***用最好的方式实现你的业务***；
与现自己情况对照，目前刚刚到达提高阶段，需要继续深入了解开发语言的内置库与第三方库使用
================================================
FILE: homework/lesson1/Huang_Biling.md
================================================
## 作业_JavaScript编程入门_第一节
1. 类比代码执行流程
代码，是人的需要转化成的、对智能机械的命令。执行命令需要资料和数据。得到资料数据后，还要先将它们审核通过后再送去执行，为的是不让错误卡住执行流程，导致混乱。
命令，可视作“回家休息”，首先，人要进门。资料数据是“门匙”，预处理是“门锁”进行审核，门匙正确，人才可以进行入门的动作。门匙在现实中是已提前由制锁工厂造好。这看起来是外部完成，但内外是相对的。这是预处理（内置服务）。“社会协作”可以看作很多命令“运行环境”，而“家”是V8引擎，比如做饭命令、看电视命令、上网命令，在家里可完成。这些命令需要电饭煲、电视、上网路由、电脑或手机等“编译器”。而这些设备的零部件或其原材料将由厂家的供应商提供，供应商即“第三方”；如果在超市购买的，超市也是“第三方”。银行的“设备”和“第三方”同理（到底是不是呢...）。那么，这个语境里最初的代码（命令）是什么...可能也许大概是人类的生活需要吧...好像圆回来了...
先这么理解着。理解不对的，后面运用时再调整贯通。
2. 运行环境
包括内置库和V8引擎，提供代码从输入到执行完成所需的全部资料、数据、功能等等。
3. V8引擎
是指真正执行代码命令，使计算机、机器完成任务的地方。
4. 编译器/解释（执行）器
将代码转换成机器可以识别的语言的（地方）。比如，电视遥控器将我们按频道的动作，转换成电视机能马上能识别（选台）的语言。
5. 内置库
提供执行命令所需的数据。在“进门”这个语境里可包括门匙，或将人送回家的交通。
6. 第三方库
所有设备的上游供应商或设备流通相关的商家。
7. 学习JS的方向
因为“变化快”（是指语言一直升级吗？视频没看到的落后份子伤不起），所以要让自己经常了解最新的语言发展，比如常看最新的开源项目。
因为“无边际”（因为是面向对象的语言，所以随着社会的快速变化，对象和对象间的关系也不断变化，JS的运用也就无边际了吗？），那不会那么闷了？随时都可以寻找对象，想办法将JS用上。随时都要想办法改进。（也许是我想太多了）
另外，
对“进阶”的理解是，“根据需求的差异性和可行性，灵活运用”。
================================================
FILE: homework/lesson1/Jaykey.md
================================================
### 基础-第一课
###### JS运行环境：
1. 浏览器
2. Nodejs
都含有V8引擎（对代码进行预处理）和内置服务（不同环境有不同）。
核心是**“内置库”**，如何调用会输出什么结果。
###### Javascript是解释性语言
一边编译，一边执行。**开发效率高，运行效率低**
###### 用自己的话解释概念：
> 运行环境：代码的运行环境，分为浏览器和Nodejs两种
>
> V8引擎：运行代码的黑箱，目前只需要知道输入什么能输出什么
>
> 解释器：对代码的解释，让机器能够读懂js代码
>
> 内置库：js内置的代码库，js的基础和共同点
>
> 第三方库：个人或者公司开发的使用js的方法
##### 目前的学习目标：掌握编程语言
------
小结：
1. JS的运行环境是很灵活的，能直接在浏览器中运行。
2. 一大特点：**边编译，边执行**，使得js的运行效率高，但是运行速度慢。
3. 需要知道不同的运行环境会调用不同的库，但是共同点是**JS内置对象**
4. 目前的学习目标：掌握JS编程语言
================================================
FILE: homework/lesson1/Learner-Chen.md
================================================
Javascript第一次课程总结
第一次上课，主要是对于编程感兴趣。现在社会的互联网、人工智能持续火爆，也是大势所趋。所以一只很感兴趣。看到新生大学改版后开课，就第一时间报了名去学习。
徐老师讲解JS时，通过对生活中常见的银行开户流程来讲解，通过一步一步引导，初步建立起有关Js代码执行流程的意识。类比优化后的银行开户流程，了解JS代码运行环境，JS运行环境主要分为前端-浏览器运行环境和后端-Nodejs运行环境。但是不一样的内置服务，运行环境之间有了显著性的差异。V8引擎是运行环境中执行代码的阶段。
JS语言是解释性语言，是边编译边执行同步进行，和银行开户最初始阶段相同。不像C/C++语言，是编译型语言，先编译，再进行解释执行。这点是不相同。因此二者在处理效率以及开发效果上迥然不同，各有特色。
内置库与第三方库是有关联的。内置库好比家庭内部自有的图书室，第三方库是外界社会共同开发共同享有的社会公共图书馆。浏览器和Node内置库方面有很多不同，但二者都有JS内置对象。
JS方面，徐老师给我打开了一扇门，当下和徐老师好好学习，一步一步摸索练习。养成自己的编程思想，有自己的独特性。
================================================
FILE: homework/lesson1/LiaoYuemin.md
================================================
## Story of Lesson 1
我有一个做运营的朋友，她一直觉得编程很重要，但是却没有多少兴趣去学。其实我也是。但是作为一个软件行业的测试者，还是觉得应该学一些编程的东西。
第一节课后跟她分享上课的感受，我跟她说第一节课的作业需要用markdown写一篇总结。于是有了下面的这段对话。
***
朋友：我一直没看懂**markdown**是个啥玩意儿？
我：其实跟word一样，你要实现某种文字格式，word里面可以点击相应的功能键来实现，markdown相当于是把你点击的动作编成了可见的语法，最终实现的效果是一样的。比如你要把“朋友”两个字加粗，word里面你是选择“朋友”两个字，然后直接点击加粗键就可以实现，markdown里你可以前后用两个*号把“朋友”两个字括起来，这两个字就加粗了。
朋友：这就是语法，对吧？
我：对的。
朋友：开发里面经常说的运行环境是什么鬼啊？
我：所谓**运行环境**就是实现输入代码输出结果所需要的环境。运行环境包括V8引擎和内置库。
朋友：**V8引擎**是什么？
我：我理解的就像一艘船的发动机，没有发动机船就开不起来，没有这个V8引擎，代码就没办法运行。
朋友：内置库又是什么？
我：**内置库**就是数据库，就像医院的不同科室。一个科室就是一个库，这些所有库加起来构成了医院这个大环境。哦，对了。JS运行环境有浏览器运行环境和Nodejs运行环境之分，不同的环境，内置库是不一样的哦。就跟不同的医院，科室不同一样。但是老师说浏览器运行环境和node运行环境中内置库里有一点是相同的。
朋友：那是什么？
我：JS内置对象。这个我还不是很懂是什么东东。
朋友：那整个代码是怎么运行的呢？
我：那要看它是**编译型语言**还是**解释型语言**咯。C／C++就是编译型语言，他们的运行流程就先是代码输入，然后编译器进行编译，再把编译好的代码交给执行器执行，最后输出结果。而JS是解释型语言，就是边输入边编译的模式，编译器承担了编译型语言里面编译器和执行器的双重工作。相对编译型语言，解释型语言因为流程比较简单，代码执行率比较高，但是也因为编译器承担了更多的工作，所以开发效率比较低。
朋友：哦。那就是内置库和你说那个发动机就构成了运行环境对吧？
我：嗯。但是在实际运行中有可能还需要**第三方库**。
朋友：第三方库又是什么？
我：这就好比你要做饭，这个动作可以在你家厨房完成，但是材料你需要去超市购买，这个超市就是第三方库。相当于别人已经完成的代码，你可以使用它来节约时间和精力，提高开发效率。
朋友：所以你知道怎么学习编程了嘛。
我：我理解的就是你要写好代码就得学会调用内置库和第三方库，就是说你不仅要学会编程语言，并且要对内置库和第三方库非常了解，还要在学习中多比较代码的差异，比如为什么这里要这么写，为什么在另外一个地方写法又不同，就是这样在比较中学习比较好。
朋友：怎么和你讨论了一下突然觉得编程很好玩儿了呢？
***
其实不知道理解得对不对，但是要知道在这节课之前我什么都不知道，markdown都是看到作业后现学的。嗯，这大概是我上过的所有网课上面最有效的一节了。
================================================
FILE: homework/lesson1/Liuzhengchun.md
================================================
##第一次作业
距离第一节课过去好几天了，终于抽出时间来写作业了，作业的主题就是理解徐老师在课上讲的那几个概念，用自己的话把它说出来。
这么久才交作业甚是惭愧，第一节课的内容也有些模糊了，不过我会迎头赶上的，这里先给自己鼓励一下，也谢谢徐老师在作业区的每一个回复，这也是促使我继续学习下去的动力之一。
还是按照老师在作业区留下的概念逐一论述一下我的理解，理解不一定全对，但是随着学习的逐渐深入，我的理解会不断更新，朝着正确的方向前进。
老师在课上用一个银行开户的流程来类比编程中的诸多概念。让我印象深刻的不是类比的概念多么容易理解，事实上我当时还是处于懵逼的状态。让我印象深刻的是老师一幅幅流程图，通过简单的箭头指示和图例，清楚的对比了前后流程的优劣。
1. 类比代码执行流程。银行开户需要提交申请，柜台按照规则进行审核，符合要求则通过，不符合则退回，代码运行也是如此，输入代码，然后执行，符合则输出结果，不符合则报错，一长串的字符，看得眼花缭乱。虽然知道执行的一般流程，但是不知道执行的差别，比如说编译型和解释型，我要学的JavaScript就属于解释型的，它是在执行的时候就按照一定的规则解释，是边执行边解释。
2. 运行环境。运行环境是我一直不能理解的，日常生活中的环境指的是除了自己之外一切互相影响的因素，对于另一个不同的人来讲，你自己也成了环境的一部分。课程提到了两个环境，一个是浏览器的运行环境，一个是JS的运行环境。它包括了V8引擎，第三方库，内置库等，每一部分都有自己的功能。不同的运行环境下产生的结果不同，或者结果相同，但是执行过程不同。
3. V8引擎。这个我就把它跟车的发动机类比了，车子是靠发动机才能启动的，启动后的速度远远大于人力和马拉车。代码执行也需要这样一个部件吧。
4. 编译器/解释器。这是代码需要提交到的地方吧，让编译器审核一下，让解释器执行一下。
5. 内置库，就是运行环境自带的库，代码可以直接利用它进行最基本的调用，方便使用者进行编程，它的使用都是最基本的，必不可少的。
6. 第三方库。这是对内置库的一个补充，可以让使用者进行个性化的编程，找到自己需要的方便的工具，但它有可能不是必不可少的。
7. 学习JS的方向。JS的世界才刚刚推开大门的一角，这个世界长什么样都不清楚，但是我想当我需要它帮我实现我的想法时，我能知道怎么使用它。
================================================
FILE: homework/lesson1/Rachel.md
================================================
### 一个总结
如果用一句话来总结第一节学的内容，我想是用**银行开户流程**这个类比，非常清楚地阐述整个**业务架构的模式**，以及其中的**重要概念**。
我非常喜欢最后的总结：
“开户环境提供集**预处理、执行**于一体的核心业务处理单元，同时还提供了**内置服务**方面用户的业务办理。
围绕开户业务，会有一系列**第三方服务**供用户使用，以满足开户业务的需求。“
这一句话，让我脱开零星的概念，从整体上去理解JS整个框架结构。
### 几个概念
**运行环境**：分两类，分别是是浏览器运行环境和NodeJS运行环境
**V8引擎**：对代码进行预处理和执行，对于初级阶段不需要了解V8引擎具体的操作流程；
**内置库**：其中有网络库、日志库、JS内置对象等等
**第三方库**：
### 编译型or解析型？
编译型：需要一个专门的编译过程，通过编译器翻译成机器语言。特点：运行效率高，开发效率低；
解析型：一条语句边翻译边执行。特别：开发效率高，运行效率低。JS
### 运行环境
用婴儿喝小学生的生活环境来类比JS的运行环境，浏览器环境和NodeJS环境不能混淆。
两个环境有一个共通的内置库：JS内置对象。
### 该怎么学JS／怎么提高／怎么进阶？
“**掌握编程语言**，用编程方式调用服务来完成你的需求” ——基础
“**了解和掌握重要的服务能力**，使其能服务你的业务”——学会第三方库
“善于比较服务／技术之间的差异性，**用最好的方式实现你的业务**”——找到解决问题的更好方法
================================================
FILE: homework/lesson1/Risexie.md
================================================
第一节课总结
===========
* ### 类比代码执行流
老师使用了一个在银行创建户口的例子，为我们说明了在js当中代码的执行流程，帮助我们理解“在终端输入代码”，到“终端返回我们结果”这样一个过程，是如何实现的。
我们在终端输入代码，相当于我们在银行股柜台填写个人信息，但是开户的要对我们的信息进行多次加工，我们的信息需要被添加、复制、粘贴、打印，非常麻烦。这个时候银行会有一个专员帮助我们来执行，给我们提供服务。所对应的也就是“运行环境”给我们提供的内置服务。
在个人信息被处理完毕，填写到所需表格之后，我们银行的开户人员会再核对一遍我们所提供信息的完整度和正确性，然后真正地帮助我们开户。也就是在运行环境里面的v8引擎会对代码做的事情。
* ### 运行环境
代码在被执行时所处的环境，把我们自己比做代码。就好像你同样是去餐厅吃饭，民工饭堂需要自己端着碗去让服务员给我们夹菜，但是米其林三星餐厅则会把菜摆的美美地放上我们的餐桌。我们同样是为了达成“把肚子填饱”这个目的，但是我们身处的环境不一样，达到目的的方式也不一样。
* ### V8引擎
不要以为电脑现在能够做这么多事，能够执行这么多操作，就代表电脑很“聪明”。其实电脑能够接受的信息就是0和1，而电脑现在能”看懂“我们在终端敲的英文：“`git add.` , `git push -m`等指令是因为编译器已经帮我们把代码编译成了电脑能够“看得懂”的01010，电脑才能够执行我们的代码。而V8引擎，就包含编译和执行两个功能。
* ### 解析器和编译器
解析器能够一边编译代码一边执行，能让我们在敲完代码之后马上看到相对应的效果。编译器只能编译代码之后，再把编译后的代码送到执行器，不利于开发。
* ### 内置库
同样把民工饭堂和米其林三星餐厅作为例子，民工饭堂的“内置库”是一个简陋的厨房，大堂里面给食品加热的设备，服务员可以从设备中，给我们打饭。
米其林三星餐厅的“内置库”是一个专业，宽敞，明亮的厨房，从厨房上得上菜处到客人餐桌有一个专业的菜品传递链。菜从平板锅做好之后，还要经过食品检测员，再传递到传菜员最后送到我们的餐桌。
* ### 第三方库
想象有一家餐厅，食物是从自己的厨房制作的，但是大堂的服务却*“外包”*了出去，是从另外一家公司负责的。而这家公司所提供的环境和人手，就是“第三方库”。
* ### 学习JS的方向
我们敲代码这个行为，其实就是为了让一个软件能够实现我们所需要的功能。一开始我们什么都不懂，需要去学习实现功能的相关代码。好不容易才把我们所需的功能实现。
后来我们了解也熟悉了实现功能的方法，但是随着学习的深入，我们了解到了实现同一功能不止一种方法。我们可以使用不同的语言、环境、第三方库，去帮助我们实现同一功能，又因为不同的语言和环境。实现功能的方式都是各不相同的，我们需要了解他们的不同，学习不同的实现方法。
到最后我们所有的方式都玩了一遍，我们了解的不同方式之间的差异和优劣。我们可以衡量不同方式的利弊，去选择一种最“合适”的方式，去实现我们的需求。
================================================
FILE: homework/lesson1/SunBo.md
================================================
第一次作业
# 类比代码执行流程
自己是第一次接触真正的编程，徐老师课上的类比的方式不仅印象深刻，而且感觉是从底层上告诉了自己，JS或者说一种编程语言到底是怎样的一种存在。自己以前看过一些平面设计软件的教程，html,css一些最基础的内容，但我觉得自己学习一门知识最重要的是在开始弄明白，这门知识能用来做什么，我们平常直观看到的一些“样子”，“功能”到底是通过什么工具连接的。
>在类比代码的执行流程中涉及到了很多完成“JS”这件大事中需要的一些“工具”，这个过程就像我们在银行办理一个开户过程一样,需要一个环境，需要项目发起者（申请人），核对，执行，申请者与窗口的交互，最终出结果。接下来，在这个过程中我们会遇到一系列"服务“，“人员”，和“工具”...
# 运行环境
>如果你的银行建在田野的账篷里这种环境，你再聪明也办不了业务。银行办理业务你也会遇到不同的环境，比如普通客户环境，椅子冷。VIP客户环境，椅子柔软温暖。
代码的执行过程肯定需要一个环境，十万个冷笑话中的河神会告诉你“年经的工程师啊，你是需要在浏览器中运行呢，还是在NODE运行呢？”
浏览器和node就是我们代码的环境，简单的可以理解为一个对应前端，一个对应后端。
# V8引擎
* 我是小白，这么高深的V8引擎，小白先了解就好喽。学开车，前期就先不要考虑发动机的原理。
>当你去银行办理业务时，会有大堂工作人员帮你填单子，初步核对你的条件，信息，单子格式等，有没有写错字；窗口里面的工作人员帮你通过银行的系统等再次审核你，录入你的信息，对信息进行解释，执行你办理的业务。
* V8就相当于解释/执行器，核对，翻译，执行整个业务，把结果通过窗口送给我们。
# 编译器/解释（执行）器
* 编译器相当于一个预处理的过程，就像在银行输业务时，大堂工作人员的职责一样。
* 解释（执行）器相当于窗口内的工作人员，正式开始处理、执行你的业务，并要给你一个结果。
* JS语言是将两个过程放在一起进行的。
# 内置库
* JS内置的
* JS语言学习中主要就是对内置库和第三方库的使用。
* 是小白重点学习，主要学习的部分。
# 第三方库
* JQuey就属于第三方库，反正以前一直感觉这个东西好像挺酷似的。
* 还要几个课上讲的库，因为笔记在家，现在回忆中只能想起JQuery了。
# 学习JS的方向
>* 用代码实现相应的小需求
>* 会比较不同库，不同功能如何搭配才能最优
>* 基础知识自己最好在业余时间也进行相当的补充，更好的完成
================================================
FILE: homework/lesson1/WangChangQing.md
================================================
# 第一节课总结 form 王长庆
因为之前一直在忙别的事情，所以直到这两天才开始疯狂赶进度。好在课程开始之前有做过徐高阳老师布置的准备作业，所以只需要重温一下，便可以上手了。
看完了第一节课的视频回放，感觉似乎并不是特别难理解。我把我的想法和理解写一下，不知道对不对，还请高阳老师指正。
## 代码是什么？
所谓代码，实际上就是程序员与计算机之间沟通、交流的时候，所使用的一种语言。因为计算机是听不懂一般意义上的中文或者英文的，所以就需要一门特殊的语言，让计算机可以知道程序员想要它做什么，怎么做。
计算机很强大，它的硬件（比如CPU、硬盘）决定了它的计算能力、反应速度、记忆力要比我们人类强得多，根本不在一个数量级。所以，让计算机来执行计算任务，可以大幅度提高我们的工作效率。
那么代码就是一种程序员和计算机都懂、都能理解的语言，也是计算机和程序员交流和沟通的媒介。
通过代码，计算机得以调用它的硬件设施，来完成程序员要求它完成的任务。程序员也可以根据计算机的反馈，来知道任务出现了什么问题、得到了什么结果。
## 计算机如何工作？
代码发展到今天，已经非常完善和复杂了，当然，也非常高效和强大。
程序员首先将一行行代码输入特定的终端，代码会首先到达对应的“后台”，也就是“编译器”，进行预处理和解析。因为复杂的代码需要先进行分析、校对和优化。
既然是一门语言，就会有词汇、语法、词法，就像中文和英文一样，错别字和病句是无法被别人所理解的。因而需要先确保这些代码通顺、流畅、可以被计算机读懂。
解析之后，代码会达到“执行器”，这时候，计算机就会根据它所理解的内容，来调动它的硬件设施和强大的计算、处理能力，来完成程序员需要它完成的任务。这就叫“执行”。
执行完毕之后，计算机这一阶段的工作也就完成了。程序员可以根据计算机输出的结果，来进行下一步的操作。
当然了，实际工作当中，为了提高效率和完成更加复杂的任务，编程语言的“运行环境”中还包含了很多“内置库”。这一点我还没有太多地接触，不过我个人理解应该是说，很多常规性的工作可以用模块化的方式来解决。就像物理、数学里面有很多公式和定理一样，就不用每次都证明一遍了。
## JS有何特点？
JS有一个很有趣的特点是，其他的编程语言提交之后，都是先解析，再执行，而JS是一边解析，一边执行。
就像大多数人都是先盛饭，再吃饭，而JS是一边盛饭，一边吃饭。虽然有点不太雅观，但是不失为一种很有效率的“吃饭”方式(๑*◡*๑) 。
因此，JS的开发效率高，但是运行效率低。一边盛饭一边吃饭的话，当然可以很快地品尝出饭的滋味，但是就没有盛好饭之后再大口吃更豪爽，更痛快。
## 学习JS的方向
就像出门旅行一样，刚开始的时候，我们只能徒步、骑自行车。又累又慢。
慢慢地，我们学会了坐公交车、打车，甚至坐火车、坐飞机、坐宇宙飞船。这个时候已经不是我们自己在“劳动”了，变成了使用别人的服务，来让我们更快地到达更远的地方。
最后，我们还要知道各种旅行方式之间的差异，用最好的方式去达到我们想要去的地方。比如中远途旅行的话，遇上天气不好的时候，高铁是比飞机更好的选择。
================================================
FILE: homework/lesson1/Wei.md
================================================
# 小白学JS 第一课总结 20170811
### 1.银行开户类比JS代码执行流程
银行开户流程
* 填写申请单
* 审核
* 发卡
具体开户业务
1.开户环境：提供一组服务，该服务包含接受申请、检验申请单信息和核对资格。提供内置服务和核心服务。
* 内置服务：为满足用户填写订单时提供的一组内部服务。
* 核心服务：涵盖预预处理和执行的服务，是银行的核心业务。预处理：在真正执行开户前进行信息检查的处理过程，以保证执行处理的效率。执行：执行开户操作的过程，操作完成后并返回想要的开户结果。
2.第三方服务：围绕开户服务，会有一系列银行之外的第三方服务供用户使用，以满足开户需求。
*JS运行环境框架*
* JS运行环境对应银行开户环境。
* JS代码对应用户。
* 第三方服务对应JS第三方库，来满足JS代码更多的需求。
***
### 2.运行环境
JS的运行环境由内置库、V8引擎组成
JS有两大类运行环境：
* 浏览器环境和Nodejs环境：两者最大的区别在于内置库和第三方库的不同。
***
### 3.V8引擎
在JS中，V8引擎是把开发人员写的 JS 代码转换成高效、优化的代码的解释/编译器，负责预处理和执行，具体处理过程处于“黑箱”阶段。
***
### 4.编译器/解释（执行）器
* 编译型语言：代码需要一个专门的编译过程，将代码翻译成机器语言，其优点是运行效率高，缺点是开发效率低。
* 解释性语言：代码边执行边翻译，优点是开发效率高，缺点是运行效率低。
*JS属于解释性语言，代码输入后，由编译器/解释器进行分析语法、分析词法、分析语义、优化代码、解释代码、执行代码。*
***
### 5.内置库
JS内置的一系列打包好的工具，其类型众多、功能丰富，帮助开发者简化和优化开发过程。
***
### 6.第三方库
和内置库的功能一样，帮助开发者简化开发过程，优化产品，但并不属于JS内置，需要额外下载。
### 7.学习JS的正确姿势
* 掌握编程语言，用编程方式调用服务来解决问题
* 了解和掌握重要的服务能力，使其能服务我们的需求
* 比较服务/技术之间的差异性,用最好的方式实现你的业务
***
*撸起袖子就是干，紧跟老师步伐，记录错误，有报错问google！*
================================================
FILE: homework/lesson1/WuGaoxing.md
================================================
运用下面这些关键词，把你知道的写出来
1. 类比代码执行流程：医生诊治病人的过程，学生上学的顺序，社会运行的次序
2. 运行环境：由不同事物组成的特定套路，环境不同 套路不同
3. V8引擎： 一个隐藏很深 较底层的平台 提供机器与代码的交互
4. 编译器/解释（执行）器 ： 对代码转换成机器可识别的二进制，机器安装二进制执行
5. 内置库：官方内含的套件礼包，较正式和常用
6. 第三方库：非官方定制化的，超级大礼包，无好坏之分，全看你是否能用到
7. 学习JS的方向：入门 多问自己什么最重要，不能钻牛角尖搞研究。实用为主。
================================================
FILE: homework/lesson1/XGunn-lesson01.md
================================================
\# 第一课总结
\## 1.类比代码执行流程
以银行受理客户业务流程类别代码执行流程。
\## 2.运行环境
JS运行环境包括浏览器运行环境和Nodejs运行环境，运行环境是用来处理和执行代码并输出结果。
\## 3.V8引擎
V8引擎高效执行代码，Google开发
\## 4.编译器/解释（执行）器
编译器用来分析词法、语法、语义、优化代码
解释器用来解释代码、执行代码
\## 5.内置库
js自带的工具，可以直接拿来使用。
\## 6.第三方库
外部机构提供的工具，可调用。
\## 7.学习JS的方向
学习编程语言，解决业务需求。
注意辨析工具差异。
================================================
FILE: homework/lesson1/ZhengChao.md
================================================
## JavaScript Lesson1 学习心得
#### JS两大构成部分
##### JS代码
1. ###### 两个概念：编译型语言（比如C,C++）和解释性语言（JS）
2. ###### JS代码属于解释性语言
3. ###### 从解析器看来，要处理的代码不仅包括JS代码，还包括把内置库，第三方库服务整合的代码集合
##### JS运行环境和第三方库
1. ###### 两大运行环境分别是浏览器和NodeJS
- ###### 浏览器运行环境可用于前端
- ###### NodeJS运行环境可用于后端
2. ###### 单个运行环境的构成：
- ###### V8引擎：编译解析代码
- ###### **内置库**
- ###### **第三方库**
================================================
FILE: homework/lesson1/anjiancai.md
================================================
# 第一次学习Javascript总结
标签（空格分隔）： 未分类
---
#类比银行开户流程环境讲解程序运行环境
通过不断优化银行开户的步骤，最终完成一套设计完美的流程。
![优化后的开户流程][1]
整个流程设计两大主体部分：用户和银行，用户和银行之间涉及三大步骤：请求服务、输入和输出。而银行内部拥有建立的开户环境，开户环境中包括内置服务、预处理和执行，其中内置服务部分是为了预处理和运行做的前期准备，预处理是为执行部分顺畅运行做的检查工作，而执行部分是开户的核心部分。
![构建业务架构][2]
银行根据用户的不同分为普通用户和VIP用户，其实每类用户包含相同的步骤，开户环境分别抽象为内置服务和业务核心两部分，而业务核心就打包合并了上述中的预处理和执行部分。除此之外还需要第三方服务，因为自己的环境中需要链接外部已经建立的优秀流程部分，需要的时候只需调用即可。
![JS运行环境框架][3]
JS运行环境框架与上述银行开户的业务架构极其相似。JS代码如同用户，JS运行环境如同银行环境，浏览器运行环境和Nodejs运行环境如同银行中的两类用户的环境，而每类环境中V8引擎负责业务核心。值得注意的是，两类环境中都存在内置服务和第三方库，但是各自的内容都不相同。
#编译型语言和解释型语言
编译型语言（如C语言和C++）是先编译后运行，需要一个编译代码的过程，通过编译器翻译成机器语言。
特点：运行效率高;缺点：开发效率低。
![编译型语言][4]
解释型语言（如JavaScript）是边编译边运行，每一句的代码都是边编译边运行的。
特点：开发效率高；缺点：运行效率低。
![解释性语言][5]
[1]: http://wx3.sinaimg.cn/mw690/95a79662ly1fihd5trymgj20mn0irdis.jpg
[2]: http://wx3.sinaimg.cn/mw690/95a79662ly1fihd5uef3qj20k70d9wg0.jpg
[3]: http://wx4.sinaimg.cn/mw690/95a79662ly1fihdw40385j20k20dfjt3.jpg
[4]: http://wx4.sinaimg.cn/mw690/95a79662ly1fiheed1dt0j20kx0cyq4j.jpg
[5]: http://wx3.sinaimg.cn/mw690/95a79662ly1fiheedv6zij20mp0bomyq.jpg
================================================
FILE: homework/lesson1/baoguoqiang.md
================================================
#类比代码执行流程
首先引入生活中在银行开户的这么一个流程，讲解了在开户过程中所需求的种种，我们把这些种种叫做开户环境；一步一步进行优化处理，最后达到满意的效果；
从这个生活中的例子引导到javascript的运行环境；
#运行环境
javascript的运行环境分为：浏览器运行环境；NodeJS运行环境
这两种运行环境都是由内置服务和V8引擎，第三方库组成
#V8引擎
V8引擎就是运行环境中的一个预处理
# 编译器/解释（执行）器
在javascript的运行环境里，编译器和解释器是合二为一的，一边编译一边解析；
#内置库和第三方库
这两个库我们在编程的时候都是要学会调用的，要熟练掌握技巧
#学习JS的方向
个人是小小白，之前从未接触过编程，刚开始的时候，直播还能看的懂，到作业部分简直就是蒙圈，还好有老师写的非常详细的文档，
一开始就是一点方向也没有就像无头的苍蝇乱飞，文档要仔仔细细的看才可以，边看边实操效果更好。
在这里也非常感谢王云飞同学的帮助的鼓励，非常耐心的去指导我这个小小白。
由于种种原因到现在才交第一次的作业，可能是最后一个提交的，但是我不想放弃，现在一有时间就是在看文档和书籍，谢谢老师的指点
================================================
FILE: homework/lesson1/caijinpeng.md
================================================
## 第一次作业
### 提交人：Marshalcy
#### 代码执行环境
我用过调用各种库（内置库和第三方库）写好我的代码后，打包成工程代码，发给解释器；这个过程好比是我去银行开户，通过大堂经理等人的帮助后，将我的个人信息完整准确的填写在申请表上，然后交给银行柜台员工，如果信息表信息无误，则通过申请，柜员发卡给我；如果还有错误，ta会将信息表给我，告诉我哪里错了，需要重新填写，好比解释器报错。
#### 运行环境
好比是饭店的后厨，里面包含洗菜、切菜、炒菜的，最后将炒好的菜交给前台服务人员。
#### V8引擎
后厨工作人员，炒菜的，将切好的菜交给他，他炒好了装盘拿给你或者炒糊了，也给拿给你。
#### 编译器和解释（执行）器
同v8引擎， v8引擎就是javascript的编译器和解释器。区别在于，编译型语言的编译器和解释器是分开的，相当于先洗菜，切菜；切好后交给解释器，炒菜；
而js的编译器和解释器是在一起的，一个人完成洗菜、切菜、炒菜。
#### 内置库
就是后厨内提供的，已有的服务，比如煤气啊、菜刀啊等等和炒菜相关的服务。
#### 第三方库
后厨内不提供的服务，外面人提供的服务，比如菜刀不够快，需要的磨刀服务。电话预约送菜上门服务等等。
#### 学习js的方向
先学习如何使用内置库和第三方的库，帮自己完成自己的需求。
然后具体掌握，了解内置库和第三方库，能调用他们服务我的业务需求。
最后能根据业务需求，知道什么时候用什么样的库能最好的完成我的需求。
================================================
FILE: homework/lesson1/caozhen.md
================================================
# 第一次作业
### 代码执行流程的类比
#### 描述
老师课上通过零基础的**类比方法**，让我们理解了代码执行是怎么回事；
在银行开户案例中；谈到了几个弊端和改进：
- 银行开户的**核心业务动作**是：先审核材料，再执行处理
- **弊端[1]**审核和执行流程积压在1个工作人员身上，顾客等待时间过长；**改进[1]**将工作人员区分成大厅人员（审核）&窗口人员（处理），银行压力减轻（*软件功能分解*）
- **弊端[2]** 对顾客来说，需要交两次不方便（*个人复杂交互*）； **改进[2]** 由大厅工作人员直接交到窗口，不需要个人转交（*优化交互设计*）
- **弊端[3]** 对顾客来说，需要识别银行的不同角色（大厅人员&窗口人员）； **改进[3]** 增加窗口的概念，顾客直接面向窗口即可（ *（类）封装*）
- **弊端[4]** 顾客可能还需要一些额外服务 ； **改进[4]** 银行内部增加提供这些服务
因此，我们得到了开户环境：包括内置服务、预处理、执行
- **补充[1]** 区分不同的用户等级，可以分别定义针对不同用户的开户环境
- **补充[2]** 用户可能同时伴随有其它非银行需求，因此还可以增加第三方服务
#### 总结几个类比
- 银行开户环境 vs JS运行环境
- 银行核心业务 vs V8引擎
- 审核&执行 vs 编译器&执行器
- 银行内置服务 vs 内置库
- 非银行服务 vs 第三方库
- 开户环境由内置服务&核心业务组成 vs JS运行环境由内置库&V8引擎组
- 针对不同用户的开户环境 vs 浏览器运行环境&NodeJS运行环境
#### 总结几个代码开发理念
- 由于软件可靠性差导致的软件功能分解
- 由于个人复杂交互导致的优化交互设计
- 为了避免个人不合理操作导致的类封装
### 运行环境
- JS的运行环境分为两类：浏览器运行环境&NodeJS运行环境
- 黑盒：直接把运行环境当成一个黑盒子，初学者完全不需要关心代码实际处理过程
- 由内置库和V8引擎组成：写代码实际上就是在使用（调用）这些内置库；写好后将代码送入V8引擎
再次类比，到底什么是运行环境？
- 比较婴儿和小学生的生活环境，有相同，有不同，有差异性
- 浏览器运行环境&NodeJS运行环境同样有差异性，他们之间的内置库是不一样的
### V8引擎
- 是JS运行环境的**核心**；实现两个功能：对JS代码编译、执行
- 真正写代码的时候，完全不需要关注它
### 编译器/解释（执行）器
- 编译：在代码执行前，对代码预处理（分析代码&优化代码等）
- 执行：运行代码
- 编译型语言：执行前需要先经过编译的过程，将全部代码翻译成机器语言再交给执行器执行，例如：C/C++/Java等
- 解析型语言：一条语句，一边翻译一边执行，没有明显的先编译过程，例如：JavaScript等
### 内置库
- 运行环境中的内部服务
- 不同类型的运行环境，内置库不完全一样
### 第三方库
不属于运行环境，但是代码执行不可缺少的组成部分
### 学习JS的方向
结合个人的方向，希望通过JS的学习，对前端技术有一个比较全面的掌握和理解。
================================================
FILE: homework/lesson1/chaigaoping.md
================================================
1.类比代码执行流程
代码传入到编译器和解释器之后，经过编译/解释处理，然后输出结果。
2.运行环境
运行环境就是能够使代码条用内置服务的一个环境，里面包含了两个运行环境：浏览器运行环境和nodejs运行环境。两者都有V8引擎，它可以理解为一个对代码进行预处理和执行的黑盒子。
3.编译器/解释（执行）器
一个是对我们的代码进行分析词法、语法、语义、优化代码，另外一个是解释代码、执行代码。
4.内置库
某种核心功能的实现集合。
5.第三方库
可以优化核心功能的集合。
6.学习js的方向
因为我这份作业是在开课后的20天，31号才补交的。从过去三周的经验来看，除了听老师的课只外，还要投入时间去玩代码。去把基础补上来。还有就是要和一群人一起走。最后是要有很强的目标感。自己之前就尝试过学编程，但是失败了。这次重新捡起来，发现自己对于技术还是没有死心。既然没有死心，那就便有了希望。
================================================
FILE: homework/lesson1/chengjun.md
================================================
###【程君的课后总结】-**javascript**
1.类比代码执行流程
银行的开户流程
请求——输入——输出
请求：内置服务
输入：预处理
输出：执行
可以把预处理与执行合起来，在内部解决，称为业务核心
于是：JS
请求：运行环境内置库与第三方库
输入：工程代码
输出：解释器执行
2.运行环境
浏览器运行环境：包括内置库和V8引擎
nodejs运行环境：包括内置库和V8引擎
运行环境的类比：婴儿的生活环境，小学生的生活环境都是不一样，如果婴儿生活在小学生的生活环境就会存在问题。
每个生活环境中，都存在一些模块，比如，爸爸、医院、家、玩具等等。相当于一个库。
也就是说，在写JS时，一定要明白是写浏览器环境的代码还是在nodejs。
3、V8引擎
不用管它，相当于一个黑盒，
4、编译器/解释器
编译型语言，执行之前先来进行编译，分析词法、分析语法、分析语义、优化代码。比如C++.
需要一个专门的编译过程，通过编译器翻译成机器语言，特点：运行效率高，缺点：开发效率低
解释型语言：变解释变执行，一条一条执行，不会用明显的编译过程，非常简单，分析词法、 分析语法、分析语义、优化代码、解释代码、执行代码。
一条语句执行的时候才翻译，特点：开发效率高，缺点：运行效率低。
5、内置库
非常重要的仓库，
代码首先调用内置库，然后送过去执行，最后给出结果。
浏览器运行环境的内置库： JS内置对象、webAPI、webGL、HTTP、webRTC、canvas
NODE运行环境内置库：JS内置对象、Node API
6、第三方库
浏览器第三方库：
Node第三方库： express koa webpack promise
7、学习JS的方向
1、掌握编程语言
2、了解和掌握重要的服务能力
3、比较服务和技术之间的差异
================================================
FILE: homework/lesson1/chenlingmin.md
================================================
# 【Javascript第一次作业】总结——陈玲敏
## 类比代码执行流程
| JavaScript | 解释 | 银行 | 解释 |
| ----------- | ---------------------------------------- | ----- | ---------------------------------------- |
| 运行环境 | 分为两种：**浏览器运行环境**和**Nodejs运行环境**。 | 开户环境 | 提供一组服务，该服务包含接受申请、检验申请单信息和核对资格。提供集**预处理**、**执行**于一体的核心业务处理单元，同时还提供**内置服务**方面用户的业务办理。可分为两种：**普通用户的开户环境**和**VIP用户的开户环境**。 |
| 内置库 | 网络库、日志库、JS内置对象... | 内置服务 | 为满足用户填写订单时提供的一组内部服务。 |
| V8引擎 | Node:JS内置对象，Node API； 浏览器：JS内置对象，WebAPI,WebGL,HTTP,WebRTC,canvas; | 核心 | 业务处理的核心，涵盖**预处理**和**执行**两个模块。 |
| | | 预处理 | 在真正执行开户前进行信息检查的处理过程，以保证执行处理的效率。 |
| 编译器/解释（执行）器 | 一个可以执行代码的黑盒。 | 执行 | 执行开户操作的过程，操作完后并返回想要的开户结果。 |
| 第三方库 | Node:Express,Koa,Webpack,Promise; 浏览器：jQuery,Vue,AngularJS,React; | 第三方服务 | 满足开户业务的需求 |
| JS代码 | | 用户 | |
## 编译型和解释性差异？
| | 解释 | 特点 | 缺点 |
| ---- | ------------------------- | ----- | ----- |
| 编译型 | 需要一个专门的编译过程，通过编译器翻译成机器语言。 | 运行效率高 | 开发效率低 |
| 解释性 | 一条语句执行的时候才翻译。 | 开发效率高 | 运行效率低 |
## 学习JavaScript的方向
##### 该怎么学JavaScript?
> 掌握编程语言，编程方式调用服务来完成你的需求
##### 该怎么提高？
> 了解和掌握重要的服务能力，使其能服务你的业务。
##### 该怎么进阶？
> 善于比较服务/技术之间的差异性， 最好的方式实现你的业务。
##### 学习JavaScript的难度：
> 变化快和无边际。
================================================
FILE: homework/lesson1/chenqiong.md
================================================
# JavaScript 入门课第一课总结
## 用现实生活中的例子来类比代码执行流程
老师用银行开户的流程类比代码执行的流程，并通过几个版本的演进来类比业务的持续迭代。这些迭代可以说都是在之前版本的执行过程中，观察总结，进而演进而来，一个产品的迭代也应是如此。
## 运行环境
JavaScript 运行环境有两种：浏览器和 node 。当我们打开浏览器，实际上是告诉计算机，帮我起一个浏览器的运行环境，之前只知道打开浏览器就是看网页而已。
## V8 引擎
> V8 是一个由 Google 开发的开源 JavaScript 引擎，用于 Google Chrome 及 Chromium 中。
> V8 在运行之前将 JavaScript 编译成了机器码，而非字节码或是解释执行它，以此提升性能。更进一步，使用了如内联缓存（inline caching）等方法来提高性能。有了这些功能，JavaScript 程序与 V8 引擎的速度媲美二进制编译。
## 编译器/解释（执行）器
JavaScript 是解释型语言，代码是边编译边执行的，开发效率比较高，但运行比较慢。其他编译型语言如 C 、C++、Java 等都是需要先编译，编译通过后才能执行，特点是运行快，但开发效率不高。印象最深刻的就是以前自学 Java 的时候，写好代码，需要运行 javac 指令，对代码进行编译。
## 内置库
JavaScript 语言本身自带的一些基本功能实现，包括基本的数据结构、模块、函数等，已经封装好了，开发者通过阅读文档，获知调用方法之后，就可以直接调用。其它语言也是如此。
## 第三方库
一般指用同种语言开发的拓展功能，用来满足多样化的需求。也有用别的语言开发的第三方库，供 JavaScript 编写的代码调用。也有个说法叫不要重复造轮子，这里的轮子应该也是指的第三方库，一个功能，如果别人已经写好了，直接拿来用就可以了，没必要再自己写一个。
## 学习 JS 方向
从一个最简单的项目开始，然后用各种新学到的东西对项目进行完善，并进行比较，多练习。
================================================
FILE: homework/lesson1/chenrushan.md
================================================
# Hello, JavaScript 总结
从设计一个银行开户流程，一次次升级，然后抽象出业务架构，类比到JavaScript运行环境架构，清晰易懂。
我们写代码让计算机满足我们的需求，就如我们提交申请，让银行帮我们开户，这个过程需要一些服务，需要经过一些处理步骤，来完成我们的开户需求。
# JavaScript运行环境架构
由银行业务架构到JavaScript运行环境架构。
有了整体架构后（心中有图），逐一理解架构中的组成部分。
- JavaScript运行环境架构
- 运行环境
- V8引擎
- 编译器/解释（执行）器
- 内置库
- 第三方库
## 1. 运行环境
运行环境，类比了不同人的生活环境，代码的运行也需要一定的环境，应该是能够使代码被计算机理解并运行起来的环境。
### 1.1 V8引擎
V8引擎，类比银行员工处理申请材料，帮客户办理开户，个人理解为处理我们编写的代码，执行代码，计算结果的模块。
#### 1.1.1 编译器/解释（执行）器
将代码“翻译”成计算机能够识别的语言，然后执行。
### 1.2 内置库
运行环境中提供的基础服务，供代码调用。
## 2. 第三方库
在运行环境之外，由第三方提供的开源/付费的服务，通过调用可实现某些功能。
# 学习JS的方法
在JavaScript运行环境架构中，代码是如何运转的？
我们的工作在最左边，写的代码以及调用的内置库和第三方库。
入门：掌握编程语言，学会怎么调用库来满足需求。
提高：知道什么库可以满足需求。途径一，自己查找，途径二，问。
进阶：知道解决同样需求的库之间的差异，能够选择合适的库来更好地实现业务需求。
================================================
FILE: homework/lesson1/chenyanxing.md
================================================
##【第一次作业】
————————————————————————————————————————
#####--*author：陈燕杏*
#####--*version：V1*
#####--*create_time：2017-08-17*
————————————————————————————————————————
###1. 类比代码执行流程
####对于代码执行流程的理解：我们写好的代码，来到运行环境，经过编译器／解析器一系列（分析词法、分析语法、分析语义、优化代码、解析代码、执行代码），运行完成后，输出结果。JS代码编写的过程中，需要调用浏览器或者Nodejs的内置对象来运行，并且提供了可拓展的第三方的类库，使功能强大。
###2. 运行环境
####JS运行环境：分为浏览器和Nodejs。他们里面的运行环境里都有V8引擎和内置服务。当然少不了的是我们底层的JS代码，对于JS运行环境的运行还需要第三方库的支持。
###3. V8引擎
####这是同学的笔记：V8引擎是一门底层技术，chrome就是基于V8引擎构建的，直接的体现就是chrome浏览器中写JS的代码，代码的执行速度快。
###4. 编译器/解释（执行）器
####编译器／解析器：就是在运行环境中一个可以执行代码的黑盒。代码的输入通过其编译／解析输出结果。
###5. 内置库
####内置库是该运行的环境下，可以调用出网络库，日志库，JS内置对象···浏览器和Node的运行环境内置库里，JS内置对象是他们共同一样的部分。
###6. 第三方库
####第三方库我的理解是对运行环境提供了更加强大的功能支持。
###7. 学习JS的方向
####跟着老师的节奏，学习编程的思想，从而入门编程的世界，最重要是掌握这门技能。
####体会：第一节课的知识点因为都是没有见过的，脑子里没有可以迁移的知识来理解，所以上述写的理解没有很深刻到位。看了学霸同学们的作业，有些不懂的地方也会豁然开朗。
================================================
FILE: homework/lesson1/chenzidong.md
================================================
第一课 git到的JS知识
# 初步了解，整体印象。
通过银行开户的类比，把JS运行的流程，一些大家都熟悉的概念，送到大家的认知里。印象最深的是开户窗口，预处理，和执行，对应JS里的 网页窗口，编译器，和执行器。还有流程可以不断优化，以达到最优的解决问题的方案。
#运行环境
在我看来就像基础设施，里面有一些内置或第三方的服务和工具。
#V8引擎
因为JS是一种解析型语言。要边解析边执行，速度就会比较慢。但它服务的对象又是直接面对用户的，要求提高速度，就需要有一种工具来加速把代码和其它数据库整合成机器语言。
#编译器/解释（执行）器
前者把中间文件，解析成机器语言，后者执行机器语言代码。在js的运行环境里，编译器和解释器是合二为一的，边编译边执行。
#内置库/第三方库
运行环境内部的服务/运行环境外部的服务
不同的运行环境，内置服务是不一样的。
#学习JS的方向
先学会习编程的方式解决问题。 然后学会不同工具之间的差异，更好的优化服务。
第一次在浏览器上运行代码并弹出自己名字的对话框，很高兴！
================================================
FILE: homework/lesson1/chenziwen.md
================================================
1. 类比代码执行流程
+ 就是把现实的事件流程抽象出来，用最精简的方式来描述一个事件的执行流程，方便思考，方便转化为代码。
2. 运行环境
+ 运行+环境
+ 运行：就是执行代码并期望得到想要的结果。
+ 环境：就是生存条件，必要条件；也就是代码执行并能返回结果的必要条件。像老师课件里说的婴儿的环境，学生的环境中除了必要条件（爸爸妈妈等）还有资源这类提高生活舒适度的条件，就好比编程中能有更方便，更快捷，更高效的方式提供。
3. V8引擎
+ >V8 作为一个 JavaScript 引擎，最初是服役于 Google Chrome 浏览器的。它随着 Chrome 的第一版发布而发布以及开源。现在它除了 Chrome 浏览器，已经有很多其他的使用者了。诸如 NodeJS、MongoDB、CouchDB 等。
V8 使用了直译的方式，即把 JavaScript 代码直接编译成机器码( Machine Code, 有些地方也叫 Native Code )，然后直接交由硬件执行。
与传统的「编译-解析-执行」的流程不同，V8 处理 JavaScript，并没有二进制码或其他的中间码。
简单来说，V8主要工作就是：「把 JavaScript 直译成机器码，然后运行」
+ 顾名思义“引擎”就像是汽车的发动机，可以更快的驱动汽车。V8引擎应该能帮助编程者更快的实现编程目标。
+ V8引擎比以前的边解释边执行的效率更高。
4. 编译器/解释（执行）器
+ > **编译器** 是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;
而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.
这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)
编译是将源程序翻译成可执行的目标代码，翻译与执行是分开的；而解释是对源程序的翻译与执行一次性完成，不生成可存储的目标代码。这只是表象，二者背后的最大区别是：对解释执行而言，程序运行时的控制权在解释器而不在用户程序；对编译执行而言，运行时的控制权在用户程序。
解释具有良好的动态特性和可移植性，比如在解释执行时可以动态改变变量的类型、对程序进行修改以及在程序中插入良好的调试诊断信息等，而将解释器移植到不同的系统上，则程序不用改动就可以在移植了解释器的系统上运行。同时解释器也有很大的缺点，比如执行效率低，占用空间大，因为不仅要给用户程序分配空间，解释器本身也占用了宝贵的系统资源。
5. 内置库
+ 内置库JS环境中（浏览器&node.js编程环境中）已经编写好的一些函数方法，可以直接调用而不用重复发明轮子，是提高编程效率的工具之一。
6. 第三方库
+ 第三方嘛，应该是相对于内置库来说的。
+ 不是当前编程环境中有的，是需要另外添加进来的。
+ 第三方库的使用方法还待研究……
7. 学习JS的方向
1. 学习并熟悉JS编程语言，熟悉语法，学会调用服务（内置库、第三方库）来提高效率。尽快给自己一个正面反馈，加强信心。
2. 理解自己项目的需求，了解并熟悉相关的（重要的）服务。
3. 找不同！比较服务/技术之间的差异，分析其优异性，寻找到最适合自己的方法。
4. JS技术更新变化速度飞快。寻找可复用的经验，加快新技术的学习速度。老师PPT中提到的难度二“无边际”，使我想到avascript无所不能，但要有取舍，要选方向。不能样样了解，样样稀松。
================================================
FILE: homework/lesson1/cloudyview.md
================================================
听徐老师的课，感觉从类比入手，体会比自己看书要好多了，理解深入了。
## 1.类比代码执行流程
代码的执行方式有两种，即解释型语言和编译型语言的的执行方式。
### 解释型语言的代码执行流程
简单说就是一条一条的执行，看到一句代码，解释一句代码。这个类似于弹钢琴的时候的视奏。视奏基本上就是看一句音符，然后弹出来。
### 编译型语言的代码执行流程
编译型语言的代码需要先由编译器编译成执行代码，然后再执行。这个类似于点歌，观众点歌，然后乐师根据观众给的曲目，直接弹奏整首曲目。
感觉不是很恰当。现在能想到的是这个。
## 2. 运行环境
运行环境包括了用于解释程序的引擎（可以是编译/执行方式的，也可以是解释的），以及内置库，第三方库。这些库和引擎核心构成了运行环境。
对于JS来说，有两种运行环境，即WEB浏览器和NODE。对于这两类运行环境，相同的是V8引擎和JS内置对象，其他的库有相当大的不同。
## 3. V8引擎
V8引擎是JS程序解释和执行的核心。
## 4. 编译器/解释（执行）器
对于JS这样的解释型语言来说，只有解释器。程序将按照顺序一句句的被执行下去。也就是一边读取，一边解释（理解），一边执行。
对于C这样的编译型语言来说，需要先由编译器将程序变成执行代码，然后再运行。
## 5. 内置库
内置库是指JS运行环境里面的一组库，这些库是运行环境自带的。
例如，WEB浏览器会自带一组JS的库，如果你的程序只调用了这些内置库的话，就意味着你的程序可以直接在任意的浏览器运行（当前主流浏览器？太古老的可能不一定支持当前的版本）。
## 6. 第三方库
第三方库不是由JS官方出品的，不会出现在JS的内置库里，即JS的运行环境本身并不带有这些库。如果你需要使用这些库，那么必须安装这些库，才能使用它们提供的服务。
## 7. 学习JS的方向
三个阶段，入门的时候，必须学会如何调用各类库的方法。
要想提高，就要学会对比和分析不同的库所提供的功能和服务之间的差异，理解这些，以便为自己的业务流程选择适合的库进行编程。
要进一步提高，就要更深刻的理解你所要解决的问题，根据业务的需要来优化编程方法。
================================================
FILE: homework/lesson1/cuimeng.md
================================================
# 第一次JavaScript课堂总结
> 由于自己在大学期间有过相关的编程语言的学习经历，后来的工作需要也写过一些小程序，本堂课的内容对我来讲理解起来还算相对容易。然而收获依然很大，对编程语言的运行机制有了比较系统的认知。
## 代码的工作流程
银行开户的流程类比代码的执行过程，让人很容易理解。
JavaScript是一种脚本语言，他的工作原理是解释型的，也就是边编译边执行。这种语言的好处是可以适应多平台的环境，可以不用每移植到一个平台就重新改写代码。通过统一的代码实现各个平台之间的无缝移植和执行。
## 运行环境
JavaScript的运行环境有浏览器端和node.js的后台端，最初的JavaScript是浏览器运行的脚本语言，后来某位大神把他重新编写，在后台运行发现也非常不错，就有了node.js。
V8引擎是一种常用、高效的JavaScript编译器，可以运行在chrome和node.js。它把JavaScript的代码编译成为执行更高效的机器码。同时可以优化代码，使得编译效率更高。
## 内置库
JavaScript的内置库分在chrome和node.js上根据功能的不同而有所差异。
内置库是一些预先写好的代码，用来实现一些基本的操作。例如输入输出、数据处理等。通过打包好常用的功能来简化编程的繁琐程度，提高编码效率。
## 第三方库
是非内置在程序中的，针对某些特定的功能来预先编写好的程序代码，在编程的过程中，需要调用进入程序中来使用，第三方库的使用需要查看document来了解其中不同函数和方法的使用方法和注意事项。
针对不同的编程目的，JavaScript有丰富的第三方库可供使用。具体的工作环境中对第三方库的使用可以参考资深人士的建议。查看GitHub上面的库的受欢迎程度来决定。
## 学习动力
学习JavaScript使我一直以来的期望，希望能够通过js的学习，让自己进入编程的大门，锻炼编程思维，同时能够通过自己的代码为世界更美好一点作出自己的贡献。
================================================
FILE: homework/lesson1/cuimiao.md
================================================
#小小白崔淼的学习之路——lesson 1
1. 类比代码执行流程
按照老师的类比，就好像是去银行办卡，先要填写表单（输入代码），然后提交审核（编译器编译），办理业务（执行器执行代码），最终拿卡（反馈结果）。此外，银行还提供了内部服务（内置库），还有第三方公司提供的便捷服务（第三方库）。
2. 运行环境
JS的运行环境分为”浏览器”和”node”，每种运行环境有着不同的内置服务（内置库）和第三方库。这就好比是每个人周边的环境都不一样，有着不同的（有时也有重叠）内置服务和第三方服务。
3. V8引擎
V8引擎为JS语言中负责预处理和执行代码的部分。
4. 编译器/解释（执行）器
应是V8引擎，对代码进行编译和执行。
5. 内置库
每种运行环境中，直接可供应用的内置库。
6. 第三方库
每种运行环境中，外部的可供应用的外部资源库
7. 学习JS的方向
焦点集中在我们写的代码上，我当前的目标就是熟练运用代码，熟练掌握编程语言。
================================================
FILE: homework/lesson1/dangfeipeng.md
================================================
### 用类比的方式推导 JS 框架
徐老师用“银行开户流程”的四次改进，由浅入深、层层递进地推导出 JS 框架，通过类比让我们借助熟悉的“银行开会流程”在很短的时间内对陌生的 JS 框架产生了感性认识，了解了主要的组成部分以及各部分之间的关系，形象生动。
### 运行环境
举个不太恰当的比喻，JS 运行环境就像智能厨房的控制中心，它有各种原材料存储位置以及使用说明（相当于内置对象），也有捡菜、洗菜、切菜、炒菜等基本功能说明（相当于内置库），以及一个菜谱制作器（相当于 V8引擎），一旦收到客户的要求（相当于代码），菜谱编制器就根据客户的要求编制菜肴的加工说明（本地代码），最后厨师机器人根据加工说明将具体食材做成成品菜肴，根据菜肴的基本分类，控制中心又分为中餐和西餐两大类，同时当控制中心的基本功能无法满足客户要求时，比如日料，就可以借助其他第三方来协作完成（相当于第三方库），这其中菜谱编制器是核心，由它来负责整体的运行、控制和调度，可以形象地类比为 V8引擎。
### 学习 JS 的方向
大致的路线图是：
- 学习：掌握编程语言，用编程的方式调用服务来完成你的需求，我的理解是掌握基础知识，包括语法、常用的内置对象；
- 提高：了解和掌握重要的服务能力，使其能服务你的业务，我的理解是重点搞清内置库，其次是第三方库；
- 进阶：善于比较服务/技术之间的差异，用最好的方式实现你的业务。
================================================
FILE: homework/lesson1/dengxy0907.md
================================================
第一次课作业
===========
### 类比代码执行流程
> 老师通过银行开户流程类比了代码，代码就是一个个功能的体现，一个个具体的功能通过翻译让计算机执行，达到获取结果的目的
### 运行环境
>运行环境是能够执行代码的环境
### V8引擎
> 一个运行代码的黑盒子
### 编译器／解释器
> 一个把代码翻译给机器的东西
### 内置库
> 一个装有js代码的背包
### 第三方库
> 一个额外选择的武器库
### 学习js的方向
> 到这已经完全忘记，对我自己而言，就是通过编辑代码、调用库来实现自己的需求。
================================================
FILE: homework/lesson1/diaozhicong.md
================================================
#【第一次作业】写一篇总结
##1. 类比代码执行流程
用银行开户流程的优化类比让我们理解整个代码执行流程，比较形象，也让我们小白更好的理解。另外一点我的感受是，流程图是一个很好的理解工具，未来需要好好打磨。
##2. 运行环境
运行环境分为Node环境和浏览器环境。
JS的运行环境我们可以理解为一个可以执行代码的黑盒。
##3. V8引擎
V8引擎是Js运行的核心部分。V8引擎是运行环境中完成编译、解析及执行代码等工作的模块。使得我们编写的易于人们阅读的高级语言代码能够顺利的转换成机器能理解的语言。
##4. 编译器/解释（执行）器
我们所编写的高级语言，本质上计算机是无法直接执行的，需要通过编译器将其编译成计算机可以识别的代码，类比于说不通语言的两个人需要相互交流，需要一个翻译一样。
目前有两种：
**编译型**： 需要一个专门的编译过程，通过编译器翻译成机器
语言。特点：运行效率高。缺点：开发效率低。典型的代表是 C 和 C++等；
**解释性**： 一条语句执行的时候才翻译。特点：开发效率高。
缺点：运⾏效率低。典型的如JS等。
##5. 内置库
编译代码通常是在调用各种内置的库，不同的运行环境的内置库有差别：
>浏览器的内置库包含JS内置对象，WebAPI, WebGL, HTTP, WebRTC, canvas等。
>Node内置库包含JS内置对象，Node API等
##6. 第三方库
第三方库是指由第三方提供的收费或者免费的库。第三方包括公司、个人、开源等。
##7. 学习JS的方向
通过学习JS，进入编程领域，以后能做一些自己或别人的项目。
学习提高的方向，借鉴老师和同学的总结：
> 1. 初学：掌握编程语言，用编程方式调用服务来完成你的需求。
> 2. 提高：了解和掌握重要的服务能力，使其能服务你的业务。
> 3. 进阶：善于比较服务/技术之间的差异性，用最好的方式实现你的业务。
================================================
FILE: homework/lesson1/donglili.md
================================================
## 第一次作业
执行代码就好像去银行办开户业务。本质上就是输入信息、获得结果。
而运行环境相当于银行，就是我们要“办事”的地方，也可以理解我们要执行代码的地方。我们的代码是针对运行环境而写的，只有在运行环境下才能够正确执行。
V8引擎就是完成代码检查和执行的地方，在初始代码经过内置服务库和第三方服务库重新整合代码后，会送入这里执行。
编程语言大致上分为两种，一种是编译型语言，这种是先通过编译器将代码编译成可执行的命令，之后送由执行器执行。他们是统一编译之后在执行，所以开发效率低，因为每改动一些代码都需要重新编译。但相对的通过执行器运行的时候就会快很多。而解释性语言是一条一条的进行，编译一条执行一条，所以它的开发效率高，因为每次做了改动，不需要全部代码都进行编译，相对的，运行效率低，因为每运行一条代码都需要编译一次。
================================================
FILE: homework/lesson1/duhongxia.md
================================================
杜红霞第一课总结
1. 类比代码执行流程
用去银行开户这一具体流程类比JS运行环境框架，框架包含：
JS运行环境［浏览器运行环境（v8引擎＋内置环境）＋Nodejs运行环境（v8引擎＋内置环境）］——
第三方库——JS代码
2. 运行环境
包含浏览器运行环境和Nodejs运行环境，JS运行环境如同银行环境，浏览器运行环境和Nodejs运行环
境如同银行中的两类用户的环境
3. V8引擎
核心：用来执行代码
4. 编译器/解释（执行）器**
是V8引擎的组成部分，用来处理和解析代码
5. 内置库
是运行环境所提供的一组服务，用来实现代码的功能
代码首先调用内置库，然后送过去执行，最后给出结果。
浏览器运行环境的内置库： JS内置对象、webAPI、webGL、HTTP、webRTC、canvas
NODE运行环境内置库：JS内置对象、Node API
6. 第三方库
付费或开源的各类服务于JS的工具库
浏览器第三方库：
Node第三方库： express koa webpack promise
7. 学习JS的方向
有难度：变化快＋无边界
学习：用编程方式调用服务来完成你的需求
提高：了解和掌握重要的服务能力，使其能服务你的业务
进阶：善于比较服务／技术之间的差异性，用最好的方式实现自己的业务。
================================================
FILE: homework/lesson1/fangqingyang.md
================================================
### JS第一课总结：
#### 1运行环境（Nodejs和浏览器）
我们写了一份代码，放到运行环境里面，运行环境为我们提供所需要的各种服务如用V8引擎来执行代码，提供内置库来满足我们的需求等。需要注意的是：JavaScript有两种运行环境，Nodejs和浏览器，这两种运行环境是不同的，就像动物和植物的生长环境的区别。
#### 2 V8引擎
V8引擎属于运行环境的一部分，是运行环境的核心，负责执行我们所写的代码，让代码跑起来，得到我们的结果。
#### 3 内置库
内置库属于运行环境的一部分，为我们提供一系列运行代码所需要的服务。比如：alert()
#### 4第三方库
不属于运行环境的一部分，是或由第三方的公司开发，或由个人开发，或收费的，或开源的服务，目的是为更好的满足我们的需求，提供让我们的业务更牛逼，更好的服务，让我们不需要重造轮子。
#### 5 编译器/解释器
编译器：将我们所写的正确的代码，转换成机器能理解的机器代码，让我们的代码变得可执行。
解释器：对我们所写的代码进行这个过程，解释-运行-解释下一行代码-运行下一行代码。。。。，好处是开发速度快，省略了编译这一步，但是运行速度慢了，因为运行时是边解释边执行，不像运行编译好的机器代码一把梭子下去。
#### 6 如何学号JS
1 掌握编程语言，运用编程的方式调用服务来完成自己的需求。（初学者，目前努力的方向）
2 了解和掌握重要的服务能力，使其能够满足自己的业务。（提高）
3 善于比较分析服务/技术之间的差异，用最好的方式实现自己的业务。 （进阶）
#### 7 用类比的来推导JS框架
我们（客户）写了代码（申请表），交给运行环境（银行柜台），运行环境里面的编译器（员工A），先审核，检查我们的代码，没问题了将处理好的文件（编译文件）就交给V8引擎（员工B）去执行，期间V8引擎调用内置库里面的服务（比如打印机），或许还有第三方库的服务（比如警察局办证），最后输出一个结果（给我们一个结果）
#### 8 代码执行流程
首先我们写代码，用编程的方式，按照自己的需求，写要用到什么内置库，什么第三方库的服务，接着交给编译器进行预处理，得到一个编译文件，接着给V8引擎执行，调用内置库，第三方库的服务，然后得出一个结果。
================================================
FILE: homework/lesson1/fanliao.md
================================================
新生大学第一次JS课作业
1. 类比代码执行流程
老师以一般的银行开户流程作为例子，类比了我们从代码的输入到编译执行到输出结果，使一个抽象的过程具体的展现在我们眼前。
2. 运行环境
JS运行环境分为浏览器环境和Node环境，不同的环境对应不同的的内置库和第三方库，但内置库中都有JS内置对象。
3. V8引擎
V8引擎是业务核心，是执行部分。
4. 编译器/解释（执行）器
编译型语言的特点是：代码执行考虑高，但是开发效率低；解释性语言代码执行效率低，但是开发效率高。
5. 内置库
内置库就是指不同的运行环境下我们的代码可以调用以实现某些功能的工具。
6. 第三方库
第三方库是有别于内置库的一个开放的外部资源，更好的帮助我们达成目标，它不断更新，不断为我们提供更好的服务。
7. 学习JS的方向
光说不练假把式，学习JS应该多练习，在实践中发现新的收获。
================================================
FILE: homework/lesson1/fanqing.md
================================================
# 第一课作业
经过好几天逐渐加码的预热练习，JS同学的学习热情都已被调动起来，17年8月8日，我们的第一次正式课开课。
第一课是Javascript的概况讲解课，并同时老师很有心的与初学者进行了学习方法的探讨，对如何利用这门课、该如何学习、该如何提高以及该怎么进阶给出了建议与方向，力求让我们的学习更加高效、更多获益。
开始我的学习与理解~
对于初期接触编程的人来说，直接讲代码设计流程、执行流程、框架等都太抽象，老师采用了类比的方式进行代码执行流程的讲解，由现实场景引向抽象世界。
### 以银行开户流程作为类比说明：
有开户需求的客户在银行内使用银行提供的复印、拍照等服务完成申请所需资料准备，提交至银行窗口，窗口服务人员受理后，由负责审查的人员对简单的填写格式、准确性问题进行检查预处理（不是每个银行都如此），预处理检查通过的后，有权限的工作人员核对征信及资格，通过的给予客户发卡，未通过的给予驳回。窗口服务人员的内部工作是整个开户业务的核心部分。对于客户来说只需要与窗口服务人员对接沟通，保证了客户的服务感知。
JS的代码执行流程与之类似，程序员通过调用内置服务功能，编写提交符合业务需求的代码至JS代码执行的核心（V8引擎），内部一系列处理后输出执行结果。
针对不同的客户，还可以区分出普通客户与VIP客户，这时会采用不同的流程——普通柜台以及VIP柜台，也就是不同的业务环境，与之类似，JS也有针对不同类业务需求的不同运行环境。
### JS的运行环境框架：
运行环境（含两类）、第三方库、JS代码。
#### 两类运行环境分别是：
1.浏览器运行环境；2.Node运行环境。总体看两个环境均由V8引擎（核心）、内置服务、第三方库以及JS代码构成。
为了更好的理解“环境”的概念，同样的，用婴儿与学生的生活环境不同进行类比，有助对于运行环境差异的理解。
细分看两个运行环境，相同在于：均有V8引擎、JS内置对象、JS代码以及某些第三方库，不同在于：其他内置服务库的不同，浏览器运行环境内置库有HTTP、WebAPI等，Node运行环境内置库仅有Node API，以及一些第三方库的不同。
#### V8引擎：
是一个可执行代码的黑盒，它发挥着编译器/解释（执行）器的功能，每条代码在需要执行时都可以进行编译，翻译成机器语言进行执行。相对C、C++等编译型语言（需要整体编译完成后才能执行），开发效率高但运行效率低。
#### 编译器/解释（执行）器：
功能包含分析词法、分析语法、分析语义、优化代码、解释代码、执行代码。JS是解释性语言，以上功能合为一体。编译型语言是将后面的“解释代码”“执行代码”需要提交至单独的执行器来完成。
#### 内置库：
即内置服务库，包含JS内置对象以及其他的内置服务。这些由运行环境内置，基本运行环境启用之后，可以直接调用，就像银行内的复印服务、拍照服务、查询逾期服务等。
#### 第三方库：
是为了提供更便利、更丰富的开发应用功能，类似银行的警务服务、理财公司专柜服务等，就像分工协作的社会，各自发挥所长。在内置库功能不能满足的情况下，我们学会充分运用第三方库，会事半功倍。JS的浏览器运行环境的第三方库有jQuery、Vue、AngularJS、React等，JS的Node运行环境的第三方库有Express、Koa、Webpack、Promise等。
### 关于学习JS的方向
Javascript是一门无边际的语言，有很多语言是基于Javascript开发出的，有一个说法“JS是编程界的汇编语言”。
对于汇编语言，在校时曾学过，印象中它是与最底层的计算机运行方式对接的语言，按照计算机的运作原理进行编译，涉及寄存器、进栈出栈等。也就是说理解了Javascript语言，其他在她的基础上开发出的语言，是不是也都更容易理解了呢？也许答案是肯定的，若真如此，对于向往编程世界的人来说，更不能错过。
JS的发展变化很快，2009年ES5（ES是JS的便趁个语言规范），至2017年已达ES8，我们现在只需要集中注意力、聚焦在2015年的ES6这个版本，学懂后，对新版本的更新功能也会很容易理解。
### 要实时关注以下几点：
该怎么学习？——掌握编程语言，用编程方式调用服务来完成我们的需求；
该怎么提高？——了解和掌握重要的服务能力，使其能服务我们的业务；
该怎么进阶？——善于比较服务/技术之间的差异性，用最好的方式实现我们的业务。
Javascript是一门编程语言，就像学习其他语言一样，只有不断的重复、应用，把头脑中的想法，刻意的尝试用她的方式表达出来，才是最佳的学习方法。
#### 如有理解不当处，请老师、同学批评指正！
P.S. 课程选的背景音乐太喜欢了，不仅因为歌好听，还因为这首歌兴起的那段时间，2002年，当时我报名参加了一个培训学校的MCSE课程，来回路上，常伴随着这首歌。时隔这么久，现在我再次报名参加与上次本质上很接近的兴趣爱好的学习，在课程中又听到这首歌，很有时光倒流的感觉，非常美好~ 2002年的学习有些懵懂，没能更多的学以致用，希望这一次能学到讲出来、学到用起来~
================================================
FILE: homework/lesson1/feixiguang.md
================================================
# 第一课总结
### 1.类比代码执行流程
使用银行开户方式
* 1.填写申请单
* 2.去柜台开户
* 3.发卡
***
类比一套业务架构：
* 开户环境：提供一组服务，该服务包含接受申请、检验申请单信息和核对资格。
（开户环境提供集预处理、执行于一体的核心业务处理单元，同时还提供内置服务方面用户的业务办理。）
```
内置服务：为满足用户填写订单时提供的一组内部服务。
业务核心：涵盖预处理和执行
预处理：在真正执行开户前进行信息检查的处理过程，以保证执行处理的效率。
执行：执行开户操作的过程，操作完成后并返回想要的开户结果。
```
* 围绕开户业务，会有一堆第三方服务供用户使用，以满足开户业务的需求。
***
JS运行环境框架：
* JS运行环境对应银行开户环境
* JS代码对应用户
* 同样针对JS代码也提供第三方的库，来满足更多的需求。
***
编译型和解释性差异？
* 编译型：需要一个专门的编译过程，通过编译器翻译成机器语言。特定：运行效率高。缺点：开发效率低。
例如：C 、C++ .
* 解释性：一条语句执行的时候才翻译。特点：开发效率高。缺点：运行效率低。例如：JavaScript .
***
### 2.运行环境
JavaScript有两种运行环境
* 浏览器运行环境： 基于浏览器的 javascript 前端 JS
* Node.js运行环境：基于服务端的 javascript 后端 Node.js
两者语法一样，组成不一样
JavaScript：
* ECMAScript（语言基础，如：语法、数据类型结构以及一些内置对象）
* DOM（一些操作页面元素的方法）
* BOM（一些操作浏览器的方法）
Node.js：
* ECMAScript（语言基础，如：语法、数据类型结构以及一些内置对象）
* OS（操作系统）
* file（文件系统）
* net（网络系统）
* database（数据库）
***
### 3.V8引擎
* V8是Google开发的开源JavaScript引擎。
* JavaScript 引擎的基本工作是把开发人员写的 JavaScript 代码转换成高效、优化的代码，
这样就可以通过浏览器进行解释甚至嵌入到应用中。
[一篇给小白看的 JavaScript 引擎指南](http://web.jobbole.com/84351/)
***
### 4.编译器/解释（执行）器
JavaScript引擎包括：
* 编译器。主要工作是将源代码编译成抽象语法树，然后在某些引擎中还包含将抽象语法树转换成字节码。
* 解释器。在某些引擎中，解释器主要是接受字节码，解释执行这个字节码，然后也依赖来及回收机制等。
* JIT工具。一个能够能够JIT的工具，将字节码或者抽象语法树转换成本地代码，当然它也需要依赖牢记。
* 垃圾回收器和分析工具（profiler）.负责垃圾回收和收集引擎中的信息，帮助改善引擎的性能和功效。
***
### 5.内置库
* 浏览器运行环境的内置库包含：JS内置对象、WebAPI、WebGL、WebRTC、HTTP、canvas .
* Node.js运行环境内置库包含：JS内置对象、Node API .
***
### 6.第三方库
[JavaScript函数库](https://zh.wikipedia.org/wiki/JavaScript%E5%87%BD%E5%BC%8F%E5%BA%AB)
JavaScript 框架（库）
JavaScript 高级程序设计（特别是对浏览器差异的复杂处理），通常很困难也很耗时。
为了应对这些调整，许多的 JavaScript (helper) 库应运而生。
这些 JavaScript 库常被称为 JavaScript 框架。
所有这些框架都提供针对常见 JavaScript 任务的函数，包括动画、DOM 操作以及 Ajax 处理。
***
### 7.学习JS的方向
* "掌握编程语言，用编程方式调用服务来完成你的需求"
***
* "了解和掌握重要的服务能力，使其能服务你的业务"
***
* "善于比较服务/技术之间的差异性,用最好的方式实现你的业务"
================================================
FILE: homework/lesson1/fengkai.md
================================================
1.类比代码执行流程
JS运行环境框架类比于银行体系的业务构架；
浏览器运行环境相当于普通用户的开户环境；
Nodejs运行环境相当于VIP用户的开发环境；
V8引擎相当于银行的业务核心；
内置库=内置服务；
第三方库相当于第三方服务；
JS代码相当于用户。
2.运行环境
提供集预处理、执行于一体的核心业务处理单元，同时还提供内置服务。
3.V8引擎
计算黑箱
4.编译器／解释（执行）器
一边编译一边解释，解释性语言，开发效率高，运行效率低。
5.内置库
系统内置封装的代码
6.第三方库
外部调用的封装代码
7.学习JS的方向
web前端开发
================================================
FILE: homework/lesson1/hanmeng.md
================================================
Javascript第一课总结
1. 类比代码执行流程
首先，老师运用“银行开户流程”类比了代码执行流程
银行这大环境类比JavaScript，在银行的大环境中有普通用户环境和VIP用户开户环境，分别对应了JavaScript环境中的浏览器运行环境和nodejs运行环境
他们都有两部分组成V8引擎和内置服务，分别提供最满足各自的需求。另外，还有有第三方库，为浏览器的运行环境和nodejs的运行环境同时提供第三方服务代码。
2. 运行环境
JavaScript的运行环境包括浏览器运行环境和nodejs运行环境，在这两运行环境中都有V8引擎和内置库，在我们写代码的时候，学会用代码调用不的内置库是关键，
完全不用考虑V8引擎的工作。
3. V8引擎
对代码进行预处理，处理，执行。我们只用知道V8引擎是编译解析执行代码的就可以了，作为菜鸟不需要知道它的内部工作原理。
4. 编译器/解释（执行）器
V8引擎的组成部分，编译执行我们创造的代码，Javacript是一种解释型语言，就是编译执行一起执行。
5. 内置库
运行环境的各种打包的服务，让我们通过代码调用，实现不同的功能
6. 第三方库
由第三方公司或个人提供的不同功能的代码库，供我们使用以实现更好，更帅的功能。
7. 学习JS的方向
重点来了，深刻理解记住这几句话：
作为小白你应该“掌握编程语言，用编程的方式调用服务来完成你的需求”，掌握语言，把基础打牢固。
提供阶段的你“了解好掌握重要的服务能力，使其能服务你的业务”，主要掌握各种库的功能
进阶阶段的您“善于比较服务/技术之间的差异性，用最好的方式实现你的业务。”，比较，思考，找出最好的方式实现你的业务。
8.学习的难度
变化快，我们要聚焦重点 ES6
无边际 创造能力无限，空间无限大
================================================
FILE: homework/lesson1/hanwei.md
================================================
## 第一次作业
执行代码就好像去银行办开户业务。本质上就是输入信息、获得结果。
而运行环境相当于银行，就是我们要“办事”的地方，也可以理解我们要执行代码的地方。我们的代码是针对运行环境而写的，只有在运行环境下才能够正确执行。
我们编写的代码就好像是提交的表单，然后获得开户的结果就相当于程序执行的结果。在我们提交表单后银行会审核我们的信息填写格式还有内容是否正确，这就类似于要执行程序前，运行环境会对代码的格式和内容进行检查，包括词法、语法、语义等等。在我们的表单审核合格后，银行会进入开户流程，如果符合开户的条件就能顺利开户。代码也是一样，在确认代码填写正确后，程序就会开始执行代码。如果代码编写符合实际情况，则能够顺利执行。
V8引擎就是完成代码检查和执行的地方，在初始代码经过内置服务库和第三方服务库重新整合代码后，会送入这里执行。在这个过程中，银行会提高填写表单的一些服务，如拍照、信息查询等等这些服务提高用户的办事效率，把用户需要做的一些事情集中了起来。在代码里，这就相当于内置服务库，他把一些功能提前整合好了，用户只需要调用就可以，不需要重新写。此外，类似的还有第三方库，他们也是提供了整合服务，只不过不是由银行或者运行环境提供的， 在银行的开户流程就好像是到房管局查资产证明之类的，而在代码里是通过接口调用来实现的。内置服务库、V8引擎还有提供第三方库构成了完整的JS的运行环境。
编程语言大致上分为两种，一种是编译型语言，这种是先通过编译器将代码编译成可执行的命令，之后送由执行器执行。他们是统一编译之后在执行，所以开发效率低，因为每改动一些代码都需要重新编译。但相对的通过执行器运行的时候就会快很多。而解释性语言是一条一条的进行，编译一条执行一条，所以它的开发效率高，因为每次做了改动，不需要全部代码都进行编译，相对的，运行效率低，因为每运行一条代码都需要编译一次。
从这里可以看出，其实V8引擎做的事情和我们关系不大，我们要做的就是写好代码、用好库。所以学习的方向也是按这个顺序来，基本的先写好基本的代码，之后会使用内置服务库、学会使用第三方库，再之后懂得比较挑选合适的库来最优的完成任务，最后可以自己写开发库、做出以前没有人提供过的功能，再进阶的话就是了解V8引擎的工作原理还有机器码等等。
================================================
FILE: homework/lesson1/haohu.md
================================================
###1. 类比代码执行流程
代码 + 库(内置库&第三方库) -> 运行环境(浏览器 or NodeJS) -> 执行结果
种子 + 养分(水&阳光空气) -> 土壤 -> 大树
###2. 运行环境
可能不准，但能帮助理解：
- 电脑硬件是操作系统的运行环境
- 操作系统是应用软件的运行环境
- EXCEL 是 .xls 的运行环境
- flash player 是 ActionScript 的运行环境
- Adobe Air 也是 ActionScript 的运行环境
- 浏览器 是 JS 的运行环境
- NodeJS 也是 JS 的运行环境
- JVM 是 Java 的运行环境
###3. V8引擎
- Google 出的、高效的JS解释（执行）器
###4. 编译器/解释（执行）器
- 编译器 是翻译，翻译完了之后你去阅读
- 解释器 是口译，一边翻译一边就说出来
###5. 内置库
- JavaScript 的官方库，一般是用以实现普遍性的底层的需求
###6. 第三方库
- 非 JS 官方库，一般是用以实现某垂直、细分领域的需求
###7. 学习JS的方向
- 万向
================================================
FILE: homework/lesson1/hewei.md
================================================
# 第一次作业 - 讲座总结
## 流程优化，事半功倍
徐老师一开始先用`设计银行开户流程`的方式，来**类比代码执行流程**。
笑来老师就说过，一个得体的比喻，可以让人很好地理解一个之前并不了解的概念。
徐老师通过不断地优化银行开户流程，让大家看到了如何改进一个框架的设计，以及因此而带来的效率的提升。
四次的流程优化，将个人和银行（即不同的模块）原本繁琐、重复的任务，进行功能上的不断细分，从而实现更好的模块化——抽离出常用的功能，单独作为内置服务；将预处理和执行模块分离开来，降低耦合；将银行的操作封装成接口，用户只需通过窗口进行输入，然后对窗口的输出进行反馈即可。
> 这只是自己目前对这个流程优化设计的理解，相信经过自己不断的学习，会理解得越来越深刻。就像徐老师说的，做项目不在于多，要在于精。只做一次项目的收获，就能超过别人做好几个项目的收获，这样的项目做得才是最有效果的。
## 运行环境
用一个不是很到位的比喻来说，**运行环境**就相当于饭馆：
浏览器运行环境相当于饭馆的前厅，Node运行环境相当于饭馆的后厨。
前厅和后厨都有必需的基础设施：水、电，等等，这个可以近似地类比为JS运行环境中的V8引擎。
而前厅和后厨还有各自不同的特色设施：前厅的桌椅，餐具区，茶水区等等，后厨则是做饭的各种区域。这两者可类比为浏览器和Node运行环境的内置服务。
第三方库，则是饭馆本职工作之外的服务，比如火锅店提供的美甲服务，就是这种情况。
## V8引擎
V8引擎直接将JavaScript代码编译成机器码——所以不管是前端环境比如Chrome浏览器，还是后端环境如Node.js，都有它在背后默默撑起一片天。
接着用前面饭馆的类比方式：不管是前厅还是后厨，水、电等基础设施都是以相同的方式使用的。不会因为是前厅或者后厨，而有所不同。
## 编译器/解释器
编译器可以类比为中餐的制作过程：我要吃鱼香肉丝，那就需要先备好食材，然后下锅开炒，最后盛到盘子里，供用户享用。
而解释器，可以理解为自助餐：每次只可以要一种食品，吃完了再拿，不能多拿，不能不拿，直到不想吃为止。
## 内置库
内置库可以理解为各种常见需求的便捷实现方式：想要煮个鸡蛋？好，给你个煮蛋器，分分钟煮好鸡蛋。想要让暂时不吃的食物保鲜？好，放进冰箱，用的时候再拿出来。没有这些工具的时候呢？要煮鸡蛋，自己支起一口锅，慢慢烧水，水烧开了把鸡蛋放进去，看着表，时间到了说明应该煮熟了，然后才拿出来，多麻烦啊！
## 第三方库
唔，写到这里了，怎么感觉上面内置库的理解方式不太对？明天再反刍一下。
## 学习JS的方向
学习一门语言，语法、框架还是次要的。更重要的，是学会其背后的思想，学会其解决问题的思想。
就像笑来老师，用计算机的思想来类比实际的生活，非常精彩的类比方式！
除此之外，合理的利用各种服务、资源也是非常重要的。
不管是初创企业，还是自己写代码做一些小东西，合理的节约时间和金钱成本也是很必要的。而且利用现有的成熟的服务，可以让我们把更多的精力放在更重要的事情上——实现自己的想法中的关键部分。
比如想做一个博客，主要目的是分享自己的知识，那么完全靠自己写代码实现博客的前后台功能就不是那么的有必要了。找一个合适的博客程序，自己一边写作一边修改，更符合主要的需求。
解决问题的时候，一定要抓住**最重要的**那个因素，优先去解决。就像做饭，好吃、好看不是最重要的，最重要的，是先把饭做熟！
================================================
FILE: homework/lesson1/huangjiashu.md
================================================
## 写一篇总结
听完课，感受还是颇深的，老师讲的还不错，我觉得最好的就是接待代码如何运作的那个图，就是在ppt中多次提到的那张图。下面试根据老师的提示写的总结
### 类比代码执行流程
老师拿银行开户的流程类比代码执行流程，还是很恰当的。
由简单的 输入 执行 和 输出。扩展到 运行环境，内置服务和第三方库。类比我觉得很好，也很容易理解。
我觉得也没啥问题，但总感觉在开户流程中，任何一个环节出错了，都会反馈到用户。在第三第四次升级中，我似乎并未体看到这一点。这一点应该可以类比为程序中出现的错误处理或者抛出异常吧。
### 运行环境
这里的运行环境，应该就是代码的执行环境。类比人所生活的环境，代码运行也处在一定的环境中的。
老师提到 JavaScript的运行环境有两种，一种是浏览器，一种是node环境。如同人类的生存环境 比如说地球吧，为人类提供光照，食物 和 水等必要的生存条件，JavaScript的运行环境也为JavaScript代码的执行提供必要的条件支持，比如V8引擎，比如内置服务等。
### V8引擎
> V8是一个由美国Google开发的开源JavaScript引擎
> 在运行JavaScript之前，相比其它的JavaScript的引擎转换成字节码或解释执行，V8将其编译成原生机器码（IA-32, x86-64, ARM, or MIPS CPUs），并且使用了如内联缓存（inline caching）等方法来提高性能。
由此可见，V8引擎大大提高了JavaScript代码的执行速度，所为引擎就类比汽车的发动机，V8印象中指的也是发动机（8缸发动机，在汽车运行中可以提供更大动力），估计V8引擎也是这么来的吧。当然只是个人臆测。
### 编译器/解释（执行）器
老师已经讲到，JavaScript是解释型语言，没有明显的编译行为。
而一般的C，C++，Objective-C 等都是编译型语言，其特点是有明显的编译过程。先编译，编译通过后才执行。
而诸如JavaScript解释型语言一般是边编译边执行。
编译器就是将写的代码（通常是高级语言，更接近自然语言）编译成机器能读的懂的机器语言。
> 一个现代的编译器的主要工作流程：源代码 - 预处理 - 编译器 - 目标代码 - 连接器 - 可执行程序。
执行器 就是直接执行编译过的代码文件
### 内置库
内置库 通常都是环境自带的内置服务，提供开发所需的基本功能，包括基本的数据结构，模块，函数等。
### 第三方库
第三方库通常是提供一套接口，供开发者使用，而这些接口通常已经实现了许多功能，只需要开发者简单的配置开发即可实现自己的业务需求，也就是说第三方库的很大一个作用就是提高开发效率。即拿来主义。站在巨人的肩膀上进行开发，相比于自己从头做起，当然是事半功倍。
下面是老师给的建议：
> 第三方库一般是同种语言开发的拓展功能，以满足多样化的需求。 当然不排除会用其他语言开发第三方库，供JS语言编写的代码调用。
比如： 用C 语音写一个高级算法（因为C语言效率更高），然后开放接口给JS调用。那么这个接口要满足JS语言对C语言的调用规范。
即：两种不同语言之间的调用，要满足一定的规范。这种规范一般只要这两种语言相互认可即可。
Python和C之间的调用又会有他们自己的规范。
在大多数情况下，JS不太会用到其他语言的开放库。在学习过程中只聚焦在JS的第三方库即可！
### 学习JS的方向
想作为一个开发人员，有时候单一的了解前端或者后端是远远不够的，我学习的JS方向是希望既了解前端又了解后端。
并能独立完成开发简单的开发任务。
================================================
FILE: homework/lesson1/huangqi.md
================================================
## 总结 ##
**2017年8月8日**我跟随老师学习了JavaScript的第一节课，认识了几个概念：“JavaScript的运行环境、V8引擎、编译器、执行器、内置库、第三方库” ，还有一个类比代码执行流程，也打开了我从JavaScript的小小白走向JavaScript菜鸟的大门。
**代码执行流程**
老师生动的用了一个银行开户的类比，让我们知道了代码的执行流程，类比中，我们编写的代码就是一个开户申请单，我们把这个申请单（代码）交给银行（运行环境），银行（运行环境）方面就对这个申请单检查（编译器编译）和执行（执行器），最后返还结果给我们。
**运行环境**
运行环境，就是一个能够使代码调用内置服务的一个环境，里面包含了两个小运行环境；一个是浏览器运行环境，另外一个就是nodejs运行环境。
**V8引擎**
对我们的代码进行预处理和执行的一个黑盒子。
**编译器/解释（执行）器**
一个对我们编写的代码进行翻译的工具，执行器就是对编译器解释完的代码进行执行。
**内置库**
一个支撑各自的业务而设定的库，而且必不可少的。
**第三方库**
支持我们把业务做得更好，更漂亮的库。
**学习JS的方向**
紧跟老师的步伐，和研究JavaScript权威指南，掌握JS编程语言，并用编程的方式调用服务来完成自己的需求。
================================================
FILE: homework/lesson1/huangxiaohui.md
================================================
javascript第一节课总结
1.1.类比代码执行流程
以银行开户流程为例，将优化后银行开户流程——分为普通用户和VIN用户两大业务模块，类比JS的浏览器和NodeJS这两种运行环境下，代码调用内
置库进行进行编写完成后输入到运行环境进行编译后，再输出到CPU进行执行的流程。
2.运行环境
相对JS来说，由内置库和V8引擎等模块组成的浏览器和Node运行环境
3.V8引擎
对代码编译后，并执行代码的核心
4.编译器/解释（执行）器
V8引擎中对代码进行编译和执行的一个模块
5.内置库
由浏览器和Node内置提供给编写代码的一些功能
6.第三方库
由浏览器和Node两个运行环境以外的第三方提供编写代码的附加功能
7、学习JS的方向
掌握以老师教的ES6编程语言
================================================
FILE: homework/lesson1/huangzhihua.md
================================================
# JavaScript 第一课作业 总结——黄志华
运用下面这些关键词，把你知道的写出来。
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
1，代码的执行过程，就像是银行开户流程一样：
a，首先需要一个运行环境“银行营业厅”。（比如node）
b，然后用户通过“填写表单等方式”，输入（提交）信息。
c，客户的“表格”通过“窗口”传递到“业务员”进行审查，如果不通过着“驳回”。（编译器）
d，当“业务员”审查你的表格没有问题，就会帮你进行业务办理操作（解释器／执行）。
e，“业务员”办理完业务之后，就会返回一个结果给客户——“您的业务已办理完毕”。
2，Node是JavaScript的运行环境，浏览器也是JavaScript的运行环境。
一个程序要跑起来，就必须有一个运行环境，相当于一个基础设施，比如说我想要游泳，那么就必须到一个有足够深的水池里进行游泳。
又比如说声音的传播需要介质，在真空中就缺乏这样的”运行环境“，所以真空中无法传递声音。
3，V8引擎：
相当于把一系列复杂的“编译器/解释（执行）器”都打包成一个黑匣子。
这样在编写代码的时候，就会简单很多，这相当于把一些繁琐重复的工作，交给了程序进行内置处理，极大的提高了编程效率。
4，内置库与第三方库：
内置库就是“原生应用app”，自带的一些基础功能库，只保留最重要的部分，这样有利于代码运行的速度与兼容性。
第三方库，在内置库的基础上写代码，有时候会遇到一些特别需求，这时候引入相关的第三方库就可以让代码流程得到极大的简化，有利于编写难度降低。
第三方库的调用，有时候会发现，库中有库，第三方库自己也调用了部分第三方库。这带来一种特别的优势，那就是别人做的很好的事情，比如某一种函数的编写，我们直接调用就可以了，不需要重新再编写一遍，我只需要做我最擅长的与最重要的事情就可以了。
5，学习JS的方向：
我的主要目的是为了可以独立编写一些小程序，比如说微信的小程序，或者是某种轻量的app。
我的英语几乎是零基础，所以也想借编程的这个机会，去实际运用英语，这样最起码我可以有一个比较特别运用英语的环境，为我之后补英语打一个基础。
学习JS未来不一定是一个专业的程序员，但我懂得一点编程技术，可以让我在很多领域里有一个特色技能，并且编程思维是一种非常好的思维锻炼方式，这可以与我的其他能力产生复合效果。
================================================
FILE: homework/lesson1/huxiaodan.md
================================================
## 1.类比代码执行流程
类比银行开户流程。用户向银行开户环境提交申请，银行通过内置服务、预处理和执行后，将结果反馈给用户。
## 2. 运行环境
运行环境提供集预处理、执行于一体的核心业务处理单元，同时还提供内置服务方面用户的业务办理。
JS运行环境有浏览器运行环境和Node运行环境。
## 3. V8引擎
V8引擎是指对代码进行预处理和执行。
## 4. 编译器/解释（执行）器
编译器对代码进行词法、语法和语义的分析，以及优化代码。
解释（执行）器对代码进行解释和执行。
## 5. 内置库
内置库是一组内部服务。
浏览器的内置库有JS内置对象、WebAPI、WebGL、HTTP、WebRTC、canvas等。
Node的内置库有JS内置对象、Node API等。
## 6. 第三方库
第三方库是由其他机构或个人编写的，有助于开发的服务。
浏览器的第三方库有jQuery、Vue、AngularJS、React等。
Node的第三方库有Express、Koa、Webpack、Promise等。
## 7. 学习JS的方向
学习JS，前端和后端都可以完成。要了解自己学习的语言，熟练掌握内置库和第三方库，用最恰当的服务实现业务。
================================================
FILE: homework/lesson1/huyong.md
================================================
编程第一课总结
#内容分为三个部分
##第一部分是对与之前预习作业的回顾，点出了大家在写代码的时候常犯的一些错误，比如写代码的时候，
需要用全英文的书写格式，尤其是像引号顿号等的使用
##第二部分是代码学习的引导和未来的路如何走，开头给了我们一个整个编程学习的准则就是”干“，
然后通过银行的开户流程类比来代码输入得到结果，给出了运行环境：包括浏览器和nd.js的运行环境，
环境，在介绍这俩个环境的时候给出了编译器和解释器，对于环境我们就可以看待成一个黑盒，
不用管他如何执行，我们只需要写出正确的代码，然后检验自己的代码，然后通过内置服务的区别
讲解了浏览器和nd的区别，同样的代码在不同的环境下是得出不同的结果的，无论是浏览器和nd
都有着js内置库，然后给出了第三方库的解释，最后进行了演示。
##第三部分，我们学习编程之后的路该 如何走，分为三步走，第一步学习，掌握编程语言，用编程
方式调用服务来完成你的需求，第二步提高，了解和掌握重要的服务能力，使其能服务你的业务：
需要对内置库和第三方库有一个深入的了解，第三步进阶，善于比较
服务/技术之间的差异性，用最好的方式实现你的业务，就是比较各种库的差异性，选出最适合你业务的库，
================================================
FILE: homework/lesson1/ianyang.md
================================================
【第一次作业】写一篇总结
1. 类比代码执行流程
老师以银行开户流程为类比，也可套用其他服务型行业的标准流程，比如物流、零售。这个类比让我认识到，从输入代码到编译执行到输出结果，不仅是商业社会的具体运作方式，也可类比人与人的沟通模式，难怪有“人机对话”这样的比喻。
2. 运行环境
JAVA的运行环境便是指一套完整服务方案的构成要素，它们相互之间有序列也有逻辑和因果关系。其中第三方服务类比的代码库非常关键，这位整个代码进入应用实现了无边无际的拓展性。
而运行环境必须分清是在浏览器环境还是Node环境下，因对应的内置库是独立的。
3. V8引擎
便是业务核心，我的理解，也就是最终要实现的功能。
4. 编译器/解释（执行）器
指C++这类更底层的语言通过编译器与执行器的分离，实现了高运行效率但影响开发效率；解释器则反之；
Java语言是通过混合了编译器与解释器来执行代码，这样一个黑盒子究竟如何解释语言不重要，重要的是理解它会如何执行出我们想要的结果，即实现功能。
5. 内置库
内置库是指在不同的运行环境下所内置的不同的可调用实现对应功能的现有代码库（不知这么理解对不对？）
6. 第三方库
第三方库一直会有更新，是开源代码工作者们的集体智慧和贡献（对吗？），而熟悉某一个第三方库能大大帮助我们根据需要实现的功能来选择最合适的库。
7. 学习JS的方向
不需要追求新版本；动手干，边写边练，实践是王道。
================================================
FILE: homework/lesson1/jaychen.md
================================================
# HW1 Lesson1总结
## 1. 类比代码执行流程
老师用银行户流程的类比让我瞬间明白了代码执行流程，开场非常精彩！我们输入代码后，调用了内置服务和第三方库对代码进行处理，再把结果喂给核心业务，核心业务类似于黑盒对代码进行预处理执行，相当于银行开户业务中的预处理和审批流程，最终将结果输出。
## 2. 运行环境
运行环境是为了保障相应业务的运行而所需要的必要资源，不同业务有不同的需求，所以他们的运行环境是截然不同的。针对不同的业务对象，要明确他们环境的差异。
## 3. V8引擎
V8引擎像一个黑盒子，对输入的代码进行预处理和执行（编译器／解释器），在初学阶段，没有必要对V8引擎过多在意。JS的前端和服务器端开发环境，都由V8引擎进行核心业务处理。
## 4. 编译器／解释（执行）器
经过编译器编译（相当于银行开户中的预处理）的代码，进入解释器（相当于银行开户重的执行），成为机器可以识别处理的code。有些语言把编译和执行分为明显的两个阶段（如C、C++），这样执行很有效率，但不利于程序员写代码；有些语言把输入的代码直接一条条完成编译和执行的整个过程（JS），这样开发很有效率，但不利于执行。两种处理方式在使用时各有利弊。
## 5. 内置库
内置库是为了运行相关程序而预先设置好的可以方便进行各种调用的各种模版框架。
## 6. 第三方库
第三方库是对内置库的补充，是由第三方提供的为了方便程序员对功能实现而能随时调用的框架。
## 7. 学习JS的方向
要想在JS的学习上持续精进，需要在学习了基础知识和熟悉了各种库的调用后，能够体会掌握各种不同的库在使用方面的细微差别，才能更灵活地使用合适的库进行开发，成为一名高手。
================================================
FILE: homework/lesson1/jianglin.md
================================================
1. 类比代码执行流程：代码执行流程就像银行开户，要先确认信息准确（编译）再进行开户操作（执行），对于JavaScript，是边编译边执行，易开发难执行；对于C/C++，是先编译后执行，难开发易执行。
2. 运行环境：运行环境是代码的环境，有各种服务，就像我们生活的环境，也可以区分成各种服务。这个概念要在编程中进一步理解。
3. V8引擎：V8引擎是运行环境的一部分，是用来执行代码的。
4. 编译器/解释（执行）器 ：编译器+解释（执行）器是V8引擎的两个功能，具体的原理现在不了解。
5. 内置库：运行环境本身提供的服务。
6. 第三方库：第三方公司等提供的数量庞大的库，可供使用。
7. 学习JS的方向：关于编程，上学时接触过C++和汇编，毕业后再没有过应用。这次学习JavaScript是当做小白学习，一定要专注，专注于老师的任务，网络的内容偶尔可以看看，切勿沉迷于最新的库/信息等。就像上学时学习制图，最重要的是如何制图的原理，而不是纠结于用什么软件来画图，所以初学的时候，图板和CAD04才是最好的朋友。在有一定基础之后，再研究其他的库和已经学习的库有什么区别，逐步掌握更广泛更深入的应用。
================================================
FILE: homework/lesson1/langjianjun.md
================================================
第一节课总结
1. 类比代码执行流程
用人去饭店吃饭做类比：饭店类似于软件的运行环境，客人从菜谱上点菜相当于输入某些指令，自动化的点菜系统类似于V8引擎，而厨师则是编译器/解释器，根据菜单做菜相当于执行一系列的程序包，这些程序包属于内置库的一部分，一些秘制的作料或半成品等属于另一部分的内置库；有些酒水菜品等是外购的，相当于第三方库。最终端到客人面前的饭菜是输出。我知道这个类比很粗糙，但要从日常生活中找出一个和程序执行高度相仿的例子来做类比好像也不是很容易。
2. 运行环境
JS的运行环境有浏览器和Node。我去年年底自学JS时只知道有浏览器，Node对我来说是一个完全陌生的环境。
3. V8引擎
JS的引擎，google研发的，最早用于chrome浏览器上，功能强大，号称使JS的运行速度堪比二进制代码。可以独立运行，也可嵌入任何C++程序中。
4. 编译器/解释（执行）器
机器只能识别二进制语言，而人类适合操作的还是类似自然语言的编程语言。因此需要有执行将编程语言转化成二进制语言的工具，这就是编译器或解释器。这转化又有两种方式，一种是高级语言，可执行程序是将源程序编译后形成的，有点精加工食品的感觉，你无法从蛋糕中看出原材料的样子；另一种是脚本语言，就是JS这种的，代码是一行一行边解释边执行的，不会转换成人类无法识别的可执行程序，就像煮玉米或者烤串，你能看懂原料是什么。
5. 内置库
预先编辑好的执行特定功能的模块，因为是随着运行环境提供的，所以叫内置库。
6. 第三方库
由第三方提供的某些特殊模块。
7. 学习JS的方向
想提高自己的自由度和解决问题的能力吧，也想看看40多岁的人能玩会哪些新东西。
================================================
FILE: homework/lesson1/leizhen.md
================================================
用银行开户流程类比代码执行过程，通过细分项目和需求，一步一步优化流程，来完成一个完整的框架结构。
我用炒菜的过程来说明我对几个概念的理解（我想了很久，但还是不够贴切）
厨房是一个大的集合：【锅， 燃气灶， 调味料， 食材， 道具， 砧板， etc 】
运行环境：最大的载体，这是最基本的工具。做不同的菜就要用不同的锅一样。煎东西要用平底锅，炒菜的话，就用最平常的大锅子。浏览器运行环境和NodeJS运行环境我觉得和这个比喻类似。
V8引擎：核心部件。类比燃气灶上要点火一样，对食物进行加热（这是核心工具）
内置库：一开始就包含的最基本的东西，管你用不用都在那里。比如：调味料。做菜就是为了好吃啊，为了追求菜的原汁原味，也可以不用的
第三方库：不是必需的，但有的话会很方便。做菜有火就行了，但以前的烧柴火做菜，和现在的天然气做菜。肯定是现在更方便啊！
编译器/解释器：切菜和炒菜的过程就像编译器，炒菜的过程就像解释器。先把一个食材处理好，才好进行下一步的炒菜。而炒菜的过程就简单多了，直接炒就好了，不用处理食材。JS像炒菜的过程，没有切菜直接丢进锅里，当然开发效率高，运行效率低了嘛。
学习JS的方向：我觉得就和做新菜一样。在了解的基本的炒菜过程后（基础），就去多看看别人的菜谱，把菜fork到自己的锅里，自己试一试，味道做得不错了，就可以按照当地人的口味自己进行魔改了。该多了就会对味道有了更深入的了解了。JS也应该差不多，多看看别人的项目，copy／paste 没有提高的。
================================================
FILE: homework/lesson1/lichen.md
================================================
# 总结
### 一、引言
#### 1、运用类比：设计一个银行开户流程
#### 2、流程优化的演进
#### 3、开户流程总结
-
### 二、JavaScript是什么？
### 1、运行环境
#### 类比
### 2、概念
##### （附注：V8引擎是用来处理代码的）
### 3、运行演示
#### 调用inspect
#### 警告实验
#### 4-1、JavaScript该怎么学
#### 4-2、该怎么提高
#### 4-3、该怎么进阶
##### （附注：我们不要由软件的变化去变化）
##### （附注：由js语言创造出来的语言有上百种）
### 三、总结
##### 【注意】
##### ES是JS编程语言的规范
##### 运行环境包含V8引擎，同时提供内部内置服务
##### Node是运行环境
### 四、代码演进
================================================
FILE: homework/lesson1/linchunlong.md
================================================
运用下面这些关键词，把知道的写出来：
<p>1. 类比代码执行流程
<p>2. 运行环境
<p>3. V8引擎
<p>4. 编译器/解释（执行）器
<p>5. 内置库
<p>6. 第三方库
<p>7. 学习JS的方向
**<p>我的总结是：**<p>
1. 在银行办理开户的流程类比代码执行流程，开户流程有两个主体：个人、银行。个人相当于用户请求服务，银行相当于数据处理的业务环境。用户请出服务请求后，银行根据用户提供的数据，在业务环境中进行处理，并向用户返回处理结果。
<p>2. JS运行环境框架，包括JS运行环境（浏览器运行环境和nodejs环境）、第三方库、JS代码。JS代码，需要放在JS代码的运行环境中执行。
<p>3. V8引擎，内置在JS浏览器运行环境和nodejs运行环境中的处理器。
<p>4. 编译型语言的代码有一个专门的编译过程，可以直接被机器读取语并执行，编译是指人把“人话”编译成“机器语言”，C+、basic、pascal都是这类语言。解释型语言的源代码不是机器语言，是“人话”，所以需要通过解释器翻译成机器语言，才能被机器执行；<p>结果就是编译型的“机器语言”被机器执行的结果快，对人技能要求是懂机器语言，解释型语言的“人话”优点就是不需要太懂机器，说人话就可以做出来程序，正因为需要中间的翻译过程，导致机器计算结果相对慢一些。
<p>5.内置库存在于JS在浏览器和NODEJS运行环境中，包含了JS代码执行时需要调用到的资源。如果JS是胎儿的话，羊水就是内置库，专门提供JS需要的东西。
<p>6.第三方库和内置库共同构成JS的运行环境，JS偶尔会用到外界的资源处理数据，这个外界的资源就叫做第三方库。胎儿光有羊水还不行，也需要母亲吃食物，食物就是JS的第三方库。（我自己大致这样容易理解）
<p>7.学习JS的方向，增加思考问题的方式，通过JS代码编写过程，渐渐理解需要解决的问题的本质，达到满足某种需求。JS不是为了学而学，写出来的代码要能解决实质的问题。如果JS不能做到就要换其他方式，JS毕竟不是万能的。<p>
<p>了解到JS的局限性在哪里，哪些问题是它能解决的。
================================================
FILE: homework/lesson1/lingxiao.md
================================================
# JavaScript第一次作业
## 前言
2017年8月8日徐高阳老师《JavaScript编程入门》第一次作业。
[TOC]
## 作业
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
## 解答
### 1. 类比代码执行流程
| 银行开户 | JS代码执行 |
| :--------------------------------------- | :--------------------------------------- |
|  |  |
| **开户环境：** 提供包含接受申请、检验申请单信息和核对资格的服务。<br>**内置服务：** 为满足用户填写订单时提供的一组内部服务。<br>**核心：** 涵盖预处理和执行。其中预处理执行开户前进行信息检查的处理过程；执行是执行开户操作的过程，操作完成后返回想要的开户结果。<br>**第三方服务：** 围绕开户业务的第三方服务以满足用户需求 | **JS运行架构同银行开户过程完全相同：**<br>1 两类运行环境类比于普通用户和VIP用户环境；<br>2 V8引擎类比于业务核心；<br>3 两者都有内置服务，各自支撑业务需求。<br>4 围绕两个运行环境，有第三方库供调用。 |
### 2. 运行环境
JavaScript脚本的运行环境有两种：**浏览器环境**和**Node.js环境**。
| 浏览器运行环境 | Node.js运行环境 |
| :--------------------------------------: | :--------------------------------------: |
|  |  |
1. JavaScript被定义为浏览器的脚本语言，其[设计的初衷](https://mp.weixin.qq.com/s?__biz=MzAxOTc0NzExNg==&mid=2665513059&idx=1&sn=a2eaf97d9e3000d15a33681d1b720463#rd)是一些本来就应该在浏览器中完成的任务，做一些浏览器与用户的交互和一些网页的特效来补充HTML和CSS的不足。
2. node.js诞生于2009年，是使得JavaScript可以运行在服务器端的运行环境，用于方便地搭建响应速度快、易于拓展的网络应用。
### 3. V8引擎
JavaScript解析引擎就是能够“读懂”JavaScript代码，并准确地给出代码运行结果的一段程序。比方说，当你写了 $var a = 1 + 1; $这样一段代码，JavaScript引擎做的事情就是看懂（解析）你这段代码，并且将a的值变为2。[^1]
V8引擎是Google Chrome浏览器内置的JavaScript脚本引擎，其设计以高效地执行大型的JavaScript应用程序为目的。Chrome仅使用V8的API，其引擎的内核部分独立于浏览器之外。V8引擎用来编译和执行JavaScript源代码，其将JavaScript源代码直接编译成机器码运行。[^2]
### 4. 编译器/解释（执行）器
| 编译型语言 | 解释性语言 |
| :--------------------------------------- | :--------------------------------------- |
|  |  |
| 对于静态语言来说（如Java、C++、C），处理上述代码的叫编译器（Compiler）。<br>需要一个专门的编译过程，通过编译器编译成机器语言。 | 于JavaScript这样的动态语言则叫解释器（Interpreter）。<br>**解释器是直接解析并将代码运行结果输出**，边翻译边执行。 |
### 5. 内置库
由两种运行环境提供的服务，用来实现代码功能。就像在中国用人民币，可以直接用。
[JS标准库的部分内置对象的常用属性和方法](https://segmentfault.com/a/1190000004954578)
### 6. 第三方库
由第三方公司或个人提供一套接口，供开发者使用，以实现代码功能。就像是在中国用外币，需要兑换后使用。
### 7. 学习JS的方向
做好笔记，做好课后补充，不怕丢脸多提问题，多操作时间，下足功夫，用心钻研，拥抱JS的美好。Ps: 当我还在困惑于zotero的文献导出怎么设置的时候，在简书上看到一位仁兄2015年的文章，人家已经在github对两个我都不知道怎么用的插件进行修改了，说着一大堆我不懂的术语，于其中看到一个熟悉的字眼，JavaScript，文中说zotero的插件是Js脚本...这刺激我另一次关于编程学习的思考。那我学习编程的目的是什么？就是为了完成私人订制，定制适用于我的代码，让我的生活越来越美好。
[^1]: http://www.cnblogs.com/mrxiaohe/p/5072034.html
[^2]: http://www.nowamagic.net/librarys/veda/detail/1579
================================================
FILE: homework/lesson1/linxiyao.md
================================================
8月8日第一节课，听完感觉秒懂，到做作业写总结却有点傻眼，看来感觉靠不住，于是听了一遍回放，试试用自己有限的理解来描述。
代码执行流程类似于写说明文的过程：代码就像各种特定素材，先输入到大脑，经过大脑这个黑盒进行梳理、阐释（编译、解析），最后输出文章（结果）。两者都有一定的格式，运用（运行）得当时都可以输出稳定且通用的结果，便于交流。
运行环境，是供代码调用、支持代码起作用的的特定环境。JS运行环境有浏览器运行环境、node运行环境。运行环境类似于作者写作时所处的环境总和，比如可以是书房（包括笔记本，书桌椅，大脑等），也可以是卧室（包括笔记本，床，大脑等）。
JS运行环境包含内置库和V8引擎，内置库类似于作者头脑中已有的稳固知识，V8引擎相当于思考，可以调动已知库。第三方库就像Google、wiki、图书馆等，延伸了已知，提供了协作，也减轻了存储负担。而大脑就像解释器吧，你输入红橙黄绿青蓝紫，它返你一个彩色的世界。我不是色盲，我想用JS的大脑看世界。
================================================
FILE: homework/lesson1/lipeng.md
================================================
#### 【第一次作业】写一篇总结
1
**类比代码执行流程**
用户在银行开户的过程，就是代码的执行过程。
这个类比引出了JS运行环境框架，无论是浏览器的环境，还是NodeJS的环境，都包括 业务核心和内置服务。
写JS代码就是，面向运行环境和第三方库，进行编程。
2
**运行环境**
js代码的运行环境，相当于婴儿生活的环境，或者新学生生存的环境，分为浏览器运行环境和 NodeJS运行环境。
浏览器运行环境和NodeJS运行环境，包含了v8引擎，和内置库。
第3方库，不属于运行环境。
3
**V8引擎**
负责JS代码的解释和执行。相当于银行执行开户命令的部门。
4
**编译器/解释（执行）器**
从编译角度区分，这是两类语言。JavaScript属于 解释类的语言，特点是编程效率高。
5
**内置库**
这是JavaScript 自己带的库，分浏览器环境和NodeJS环境。
浏览器的内置库，包括网络库、日志库、JS内置对象、...
NodeJS的内置库包括 JS内置对象，Node API。
6
**第三方库**
第三方提供的，实现一些功能的库。浏览器和NodeJS的对应的第三方库不同。
7
**学习JS的方向**
三个步骤：
> 学会 JavaScript的语法，熟悉 内置库和第三方库
> 用上述技术实现业务需求
> 了解第三方库的优缺点，能找到最合适的解决方案
让我惊讶的地方是，JS竟然是无边际的，竟然有100多种语言 base 在javaScript上。
还是老师的概括更准确：
掌握编程语言，用编程方式**调用**服务来完成你的需求。
了解和掌握**重要的服务**能力，使其能服务你的业务。
善于**比较服务**/技术之间的差异性，用最好的方式实现你的业务。
换一个角度，第1步知道怎么用，第2步知道用什么(重要)，第3步 知道用什么最好。
================================================
FILE: homework/lesson1/lipengyu.md
================================================
## 第一次上课总结
本次课程以银行开户流程为例子，由银行的业务架构引出JS的**运行环境**框架，生动易于理解。
### JS运行环境
1. 浏览器运行环境
* V8引擎
* 内置库
2. Nodejs运行环境
* V8引擎
* 内置库
一句话：运行环境包含了**V8引擎**和**内置库**。其中，V8引擎可以理解为一个可以执行代码的黑盒子，内置库就是我们写代码时可以调用的内置服务。
另外，因为内置库的数量和种类有限，这时就要用到功能更加丰富的**第三方库**。
### 两种语言类型
1. 编译型语言
2. 解释型语言
刚开始的开户流程也是**类比代码的执行流程**。
编译型语言代码执行流程大致是：代码--编译器（负责分析词法／语法／语义等）---编译好的代码---执行器（负责解释代码／执行代码）---输出结果。
这种语言的特点是：代码执行考虑高，但是开发效率低。
解释性语言（比如JavaScript）是代码直接到**编译器／解释器**---输出结果，代码执行效率低，但是开发效率高。
### 学习JS的方向
认真和专注。
================================================
FILE: homework/lesson1/litao.md
================================================
第一次课听下来，由于老师用生活中常见的事物进行类比，讲的通俗易懂，使得这些抽象的概念比较容易理解。尽管如此，还是又听了一次回放，才感觉不那么晦涩了。
反而是课前的预习作业，对git工具和GitHub社区的陌生，让我反反复复地阅读老师的操作说明，一次次地练习，慢慢建立起相互之间的逻辑关系，熟悉操作指令，理解每一个步骤的作用，才能将完成的作业提交给老师。
今天再次打开github，发现我之前的作业根本没有提交成功，而且都没有了，就重新再写一次吧。
运行环境：打个比方说就是适应不同人的生活工作学习的环境。而对于编程来说，就是让这个程序语言能够运行的环境，在这个特定的环境下，这个语言才能发挥出作用。对于javascript来说，就是浏览器和node，分别是前端和后端的运行环境。
v8引擎：就好比汽车发动机的核心部位，在这里进行代码的编译和解析。
编译器／解释（执行）器：那就是汽车的发动机了，直接将输入的代码进行编译和解析。
内置库：类似于银行开户时提供的内置服务体系。
第三方库：围绕JS语言开发所提供的许多外围的服务。
学习JS的方向：基础太薄弱，每走一步都要理解补充很多想不到的概念。总算知道了git是一个工具，GitHub是一个开源社区，可以使用git这个工具将GitHub与个人电脑关联起来，进行各种操作，在GitHub上创建保存各种项目，并可以让全世界的软件人员直接在上面进行添加修改，我想GitHub的储存功能应该类似于一个服务器了。而在它上面进行的添加修改的功能则属于GitHub独有的创新了。
这只是我到现在的一些认识，随着课程的推进，会随时刷新改变我的很多认知。
我目前唯一要做的：跟着老师的安排，一步步跟上，完成作业。多阅读理解操作说明，多进行实际操练。
================================================
FILE: homework/lesson1/liujuanjuan1984.md
================================================
## 听新生大学CTO讲JavaScript编程入门-1
by 刘娟娟 2017-08-17
第一课，是切换认识世界的视角，从现实世界切换到编程世界。
用**类比**的方式，来学习新知识，新知识显得那么亲切。_不愧是李笑来老师的新生大学，连CTO都非常热爱类比，并运用的太棒了。_
老师带领我们用银行开户这个类比，来理解编程世界。
我们**去银行开户**，是我们的目的。
我们需要向银行提交资料，拿到卡或者获得不能办卡的理由。这里有一个业务交互的**流程**。
资料是我们向银行提交的数据，拿到卡或者获得不能办卡的理由是银行返回给我们的结果，这个结果也是一种数据。万物皆**数据**。
我们编写代码，正是为了处理数据，获得结果。这是我们目的，有它的业务流程，有它的数据交互。而它们所发生的**环境**，即运行环境。
运行环境，是我们提交代码、运行代码、输出结果所在的环境，有内置服务、解释器和编译器。我们重点要关心服务，解释器和编译器不是我们关心的范畴。_此时A8引擎默默哭晕在厕所。_
编写代码的环境，是**编辑器**。编辑器太多了，每个人都有自己的心头好。比如我曾经爱用notepad++，这次吃了utf-8的亏，按老师建议换成了vscode。
既然说，要重点关心**服务**，那么什么是服务？
就像去了银行，有免费的饮用水、复印机、沙发、大堂经理解释引导之类，帮助我们获得更好的用户体验，在代码的运行环境里，也有各种服务，帮助我们更好的编写代码、处理代码。
记住，服务既有运行环境内置的服务，也有第三方提供的丰富服务。而服务总归是服务，良莠不齐，帮助我们达成目的，但很显然并不是我们的目的。
银行向客户提供了普通用户、VIP客户等不同的服务，或者说，个人业务、公司业务、理财业务等等不同的服务，编程世界也类似。具体如JavaScript，我们这次要学的就有浏览器、node这两个运行环境。
银行在处理开户流程上也有不同的演变，就如同编程语言也有不同的演变。但这不重要，因为我们要学的是JavaScript入门课程。
老师向我们洗脑了3个重要的心法：
第一条，老夫写代码就一把梭子，复制粘贴，**开干**就是！
第二条，把注意力放在最重要的点上，什么是最重要的点？跟着老师的课**划重点**！
第三条，学会老师的**编程思想**，跟着老师引导认真走一遭，而不是东搞西搞花里胡哨。
记住，从零入门，你可以的，我也可以的。老师把自己的底线拉的特别低，并且总是会回答任何小白的问题。_令人震惊的耐心，老师为什么如此做，你和我一样一定也很好奇对吧？_
第一次课程要点：
1、类比代码执行流程 _用银行开户流程这个类比，来理解代码的执行流程_
2、运行环境 _JavaScript的运行环境这次课程学浏览器、node两个，分别对应前端、后端_
3、V8引擎 _忘掉它吧，它但重要但默默无闻，不用关心它是怎么做的，它总是在那儿_
4、编译器/解释（执行）器 _JavaScript是解释型语言，编译器与解释器都已经被封装起来了，就是A8引擎内部的结构_
5、内置库 _运行环境中内置的服务，这些服务打包起来，就是一个一个的库_
6、第三方库 _运行环境之外，由第三方提供的服务_
7、学习JS的方向 _不用怕，跟着老师学，老师教思想、划重点，我们撸起袖子开干_
小结一下，今天记住银行开户流程图，就能理解编程世界的运行环境。
至于怎么学习JavaScript呢，在短短的一个半月12节课程，尽可能多的投入，老实领悟和按老师划的重点去学就好了。
================================================
FILE: homework/lesson1/liujun-sh.md
================================================
# 第一课总结
## 1.类比代码执行流程
代码的执行流程就好比我们去银行办理银行卡，首先你需要填写表格（编写代码），当你在填写表格的时候发现需要打印身份证（打印机就好比内置库，你调用了打印机可以打印图片的功能），如果你还需要办理贷款业务，你需要证明机构用来证明自己有还款能力（证明机构就好比第三方库，可用用它出具的证明才说明自己有能力还款），表格填好后递交给大厅工作人员，大厅工作人员检查申请表格填写是否正确规范（这个过程就是一个预处理的过程），检查没有问题后转交给了窗口工作人员，由窗口工作人员进行征信及资格等校验（这一步就是执行的过程），校验完之后通过发卡/不通过驳回并告知为何不通过（代码输出成功/错误并显示错误信息）。
## 2.运行环境
JS本身就是一个运行环境，在其内部又分为浏览器运行环境和Nodejs运行环境，运行环境是用来处理和执行代码并输出结果。
## 3.V8引擎
V8引擎用来提高代码运行效率、运行速度
## 4.编译器/解释（执行）器
编译器用来分析词法、语法、语义、优化代码
解释器用来解释代码、执行代码
## 5.内置库
编程语言本身自带的工具，可以直接拿来使用。
## 6.第三方库
外部机构提供的工具，使用的时候，需要先导入进来，才能使用。
## 7.学习JS的方向
学习编程语言，使用编程调用服务来解决自己的个人需求或工作需求。
面对问题选择效率最高的工具来解决自己的需求。
================================================
FILE: homework/lesson1/liujun.md
================================================
JavaScript第一课课后总结
1.类比代码执行流程
用银行开户的的流程类比代码执行的流程。用户类比代码，银行类比运行环境，开户流程中的审查、执行类比代码执行中的内置库和V8引擎。
再通过定义板块，环境、内置服务、业务核心、第三方服务。使得与编程流程达到逻辑一目了然。总体上理解了编程的实现过程。
2.运行环境
有web运行环境和Node运行环境二种。前端开发用浏览器运行环境，后端开发用node运行环境。
3、V8引擎
V8引擎就是运行代码的。
4、编译器/执行器
编译器：1.分析词法 2.分析语法 3.分析语义 4.优化代码
执行器：1.解释代码 2.执行代码
5、内置库
是运行环境提供的一组服务，有利于我们更好的实现代码功能。
6、第三方库
由第三方提供的各种各样的服务，更好地促进我们的代码功能的实现。
7、学习JS的方向
小白阶段
谨记“掌握编程语言，用编程方式调用服务来完成你的需求。”
提高阶段
“了解和掌握重要的服务能力，使其能服务你的业务。”
进阶阶段
“善于比较服务/技术之间的差异性，用最好的方式实现你的业务。”
================================================
FILE: homework/lesson1/liuliyuan.md
================================================
# 第一节 JavaScript编程入门 课程总结
###一、关键词
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
###二、课程总结
以在银行开户类比代码流程开始课程：
开户流程：我们将申请递交给窗口，然后得到我们的银行卡；
代码流程：我们将代码输入运行环境，然后得到我们的结果。
在这个过程中，窗口和运行环境对于我们就是**编译/解释（执行）器**，我们不需要知道其中的原理，只要其可以输出我们想要的结果即可。
但由于流程太过简化，所有工作由一个人或者单单引擎完成的话，会导致速度缓慢，不利于用户体验，所以通过对其流程不断优化，最终达到：
- 客户的友好性：第三方服务搞定复印等业务；然后客户在业务窗口会得到满足用户填写订单时提供的一组内部服务，也就是直接跟你交流的业务员的服务；
- 分工明确：分管不同类型客户的窗口，比如普通用户窗口和VIP用户窗口；每个窗口内部分工明确，有帮助你填写订单的业务员（内置服务）和资料审核人员（业务核心）
**类比代码执行流程**，也就得出了JS的运行环境：
- 用户的友好性：用户只需要敲入代码调用内置库、第三方库进行输入即可；
- **运行环境**：运行环境分为浏览器运行环境和nodejs运行环境；各个运行环境中又都有内置库和V8引擎。
**V8引擎**：进行代码预处理以及执行，就像我们在办理银行业务时只跟坐在窗口的业务员打交道，而不跟后方核审资料的人打交道一样，我们在用JS的时候，也只是用代码调用内置库和第三方库进行输入，而不用知道V8引擎怎么工作；
**内置库**：不同运行环境的内置库不尽相同，但浏览器和nodejs的相同内置库是JS内置对象；
**第三方库**：由其他公司或者开源形成的对于我们完成工作有帮助的服务库。
在基本了解了JS这种解释性语言后，针对这种语言的特性，得出自己的**JS学习方向**：
- 个人情况：自己是小白，对于编程了解甚少,需要从最基本的学起。
- 学习流程：
>1、基本了解JS语言与其他语言的相同及不同
>2、尽快熟悉JS语言中基本的命令，能够较熟练
>3、了解内置库和第三方库
当然这些是基于现在的知识所订出的流程。之后跟上老师课程，及时发现自己的不足并加以改正，希望能在课程结束后有完整的提高计划。
================================================
FILE: homework/lesson1/liuqing.md
================================================
# 第一次课程总结
在完成徐老师布置的课前预习作业时，还一脸懵圈，只知道生搬硬套过来，虽然还是完成了，也有了学习编程的信心，但是对开始的编程课还是有些忐忑，生怕自己听不懂。
没想到小白的编程之旅——第一堂课会是以“银行开会流程”来切入的，跟着老师的思路，信心马上就提升上来了。整个1个半小时下来，虽然仍有不明白的地方，但是对JS编程终于也有一些感觉。
再加上回看了几遍，补充了一些断层知识和概念，下面就对第一堂课的学习内容进行一下总结。
## 一、梳理课程所学概念及内在逻辑
第一堂课主要通过类比“银行开户流程”的方式，认识了JavaScript运行环境框架及其涵盖的概念，以及代码解释、执行的基础流程。
### 1. 所学概念
“银行开户流程”的业务架构与JS的运行环境架构非常相似，JS的运行环境架构主要由内置库、V8引擎组成，再加上一个第三方库，JS代码就能运行起来
- 运行环境：JS代码能被执行的前提，就像植物需要土壤才能长出花草一般，有了运行环境，代码才能通过计算机实现操作意图。JS的运行环境分为web端和nodejs在不同运行环境中，有不同的功能。
- V8引擎：属于JS运行环境中的核心，主要用来执行代码，JS代码被编译成计算机能懂的指令后，再执行代码。就像汽车的发动机，把燃油转化成汽车所需的动力。
- 编译器、解释（执行）器：JS作为一种编程语言，在输入端，由程序员来编写，然后V8引擎来执行代码。PS：JS属于边解释边执行的编程语言，开发率较高，但是运行效率较低。
- 内置库：类比为“银行开户流程”中的内置服务，为输入进来的JS代码提供一些额外的加成服务，对输入进来的代码进行一些预处理，方便V8引擎执行代码。
- 第三方库：类比理解为第三方服务，为主业提供一些直接可以调用的功能便利，转嫁一些风险。第三方库的作用同样是为JS代码提供一些方便执行的功能。
而不是要求JS什么功能都具备
### 2. 课程内在逻辑框架搭建
- 流程：（代码+调用内置库和第三方库）→V8引擎编译、解释（执行）→输出结果
- 框架：运行环境包括内置库+V8引擎+第三方库，按照前、后端又分为浏览器运行环境和nodejs运行环境，在前、后端内置库的共同点都有内置对象
### 3. 课程中有所启发的学习方法
老师通过类比“银行开户流程”来告诉我们JS运行环境架构，其中有一个思路值得借鉴。
- 设计流程→优化流程→定义流程→抽象出框架
### 4.学习JS的方向：
一开始认为JS是专业人士的专用工具，后面加入新大之后，认识到编程的思维其实每个人都应该学习、具备，因为这是一种机器智商，关于人如何操作机器去高效完成工作，实现自己的意图。
编程语言是人和机器沟通的工具，就像不同国家的人使用不同语言一样，学会了编程，能与计算机沟通。JS作为一种前端、后端都能使用的语言，学习JS既要学会编程的思维，又需要出成果。
所以JS学习的方向是，掌握好JS的基础知识，以微信小程序为目标，实际出一个成果。
## 二、预习作业实际操作中存在的问题
- github网页和终端使用流程：
1. git clone URL→本地修改→git status查询状态→git add 添加→git commit -m"提交日志信息"→git push origin master推送到远程
2. fork到自己的仓库→编辑、修改（网页版git上操作）→pull request给老师
- 存在问题：
1. 没搞清楚GitHub是搞什么的，先用再说吧
2. 在pr的时候，是直接在网页上操作的，没clone到本地仓库操作后用终端推送远程。
有个疑问：如果clone到本地仓库进行编辑修改，文件扩展名是.md这个是不是需要找个专门的编辑器来打开使用呢？
================================================
FILE: homework/lesson1/liuruyong.md
================================================
#1. 类比代码执行流程
高级语言写的代码 > 编译后的中间代码 > 不同平台的机器码 > 机器指令
中央文件 > 官僚系统传递 > 各地根据当地情况做解读 > 群众去执行
#2. 运行环境
运行时需要的支撑环境，运行依赖的库。
#3. V8引擎
wiki解释
> V8在运行之前将JavaScript编译成了机器码，而非字节码或是解释执行它，以此提升性能。更进一步，使用了如内联缓存（inline caching）等方法来提高性能。有了这些功能，JavaScript程序与V8引擎的速度媲美二进制编译。
我的理解：v8引擎厉害的地方，方便代码书写的同时，没有降低代码执行的效率。
#4. 编译器/解释（执行）器
编译器把高级语言编译为二进制文件，二进制文件加载到内存执行
解释器在运行时才进行代码的解析。
#5. 内置库
只有安装相应环境就包含的支持程序运行的最小代码库
#6. 第三方库
遵守相应规范开发的非官方代码库，实现官方库未实现的功能。库的质量由开发者能力决定。
#7. 学习JS的方向
基础语法+常用库+编程思想
================================================
FILE: homework/lesson1/liushengsi.md
================================================
# 小白学JavaScript：JavaScript的怎么玩儿？
#### JavaScript是怎么一回事儿？
###### 1. 银行办理业务类比JavaScript执行代码
回想一下我们在生活中是怎么办理银行业务的：
- 我去到银行，准备在叫号机上取号，这时我发现叫号机上有“个人业务”、“对公业务”可供选择。因为这次是为自己开户，所以我选择了“个人业务”。顺利拿到号，正准备静静等候......
- 这时大堂经理过来询问我要办理什么业务，在得知我要开户后，大堂经理让我填写开户申请表，并准备好身份证复印件等材料
- 复印身份证？糟了！我来之前不知道所以并没有复印。这时大堂经理告诉我说不要紧，银行大堂就提供复印服务，免费！😄太好了！顺利复印好身份证，准备好所有开户所需要的材料。静静等候叫号......
- 终于到我了。快速走到窗口，告诉柜员我要开户并递上了所有准备好的材料。柜员顺利地帮我开通了账户，并交给我一张银行卡。嗯，开户到这里就办完啦！效率还算不错，等待时就准备好了所需材料，减少了很多在窗口等待的时间。
- 正准备离开银行，突然发现大堂的另一侧有保险相关的柜台。我想了想觉得保险这个东西最好还是买一份，于是我走向了保险柜台去办理保险业务。办理过程中得知这家保险公司支持用我刚办理的银行卡付钱，这真是太方便了，于是顺利购买了一份保险。
以上就是我们去银行办理个人业务时会发生的场景，当我们办理的不是个人业务而是别的业务时，有些具体的服务内容和业务内容会发生变化，但是办理流程基本不会变。
这跟JavaScript有什么关系呢？JavaScript玩儿起来就是这样的啊！
- 你要用JavaScript做事情了（你去到银行准备办业务了）
- 你要实现前端功能，JavaScript启动浏览器运行环境（你要办理个人业务，银行走的是个人业务流程）；你要实现后端功能，JavaScript启动Node运行环境（你要办理对公业务，银行走的是对公业务流程）
- 不论要实现什么功能（不论什么种类的业务），你都需要做一些准备工作（大堂经理预先让你准备好所需材料），准备过程中需要用到一些JavaScript的内置库提供的服务（银行提供的打印服务）
- 写好了代码，不论前端还是后端，都送到各自运行环境里的V8引擎去执行（银行办业务的窗口），V8引擎里的解释器一边解释一边执行代码（窗口的柜员一边看材料，一边进行一步步操作，比如输入新开的账户的户名等），V8引擎执行完毕，输出结果（窗口的柜员办理业务完毕，交给你属于你的银行卡）
- 我要增加一个功能，JavaScript的内置库没有提供这个服务（我要买一份保险，可是银行不卖保险），于是我调用了第三方库，第三方库提供这个服务（于是我去了保险公司，他们卖保险）
这样一类比，JavaScript怎么玩儿的是不是就相当清楚明了了呢？😄，我自己是觉得很清晰了的。当然，还需要在后续过程中不断去通过实践来不断加深理解。
###### 2. 我的JavaScript学习方向
理解了JavaScript的玩儿法，我接下来的得明确自己在JavaScript这条路上的玩儿法了。
首先，作为一只小白，我该怎么学JavaScript呢？
>要掌握一门编程语言，就是要能够用编程的方式调用各种服务来完成我的需求
其次，我该怎么提高呢？
>要了解和掌握重要的服务能力，让它能够服务我的业务需求，即要熟悉内置库和第三方库
之后，我该怎么进阶呢？
>要做到善于比较服务／技术之间的差异性，用最好的方式去实现我的业务
学习JavaScript的难点是什么呢？
- 变化快：应对这一点，作为新手的我应该聚焦ES6，对于ES7、ES8等稍微关注下就好
- 无边际：这一点只能在后续学习和使用中去慢慢体会、摸索了
最后，想引用屈原的一句话来说明一下我当下的心情，并与同学们共勉！
>路漫漫其修远兮，吾将上下而求索
================================================
FILE: homework/lesson1/liushengxin.md
================================================
# 开始学习javascript第一节课总结
## 1. 类比代码执行流程
代码其实就是把现实中的流程规范化，通过类比、对两者都加深了印象。一是现实生活中你觉得寻常的流程其实都需要严密的逻辑、也可以进一步的升级，可以加快流程的进度。二是学习代码就是认知流程的过程，只有逻辑可行、代码才会运行、要不只有崩溃。
我从中学到了几点：
1. **类比可以让人从未知到已知**，因为以前没有代码的概念，如果直接讲解代码会一头雾水，通过用已知代替未知、才会深刻的理解未知的事物。
2. **每件事都可以深入思考**。 银行流程有很多事情可以改进、生活学习中也有很多事情可以改进、画好流程图、可以突破自己
## 2. 运行环境
JS的运行环境有两类：浏览器运行环境和nodejs运行环境。两类运行环境都有V8引擎和各自的内置库。
就像我们人类、活着需要自然环境、需要空气和水。这是我们生存的前提、但是热带和寒带的环境也稍有不同、所以一个地方需要光着膀子、另一个地方需要穿上大衣。
## 3. V8引擎
V8引擎我类比成意识和大脑的关系，意识需要大脑的代码处理才能变成身体能够执行的神经脉冲、就是代码。
V8引擎是识别你整个语言逻辑的框架。
## 4. 编译器/解释（执行）器
编译器就是把别人听到的话、转变成自己的行为的过程
说起来就是把你能理解的编程语言、翻译成机器能理解的语言、就是一个翻译执行器。
## 5. 内置库
内置库就相当于我们的眼睛库、耳朵库、手库、脚库、大脑调用这些库就可以看见东西、听见东西、我们的大脑识别了猫。以后看到猫就可以直接调用这个库。
## 6. 第三方库
第三方库就相当于小时候背的诗、读的文章、虽然都是别人的、但我们写文章的时候也可以拿来用。
## 7. 学习JS的方向
编程就是另一个语言、就相当于英语。不会编程、就不会和电脑沟通，这个世界你只能了解你了解的那一小部分。
================================================
FILE: homework/lesson1/liuxiaohaohao.md
================================================
Title: JavaScript第一次总结作业
Created On: 2017-08-11 19:43:28 +0800
其实，来学这门课是想要逼自己一把，觉得自己太久没有从零开始学什么东西了，想要找回一种学生时代的认真感吧！
“怎么说呢，技术一点都不难，主要是方向感，拿起键盘就开干！”
老师说这话的时候，我就觉得特靠谱。好多时候多说无益，多做才是硬道理。
代码的执行流程是怎样的？
其实，就像是银行开户一样，你需要有很多操作，有一定的顺序。代码执行需要一个运行环境，这个运行环境就像是银行。
有了环境之后，代码跑起来需要有一个核心服务，V8引擎就来干这个工作，就相当于银行窗口内部的核心工作人员。V8引擎就相当于银行的核心业务，对代码进行预处理。
同时，代码的执行，还需要有一些内置的服务，相当于银行帮忙复印拍照的业务，虽然不是核心，但也不可缺少，方便代码正常的执行。
代码的执行，会用到一些第三方库，它不在JS的运行环境里，但JS代码的执行需要它的帮助，就像银行会有一些第三方的服务，而这些资源不属于银行本身，但你办业务时可能会用得到。
这么来看，代码的执行只是三次元世界里的一个变体，如果我们把代码的世界当作是日常，三次元世界，其实就是代码的具象化。突然想起了数码宝贝里游戏世界的具象化。
编程语言分为编译型语言和解释性语言两种。编译型语言，就像银行的开户流程一样做了几步，需要输入代码到编译器，然后输出，再输入到执行器里，输出执行结果。而解释性语言就比较简单，一步到位，输入到编译器解释器，然后输出结果，就OK了。
编译型语言和解释性语言相比较的话，前者是运行效率高，但开发效率低。后者是开发效率高，运行效率低。JS属于解释性语言。
内置库在我看来，就是自己家帮忙做事的小伙伴，而第三方库，就是别人家的小伙伴，但是也可以拿来帮忙做事的。
其实，学什么都需要做到独立思考。新手刚开始需要照葫芦画瓢式的学习，但是一旦掌握了规则和一些技巧之后，你就要开始做点自己的东西。基础打好了，可以让你吃上饭，但是想要成为牛逼的人，需要多问自己“为什么”，“技术的差异性在哪里”，“还可以怎么做”？等等一些，给自己开脑洞的问题。
================================================
FILE: homework/lesson1/lixiang.md
================================================
<b>运行环境</b>就像是一个人的大脑，负责处理接收到的信息，比如一条新闻，一个故事。
<b>V8引擎</b>是人脑中最智能的核心，至于它具体是怎么工作的，诸如神经元之间的链接之类，我们现阶段不需要掌握。
<b>编译器</b>就像是人脑里的语言模块。一老外跟自己说话，他的话就是一串代码，人脑分析完语法语义之后，整理一下，用自己语言表述出老外说了啥。
<b>执行器</b>就相当于，老外跟自己说话，听懂以后，按照他说的话去做了，而不只是停留在理解的层面。
<b>内置库</b>就像人脑里装了不同学科的内容。来西班牙语就调用西班牙语的库理解和分析，来了天文学的知识我就调用天文学的背景知识 。
<b>第三方库</b>就类似书本，在线课程，给自己在处理信息的时候添加辅助工具。
<b>学习JS</b>就是给自己脑子里增加多一个，甚至在此基础上发展出来N个，内置库；<b>方向</b>就是最简单朴素的：认真上课/写作业/研习课本/从错误中总结提高。要有耐心，要有恒心，脚踏实地！
================================================
FILE: homework/lesson1/lixiaoxin.md
================================================
# Javascript 初探
## 【第一次作业】
运用下面这些关键词，把你知道的写出来。
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
报名这门课时，我对JavaScript基本一无所知，只知道它是一种程序语言，Google了JavaScript，在维基百科看到了如下简介：
> JavaScript，一种高级编程语言，通过解释执行，是一门动态类型，面向对象（基于原型）的直译语言。它已经由ECMA（欧洲电脑制造商协会）通过ECMAScript实现语言的标准化。它被世界上的绝大多数网站所使用，也被世界主流浏览器（Chrome、IE、FireFox、Safari、Opera）支持。JavaScript是一门基于原型、函数先行的语言，是一门多范式的语言，它支持面向对象编程，命令式编程，以及函数式编程。它提供语法来操控文本、数组、日期以及正则表达式等，不支持I/O，比如网络、存储和图形等，但这些都可以由它的宿主环境提供支持。
> 虽然JavaScript与Java这门语言不管是在名字上，或是在语法上都有很多相似性，但这两门编程语言从设计之初就有很大的不同，JavaScript的语言设计主要受到了Self（一种基于原型的编程语言）和Scheme（一门函数式编程语言）的影响。在语法结构上它又与C语言有很多相似（例如if条件语句、while循环、switch语句、do-while循环等）。
> 在客户端，JavaScript在传统意义上被实现为一种解释语言，但在最近，它已经可以被即时编译（JIT）执行。随着最新的HTML5和CSS3语言标准的推行它还可用于游戏、桌面和移动应用程序的开发和在服务器端网络环境运行，如Node.js。
意料之内地———基本看不懂，因为定义里面还嵌入了无数不懂的名词，而大脑无是法用未知解释未知的。倒也不慌，就跟着新大的JavaScript入门课，一探究竟吧。
第一节课，老师以银行开户流程类比代码执行流程，让我们迅速了解了JS运行的整体架构，
关键词：
- 环境
- 内置服务
- 核心
- 预处理
- 执行
- 第三方服务
此外透过银行开户流程的改进过程我还学到了：
1. 对于重复事件，要有设计流程思想；
2. 流程不是设计出来就完了，还要不断优化
这正是我想踏入编程世界的初衷之一，即利用编程把自己从重复劳动中做解放出来。
而在使程序自动运行之前，需要对一整套流程做梳理和优化，才能使程序执行更合理及高效。
- 运行环境
如同人到一个陌生环境不是要急着行动，而是要先熟悉周围环境，知道自己在这个环境里有什么资源可以利用，要学习JS，首先也应该对JS处在什么环境、有什么资源可以调用有一个基本的了解。
运行环境有两种：浏览器和Nodejs，它们都有自己的核心（V8引擎）和内置服务，以及对应的可以调用更多服务的第三方库。
需要注意的是，浏览器和Node的运行环境是不一样的，各自提供的服务（包括内置库和第三方库）是不一样的，唯一一个共通点是两者具有一样的JS内置对象。
另外作为核心的V8引擎，老师说了对于新手，不需要知道它的运作原理，只要知道V8引擎是用来做对代码进行预处理和执行的就行了。
- 编译器/解释（执行）器
编译型语言，先编译后执行，需要专门的编译过程，通过专门的编译器翻译成机器语言，因此开发效率低，运行效率高；
解释性语言，边解析边执行，因此开发效率高，运行效率低。JS是解释性语言。
- 内置库
内置库简单来说，就是运行环境提供的内置服务，JS的内置库包括：网络库、日志库、JS内置对象，等等。
- 第三方库
第三方库，我理解的就是各种第三方（除了”我“、JS运行环境外的第三方）提供的更为或便捷或强大的服务，不需要自己从头设计、制作。比如穿衣服，不需要买布料自己做，只需要到服装店买回来穿就是了。
- 学习JS的方向
对于JS的学习方向，老师给了一些方向：
该怎么学习？
> "要掌握编程语言，用编程方式调用服务来完成你的需求。"
我的理解是，在入门阶段，学习内置库和第三方库的功能，这个阶段，要能够通过调用内置服务和第三方服务写出代码，并让代码能够跑起来，成功实现需求功能。
该怎么提高？
> "理解和掌握重要的服务能力，使其能服务你的业务。"
我的理解是，在入门之后，要学习和积攒一些重要的高频小套路，快速实现业务功能需求。
该怎么进阶？
> "善于比较服务/技术之间的差异性，用最好的方式实现你的业务。"
我的理解是，在进阶阶段，对于实现某一个业务需求，应该要会不只一种方法，并且能对比出不同方法、路径的优劣，从而知道最短路径、最优选择是哪一种。
================================================
FILE: homework/lesson1/liyihang.md
================================================
#1. 类比代码执行流程
类比银行开户，加入了计算机的部分概念思想，如预处理，封装，uml图
输入-》处理-》输出
#2. 运行环境
Javascript的运行环境有，浏览器和node
VC的运行环境就是runtime， 包含各种dll等，如msvc.dll
#3. V8引擎
google开发的java引擎，用于客户的，服务端，可高性能的编译执行
#4. 编译器/解释（执行）器
编译器，把源代码，编译、汇编和链接，输出为机器码的目标程序，运行时就直接运行机器码
解释器，把源代码产生易于执行的中间代码，在运行时进行解释
编译型语言：c c++
解释型语言：javascript，lua，python
#5. 内置库
运行环境自带，如 数学math库
#6. 第三方库
如算法库，控件库，组件库。
#7. 学习JS的方向
js用于网页开发，移动端开发，后端开发。
================================================
FILE: homework/lesson1/luoruijun.md
================================================
# 第一课作业
1. 代码的执行流程：输入代码到运行环境，调用运行环境中内置库的服务，或调用第三方库的服务，送入运行环境中的v8引擎进行预处理和执行。
2. 运行环境是代码执行的环境，提供内置库的服务和v8引擎对代码的预处理和执行。JS运行环境有nodejs和浏览器运行环境。
3. v8引擎的作用是运行环境中对输入的代码进行预处理和执行，包括编译器器和执行器，编译器进行分析此法、语法、语意、优化代码，解释器进行解释代码、执行代码。
4. 内置库提供内置服务，内置库例如：网络库、日志库、JS内置对象等。不同运行环境等内置库包括等服务不同。
5. 第三方库包括jQuery、Vue、React等。
6. 学习JS的分不同的阶段，方向是掌握编程语言，掌握调用服务。第一阶段掌握编程语言，能用编程调用服务完成需求；第二阶段是了解掌握重要的服务能力，使其服务于业务。第三阶段是善于比较服务／技术之间的差异性，用最好的方式实现业务。
================================================
FILE: homework/lesson1/maggiewong.md
================================================
# 作业1——总结第一节课的内容
1.类比代码执行流程
将代码执行流程和银行开户类比：JavaScript的运行环境分为浏览器运行环境和Nodejs运行环境，针对这两个运行环境有各自的核心V8引擎和内置服务，有一大批第三方库满足JavaScript代码的调用
2.运行环境
运行环境是一个可以执行代码的黑盒，分为编译器和解释器。V8引擎只是运行环境里很小的一部分，核心是内置库。JavaScript的浏览器运行环境和Nodejs运行环境内置库不一样，调用的第三方库也不一样，其提供的服务是有差异的——浏览器运行环境是前端，Nodejs运行环境是后端。
浏览器运行环境和Nodejs运行环境有一个共通的内置库JS内置对象，提供了一组JavaScript语言的特性。
3.V8引擎
V8引擎是对代码进行预处理和执行的核心。
4.编译器/解释（执行）器
编译器对输入的代码进行编译，即分析代码的词法、语法和语义并优化代码。
解释器对编译好的代码进行解释和执行，是V8引擎的一个组成部分。
对于编译型语言，如C语言，编译器和解释器是分开按顺序运行的，编译器将代码编译成机器语言再去执行代码，工作流程类似于银行开户流程优化版四。特点是运行效率高但是开发效率低。
对于解释型语言，如JavaScript和Python，编译器和解释器的运行是一次性完成的，不会对整个代码有明显的编译过程，工作流程类似于第一版简易银行开户流程。特点是开发效率高但是运行效率低。
5.内置库
由运行环境提供的一组实现代码功能的服务。
6.第三方库
由很多的公司、个人提供的商用或免费开源的库，提供比内置库更强大完善的功能。
7.学习JS的方向
初学者的方向是**掌握编程语言**，用编程方式调用服务来完成需求，这是学习的第一步。提高的途径是**了解和掌握重要的服务能力**，使其服务你的业务。了解第三方库的功能。进阶的方法是善于比较服务/技术之间的差异性，**用最好的方式实现你的业务**。思考有没有另外的库能解决这个问题，哪个更好。
================================================
FILE: homework/lesson1/panqi.md
================================================
#第一次课程总结
##代码执行流程：编写代码，解释并执行，输出内容。
##JS运行环境：多样化，浏览器（前端）和Nodejs（后端）两种环境，拥有相同的JS内置对象，不同的内置库和第三方库。
##V8引擎：用于完成预处理和执行等核心任务。
##编译器/解释（执行）器：和英语翻译类似，编译器好比是将英语翻译成中文的工具，要先有英文输入、在工具内发生变化、最后输出中文；而解释器好比是同声传译，边听边译、随听随译，工作具有同步性特点。
##内置库：属于自带资源，能够满足常规和经常使用的需求。
##第三方库：属于外部资源，进一步扩大了可用资源范围，以满足多样化、差异化的开发需求。
##学习JS的方向：
###初级——掌握编程语言，用编程方式调用服务来完成你的需求（有如小孩子学说话、中国人学外语，学习JS语言也要多学多练多琢磨，熟练运用、扎实掌握、内化为自己的一部分，才能充分有效利用各种资源，信手拈来、满足需求。）
###提高——了解和掌握重要的服务能力，使其能服务你的业务（JS有很多资源、功能，结合自身的需求，有针对性地突出重点，单点突破、纵深延展。）
###进阶——善于比较服务/技术之间的差异性，用最好的方式实现你的业务（正所谓条条大路通罗马，业务需求的解决路径和方案也非唯一，随着学习的深入，权衡各种方法的利弊得失，综合判定选择最适合的）
================================================
FILE: homework/lesson1/panyong.md
================================================
# 【第一次作业】写一篇总结
运用下面这些关键词，把你知道的写出来。
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
## 总结
现在是8月29日凌晨，回想8月8日那一节课，回放已经关闭了...
记得开课前，课程留言里有推荐这篇文章，[《在 2016 年学 JavaScript 是一种什么样的体验？》](https://zhuanlan.zhihu.com/p/22782487)，看完就晕了，感觉要掌握JS好复杂。
老师上来，就贴了一张非常有执行力的图：不要给我说底层原理，框架内核，老夫敲代码就是一把`梭`！复制！粘贴！拿起键盘，就是`干`！然后开始讲框架内核。
从类比说起：银行开户流程，针对流程上存在的问题，一步一步优化，得到了一个高效的银行业务框架。而这个银行业务框架，和JS运行框架正好类似。
### 1、先说js运行环境（V8引擎+内置库）
#### V8引擎
js有`浏览器行环境`和`Nodejs运行环境`两个运行环境。就像银行开户时，有`普通用户开户环境`和`VIP用户开户环境`一样。`普通用户开户`和`VIP用户开户`，最核心的功能就是开户。`浏览器`和`Nodejs`，最核心的功能就是解释执行js代码，由V8引擎完成。
#### 内置库
`普通用户`和`VIP用户`去银行开户是，享受的服务是不一样的(当然，这里类比的重点不是VIP享受的服务更优越，类比的重点是二者享受的银行服务是不一样的)，就像`Nodejs运行环境`提供处理文件服务`var fs = require('fs')`，而`浏览器行环境`为了安全是不允许访问本地文件的，另外`浏览器行环境`有`alert()`，这个服务又是`Nodejs运行环境`所没有的。也就是说运行环境内部提供的服务，就是内置库。
### 2、再说第三方库
`普通用户`和`VIP用户`，除了开户以外，还有第三方需求，也就是银行不提供但是用户又需要的需求，比如绑定支付宝、公积金卡、医保卡、金融产品、股票，这些服务都和银行卡关系，但又需要银行之外的第三方来提供服务。`普通用户`主要需要的第三方服务可能是绑定支付宝。`VIP用户`需要的第三方服务可能是购买海外股票。也就是说，不同的用户，需要的第三方服务不同。`浏览器`主要的第三方库是和前端相关的，比如jQuery、Vue、React等。`Nodejs运行环境`主要的第三方库是和后端相关的，比如Express、Koa等(这些具体是什么？后续再了解)
### 3、学习JS的方向
学习JS的难处在于`JS变化快`、`JS无边际`。所以，学习JS首先要又一幅地图，上面类比中的`V8引擎`、`内置库`、`浏览器第三方库`、`Nodejs第三方库`就是地图，可以随时让你知道自己在哪里而不会迷路。
初学：先掌握编程语言，用编程调用服务（内置库，第三方库）完成需求。
提高：掌握重要的服务能力，使其能服务于重要业务。
进阶：善于比较服务/技术直接的差异，懂得用最好的方式实现业务。
================================================
FILE: homework/lesson1/qiujingyu.md
================================================
#### 第一节课作业：总结
##### 1. 类比代码执行流程
与银行开户流程进行类比：
+ 用户相当于程序员
+ 普通用户相当于：开发前端使用js的程序员
+ VIP用户相当于：开发后端使用js的程序员
+ 开户申请相当于代码
+ 银行相当于JS运行环境
+ 普通用户的开户环境相当于浏览器运行环境
+ VIP用户的开户环境相当于Nodejs运行环境
+ 业务核心相当于V8引擎
+ 内置服务相当于内置服务
+ 第三方服务相当于第三方库
+ 改进版的开户流程相当于C语言等编译型语言即C语言，编译器与执行器分开，运行效率高，开发效率低
+ 传统的开户流程相当于JavaScript等解释性语言，编译器/解释器兼具有执行器功能，开发效率高，运行效率低
##### 2. 运行环境
指处理JS代码的环境，包括浏览器的运行环境与Node的运行环境。
##### 3. V8引擎
由美国Google开发的开源JavaScript引擎，用于Chrome浏览器中。目的是编译和运行JS源代码，处理对象内存分配，对不再使用的对象进行回收。
##### 4. 编译器/解释（执行）器
编译器能分析词法、语法、语义，并优化代码。
解释（执行）器能解释代码、执行代码。
##### 5. 内置库
JS本身提供的用于实现相关功能的模块。
##### 6. 第三方库
国际标准化组织（ECMA）以外的个人或组织为JS开发的能实现相关功能的模块。
##### 7. 学习JS的方向：
+ 对初学者来说
> 掌握编程语言，用编程方式调用服务来完成你的需求。
+ 对提高者来说
> 了解和掌握重要的服务能力，使其能服务你的业务。
+ 对进阶都来说
> 善于比较服务/技术之间的差异性，用最好的方式实现你的业务。
================================================
FILE: homework/lesson1/shaozhen.md
================================================
#JavaScript第一堂课学习总结
###徐老师通过讲解如何优化银行柜台工作流程，抛砖引玉类比出JavaScript代码的执行流程，深入浅出的介绍了JavaScript的总体面貌，令人印象深刻。
###随后老师使用同样方式通过介绍婴儿和小学生的生活环境来类比出浏览器环境和node.js环境对JavaScript来说，有什么不同和相同点。
###在浏览器和node.js中，它们都含有内置库可供JavaScript进行调用，虽然它们有部分是相同的，但是也有部分是不同的。因此同一段代码，未必能同时在浏览器和node.js环境中正常运行。而且他们都有很多第三方库来扩充它们的功能,第三方库有很多优秀功能，可以减少开发者大量时间和精力。它们之间还有一个共同点就是都具有V8引擎，这是JavaScript代码能够运行的关键，由对JavaScript代码进行解释执行，效率非常高，谷歌浏览器的优秀表现离不开V8引擎的加持。
###JavaScript是一个开发效率很高的语言，这归功于它是一门解释性语言，它的一条语句可以在执行的时候再翻译。但是，这也导致了它运行效率低下。
###JavaScript是一个应用广泛的语言，官方对它的更新也很频繁，可谓相关知识浩如烟海，无边无际，所以我们要找到学习的要点，深入研究。我们要利用JavaScript丰富的内置库和第三方库，用编程方式调用服务来完成相关需求，而且还要对重要的服务有足够多的了解和优劣的分析能力，善于比较服务和技术之间的差异性，使其能更好的服务业务，记住贪多嚼不烂。
================================================
FILE: homework/lesson1/shenzhili.md
================================================
# 第一节课的总结
## 1. 类比代码执行流程
老师课上讲了一个非常棒的类比：银行开户流程与JS代码运行环境。直播开始先讲银行开户流程，先是一头雾水地听了一段，后是恍然大悟。当徐高阳老师
将银行开户流程和JS运行环境的框架对应的时候，真的惊艳了：原来是这样，很好理解！
我从中学到了几点：
1. **类比这个工具的强大**，超出想象。（亲身感受才明白它的威力，仅仅从文字理解是不够的）
2. **优化流程**。 很多事情可以用效率低的方法完成，但做一个有心人去优化办事的流程，能达到事半功倍的效果。
1. **定义流程**。 定义流程是我课上才接触的概念，但我能想象它的强大：将流程定义清楚，不模棱两可，可以减少思考时的散乱，有助于提高思考质量(还有与人交流的效率)。
2. **总结概括能力可以训练**。 见识到了高手的总结概括能力，对比自己，发现有一个地方很关键：定义流程。
没有准确地定义流程，没有准确地把握事情先后关系和包含与被包含关系是影响叙述能力提升的障碍。
## 2. 运行环境
JS的运行环境有两类：浏览器运行环境和nodejs运行环境。两类运行环境都有V8引擎和各自的内置库。
需要注意的是，在进行JS代码编写的时候，要明确自己写的程序是运行在哪个环境下的。由于浏览器和nodejs的内置服务是不一样的，如果你的JS代码调用了浏览器的内置服务，却在nodejs的环境下运行，那结果可想而知。
## 3. V8引擎
V8引擎是JS运行环境的核心，V8引擎的功能是对代码进行预处理和执行，相当于编译器+执行器。初学者甚至初级中级工程师都不需要知道具体原理，把它当成黑盒就好了。
## 4. 编译器/解释（执行）器
编译器：将代码翻译成机器语言
解释（执行）器：直接对代码进行excute
## 5. 内置库
内置库：运行环境提供的一组服务，更好的实现一些功能。**不用重复造轮子了，直接拿来用就好。能省许多力气。**
## 6. 第三方库
第三方库封装好了代码，并提供了接口。第三方库收到数据后将处理结果反馈回来，能帮助实现更强大的功能。
## 7. 学习JS的方向
作为刚进入编程世界的小白，应该把注意力放在如何掌握编程语言这块，而且要深入学习，吃透概念。
================================================
FILE: homework/lesson1/sophieQi.md
================================================
第一次课程作业
老师在可用用类比的方式，用银行的办卡的服务流程推导出了代码的执行流程，用已知解释未知。
从程序的执行方式上分为编译器和解释（执行）器。
- 编译型是先编译后执行，需要一个专门的编译过程，通过编译器翻译成及其语言，运行效率高，缺点是开发效率低。
- 解释性是一条语句执行的时候才翻译，开发效率高，缺点时运行效率低。
在网上看了一个例子，对于采购日常用品来说，需要什么买什么，一次买一个内容，类似于编译器，是高需求，但需要不断的去响应新出现的需求。如果一次性列一个购物清单，把需要的内容一次性买回来，类似解释器，打包购买一次性齐活。
Javascript是解释型语言，有2种运行环境，分别为Node运行环境（后端使用）和浏览器运行环境（前端使用）。2者都包含内置库和第三方置库。
- 内置库：JS内置对象是2种运行环境的共同内置库。运行环境提供的一组服务内置库是 JS 内置的一些库，可以直接拿来调用。
- 第三方库：不同于内置库，需要require才能从外部调用。
V8引擎：用来执行代码，代码在V8中执行。解释器在V8引擎中。
## 学习JS的方向
- 掌握编程语言——用编程方式调用服务来完成你的需求
- 了解和掌握重要的服务能力——使其能服务你的业务
- 善于比较服务／技术之间的差异性，用最好的方式实现你的业务。
================================================
FILE: homework/lesson1/sunxl.md
================================================
## 小白学JavaScript
## 共建小白用的JavaScript技术文档
1. 用去银行开户的流程来类比代码的执行流程
2. 运行环境有nodejs和chrome浏览器，V8引擎暂时不用理他。
3. 编译器/解释器 chrome浏览器就可以编译，JavaScript是基础语言，应用很广，基于它设计出的语言都有100多种，了解它对学习其他语言很有帮助。
4. 内置库需要初学者花时间精力学习的，第三方库也很重要，初步了解
5. 学习js，在不同的阶段，都有不同的提高方式，所以说这是一个可以不断提升的技能，徐老师总结的三个阶段的不同突破方法，也可以用到其他语言学习上。
================================================
FILE: homework/lesson1/tangjianfeng.md
================================================
##1、用开户流程来类比JS运行环境框架
用银行的开户流程来类比Js运行环境框架，JS代码类似对银行有服务需求的客户，以v8引擎对应业务核心（即预处理和执行），用内置服务对应内置库，用第三方服务对应第三方库。同时了解到运行环境包含浏览器运行环境和Nodejs运行环境，这两种运行环境分别对应前端和后端，分别在浏览器上或Node上运行，他们主要的共同点在于JS内置对象，两者有通用的命令，但各自主要运用的内置库和第三方库大多不同，某些命令如alert在浏览器环境中能跳出警告窗口，而在Node上却是运行错误，因此学习Js要分清在哪个环境中用，才能有的放矢。
##2、主要学习的方向
主要学习的方向应该是熟悉代码的写作和了解内置库和第三方库，按照我上课的理解就是好好了解内置库和第三方库的作用，按照项目的实际来通过代码调用这些库中的资源，以达到用合适的库来做相应的事情，打个比方就是要解直角三角形三边长的问题最好用勾股定理，而不是用微积分。
##3、运行环境
运行环境类似于一个婴儿或者小学生的生存生活的环境，由供他生存的生活的各种具体的环境来对他做各种服务
运行环境主要有浏览器环境和Nodejs环境，前端开发一般用浏览器运行环境，后端开发一般在Nodejs环境中用
运行环境中有内置库和v8引擎。
##4、V8引擎
对代码预处理和执行
##5、内置库
是运行环境提供给我们的一组服务。
内置库中有网络库，日志库，js内置对象等库。浏览器中包含很多内置库，例如js内置对象，WebAPI,WebGL,HTTP，WebRTC，canvas等
Nodejs的的内置库中有JS内置对象，Node API。
##6、第三方库
第三方的库是由各种个人或公司编写出来方便我们实现更好更优质的服务的工具。
浏览器运行环境的第三方库主要有jQuery,Vue,AngularJS,React等.
NodeJS的第三方库主要有：Express,Koa,Webpack,Promise等
##7、编译器／解释（执行）器
编译器的几个主要作用：1、分析词法；2、分析语法；3、分析语义；4、优化代码。
解释（执行）器的主要功能是：1、解释代码；2、执行代码。
代码输入编译器，通过编译器分析词法、语法、语义及优化代码后，输出编译好的代码送入执行器，让执行器解释代码和执行代码，从而输出结果
JS是一种解释型语言，直接将代码输入编译器／解释器，它就能边进行分析词法、语法、语义，优化代码，解释代码，执行代码，不会有一个明显的编译过程，边编译边执行。
和编译型语言的区别是开发效率高，但运行效率低，因为它是边翻译边执行的。
================================================
FILE: homework/lesson1/taobao.md
================================================
【第一次作业】写一篇总结
运用下面这些关键词，把你知道的写出来。
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
提交方式：
1. 请向getting-started-with-javascript项目发起pull request。
https://github.com/xugy0926/getting-started-with-javascript
2. 文档格式，markdown。
3. 提交homework/lesson1目录下。
---
1. 类比代码执行流程
JS 代码流程，类比，银行开户的流程，内置服务，核心服务，第三方服务，不同的运行环境以应对不同的使用人群。
vip 和 普通用户， javascript 和 nd.js
2. 运行环境
可以运行代码的地方就是运行环境，例如浏览器或者编译器
3. V8引擎
谷歌开发应用Chrome 的一种引擎，在运行js 前转换成机器码以次提升效率
4. 编译器/解释（执行）器
编译器，将手写字符串或字节转换成机器码，再进行运算
解释器，直接执行
5. 内置库
语言本身开发所附带的库，以没满足基本使用
6. 第三方库
由第三方提供并支持的开源或闭源，免费或收费的库，以更好的服务
7. 学习JS的方向
“善于⽐比较服务/技术之间的差异性，⽤用最好的⽅方式实现你的业务。”
================================================
FILE: homework/lesson1/tuyilang.md
================================================
### JavaScript编程入门第一节课总结：学习JavaScript的最少必要知识
老师先后通过两个类比向我们展示了学习JavaScript的最少必要知识。
##### 第一个类比
用银行开户流程的优化过程类比出代码的执行流程，同时具体而形象的展示了编译型语言和解释性语言的区别。在这两种流程（银行开户和代码执行）中，真正重要的是（运行）环境。
JS的运行环境包含了内置库和V8引擎。当然，在这个运行环境之外，我们还需要第三方库（第三方服务）的支持。
而**在这个运行环境中更重要的**（对于新手，初级乃至中级学习者而言）**是其中的内置库**，而不是V8引擎（负责代码最终的执行）。
但是V8引擎恰好体现出了编译型语言和解释性语言的区别，编译型语言需要一个专门的编译器，经过编译器编译之后再送去执行，而解释性语言（JavaScript）的执行过程是边解释边执行，靠的就是V8引擎这个解释（执行）器。
##### 第二个类比
用婴儿和小学生的生活环境的区别类比出浏览器和Nodejs的运行环境的区别。它们之间最大的区别也是使用的内置库不相同，还有一部分是用到的第三方库不同。
##### 总结
通过这两个类比，可以总结出学习JavaScript的**最少必要知识**就是：
> - **运行环境中的内置库**
> - **第三方库**
而这两者（S的内置服务和第三方服务）也决定了我们学习JavaScript的正确方向：
> 1. 初学：**掌握编程语言**，用编程方式调用服务来完成你的需求。
> 2. 提高：**了解和掌握重要的服务能力**，使其能服务你的业务。
> 3. 进阶：善于比较服务/技术之间的差异性，**用最好的方式实现你的业务**。
================================================
FILE: homework/lesson1/wangmeiling.md
================================================
【第一次作业】写一篇总结
运用下面这些关键词，把你知道的写出来。
1. 类比代码执行流程
银行开户流程，由客户和桂圆的简单分工，到银行方面有了内置的服务，比如打印身份证；到有了第三方，比如派出所。
通过银行开户流程的逐步优化到全面介绍代码的整个框架。我体会到编程思维是不是可以应用于日常工作的优化？
2. 运行环境
婴儿面临的世界和10岁小孩的世界是不同的，他们面对的世界就是环境；
而当我做在办公室里工作时，办公室的空间、办公室里的同事、空气、光线就是我工作的运行环境。
JS的运行环境是一个可以执行代码的黑盒。
3. V8引擎
V8引擎是属于运行环境中的一个小小盒子，它是执行代码的。
4. 编译器/解释（执行）器
对输入的代码进行解释、翻译，就像豆浆机一样把豆子打碎最后输出豆浆。
5. 内置库
可以直接调用的工具，就像修车行的工具箱里的工具。
6. 第三方库
公司、个人、开源、收费等提供的库（工具）
7. 学习JS的方向
我想学会搭建一个网页APP，用来记录每本书的阅读时间。
================================================
FILE: homework/lesson1/wangshasha.md
================================================
# lesson1 homework 王沙沙
标签（空格分隔）： javascript
2017.8.13
##对编程的感性认知
就像去办银行卡，基本服务和增值服务分窗口，每个窗口执行特定功能，但都在银行里面完成的，偶尔特殊功能银行也需要和外面的组织合作；代码也是一样，在一个平台上可以进行多种服务的调度，你要哪种用代码调过来就好了（就像在银行/营业厅，你需要什么跑到对应窗口就好），有时候有些功能没有，就需要用到外面的功能集合（库）——小白的理解，不造是否有误
##语言类型
javascript是解释型语言，就是你把代码拼好了塞进去让它耍，它自己在哪折腾就会有点慢；C,C++是编译型语言，大概是它做点事要向你反馈一下，进度稍微慢一点，其他好处我还不知道
##编程环境
js可以用在很多地方，根据做出来的效果能不能直接呈现在大家电脑上，大概分两类：看得到的和一般人看不到的能呈现的是前端，不能的是后端。就像每个人在自己不同阶段所处的环境不同，js编程也需要不同的运行环境；前端的开发环境是chrome，后端是nodejs
##学js学的是什么
js编程是干什么：会用命令，调用内置库和第三方库
所以学习内容：小白起步时，会用命令；
进阶：熟悉这些库的用法；
提升：用最好的方式来实现需求
================================================
FILE: homework/lesson1/wangwei.md
================================================
1. 类比代码执行流程
> 比如去银行开一个户,先要填写申请单,对应的就是编写代码,把申请单交给银行工作人员审核,就是编译器和解释器 编译执行的过程, 然后是银行给出一个结果,或者有错误,重新修改代码,或者是通过,给出一个结果
2. 运行环境
>一个执行代码的黑盒,里面有 V8引擎 和 内置库
>JS 运行环境有两大类:
>>1. 浏览器 运行环境
>>2. Nodejs 运行环境
>两种运行环境包含各自的 V8引擎 和 内置服务
3. V8引擎
> 代码在V8引擎里面编译和执行代码,然后给出结果.
4. 编译器/解释（执行）器
>对高级语言来说,需要一个编译器,将高级语言编写的代码 编译成 中间文件,然后 这个中间文件又再解释(执行)器里 给 电脑,最终给出结果.
5. 内置库
>运行环境自带的内置对象,可以直接调用
6. 第三方库
> 第三方开发的对象,需要引入,才能调用
7. 学习JS的方向
> 从小白到入门,掌握编程语言
>入门到提高, 了解掌握重要服务,解决实际需求
>提高到进阶 ,能够比较各个技术,服务之间的差异,用最好的方式来实现
================================================
FILE: homework/lesson1/wangxuanding.md
================================================
第一次作业
=
1. 类比代码执行流程
---
代码执行流程，就像银行开卡，我们把要求填写的资料都填完（代码），银行职员（程序）检验我们的输入是否正确，正确则往下执行，有错误，则提示有错误，申请退回
2. 运行环境
--
运行环境就是银行职员以及银行对于我们所输入信息进行处理，且有标准化规定的东西。
3. V8引擎
---
V8引擎就是职员对我们所输入信息的监视以及处理的过程
4. 编译器/解释（执行）器
---
银行职员的读写能力
5. 内置库
---
银行内部已涵盖的一些服务
6. 第三方库
---
能客户提供服务的第三方，并不一定业务和银行没有重合的，也并不一定比银行好。
7. 学习JS的方向
---
没特在意老师说的，我还是按照自己的方式来。
1. 大脑是无法通过未知的东西去理解未知的东西的。国内大学里的编程课，一上来讲了大段大段的基础概念，让人弄的云里雾里，难道要我们死记硬背吗？我的方式是，通过大量的实例，让自己知道这一个命令干什么的，那个命令有什么用，为什么要这样子。第一阶段，复制黏贴，第二阶段，对着代码敲，第三阶段，对着代码敲，同时划出部分精力去理解。一共运行3次代码
2.这样下来，自己对于那些概念已经有了一个大致的认识了，而且并不是那些空洞的文字，而是直接把这个命令和会带来的后果联系起来了。之后，就像是拼图，把之前已知的块与块结合，去拼凑出更大的东西，期间会不断的试错，同时会加强自己对于语法的掌握。
3.拼图大块地方都拼好了，剩下一些小角落，就查缺补漏，由于通过大量实例，已经知道哪些命令常用，且有使用价值，而且大半已经掌握了，去弄懂剩下小部分。还剩一些不常用的，遇到了之后再去学。
================================================
FILE: homework/lesson1/wangyuliang.md
================================================
##【第一次作业】写一篇总结
###1. 类比代码执行流程
通过银行开户，输入开户人信息类比代码的输入，通过银行的处理类比编译器/解释器，然后输出结果。而JavaScript通过类比它是非常高效的，输入代码，通过内置库和编译器、执行器的处理就能实现效果。把麻烦都丢在内置库里的感觉。
###2. 运行环境
运行环境，我想的是上班和下班回家，面对的情况不一样，你应对方式也不一样，不能拿工作的状态和家人相处。运行环境不一样，使用的第三方库也不一样，错用内置库和第三方库会使代码显示不了。见人说人话，见鬼说鬼话。
###3. V8引擎
踩下油门（输入代码），引擎开始给油做功加大（V8引擎执行加快速度这个代码的），输出速度加快，编程就是踩下油门等待引擎加快速度
###4. 编译器/解释（执行）器
编译器/解释器是V8引擎的一部分，它们负责分析你输入的代码表达的什么意思，到底给油还是减少给油。
###5. 内置库
内置库就是系统自带软件，如去住宾馆，提供的房价包含服务基本保证你的需求，但你有些时候需要其他服务，这时候就会去第三方库寻找。
###6. 第三方库
###7. 学习JS的方向
>掌握编程语言，用编程方式调用服务来完成你的需求；了解和掌握重要的服务能力，使其能服务你的业务；善于比较服务/技术之间的差异，用最好的方式去实现你的业务。
放下傲慢虚心学习才是成为高手的方法， 带有目的性学习，学习这个编程语言是完成什么需求，把这个语言与实际需求相结合，掌握它们之间的差别，用最好的方式去帮自己达成目标。
================================================
FILE: homework/lesson1/wangyunfei.md
================================================
## 第一课作业
经过了连续几天的折腾，终于走到了交第一课总结作业的地步，感觉好不容易。下面我以一个小白的理解，来叙述一下第一课的感悟。
### 一、运用类比
课程一开始，老师并没有着急直接讲专业的编程知识，而是讲了一个银行开户的例子，从一张最简单的开户流程图开始，几经优化，勾勒出一幅效率更高的开户流程图。但是这绝对不是单纯的讲故事。
这一类比的方法，是为了形象的勾画出代码的一个运行流程图。客户最初提供的的表单就是一页代码。客户开卡，就是代码的输出结果。
这一页代码（开户申请单）经过内置库（内置服务），然后流转到编译器、解析器（银行的业务核心），经过编译器、解析器的执行，最终输出结果（客户开卡）。
真的很佩服老师的智谋，通过这么一个形象的类比，来阐述代码运行流程。这种类比确实非常有效。
今天我又看了一遍课程回放，对老师经常讲的一句话有了初步理解。这句话是：“编程最重要不是敲代码，而是思考。” 我的理解就是，如果不去优化银行的整个业务架构，仅仅是靠提高窗口人员的技术水平， 那么就是把窗口人员累死，恐怕银行的整体运营效率也提高不了多少，开户的人一多，银行系统就要崩溃。
反之，经过优化了银行的业务架构，也就是优化了环境框架，可以迅速提高运行效率，这个是本质的提高。
### 二、环境
提高环境，我就想起一个词，叫大环境。 老师通过类比讲故事的方法，是为了更好的阐释“编程语言的运行环境”。后来又举例婴儿、与小学生的生活环境，来类比程序的运行环境。简而言之，就是程序运行，到底需要多少组件类支撑他？ 他才能生存下去，也就是运行下去。
银行的运行环境，包括很多。内置服务（第三方服务），预处理服务，核心执行服务，等。
通过类比，代码的运行环境，也是雷同。包括内置库（第三方库），编译器/解析器，等。
只不过，不同的代码，不同的编程语言，他们需要的内置服务（内置库），是不相同的。但是代码整个运行的流程大致相同。
### 三、V8引擎：
V8引擎，通俗的讲就是8缸的发动机，缸体呈V字型排列。 在编程体系里面也有这个词汇，我去百度去搜，大概意思是：V8将其编译成原生机器码（IA-32, x86-64, ARM, or MIPS CPUs），并且使用了如内联缓存（inline caching）等方法来提高性能。有了这些功能，JavaScript程序在V8引擎下的运行速度媲美二进制程序。
请恕我水平太低，连读三遍，愣是没读懂。不过既然是引擎，那他肯定就是核心部件，有了它，整个运行环境才能运转下去。相较于银行的运行环境，V8引擎指的银行的就是银行的业务核心。这个核心部件，包括编译器/解析器，靠他们来执行。
至于V8引擎他们的原理，暂且不懂，不过V8发动机虽然不知道怎么制造的，但是只要能把车子开好，也OK。
### 四、编译器/解释（执行）器：
编译器/解析（执行）器，这个到底是两个机器呢，还是一个机器呢？
在编译型语言中，比如c语言，他就是两个机器，先编译，后解析执行。 银行开户时，预处理人员搞好后，在交给核心审核人员，最后输出。 这两个人分开干活，运行效率高，但是开发效率低。
在解析性语言，比如JS语言中，他就是同一台机器，边解析，边执行。银行开户时，预处理与核心审核，两个活都是这一个人干，运行效率低，开发效率高。
### 五、内置库：
内置库，这个在银行的运行环境中，就是指的内置服务。为了能够提高核心人员的运行效率，需要把客户的单子，进行同一的编排，嵌入，复印、格式化等。
这个内置库，在语言运行环境中，就是给代码进行相关的包装、整形、打磨、切割、清洗、编码、统一格式、等，然后让代码能够高效率的通过V8引擎，快速输出。或者说是为了让V8引擎快速识别他，并处理他，执行他。
### 六、第三方库：
第三方库，这个说法是相对于内置库来的，因为内置库毕竟有限，所以需要有第三方库来支持。毕竟代码的格式千千万万，内置库也不可能全部搞定，需要第三方来援助。但是第三方库与内置库在功能上是一致的。如果有一天，第三方服务被银行收编了，呵呵，那么这个第三方库，也就成了内置库了。
### 七、如何学习编程
本来第7个话题是学习JS的方向，但是我把它改成如何学习编程了，因为我确实还没有找到学习JS的方向，不过我可以说说我的大致规划。
因为，我是完全不懂编程，甚至对于操作计算机来说，也不是很熟练。
学习语言编程，我觉得首先自己要固定好时间，是上午学?还是下午学?每天学多久? 因为我工作性质的原因，我给自己订的目标是每天不低于一个小时，周末不低于三个小时，且每天都要进行，就按着老师的授课顺序来。
根据我这几天的思考，我觉得我只能按着我自己的基础来制定学习进度。没有办法去同他人的进度保持一致，大家的水平相差太多。学编程这个东西，我感觉不比吃饭，嚼烂嚼不烂只管往下吞吞，编程一旦有一个环节没学会，后面的根本进行不下去。
鉴于我的基础，以及我毅力差的性格，我暂时不给自己订学习目标，不打算这个月，或者这个季度，达到某种水平。每天保证学习一个小时以上，哪怕连续几天都在演练同一个项目，那也没关系。
至于具体学习步骤，就是两个字：“试错”，不停的试错。该试的动作，一个都不能拉下，我始终觉得，学习不能走捷径。
有一句话叫做“每天进步一点点，坚持带来大改变。” 能碰到这么具有爱心的“幼儿园老师”，如果不珍惜，恐怕是这一辈子的遗憾。最好的学习方法是什么呢？答案就是“做”。
做，你就对了。
### 班级：JS编程幼儿园
### 学生：王云飞
### 日期：2017.08.12夜
================================================
FILE: homework/lesson1/wangzhongbin.md
================================================
第一节课的总结.md
---
周二听老师的课，第一次不是从字面，而是从普通人去银行开户的场景来了解整个js,对js的环境、执行逻辑有新的认知。
受益匪浅，类比是帮助理解的绝佳方法。
> ps: 这次是根据老师的建议，结合ppt,进行的第二次修改。
> 还是要注意听讲，不能自以为是……对于代码的理解出问题了。
## 类比代码执行流程
**老师的类比是通过优化银行的开户流程**
假如你去银行开户,流程是3个：
1. 填写申请单
2. 去柜台开户
3. 发卡
最简单的是你填写申请单，然后直接就能去柜台进行开户申请。
窗口的工作人员，会进行2个工作：
**1.检查用户填写的申请表对不对，包括格式和信息的准确性。**
>* 这里用户填写的申请单，就是你的代码：
每一个编程语言都要遵循相应的格式，即申请表的信息格式；
编程语言的内容，就是申请表上你填写的信息（包括格式）。**
**2.申请表填对了，银行才会对用户开户进行审批。**
上图中，银行窗口是一边检查一边执行，这样用户的申请表填写流程不会很麻烦，但银行的运行效率会很低。
这和解释性语言类似，
javascript作为解释性语言，就是一边编译一边执行，每一条代码在要运行的时候才会被编译，开发效率会很高，但执行效率会很低。
之后，老师对流程进行了4次优化，分别定义了银行的各种服务，包括：内置服务（打印身份证、存储款）、运行器（先预处理、确认申请表、再执行），以及第三方服务（充值话费或缴纳贷款？）。
从而定义了开户环境，这里，银行的开户环境就是代码的运行环境。
同时，针对不同的客户（普通客户/VIP金卡），银行会开辟出不同的工作环境，比如普通柜台，和vip柜台。
在不同的柜台窗口，银行的提供的服务，不都是一样的，这就类似javascript的2个运行环境，一个是浏览器，一个是nodejs。
在每个柜台窗口中，都会有一些自带的服务，比如（打印身份证、存储款）之类的，即是内置库。
## 运行环境
运行环境，是代码的执行环境，就是之前提到的银行的工作环境。你的申请，需要到银行的窗口才能被执行。
假如javascript是一条鱼，运行环境就是水。
但javascript是淡水和咸水都能活的鱼。
在电脑里面，js能执行的地方，一是浏览器，一是nodejs，在这两个不同的地方，js可以做出不同的功能。
## V8引擎
> V8是Google开发的JavaScript脚本引擎。
V8引擎编译和执行JavaScript源代码。
速度是V8追求的主要设计目标之一，它把JavaScript代码直接编译成机器码运行，比起传统的“中间代码+解释器”的引擎，优势不言而喻。
V8引擎是提升javascript运行速度的引擎
> 是javascript的发动机。
## 编译器/解释（执行）器
每一个编程语言在运行环境执行时，是先通过编译器、执行器来变成机器理解的语言，再让电脑执行。
javascript是解释性语言，即一边编译，一遍执行，它的运行环境是编译器/执行器合二为一的，这样它的开发效率很高。
不过因为是边编译边执行，运行效率就低。
而编译型语言则是把编译器和执行器分开，需要先把编译型语言分析优化，生成一个编译过的机器语言，再把它进行执行。
编译和执行是分开的，这样它的开发效率会低，但运行速度很高。
## 内置库
内置库是环境里面自带的服务。
javascript运行环境，是浏览器和nodejs，已经带有的各种服务，不需要再安装了，比如js的内置对象啊，网络库之类的，只要有浏览器和nodejs，就会有这些服务。
## 第三方服务
第三方服务，是除了运行环境中自带的服务之外，又被很多人/公司添加的服务。
比如，js要在水里游，这个环境里面的水啊、氧气啊之类，就是自带的服务，即内置库。
第三方服务就是被人/公司添加出来的，原生态的水和海里面是没有的，比如为了让鱼更好更快，有人投放了不同的饲料。
**复制了huangjiashu童鞋的话**
>第三方库一般都是指同种语言开发的拓展功能，以满足多样化的需求。当然不排除会用其他语言开发第三方库供JS语言编写的代码来使用。比如：用C语言写一个高级算法（因为C语言效率更高），然后开发接口给JS用。那么这个接口比如满足JS语言对C语言调用规范。即：两种不同语言之间的调用，要满足一定的规范。这种规范一般情况只能是这两种语言相互认可。。python和C之间的掉拥又会有他们自己的规范。在绝大多数情况下，JS不太会用到其他语言的开放库。在学习过程中只聚焦在JS的第三方库即可！
## 学习js的方向
* 掌握编程语言，用编程方式调用服务来完成你的需求。
* 了解和掌握重要的服务能力，使其能服务你的业务。
* 善于比较服务/技术之间的差异性，用最好的方式实现你的业务。
这是老师的语言。
对于小白的我来说，
最好的方法还是：
1. 紧跟老师的步伐，先把老师讲的吃透，明白。
2. 掌握编程的思维和方法，如学习读代码，理解编程的思维和语言逻辑。
3. 精进，掌握具体的代码编写方法。
我理解一个东西，会先从大的概况来统筹理解它，然后再模仿，再抄袭，各个击破，错误的话，知道是哪一个部位出错了。
目标：掌握自学javascript的基本知识。
更大的目标：用windows，掌握前端和后端技术，能够独立开发一些小程序，或者微信端页面，是我的基本目标。
附属目标：在学校的工程中，我也积累了很多windows学js的坑，希望能够整理出一套系列的文章。
================================================
FILE: homework/lesson1/wenliuxin.md
================================================
### 1. 类比代码执行流程：
a) 银行开户程序有用户，内置服务（打印、照相等），业务办理（核对申请表基本格式、审查申请内容是否符合标准）
b) 编程中，用户就是代码，内置服务就是编译器，业务就是执行器。
c) 代码执行流程类比银行开户：写代码（用户），代码在编译器编译（使用内置服务），提交到执行器（业务办理），执行。
### 2. 运行环境
好似小孩子生活环境的不一样，js有html环境和node.js环境。两种不同环境生活的孩子有不同的生活习惯，所以，不同的运行环境需要不同的代码
### 3. V8引擎
黑盒子，输入一样东西，出来相应结果。一种类似烤箱一样的东西，你把面包弄好形状放进去，出来就是想要的烘培好了的面包。
### 4. 编译器/解释（执行）器
编译器是把人类写的代码翻译成机器能够明白的代码，然后把这些代码发送到解释（执行）器中，电脑执行代码内容。
### 5. 内置库
运行环境自带的功能，也就是好像银行里面请求打印、照相之类的服务
### 6. 第三方库
除了js本身带有的功能，其他公司开发可以兼容到js的软件or功能
### 7. 学习JS的方向
掌握编程语言；掌握服务器；比较不同服务器，哪种能够最简洁完成任务就选哪种
================================================
FILE: homework/lesson1/wenyunxin.md
================================================
## 1、类比代码执行流程
代码的执行流程就好比人根据一项说明说去完成某件事情，比如制作番茄炒鸡蛋，根据食谱的说明，调用准备的材料，按照某种顺序将材料进行加工，最后完成制作。
## 2、运行环境
未查找资料我的理解：程序的运行所依托的系统构造。比如软件运行在windows系统和运行在lunix系统下，其运行环境就不一样。
## 3、V8引擎
运行JavaScipt初始功能代码的系统功能。
## 4、编译器/解释（执行）器
这应该是指能用代码运行的shell,如cmd,IDE,编程语言安装的shell等等。
## 5、内置库
编程语言自带的可直接调用的使用某些功能的函数。如python里的max等函数。
## 6、第三方库
需要额外安装的，有第三方编写的能实现某些功能的pakage。
## 7、学习JS的方向
网页设计的HTML、CSS、JavaScript。其中JS是使网页实现动态交互和数据传输的语言。微信程序开发。
================================================
FILE: homework/lesson1/wufan.md
================================================
# 类比代码执行流程
## 1开户的流程
个人到大厅填写申请，递交给窗口工作人员，然后，由工作人员校验/审核资质（这个过程包括1检查信息格式2检查信息准确性；核对1征信2资格），最后要么通过发证，要么驳回重新填写。
优点是结构很简单，缺点是操作效率低下，一次过关率低。
银行开户流程是为了完成一项任务--开户。
#### 四次优化的开户流程
改进后第一版递交给窗口工作人员之间介入了大厅工作人员预处理，类似于氨压缩机预先冷气，然后再膨胀机再制冷，若不这么做，膨胀机入口温度高会导致膨胀机受损。同样预处理后就会方便下一步运行。预处理后，开户申请正确进入窗口环节，错误则驳回重新填写申请。正确申请后，再核对征信和资格，正确则发证，错误则驳回。
改进第二版，省去了递交回个人的步骤，直接由大厅工作人员确认好申请单交给窗口人员。在大厅工作人员环节保证信息正确包括格式和准确性。这就防止了用户的过多负担和反复修改的可能。
改进版三，减少了大厅工作的内容，直接在窗口内的环境完成，窗口内由审查申请和执行申请，组成预处理和执行部分。预处理完交给执行确认好的申请。然后返回到窗口传递到用户那里。
改进版四，窗口内的环境增设了很多内置服务，方便快捷更有针对性服务，因为有了各种模板所以非常快捷便于用户操作。
定义开户流程，用户，银行/开户环境/内置服务、预处理、执行、窗口。
## 2运行环境
运行环境（浏览器、node）就是你要实现你需求必须去什么样的地方，这个地方能够满足你的需求，这就叫运行环境，比如你要洗澡要么去澡堂，要么去自己家里，要么去有干净水源的地方，这个地方就是你实现洗澡目的的环境。
为了实现你的一个业务或者需求，必须从某些内置服务或者第三方库的环境中调用相应的数据，这个环境就是运行环境。
开户环境就是一个办业务的环境，它能提供内置服务，预处理和执行业务的一些列流程。
开户环境：为了完成所需的银行服务必须去银行相关的地方来办理，这个银行就是开户环境。
多样化的业务环境包括普通用户或者VIP，类似于此，js的代码分浏览器业务和nodejs业务环境，代码在不同环境中的语法也是不一样的，编写的方法也不一样。
浏览器中的内置库，就是可以供代码调用的一切函数和第三方库如图所示
node的运行内置库与js只有js内置对象一样，其他的包括第三方库都不一样，所以这两者不能完全兼容，能在js环境跑的，不一定能在node上跑，这也是为什么js可以作为开发前端和后端的工具。
类似于不同的生活环境，js和node的不同环境属性，决定了了他们不能完全兼容，有一部分是可以跑的
业务架构，银行，用户，第三方服务。第三方服务类似于去公安局啊，单位开一些证明材料。
类似于业务架构，JS运行环境框架中，包含了浏览器运行环境，Nodejs运行环境对应的是普通用户的开户环境和VIP用户的开户环境。
输入代码是为了获得想要的结果，这个结果需要一个环境，就好开户只能去银行这个环境一样。如同递交申请和预处理执行审核一样，代码输入也希望能有想要的输出结果。
详细的环境是如何工作的，有代码调用各种库的函数等，再输入用V8引擎去执行。
## 3v8引擎
v8引擎：在编译型或者解释型的过程中，加速执行效率的那么一个内置服务，在黑盒子里。
## 4编译型和解释器
编译型先编译好完整的代码，然后执行。特点是，开发写代码效率低，执行运行快。
解释性是边解释边执行，运行效率低下，但是开发效率高。
编译型就是编译完再一块执行，如果有错误就要逐步检查，开发效率低，但是运行效率高。解释型边解释，边执行，开发效率高，运行相对来说低。
编译的进化之路，由开始的机器语言，到低级指令语言，到后来的间接调用低级语言的高级语言文件，一步步使得编程语言符合我们的自然语言逻辑。
通过阅读优秀代码库，来优化你的程序，更加高效的实现你的目的。
通过研究内置库和第三方库比如freecodecamp等github上排名靠前的js开发库来学习服务与技术之间的差异性，写出合适环境下的代码用于调用出最利于实现你业务的一些库
编程语言学的就是写出优雅的代码调用那些内置库，第三方库。
需要边编译，边执行的机器。
## 5内置库
内置服务：开户时银行内部提供的一组服务。开发环境中固有的一系列服务，比如澡堂有卖拖鞋毛巾等，提供橱柜保管财物的服务。
## 6第三方库
还是澡堂，它没有吃饭的服务，你需要去饭店吃饭，这个饭店就是第三方库，它可能就在澡堂附近。因为众多，所以称库。
第三方服务：银行不具备出具提供的证明等服务，需要由个人实现准备后，才能完成银行内部业务的服务。
核心业务：银行会有哪些直接提供的服务，供你能选择的业务，这些服务和业务就是核心业务。
预处理：在提供服务的时候，为了提高效率减少出错率，采取的有效措施。
执行：就是通过或者驳回客户的各种服务的申请。
第三方库一般都是指同种语言开发的拓展功能，以满足多样化的需求。不排除会用其他语言开发第三方库供JS语言编写的代码来使用。比如：用C语言写一个搞计算法（因为c语言运行效率更高），然后开发接口给js用。那么这个接口比如满足js语言对c语言调用规范。即：两种不同语言之间的调用，比如满足一定的规范，这种规范一般情况只能是这两种语言相互认可。python和c之间的调用会有他们之间的规范。在绝大多数情况下，js不太会用到其他语言的开发库。在学习过程中只聚焦在js的第三方库即可。
## 学习js的方向
分为浏览器的前端开发，和nodejs或者node，后端开发。方向不一样环境也不一样。
================================================
FILE: homework/lesson1/wukuipin.md
================================================
1. 类比代码执行流程
> 当你去银行开户，将开户申请表提交到银行窗口，银行接收申请，在后台处理，通过审查和执行申请，然后返回结果。如果信息审核通过，银行就通过申请，这样就开好银行账户了。
2. 运行环境
> 运行环境分为（前端）浏览器的运行环境和（后端）Nodejs的运行环境。
> 他们的内置库都包含有JS内置对象，都有第三方库。运行环境就相当于一个人的生活环境，他生存下去的物质需求以及生活和工作上的各种社会关系构成的生活环境。这相当于JS运行的库，JS代码要执行就的有运行环境，否则代码就失去意义。
3. V8引擎
> 就是对代码进行预处理和执行的黑盒子。
4. 编译器/解释（执行）器
> * 编译器：需要一个专门的编译过程，通过编译器翻译成机器语言。特点：运行效率高。缺点：开发效率低。
> * 解释性：一条语句执行的时候才翻译。特点：开发效率高。缺点：运行效率低。
5. 内置库
>运行核心，就是在运行环境里面有哪些东西我们可以去使用。如：网络库、日志库、JS内置对象等。
6. 第三方库
> 围绕浏览器运行环境和Nodejs运行环境有很多第三方库，以满足javascript代码的调用。
7. 学习JS的方向
> ***掌握编程语言***，用编程方式调用服务来完成你的需求。
第一步：学会如何调用内置库和第三方库；
> ***了解和掌握重要的服务能力***，使其能服务你的业务。
第二步，深入了解内置库和第三方库；
> 善于比较服务/技术之间的差异性，***用最好的方式实现你的业务***。
================================================
FILE: homework/lesson1/xianengqi.md
================================================
#
+要熟练掌握`编程语言`
##
+要熟练运用`内置库`
###
+运用编程语言灵活运用`第三方库`
================================================
FILE: homework/lesson1/xiaochaoge.md
================================================
# JavaScript 的基本概念
## **一、理解篇**
### **1.1 类比代码执行流程**
银行开户的流程演进就是程序语言一步一步演进的历史：
1. 最早开始的开户流程，主要依赖于用户自身和银行的交互，用户通过发出开户申请，银行负责审查和执行，最终确定是否开户。
> 这和最早的代码执行过程很像：代码向客户端请求一个命令，客户端核对无误后，才能执行。写代码的程序员花大量时间，千方百计的查找到错误，修正错误，才能进行下一步。更有可能的是，好容易通过了开户的资格审查，但是得到的并非正确的结果，就像开户的时候，张三的户挂着李四的名字，这个可是大大的不好了。修正这个难题本身，可能回比能正确的执行更重要。
2. 从用户出发，不仅仅是商业史上的重大演进，更是程序员的福音。通过大厅工作人员的检查校对，柜台办理人员的执行申请，是在编程里把编译器和执行器分开，编译的同时预处理，检查是否代码格式存在问题，执行时，关注内部的逻辑关系，把预处理和执行分开，极大的提高了语言的处理效率。
> 例如编辑性语言的 C 语言，通过编辑器的预处理和执行器的运行，提高了代码的处理效率。
3. 虽然按照两个模式提交代码能提高代码的运行效率，但是预处理和处理器能执行后自动执行，而不是让用户跑完大厅后继续在柜台前排队更能提高效率。
> 例如解释性语言的 JavaScript 做到了一边编辑同时执行，虽然从银行的例子来看，是提高了效率，但是不代表 JavaScript 比起 C 语言百利而无一害。
#### JavaScript 与 C 语言的区别
- C 语言运行起来不需要预处理，会体现为 **运行效率高，开发效率低** ；
- JavaScript 语言运行起来一边处理一遍运行，更符合人类语言，更容易读懂，更容易移植到其他平台，体现为 **开发效率高，执行效率低** 。
### **1.2 运行环境**
运行环境和代码的关系，说简单点，就是购物平台和电商的关系。以淘宝为例，淘宝是电商的平台，电商只有有货物，同时把货物上架到淘宝才能出售，确保货物能出售的买家卖家交流服务、能编辑处理货物的物理服务、以及处理钱款关系的支付服务，构成了交易体系的运行环境。
那么代码就相当于是货物，货物上架到运行环境后，要调用环境中服务来执行这段代码，包括这种货物能否找到以及调用合适的内置服务和第三方服务，是否符合可代码的正确格式，以及最终从输入到执行获得输出的结果。
- **总结一下，运行环境就是能满足代码处理和执行的环境，环境本身由内置服务和第三方的服务支持，以及预处理和执行器构成。**
当然，购物平台不止淘宝一家，所以执行代码的工具在不同环境会有不同的服务和体验，就像在亚马逊开店和在淘宝、京东开店一样，肯定有相似之处，但是也有不一样的服务 —— 关于买卖家的沟通，可能淘宝是我看到最好的，没有之一。
那么同样一串 js 代码，由于不同的需求，被送到浏览器的环境和 Node.js 环境，支持第三方库、内置库的不同，会导致编译的结果会有所不同。
### **1.3 V8 引擎**
V8 引擎，对初学者的我而言，并非一个很熟悉的概念。
简单检索了一下， V8 指的是效率高的 8 缸发动机， V8 引擎可能也是为了说明这个引擎快吧。 V8 引擎是由于 Google 为了提高编码的效率利用 C ++ 编写的一套提高效率的工具，缺失不产生中间代码、直接编译和执行确实提高了效率，但是提高效率更深层次的内容，我并没有看懂，下面是我检索到的文章，我觉得如果你想深入了解V8 引擎，或者以后我想深入了解它，可以借助这篇文章：
http://blog.csdn.net/horkychen/article/details/7761199
但是，我可以理解 V8 引擎像游戏机，当我按下游戏机的按键时，游戏机内部发生了什么我并不知晓，但是我还能很好的控制遥控游戏中的角色，不是吗？目前，我先要看到结果，学会输入和结果之间的关系已经足够了。
- **总结一下，V8 引擎我可以认为它是个神奇的黑匣子，我不知道黑匣子里面是什么，但是我知道它能同时预处理和执行代码，是运行环境最为核心的组成部分。**
### **1.4 编译器、解析（执行）器**
就我的理解而言，编译器、解析（执行）器其实就是黑匣子 V8 引擎干的事。把它们分开的依据，可能是因为他们的目的不同吧：
- 编译器：分析词法、分析语法、分析语义、优化代码
- 解析（执行）器：解释代码、执行代码
**对于编译器、解析（执行）器，前者负责看代码是否有错误，进行预处理，后者加工。把 V8 引擎看成一个黑匣子般的香肠的加工工具，输入的代码就是肉，输出的是结果是香肠 —— 那么编译器就是肉类的分拣、简单处理、剔除杂质，保证更容易被加工；解析（执行）器就是个干！**
### **1.5～1.6 内置库、第三方库**
理解库的关键在于 —— 为什么需要库？
库是为了能使得代码执行高效而可以被调用的一组程序。其中的一组程序和编译器、解析器一起直接被植入环境，被植入环境的程序叫内置库，不在环境内的叫第三方库。
当环境改变的时候，内置库和第三方库都会改变，就像一个婴儿和一个中年人所生活的环境不同，类似于浏览器的环境和 Node.js 环境的差异，那么它们所需的内置库和第三方库也就不同。
### **1.7 学习 JS 的方向**
工具只是实现方法，而想象力可以把我们带到任何地方。学习 JS 或许是想把想象中和真实构建连接的台阶吧。
学习 JS 之初，先能满足想法的需求，做出来，掌握语言，保证先能实现再说；其次，需要了解服务的类型，用更好的服务服务你的需求；最后能对比服务和技术的差异，用最好的方式实现你的服务。
或许以上是做一个好程序员的需求，但是对我而言，了解 JS 的发展，判断它以后还会怎么发展，以及 JS 的理论还能用在别的其他什么地方，以后未来人和计算机是怎么沟通的，或许是更吸引我深入与它对话的原因吧。
反正未来大部分人的判断是人工智能，那么，如果人类和计算器交流的是未来的趋势，为什么不先假定这个计算器领域使用最广泛的语言 —— JS 开始呢？
## **二、代码篇**
### **2.1 git 基础**
#### GitHub 新建项目指南
1. Fork项目／新建自己的项目
- New repository
2. 克隆项目到本地
- git clone url
3. 第一次改动
4. 查看改动的文件
- git status
5. 改动本地提交
- git add -A
- git commit -m"改动内容"
6. 推送到远程仓库(远程服务器)
- git push origin master
#### Fork 项目更新
**命令模式：**
1. 确定同步的本地文件地址
- 终端 > cd 到自己 fork 后 git clone 的项目
2. 数据源
- git remote add upstream xxxx
- “xxxx”代表你需要与之保持同步的数据源，需要键入同步的git项目地址
3. 取上游数据
- git checkout master //切换至master分支下
- git fetch upstream //获取上游数据
4. 数据合并
- git merge upstream/master//进行主节点和上游节点数据的合并
5. 本地合并后文件上传至 github 服务器上
- git push origin master
#### 山穷水尽：丢弃所有本地改动和提交，从服务器获得新历史版本
git fetch origin
git reset --hard origin/master
### **2.2 还未熟悉掌握的指令**
#### rm 命令 删除文件或牡蛎
rm file_name
rm -rf file_name // 强制删除
================================================
FILE: homework/lesson1/xieyuhui.md
================================================
带你走进Java script
1. 当你去银行开户，你需要填写表格然后提交至窗口，静等银行工作人员校验、审核。通过之后你的开户任务就完成了。
http://t3.qpic.cn/mblogpic/6623754549bead7e26ac/460
2. Java script和银行开户是一样的流程，你需要把代码写入终端提交，解释器分析、解释、执行。通过后你就得到了你要的结果。
http://t3.qpic.cn/mblogpic/640a2eec3d0a15fae874/460
3. 当然银行开户还需要你的身份证复印件、相片，银行都配有这些内置服务。银行之所以能够审核你信息的真实性需要必不可少的第三方服务，
也就是必须有公安系统的支持。银行开户分普通开户和VIP开户，普通用户标配的内置服务、调用的第三方服务和VIP用户标配的内置服务、调
用的第三方服务会有所区别。
http://t3.qpic.cn/mblogpic/6abf7e2de0d11db1ac4e/460
4 JS也配也有标配的内置服务，和可以随时调用的第三方库。JS分为浏览器运行环境、nodejs运行环境，不同的运行环境所提供的内置服务和
第三方库是不一样的。
http://t3.qpic.cn/mblogpic/f2ead7db649e3baf4f9c/460
5. JS的运行环境：
http://t3.qpic.cn/mblogpic/868ff88839c94709c5e0/460
http://t3.qpic.cn/mblogpic/6604ded60b59ad706640/460
http://t3.qpic.cn/mblogpic/d6ab25e3dcaa5cedc0fa/460
6. 浏览器的运行环境包含的内置库、第三方库：
http://t3.qpic.cn/mblogpic/34f8789aa6ee3fe82650/460
7. node运行环境包含的内置库、第三方库：
http://t3.qpic.cn/mblogpic/d0f9ea51b80e027fb65a/460
8. v8引警就先省略了，反正我是不懂。
9. 编译器/解释器的差异？
• 编译型：需要⼀个专⻔的编译过程，通过编译器翻译成机器语⾔。你需要输入程序代码 -> 得到可执行代码要得到执行结果还得再去执行可执行代码，
从用户的角度看有[一个单独的编译步骤]和[一个单独的执行步骤]特点：运⾏效率⾼。缺点：开发效率低。
http://t3.qpic.cn/mblogpic/39ddd5d9e61879d020e2/460
• 解释性：⼀条语句执⾏的时候才翻译。你只需要输入程序代码 -> 得到执行结果，从用户的角度看一步到位。特点：开发效率⾼。缺点：运⾏效率低。
http://t3.qpic.cn/mblogpic/027f3f9f2b0bd625fd64/460
10. 下图是学习JS的方向：
http://t3.qpic.cn/mblogpic/237d52b51d29cd39d1b8/460
http://t3.qpic.cn/mblogpic/16dcfb93b2bfaf59c8f8/460
11. 无论你是小白还是已经在工作，你都应该明白该怎么进阶：
http://t3.qpic.cn/mblogpic/814e89b2c5bc04d4cffc/460
================================================
FILE: homework/lesson1/xiongliyu.md
================================================
-----
# 第一次作业
## 1.类比代码执行流程
老师用银行开户的流程来类比代码执行流程，首先把开户的流程大致的分为 了三步，从这三个步骤触发，逐一思考如何改进流程，发现了4各个需求：
1. 银行工作压力大 。
2. 用户压力太大，流程过多（其实到到改进版二我觉得基本的问题就没有了，接下来的改进，就是让这个流程更加优质）。
3. 提出一个疑问，能不能让用户只面对一个对象。
4. 用户在进入流程填写申请单之前用户还需要哪些东西。通过不断地分析需求、优化流程，最终得出一个完美的“用户开户流程”。
> 我的感受：从学习的角度看：
> 1. 我们可以借鉴老师的思路，首先学会最基本的知识，然后去思考，去主动发现不足，带着思考和问题去主动学习。
> 2. 我们写的代码的执行过程就像上面的例子，今后的学习过程需要我们不断地去思考我们的代码，从而优化我们的代码。
> 3. 写代码的时候，是不是可以先梳理清楚我的思路？我要解决的问题是什么？还有没有别的更好的办法，然后再去把我的思路用代码书写出来？是这样吗？如果是这样的话，那么养成这种习惯就很重要。
## 2.运行环境
浏览器的运行环境就是支持浏览器正常运行的各种资源（库），如果少了某一种资源（库），就会出问题。JS和node的运行环境就是不一样的，我们得区分开来。得清楚我在什么运行环境，我需要掉什么库，来解决我的问题。
## 3.V8引擎
老师把他比如城一个 黑盒，不用去管的东西，不用去管代码是如何执行的。我发现一个现象：我们在学习JS的路上好像会很多的“V8引擎”，函数中有、数据类型转换中有、vue中有等等。我感觉每一个新的知识点都有，又好像，新手会不自觉地去思考它道德是如何实现的，那么是不是在我们的学习过程中，就应该清醒知道那些是V8，别去管它。是这样吗？
## 4.编译器/解释器
属于V8引擎类的东西。JS代码就是边翻译边解析边执行，也是不用管的。知道有这么个东西就可以了。
## 5.内置库
属于JS运行环境中最重要的部分，也是我们学习JS的重点，需要去聚焦、熟练的部分，它是服务于我们写代码的，只有掌握了才能去调用这些内置库，从而完成我们的代码。梦想大楼的地基啊。
## 6.第三方库
由第三方开源出来的库，也是学习需要聚焦的重点，学习初期听老师的话先把注意力在vue上。
## 7.学习JS的方向
谨记老师给初学者的建议：**掌握编程语言，用编程的方式调用服务来完成我的需求 **。掌握编程语言，犀牛书就是我们要去搞懂的，多练的编程语言。
================================================
FILE: homework/lesson1/xugang.md
================================================
# lesson1 学编程，为更好--xugang(徐钢)
## 更高、更快、更强
计算机、互联网处理信息、传递信息的效率很高、成本很低。如简单类比，处理信息对应生产，传递信息对应交易。一个行业生产、交易的效率高、成本低。这样的行业不火，很难。
但计算机、互联网再厉害，还是得靠人告诉他们做什么和怎么做，才能创造价值，服务于人。离开了人，就什么都不是。人既是起点，也是终点。
所谓编程，就是告诉计算机和互联网做什么以及怎么做，就是给计算机和互联网设计工作流程。计算机和互联网的高效率是否能够发挥出来、能够多大程度的发挥出来，取决为他们设计工作流程的人的水平。就好比屠龙刀拿在樵夫手里，只能多砍点柴；拿在张无忌手里，才能号令天下。学编程就是为了学会利用计算机、互联网这两个当今世界的倚天剑、屠龙刀，实现更高、更快、更强的目标。
## 编程就是做流程
徐老师在课上以银行业务流程为例，非常生动的为我们介绍了编程中最重要的思想，我总结为：
“以安全、稳定为前提、以高效为目标的流程意识。”
课上徐老师还通过对银行流程的4次优化，让我们理解了流程的重要性，以及流程改进的空间及方法。作为一个小白，对此的理解定然浅显。以后还通过学习和实际项目加深领悟。
##人人都是程序员
回味徐老师的讲解，我觉得学习编程不仅是学习编程，更是学习一种方法论。编程中的流程意识何尝不是做人、做事的道理？对安全、稳定、效率的权衡拿捏，不也是为人处世的主要议题吗？那些不就是人生事业中的流程意识吗？对于我们普通人，三分天注定，七分靠打拼，我们就是自己的程序员，事半功倍、人生几何，主要靠自己的编程水平啊。既然人人都是程序员，有什么理由不学习编程呢？
跟着徐老师从JS学起，人生幸事！
================================================
FILE: homework/lesson1/xugaoyang.md
================================================
【第一次作业】写一篇总结
运用下面这些关键词，把你知道的写出来。
1. 类比代码执行流程
2. 运行环境
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向
提交方式：
1. 请向getting-started-with-javascript项目发起pull request。
https://github.com/xugy0926/getting-started-with-javascript
2. 文档格式，markdown。
3. 提交homework/lesson1目录下。
================================================
FILE: homework/lesson1/xuli.md
================================================
# Lesson 1 上课心得-许丽
## 写在前面
当课程进行到了后1／2，我才来提交lesson 1的作业，其实还真是相当惭愧。
认真分析自己如此拖延的根源在于：
1. 自己的探索能力真心不够，卡在一个环节后，不进行各种方式去自我尝试。 然后就一拖再拖，每天充满内疚感。
2. 自己终究还是表现型选手，不好意思去请教自己觉得太low的问题，然后一个劲地瞎琢磨，学习效率极低！
3. 总是想着，每个人的注意力都那么宝贵，我真不好意思去打扰。其实在再次看了笑来老师关于“贵人”那一期专栏时，我就应该告诉自己，其实求助不等于乞讨。。。
其实都是自己内心想得太多再作祟。谢谢娟娟组队不嫌弃我。终于，我才真正意义上开始了自己的做作业之旅～，这种感觉真好～
## 关于lesson 1 知识点的理解
### 类比代码执行流程
第一遍听高阳老师通过`设计银行开户流程`的方式，从而类比代码执行的流程。就在内心表示非常诧异。
以前只是感慨笑来老师的几个类比特别经典，但是现在却是看到高阳老师将类比用得如火纯青的感觉。
当我再重听了几次回放之后，我自认为自己是理解了代码具体怎么执行的，当我想不清楚的时候，我就重新回顾下老师是怎样用银行开户流程一步步地优化出最后的架构来的，然后再将 js代码与用户做替换，将运行环境与开户环境做替换。似乎就慢慢完全理解了。
### 运行环境
一方面，老师用银行的普通用户开户环境与vip用户开户环境，分别类比为：浏览器运行环境与Nodejs运行环境；另一方面，老师又用婴儿生活环境与小学生生活环境进行同样的类比。
我是直接简单粗暴地理解为代码运行犹如很平常的每一个人做一件事都有其特定的环境一样正常。只是似乎Nodejs运行环境是更高一级的运行环境，而浏览器运行环境更低级一点点。
### V8引擎
V8引擎包含预处理与执行的模块，我根据老师ppt图片简单地理解为运行环境的一部分，类似银行窗口人员对开户申请单的审查申请与执行申请功能。
根据老师上课时说的话，我甚至又简单粗暴地理解成——对于我们这种初学者纯小白而言，可以暂时不用去管v8引擎到底是如何运作的，它对我而言暂时一点都不重要～
### 编译器／解释（执行）器
看了其他同学的作业，似乎我感觉我更应该理解老师的意思是让我们理解解释型（JavaScript)语言中的 编译器／解释器。 不知道我理解错了没有。
类比于银行开户流程设计中的 第一个最简版本的流程，其中的窗口工作人员既负责校验格式等初阶工作，又负责审核资质核对征信等高级工作的内容。
似乎可以理解为编译器／解释器做了所有的工作，包括：分析词法、分析语法、分析语义、优化代码、解释代码、执行代码等工作。 因为工作内容繁多，所以运行的效率偏低。
### 内置库
我依然是基于老师对银行开户的内置服务类比，理解得总是非常简单粗暴。内置库就是为用户的代码提供一些最基本的最常用的内部服务。这个库可以供不用的用户进行调用，类似于一项公共服务，可以节约社会资源。
### 第三方库
第三方库类似于对内置库，这项公共服务的补充服务，但是是由单独的第三方提供的，有针对性的一些也会经常用到的个性化服务的一种资源。
## 关于我自己学习JS的方向
直到今天（2017年8月31日），似乎我也不知道自己要学习的JS方向到底是什么，也许会向老师在第六节课内给出对女生的建议一样吧——做前端。
不过暂时倒是没有想过要做个女工程师。暂时的想法是从本职的财务工作，转销售。 希望学习了编程之后，能够提升自己的工作效率～
## 我还想说......
感谢高阳老师，特意给我建了一个“准妈妈帮帮团”，还给我一对一远程地指导～
感谢娟娟同学，组建了一个妈妈帮，让我终于迈出了第二步，进入学习状态，好像我终于不会再那么不好意思啦～
娟娟昨天微信上问我：讲真，你有没有想过放弃js课程？
我说： 还真不想放弃，这是我最想学成的一门课，虽然落下很多，坚持得有点累，但是，我依然会努力跟上，大不了我下次，下下次再接着上课！
是的，这就是我最想学会的一门课，不像英语，财报那些我多少有点儿基础，而这门课就是我零基础学的，我想，如果我能学成它，以后就不会有太多事儿能够难倒自己了～
我得加油！我知道， 只要我自己不放弃，我就永远有救！ 再次谢谢老师和同学们！
================================================
FILE: homework/lesson1/xuluchun.md
================================================
<h1> 许路春第一课总结 <h1>
<h3>牢记学习的方向</h3>
<ul>
<li>入门，掌握编程语言</li>
<li>掌握，经常使用的库</li>
<li>进阶，熟习各种库，并能够比较其优缺点</li>
</ul>
<h3>javascript组成</h3>
<ul>
<li>第三方库</li>
<li>自己的代码</li>
<li>内置的的v8引擎</li>
</ul>
================================================
FILE: homework/lesson1/xumin.md
================================================
# JavaScript入门第一次作业小结
> 参考：markdown语法 [http://wowubuntu.com/markdown/]
> 回顾：pull request [https://github.com/xugy0926/getting-started-with-javascript/wiki/%E7%AC%AC%E4%B8%80%E6%AC%A1pull-request]
> PPT课件：[https://github.com/xugy0926/getting-started-with-javascript/blob/master/ppt/JavaScript%E7%BC%96%E7%A8%8B%E5%85%A5%E9%97%A8_%E7%AC%AC%E4%B8%80%E8%8A%82.pdf]
## 第一步，优化流程设计
老师使用银行开户流程设计来类比代码执行流程，通过具体的流程图，帮助我们这些小白更好地理解程序设计的思维方式。
首先搭建整个银行开户流程框架，然后不断优化执行流程，提升整体效率。
通过任务梳理、罗列操作步骤、细分功能，找出可优化的模块；并单独组建新的内置服务模块，从而将预处理和执行模块有效分离；再将银行的操作封装，用户只需通过窗口输入需求，再对窗口的输出反馈。
## 运行环境
如果银行相当于JS运行环境，用户的开户环境就是浏览器运行环境、Nodejs运行环境。浏览器是普通用户的开户环境，Nodejs是VIP的用户环境。无论普通用户还是VIP用户，他们的运行环境都包含内置服务和V8引擎。此外，还有第三方库，也就是银行本职工作之外的服务，比如保险理财产品之类，有需求可供调用。
## V8引擎
V8引擎直接将JavaScript代码编译成机器语言，相当于打包成一个可以执行代码的黑盒（内含编译器/解释器），不管是Chrome浏览器，还是Node.js，都经由V8引擎处理。
## 编译器/解释（执行）器
编译器，把用户需求转换为计算机机器语言，由后台执行处理。特点：代码运行效率高，但是开发效率低。
解释（执行）器，一条语句执行的时候才翻译。特点：开发率高，但是运行效率低。
## 内置库
内置库提供了可调用的用来实现某些特定功能的便捷服务。比如浏览器运行环境中的JS内置对象、HTTP、WebAPI；Node运行环境中的 Node API等。
## 第三方库
第三方库是有别于内置库的一个开放的外部资源，不断更新，并为用户提供更好的服务。比如Vue等。
## 学习JS的方向
JS变化快，范围广（用老师的话说是没有边际的），一入JS深似海。其实我们的学习成长之路也一样是充满变数而又漫长的，所以正好可以把学到的JS思维方式平移到工作学习中。
世界将在我们的探索中更加宽广。
================================================
FILE: homework/lesson1/yammy.md
================================================
# 第一节 JavaScript 课程总结
今晚在新大学了第一节 JavaScript 课程，以下是课程总结：
1. 类比代码执行流程
徐老师开场用一个银行开户的流程来类比代码的执行流程。
首先，我们知道，开户的大致流程可以分成三个部分：
其中有两个角色，一个是开户人，一个是银行工作人员，图解就是：
这个流程改进一下，就是分工明细，图解：
接来下，本着客户是上帝的责任心（并没有），银行还可以优化客户的流程，跑来跑去也挺累的，跑腿的活交给工作人员吧。
其实管他工作人员是谁，只要有人为客户服务就好，给我们一个窗口，我们客户只需要坐着填表和检查核对信息就好了。
是不是还有优化的余地呢？复印查询这样的活儿有人帮忙做就好了。
最后抽象一下流程，图解：
代码的执行过程也是类似的流程，比如 JavaScript。
虽然我之前学过 一点 ruby 和 python，通过这样类比的方式，更加加深了我对代码执行的流程的理解。
2. 运行环境
JS 运行的环境有两种，一种是浏览器运行环境，一种是 node 运行环境。
这是两种不同的运行环境，就像小盆友和成年人的生长环境不一样是一个道理。
举例来说，浏览器的运行环境可以运行 `alert("hello");`，浏览器执行这段代码会弹窗一个 hello 的警告。
3. V8引擎
V8引擎是 JS 运行环境中的一个重要组成部分，是由Google开发的开源JavaScript引擎，用于Google Chrome中，专门处理JavaScript脚本。
除此引擎外，不同的浏览器都有自己的 JS 引擎，比如Safari的JavaScriptCore引擎，Firefox的SpiderMonkey引擎等。
4. 编译器/解释（执行）器
编译器和执行器是编译性语言的重要组成部分，这种类型的语言先用编译器编译写好的代码，然后用执行器来执行编译好的代码，特点是运行速度快，但开发效率低下，典型的代表是 C 和 C++等，这种语言是机器友好型语言，但对人类不友好。
编译器和解释器，在解释性语言中的作用是一边编译代码一边翻译代码，最后交给机器去执行，特点是开发速度快，但运行效率低，典型的代码是 Python、Ruby 和 JS。这种语言是高级语言，对人类友好。
5. 内置库
内置库是 JS 内置的一些库，可以直接拿来调用。
6. 第三方库
第三方库不同于内置库，需要require 才能从外部调用。
7. 学习JS的方向
学习 JS 最好最快的方法是去不断的使用他，让他帮你实现你的想法，解决你的问题，服务你的业务。
================================================
FILE: homework/lesson1/yangchunguang.md
================================================
##第一次作业
第一次提交作业，还不懂如何使用GitHub，就当跟它混个脸熟吧。
上编程课给我最大的感受就是，提出一个问题，会引出一堆问题来，这些问题好像没有穷尽，以至于差点放弃。我争取跟上大部队的进度。
感谢高阳老师耐心授课，感觉学不会都对不住老师。
1. 类比代码执行流程
我理解的执行流程是：定义-运行-输出。
当老师用银行开户去类比时，我还想，这个比喻倒挺贴近生活。当进行到优化开户者的使用体验时，我感到编程的思维太牛逼了！
如果能把编程思维用到生活中，那解决起问题来不是要逆天！但是后边一没听懂就泄劲了...
2. 运行环境
我理解的运行环境，就像是鱼生活在海水里，自带了氧气、水、矿物质等元素。代码就是鱼，环境就是海水和海水所包含的元素。
JS的运行环境有浏览器和nodeJS两种。
3. V8引擎
就是代码的处理器。
4. 编译器/解释（执行）器
就是对代码进行翻译和执行的工具。
5. 内置库
供代码调用的功能模块
6. 第三方库
第三方供调用的模块
7. 学习JS的方向
页面、小程序
================================================
FILE: homework/lesson1/yanglovewo.md
================================================
【第一次作业】写一篇总结
1. 类比代码执行流程
2. 运行环境：终端，浏览器
3. V8引擎
4. 编译器/解释（执行）器
5. 内置库
6. 第三方库
7. 学习JS的方向:想要完成专门课程，实现从0到0.5.
================================================
FILE: homework/lesson1/yangtieming.md
================================================
# JavaScrip Lesson 1 homework.
对于编译型语言，原始的代码需要经过**编译器**的加工处理，把它先变成**解释器/执行器**可读懂并可执行的代码，然后再交由**解释器/执行器**执行。
这个过程就像我们过年时买回家的半成品年夜饭，所有的食材和佐料是由商家帮我们加工好了，我们自己只要在锅里炒一下就可以了。
商家就是这个**编译器**。我们自己的炒菜行为就是**解释器/执行器**的行为
对于解释型语言，则是将原始的代码直接输入给**编译器/执行器**，由**编译器/执行器**逐条的解释和执行。
这个过程就像一个看菜谱烧菜的人，通常会读懂一步，按照说明操作一步。
假设我们准备的生的食材就是我们自己编的代码。
我们烧菜所需要的锅，铲，煤气灶，油，盐，酱，醋等等烧菜必备的工具和调料就类似于原始的代码**运行的环境**。
假设左边的灶头上只能用来烧菜，而右边的灶头只能用来烧饭。
那么左边烧菜的灶头就像**浏览器运行环境**，而右边的灶头就像**Node.js的运行环境**。
而专门用作烧饭的各种专业锅具就是浏览器的各种内置服务，而专门烧菜用的各种锅具就是Node.js的各种内置服务（**内置库**）
有时家里来了要宴请客人，锅碗瓢盆不够，就向邻居去借，而邻居提供的锅碗瓢盆就像第三方提供的服务（**第三方库**）
家里古董似的老旧灶头火候太小，烧菜烧饭要一个小时，换了新的老板牌燃气灶烧菜烧饭10分钟就搞定，老板牌燃气灶就像**V8引擎**，可以提供大火，快速加热。
然后人类食欲无边，总是不断推出新的菜品，要提高自己的厨艺，就只能不断的学习，这就是**学习JS的方向，无边无际……**
================================================
FILE: homework/lesson1/yangxuewu.md
================================================
# 第一节课总结
## 1. 代码执行流程
老师通过“到银行开户”这样一个事件需要操作的流程，把用户比作代码，银行内部操作比作运行环境，银行提供的第三方服务比作第三方库。用户与银行以及第三方服务之间的关系，即代码与运行环境及第三方库之间的关系。
用户在开户时，按照银行内部提供的表格填写自己的信息，再交给银行进行处理，最终用户得到开户账户，同时一些第三方的服务会给用户提供各类开户所需要的证明，方便了用户的整个开户流程。
代码的执行流程与此相似。程序员根据运行环境要求编写符合语言要求的代码，运行环境对代码进行处理，最终反馈结果，同时用很多的第三方库方便程序员调用，以更高效的编写代码。
## 2. 运行环境
运行环境分为浏览器运行环境（前端）和Node.js运行环境（后端）。
运行环境类似于我们人类的生活环境，小孩和大人有着不同的生活环境，老师和学生也有不同的生活环境。每个人只有在适合自己的生活环境中才能更好的生存，否则生活将会很艰难，而代码的生活环境（运行环境）则更苛刻，离开了自己的运行环境，代码将根本无法执行，也就失去了意义。
## 3. V8引擎、编译器/解释器
V8引擎是Js运行的核心部分。我们所编写的高级语言，本质上计算机是无法直接执行的，需要通过编译器将其编译成计算机可以识别的代码。就相当于说不通语言的两个人需要相互交流，需要一个翻译一样。V8引擎中的编译器就起到了将高级语言翻译成机器语言的功能，使得我们编写的易于人们阅读的高级语言代码能够顺利的转换成人们不易读懂但机器能轻松理解的机器语言。
## 4. 内置库、第三方库
内置库是支撑我们编写的代码的核心，是我们编写js代码的基础。即只要我们开始编写js代码，不需要任何的操作，就可以使用的方法、函数等都是来自内置库的，例如在老师的演示中使用的`console.log()`,`alert()` 。
第三方库是一些高级开发人员为了方便大家编写代码而基于 JavaScript 开发的库文件，它在js的基础上扩展了其功能，是的开发人员在引用了这些库之后，开发效率更高。第三方库有很多，但在学习的时候不能盲目贪多，应该根据自己的需要选择一个合适的库，然后深入的去研究它，吃透它，让第三方库为自己的项目服务，而不是让自己的项目跟着第三方库跑。
## 5. 学习JS的方向
1.
学习一门新的编程语言，首先要掌握好这门语言的基础知识，通过一段时间的学习，要使得自己不再犯一些低级的错误，掌握最基本的操作。
2.
> 了解和掌握重要的服务能力，使其能服务你的业务。
JS的方法、函数、第三方库有很多，不能盲目的学习。首先要知道自己用这个服务能做什么，能实现自己项目的什么功能，然后从实现自己项目功能这个点出发，利用内置库和第三方库，解决自己的问题，在解决问题的过程中不断掌握重要的服务能力。当能够熟练运用好一项服务/技术时，就需要进入的下一个阶段。
3.
> 善于比较服务/技术之间的差异性，用最好的方式实现自己的业务。
即在上一个阶段，为了解决问题，选了一种解决方法，最终解决了问题，之后就应该思考这个问题还有没有更好的解决方法，鉴于js第三方库的种类繁多，解决同一个问题有很多种解决方法，如何区分这些方法的差异性，是快速提高自己的关键。
会用内置库、第三方库是第一步，深入理解内置库、第三库的工作流程是第二步，学会在不同的库之间进行比较，使其能更好的实现自己的业务，是第三步。
4.
JS的世界有两大特点。
一是变化快，可能几个月就会出现一个新的库，每年都会有新的JS标准，但在学习的过程中不要害怕赶不上潮流，更不要随波逐流，潮流是永远都追赶不上的，只有深入研究，使其服务于我们的业务。
二是无边际，js本身的创造能力非常强，看看那么多第三库就知道了。但我们再学习的时候一定要聚焦，瞅准一个目标进行深入的研究，而不是陷入js 的浩瀚烟海中无法自拔，最后成为一个对各类库性能如数家珍却根本不会用的人，就像知道所有的车标却不会开车一样。
================================================
FILE: homework/lesson1/yangyepeng.md
================================================
## Lession one homework **javascript**
### 1. 类比代码执行流程
以银行开户流程来为例，用户要开银行账户，需要先填写申请表，准备申请资料等信息。
然后申请表和申请资料需要提交给银行大厅工作人员或者窗口工作人员进行资料审核，审核之后再进行开户操作。
这个过程我们抽象出三个步骤
- 资料填写
- 资料审核
- 执行申请
这个过程类比到程序执行的过程就是
- 资料填写： 可以理解为代码编写过程
- 资料审核： 可以理解为代码的编译和解析
- 执行申请： 可以理解为执行代码
资料审核过程的不同，对于效率的影响也不一样。如果资料审核和开户申请一起执行，对应到程序就是解释性的开发语言，它的特性就是程序运行效率低。
很容易理解，如果银行窗口的人员既要审核用户的资料，又要同时进行开户，那么处理的过程就比较缓慢
但是如果资料审核这个过程交由大厅工作人员进行提前核查，那么就相当于做了程序的预处理，也就是对代码进行编译。而这个对应到开发语言就是编译性开发语言。那很容易想象到就是，窗口工作人员的开户效率会大大提高，因为提交过来的资料都是审核过的正确无误的。执行的效率也就非常的高。因此也就很容易理解编译型语言为什么执行效率比较高。
最后，我们知道基本上所有的银行都会把用户分成普通客户和VIP客户，对于两种不同的客户会提供不同的业务和服务。
通过这个例子的类比让我们理解，JS也会分浏览器环境和Nodejs两种运行环境，在不同的运行环境下，会有不同的内置服务和第三方库。
### 2. 什么是运行环境
前面已经提到JS有两种运行环境，浏览器的运行环境和Node运行环境。
那么什么是运行环境，运行环境是即是程序运行的基础，配套服务，以及能够调用的模块等等。
### 3. V8引擎
就是相当于一个代码执行的编译器或者解释器。我们可以把它理解为一个程序预处理和执行的黑盒子。
你把程序交给引擎之后，它会把处理结果给你输出出来
### 4. 内置库
写代码其实就是在调用各种内置的库，不同的运行环境的内置库是会有区别的
- 浏览器的内置库包含JS内置对象，WebAPI, WebGL, HTTP, WebRTC, canvas等。
- Node内置库包含JS内置对象，Node API等
### 5. 第三方库
第三方库是指由第三方提供的收费或者免费的库。可以理解为别人提供的武器库，拿来就可以用。
### 6. 学习JS的方向
之前学习Ruby的时候，感觉学的懵懵懂懂，很多概念没理解清楚。
通过徐老师的JS课程，对编程的很多概念和逻辑有了更深入的理解，所以希望通过这个课程促进编程学习的融会贯通。
使自己能在编程这条路上再往前一步，从小白慢慢想着新手，高级新手和熟练运用的方向迈进
================================================
FILE: homework/lesson1/yanqingmu.md
================================================
# 编程世界类比理解大法
本文是JavaScript编程入门第一节课的作业，之所以起这个名字，是因为徐高阳老师活用类比的方法，重新刷新了我对编程的认知。
过去我学习编程的经历是这样的，翻开一本编程教程，一上来就是数据类型、变量、数组、指针、循环、函数、迭代等等，然后基本就差不多了——差不多到放弃的时候了。所以在编程的世界里我在不停的「入门」，这道「门」很邪乎，每次我一进去就又出来了。
而这节课也让我终于明白到底是哪里出了问题。既然进了「门」就应该往前看，去发现眼前全新的世界，而不是继续盯着「门」看，那只会让自己又重新走出来。所以来一起看看这编程世界到底是什么样子吧。
### 1.代码执行流程
我把「代码的执行流程」看做是「工业产品化的过程」。通常一个工业产品化的过程包括设计、工艺、采购、生产加工、质保、销售、售后等诸多环节。而代码的执行似乎很简单，只是输入代码然后输出结果。
但实际上程序猿在打代码之前要先构思程序的功能和实现功能的方法，然后把这些思考用代码的方式表达出来，以便计算机可以执行。这跟工业产品设计师做到事情是一样的，设计师同样会根据产品功能要求思考实现方法，然后形成图纸和设计文件，以便后面可以顺利的生产。
区别只不过是计算机把后面生产的过程都完成了而已。这分明是逼着人转行当码农的节奏。
### 2.运行环境
把注意力集中放在了「环境」这两个字上，可以更容易的理解这个概念。所谓环境，就好比我们去商城购物、吃饭、看电影；去医院看病；去球场踢球一样。商场、医院和球场就是环境，在不同的环境里我们做的事情也是不一样的。
所以当我们听到，浏览器环境是做前端的，Node环境是做后端的，也就没什么可奇怪的了。它们不过是在不同的环境，做不同的事情而已。
### 3.V8引擎
喜欢汽车的同学都知道，引擎性能越高，车子的动力越强劲。至于是V8还是V12，那都不是重点。既然「V8引擎」是「运行环境」的核心，那么为了更好的理解，我再用医院做个类比好了。虽然在医院这个「环境」下我们行为都是看病，但是在不同的医院看病的效果是完全不一样的。「引擎」强大的医院好比是大城市的三甲医院，而「引擎」弱的医院好比是乡村医院，这体验能一样吗？嗯，肯定不一样啊，听说北京的大医院，挂个号都要找黄牛帮忙。
### 4.编译器VS解释器
一天BOSS走进办公室，手里拿着厚厚的一摞文件，走到「小编」面前说：小编啊，这些是国外传过来的文件，下班前**全部翻译好**放我桌上。翻译不完，加班！懂了吗？「小编」：哦……
第二天BOSS又来了，这次他走到「小解」的座位前说：小解啊，中午我要请几个国外的客户吃饭，你来给我当翻译，**我说一句，你翻译一句**。「小解」：好呀！好呀！
嗯，就这样。
### 5.内置库和第三方库
我们都用过12306买火车票吧，觉得这个网站好用的同学举手。嗯，没人。很好，说明大家是正常人。虽然12306不好用，但是它确实实现了网上购票的功能，我们可以把它当做是实现这个功能的内置库。恰恰就是因为它不好用，所以第三方库一定会出现，比如360、智行等等。从此，妈妈再也不用担心我买不到回家的票了。
### 6.学习JS的方向
方向感很重要，有目的的学习编程可以让我们知道自己在做什么，并因此保持动力。虽然我还没有这种体验，但是似乎这个逻辑比之前反复「入门」靠谱多了。于是我开始思考学习JS的方向。
> 这个方向一定是自己最想要的做。嗯……如果可以把股票的历史价格输入，然后输出未来股票价格走势，那要发大财了，哈哈，直接屌丝逆袭，赢取白富美了，哈……咳……咳！
友情提示，做白日梦的时候千万不要喝水。
================================================
FILE: homework/lesson1/yimiao.md
================================================
### 第一次作业
## yimiao
学会了java的基本组成：
1. 类比代码执行流程
按照老师的类比，就好像是去银行办卡，先要填写表单（输入代码），然后提交审核（编译器编译），办理业务（执行器执行代码），最终拿卡（反馈结果）。此外，银行还提供了内部服务（内置库），还有第三方公司提供的便捷服务（第三方库）。
2. 运行环境
JS的运行环境，分为两个，一个是浏览器的运行环境，一个是NOTE的执行环境。所谓执行环境，可以看做为了执行代码可以调动的资源总和，包括JS内置配置，内置库，外部库等。
3. V8引擎
V8引擎为JS语言中负责预处理和执行代码的部分。
4. 编译器/解释（执行）器
V8引擎的功能是对代码进行预处理和执行，相当于编译器+执行器.
5. 内置库
每种运行环境中，直接可供应用的内置库，好比直接可以用的轮子和模块。内置库需要初学者花时间精力学习的.
6. 第三方库
每种运行环境中，外部的可供应用的外部资源库。
7. 学习JS的方向
学习js中什么最重要？掌握编程语言最重要，现阶段。
================================================
FILE: homework/lesson1/yongfei.md
================================================
**类比代码执行流程**
* 代码 输入 执行 输出
* 类比：银行开户 申请 检查 反馈
**运行环境**
* Javascript的环境，一种是chrome浏览器，一种是Node.js
* 类比：婴儿的生存环境 家、游乐场、玩具、食物
小学生的生存环境 家、学校、游戏、体育馆
**V8引擎**
黑盒、用于执行代码
**编译器/解释（执行）器**
1. 分析词法
2. 分析语法
3. 分析语义
4. 优化代码
5. 解释代码
6. 执行代码
编译器／解释器是V8引擎的组成部分
* 编译型：需要一个专门的编译过程，通过编译器翻译成机器语言；特点：运行效率高；缺点：开发效率低。
* 解释型：一条语句执行的时候翻译，特点：开发效率高；缺点：运行效率低。
**内置库**
包括JS内置对象、网络库、日志库等
是运行环境提供的服务。
**第三方库**
由成千上万的公司或个人提供的开源或收费的库。
第三方库是有别于内置库的一个开放的外部资源，更好的帮助我们达成目标，它不断更新，不断为我们提供更好的服务。
**学习JS的方向**
通过练习一个个小项目，达到能独立开发项目的程度。
================================================
FILE: homework/lesson1/youshilei.md
================================================
#【第一次作业】写一篇总结
### 1. 类比代码执行流程
用银行办卡业务流程做类比，形象的解释了JavaScript的运行方式。
### 2. 运行环境
主要是软件环境，有浏览器环境和NODEJS的环境。
### 3. V8引擎
V8 是 Google 发布的开源 JavaScript 引擎，采用 C++ 编写，在 Google 的 Chrome 浏览器中被使用。
### 4. 编译器/解释（执行）器
- 编译器
就是将“一种语言（通常为高级语言）”翻译为“另一种语言（通常为低级语言）”的程序。
- 解释（执行）器
又译为直译器，是一种电脑程序，能够把高级编程语言一行一行直接转译运行。
### 5. 内置库
软件自带的，已经封装过的，可直接调用，提高写代码的效率。
### 6. 第三方库
可以满足更多个性化需求，弥补了标准库的不足，大大方便了JavaScript的编程。
### 7. 学习JS的方向
跟着老师，体会编程的魅力，掌握基本的编程技能，不断学习，服务生活。
================================================
FILE: homework/lesson1/yueruiqi.md
================================================
# 作业1
JS课程1总结
---
**1.类比代码执行流程**
以银行开户流程类比代码执行流程。
- 提交开户申请：对应代码输入。
- 银行的各项服务及内部处理
：对应代码进入编译器/解释器后的各自分析，解释，执行。
- 银行的最终通过/驳回用户的申请
：对应代码最终的运算后的结果。
**2. 运行环境**
- 运行环境可以理解位一个可以执行代码的黑盒，按预设的格式输入数据，经过运行环境处理后，最终输出结果。
- JS运行环境，一般包含内置库，V8引擎。
-JS，有两种运行环境，浏览器运行环境，Node运行环境。
**3. V8引擎**
- V8引擎，就是JS代码编译成机器可以识别的代码，也就是解析和执行JS代码。
**4. 编译器/解释（执行）器**
- JS是解释型语言，边编译边执行，就会用到编译器/解释（执行）器，编译器/解释（执行）器V8引擎的一部分。
**5. 内置库**
- 内置库，就是JS运行环境自带的,已经封装好的,常用的功能服务的集合，写代码的时候可以直接引用。
- 需要注意的是知道特定代码是什么含义和用法，还有就是不同运行环境下，内置库可能有区别，某些服务无法使用，或者写出来的代码调用的东西不一样。
**6. 第三方库**
- 第三方库，就是相对于内置库而言的，是由个人，公司等组织开发的库，能实现内置库没有涉及到的功能和服务。
**7. 学习JS的方向**
- 多练习，先把要实现的需求想清楚，流程列出来，尝试用学到过的代码把这个功能写出来，然后测试运行，挑错，直到能够实现功能。
- 接着，多看相关资料书籍，多问问前辈，看看网上类似的代码，想想又没更好的实现方式，优化代码。
================================================
FILE: homework/lesson1/yujianke.md
================================================
1. 类比代码执行流程
--编写代码--编译器分析代码--输出结果。
2. 运行环境
--有浏览器和Nodejs。
3. V8引擎
--对代码的预处理，检查代码是否有错误。
4. 编译器/解释（执行）器
--把高级语言转换成低级语言。
5. 内置库
--浏览器运行环境：JS内置库；WebAPI；WebGL; HTTP; WebTRC; canvas。。。。
--Node运行环境： JS内置对象； NODE API.
6. 第三方库
--浏览器：jQuery; Vue; AngularJS; React......
--Node ：EXPRESS; Koa; Webpack; Promise.....
7. 学习JS的方向
--学习怎样调用内置库和怎样使用第三方库。
================================================
FILE: homework/lesson1/zhanggaoyang.md
================================================
看了大家的总结，有几篇总结写的非常到位，让人一目了然，但是看到文章末尾发现也是小白，自愧不如。看到大家都是对老师整个讲课过程进行的总结，我决定对讲课思路进行总结。
可以注意到全程都是建立在银行开户流程改进这个类比上的。由一个简单的流程一步一步变得复杂，再通过类比到js，再拆分出每个概念。
老师通过对银行开户流程的一步步改进后的类比让我们一步一步的跟着老师的思路对整个js语言的运行环境的概念有了清楚的了解。比如，当我们不清楚什么是内置库的时候，只要想到银行提供的那些服务就会通过联想达到理解。
在进行解释器和编译器以及浏览器环境和node运行环境的对比，和最后讲学习java时需要考虑到其中服务或技术之间的差异性相呼应。
所以
>对比差异性，掌握你的编程语言，了解那些内置库和第三方库是学习过程成中最重要的事。
================================================
FILE: homework/lesson1/zhanghuanyuan.md
================================================
1. 类比代码执行流程
+ 就是把现实的事件流程抽象出来，用最精简的方式来描述一个事件的执行流程，方便思考，方便转化为代码。
2. 运行环境
+ 运行+环境
+ 运行：就是执行代码并期望得到想要的结果。
+ 环境：就是生存条件，必要条件；也就是代码执行并能返回结果的必要条件。像老师课件里说的婴儿的环境，学生的环境中除了必要条件（爸爸妈妈等）还有资源这类提高生活舒适度的条件，就好比编程中能有更方便，更快捷，更高效的方式提供。
3. V8引擎
+ >V8 作为一个 JavaScript 引擎，最初是服役于 Google Chrome 浏览器的。它随着 Chrome 的第一版发布而发布以及开源。现在它除了 Chrome 浏览器，已经有很多其他的使用者了。诸如 NodeJS、MongoDB、CouchDB 等。
V8 使用了直译的方式，即把 JavaScript 代码直接编译成机器码( Machine Code, 有些地方也叫 Native Code )，然后直接交由硬件执行。
与传统的「编译-解析-执行」的流程不同，V8 处理 JavaScript，并没有二进制码或其他的中间码。
简单来说，V8主要工作就是：「把 JavaScript 直译成机器码，然后运行」
+ 顾名思义“引擎”就像是汽车的发动机，可以更快的驱动汽车。V8引擎应该能帮助编程者更快的实现编程目标。
+ V8引擎比以前的边解释边执行的效率更高。
4. 编译器/解释（执行）器
+ > **编译器** 是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;
而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.
这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)
编译是将源程序翻译成可执行的目标代码，翻译与执行是分开的；而解释是对源程序的翻译与执行一次性完成，不生成可存储的目标代码。这只是表象，二者背后的最大区别是：对解释执行而言，程序运行时的控制权在解释器而不在用户程序；对编译执行而言，运行时的控制权在用户程序。
解释具有良好的动态特性和可移植性，比如在解释执行时可以动态改变变量的类型、对程序进行修改以及在程序中插入良好的调试诊断信息等，而将解释器移植到不同的系统上，则程序不用改动就可以在移植了解释器的系统上运行。同时解释器也有很大的缺点，比如执行效率低，占用空间大，因为不仅要给用户程序分配空间，解释器本身也占用了宝贵的系统资源。
5. 内置库
6. 第三方库
7. 学习JS的方向
================================================
FILE: homework/lesson1/zhanghy.md
================================================
1. 类比代码执行流程
+ 就是把现实的事件流程抽象出来，用最精简的方式来描述一个事件的执行流程，方便思考，方便转化为代码。
2. 运行环境
+ 运行+环境
+ 运行：就是执行代码并期望得到想要的结果。
+ 环境：就是生存条件，必要条件；也就是代码执行并能返回结果的必要条件。像老师课件里说的婴儿的环境，学生的环境中除了必要条件（爸爸妈妈等）还有资源这类提高生活舒适度的条件，就好比编程中能有更方便，更快捷，更高效的方式提供。
3. V8引擎
+ >V8 作为一个 JavaScript 引擎，最初是服役于 Google Chrome 浏览器的。它随着 Chrome 的第一版发布而发布以及开源。现在它除了 Chrome 浏览器，已经有很多其他的使用者了。诸如 NodeJS、MongoDB、CouchDB 等。
V8 使用了直译的方式，即把 JavaScript 代码直接编译成机器码( Machine Code, 有些地方也叫 Native Code )，然后直接交由硬件执行。
与传统的「编译-解析-执行」的流程不同，V8 处理 JavaScript，并没有二进制码或其他的中间码。
简单来说，V8主要工作就是：「把 JavaScript 直译成机器码，然后运行」
+ 顾名思义“引擎”就像是汽车的发动机，可以更快的驱动汽车。V8引擎应该能帮助编程者更快的实现编程目标。
+ V8引擎比以前的边解释边执行的效率更高。
4. 编译器/解释（执行）器
+ > **编译器** 是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时计算机可以直接以机器语言来运行此程序,速度很快;
而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,所以运行速度是不如编译后的程序运行的快的.
这是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制的形式)
编译是将源程序翻译成可执行的目标代码，翻译与执行是分开的；而解释是对源程序的翻译与执行一次性完成，不生成可存储的目标代码。这只是表象，二者背后的最大区别是：对解释执行而言，程序运行时的控制权在解释器而不在用户程序；对编译执行而言，运行时的控制权在用户程序。
解释具有良好的动态特性和可移植性，比如在解释执行时可以动态改变变量的类型、对程序进行修改以及在程序中插入良好的调试诊断信息等，而将解释器移植到不同的系统上，则程序不用改动就可以在移植了解释器的系统上运行。同时解释器也有很大的缺点，比如执行效率低，占用空间大，因为不仅要给用户程序分配空间，解释器本身也占用了宝贵的系统资源。
5. 内置库
+ 内置库JS环境中（浏览器&node.js编程环境中）已经编写好的一些函数方法，可以直接调用而不用重复发明轮子，是提高编程效率的工具之一。
6. 第三方库
+ 第三方嘛，应该是相对于内置库来说的。
+ 不是当前编程环境中有的，是需要另外添加进来的。
+ 第三方库的使用方法还待研究……
7. 学习JS的方向
1. 学习并熟悉JS编程语言，熟悉语法，学会调用服务（内置库、第三方库）来提高效率。尽快给自己一个正面反馈，加强信心。
2. 理解自己项目的需求，了解并熟悉相关的（重要的）服务。
3. 找不同！比较服务/技术之间的差异，分析其优异性，寻找到最适合自己的方法。
4.JS技术更新变化速度飞快。寻找可复用的经验，加快新技术的学习速度。老师PPT中提到的难度二“无边际”，使我想到avascript无所不能，但要有取舍，要选方向。不能样样了解，样样稀松。
================================================
FILE: homework/lesson1/zhanglina.md
================================================
##【第一次作业】
————————————————————————————————————————
#####--*author：张丽娜*
#####--*version：V1*
#####--*create_time：2017-08-09*
————————————————————————————————————————
###1. 类比代码执行流程
####开篇老师用一个银行办卡的业务流程，逐步优化，衍生出了JavaScript的流程，晚上听完课以后，早上去公司的路上，javaScript的执行过程，我的大脑里面有了一个更清晰的认识，一个形象的类比，让我深刻的记住了js的执行过程，我甚至在思考，如果别人此刻问我，js是什么？我也能清晰的讲明白。高手和普通人的区别就是：高手可以把复杂的过程，用非常直白的话，让小白们都能听懂！
####我对于代码执行流程的理解：程序媛写好的底层的js代码，首先会经过编译环境基础语法的检查（预处理阶段），校验通过之后，js代码被交付给编译器／解释器执行，运行完成之后，会将结果返回给用户。js代码编写的过程中，需要调用浏览器或者是nodejs的内置对象，针对与不同的运行环境，为了使功能更强大和牛逼，提供了可扩展的第三方的类库。
###2. 运行环境
####运行环境分为：浏览器环境和NODEJS的环境，在不同的环境中，需要遵循不同的规则，并且不同的运行环境提供了其特性的内置对象，以及针对不同的运行环境，有与之对应的第三方类库。
###3. V8引擎
####结合老师的讲解和自己的理解：V8引擎是一门底层技术，chrome就是基于V8引擎构建的，直接的体现就是chrome浏览器中写JS的代码，代码的执行速度快。
###4. 编译器/解释（执行）器
####编译器：就是把所有的代码都编译成计算机可识别的二进制文件，这样运行时，计算机可以直接运行，速度非常快
####解释器：就是执行程序时，将程序逐条解释为机器可识别的二进制文件，编译一条，执行一条，运行效率低，消耗资源大。
###5. 内置库
####内置库就该运行的环境下，提供了封装好的，可直接被调用的类，函数、方法。通过访问这些内置的库，极大的提高的编程的效率。
###6. 第三方库
####第三方库是针对内置库中的扩展，提供了更加强大和炫酷的功能。合理的使用第三方的库，可以使程序展现更加锦上添花。
###7. 学习JS的方向
####跟着老师的节奏，调整自己的心理和身体状态，去掉浮躁和杂念，学习编程的思想，以及解决问题的方式方法，成为一名真正的程序媛，利用编程这门工具来真正的服务生活、解决问题。
####体会：经过几天的预习，从老师，助教，以及战友们的身上我理解了什么叫敬业，什么叫专业，和一群优秀人共同上路，感觉很荣幸，当然我也在路上。
================================================
FILE: homework/lesson1/zhangqian.md
================================================
### 第一课作业
####1、类比代码执行流程
好比我们去银行办理汇款业务，先要填写申请单，到柜台交给工作人员核对数据，他们在录入系统进行再次比对，然后产出结果，代码执行的流程就是我们把相关语言输入到电脑的软件，软件对输入的语言解析，从而产出你想表述的内容。
####2、运行环境
编程的运行环境好比人类的生存环境，需要水、空气、食物、衣物及思想，而程序的环境就是具备内置库及处理引擎。
####3、V8引擎
老师说是黑匣子，对代码进行预处理，对代码进行解析。我认为应该好比华罗庚的泡茶方法论，是一种基于底层原理的处理环境。
####4、编译器／解释（执行）器
对问题的拆解能力。
####5、内置库
比如我们需要做一道菜（蚂蚁上树），锅、铲子、灶台就是内置库。粉条和肉末就是代码，人为的翻炒动作就是运行环境里的编译器／解释器，最终成品就是一道美味佳肴。
####6、第三方库
第三方库就是帮我们更好的完善结果，我们现在正在用的github就是开源的库。还是做菜的例子，想要菜好吃，佐料就属于第三方库。
####7、学习JS的方向
高阳老师的教学方法很贴近学生，尤其是和同样教授编程课的老师们比，更多的是仔细与用心，建群及助教帮助学生解答疑难问题都是很好的促进学生学习的方式。不管学习任何一门知识，更多的是“师父领进门、修行靠个人"。我最初阶段的学习方向就是紧跟老师步伐，完成每一课作业。明天比今天多知道一些javascript的知识点。
================================================
FILE: homework/lesson1/zhangruirui.md
================================================
js第一次作业
1.类比代码执行流程
对于js这样的解释性代码的执行流程，我觉得有点像请客吃饭，你和朋友先到了餐馆，点好几道菜，厨房立马看是什么菜，开始做了起来，什么菜先做，什么菜后做，口味是重是轻等等等等，谁知中途有别的朋友知道你俩在这吃饭，于是加入进来，这时你喊来店主加碗筷加菜，新来的朋友不能吃辣，于是还没做的几道菜都给改成清淡的，后厨立马又调整顺序，调整用料，整个饭菜做出来你和朋友们觉得很是满意，于是痛痛快快地吃喝起来。
而对于编译型代码的执行流程，就像一个婚宴的流程，你事先确定好了菜单，到时间了酒店按照菜单来做，基本就不改变菜单了，到时间了就上菜，整个过程基本是固定的，厨师也有各自的分工，因此效率很高，几个厨师就可以准备好几家婚宴。
2.运行环境
运行环境由浏览器运行环境和nodejs运行环境组成，两个运行环境中都有内置库和V8引擎，V8引擎不是我们需要去折腾的，因为这主要是js研发者的事，于是我们折腾的主要对象就是内置库了，而浏览器和nodejs的运行环境中的一个共同点就是都用到了JS内置对象，这是因为两种环境都是用了js来编写代码，都具有js的语言特性，而不同语言之间的差异其实也就是它们的语言特性差异，语言特性不同决定了它们干什么是擅长的，干什么是不擅长的。
3.V8引擎
V8引擎会在程序运行之前，将JS代码编译成机器码，但不是解释执行，更像是对代码做进一步改良，以更好地适应chrome浏览器。
4.编译器／解释器
编译器和解释器分别对应了编译型语言和解释性语言，使用编译器会将高级语言所写的源代码转换成机器能理解的机器代码，而解释器则是将代码一行行地解释运行，而它们各自的优缺点也和编译型语言和解释性语言一样。
5.内置库
将一些必要的JS服务内置在运行环境里，以更方便地使用。
6.第三方库
这世界上开发者很多，很多人将各种功能做成一个库，而我们就可以通过使用这些库来快速实现一些功能。
7.学习JS的方向
学习JS不仅仅是学习一门语言，更重要的是学会用编程的思维，用编程思维来帮助你更好地处理各种事情，比如在学习了变量定义后，你在日常生活中就要学会尽可能地把话说清楚，让你说的话更准确，而不是模模糊糊地只存在于你的脑子里；
而在你初步懂得用编程思维去理解代码后，如果想进一步提高的话，你就需要进一步了解和掌握内置库和第三方库，不仅要学会用，还要学会它们是怎么运行的，这样才能利用好各个库的特性去服务于自己；
正如每种语言都有自己的特性，有自己的优点和局限一样，不同的库，不同的技术都有自己的特性，有时候你埋怨某个库不好、坑爹时，其实很大可能不是库不好，而是你用错了地方，而高手都是懂得去比较各种库和技术的差异性，挑一个最合适自己的。
================================================
FILE: homework/lesson1/zhangxuedong.md
================================================
# JS第一课总结
## 类比代码执行流程
代码执行流程类似用户在银行开户：
1.**银行提供开户环境**：提供一组服务包括接受申请、检验申请单信息和核对资格。
2.**内置服务**:帮助用户填写订单提供复印、拍照、查询逾期、查询外国人入境等服务。核心：预处理和执行。
3.**预处理**：在真正执行开户前进行信息检查处理过程，以保证执行处理的效率。
4.**执行**：执行开户并返回想要的开户结果。
## 运行环境
代码的运行环境有2种：浏览器运行环境和服务器运行环境。
## V8引擎
对代码进行预处理和执行
## 编译器/解释（执行）器
编译器对输入的代码进行以下操作：1.分析词义 2.分析语法 3. 分析语义 4.优化代码(其实远不止这4种)
执行器对编译好的代码进行以下操作：1.解释代码 2.执行代码
> JavaScript是解释性语言，其编译器和解释器是一体的（边分析边执行）
## 内置库
浏览器自身提供的库： JS内置对象,WebAPI,WebGL,HTTP，WebRTC，canvas
Node.js提供的库：JS内置对象，Node API
共同点：JS内置对象（都使用js来编代码，都提供JS的语言特性。）
> 数组、数据对象、数据结构、数据类型、运算符。
## 第三方库
浏览器包括：jQuery,Vue,AngularJS,React
Node.js包括：Express、Koa、Webpack、Promis
## 学习JS的方向
打包（你写的代码，调用内置库，调用第三方库）--> 你的工程代码
换成自然语言就是：
“掌握编程语言，用编程方式调用服务来完成你的需求。”这就是初学者的目标。
“了解和掌握重要的服务能力，使其能服务你的业务”这就是提高的方法。
“善于比较服务/技术之间的差异性，用最好的方式实现你的业务”这是近阶的方法。
tips: 可参考黄杰素总结？
================================================
FILE: homework/lesson1/zhaokaili.md
================================================
【JavaScript第一次课后总结】
1.类比代码执行流程
语言分为编译型语言和解释性语言，两种语言对应代码的执行流程自然也不同：
拿敲章来类比，假设现在有一本投标书，要求每页都要盖公章和法人章。
（1）对于编译型语言来说是这样操作滴：先拿起公章，在每一页上都盖好章；确保所有的纸上盖完章后，再拿起法人章，从第一页开始把每一页都盖好法人章。
也就是说把盖章这件事情分成两段：先完成前半部分 盖公章 然后完成后半部分 盖法人章
优点：运行效率高 我中间不用来回切换公章和法人章，盖章速度比较快
缺点：开发效率低 我开始盖第一个法人章的时候才能得到第一个成品（既有公章，又有法人章的一张纸）
（2）对于解释型语言来说是这样操作滴：拿起一页纸，盖好公章，然后盖法人章，把盖好章的纸放在一边，接着在下一页纸上盖章。
也就是说把盖章的最终目标（拿到盖有公章和法人章的纸）分成无数个小目标（每一张纸上都盖章）
优点：开发效率高 每操作一次都能得到一张满足要求的纸 都能看见成品的一部分
缺点：运行效率低 每次都要来回切换公章和法人章，速度会比前者慢
2. 所谓运行环境，就是代码的生活环境，以代码类比人来说：
不同的人有不同的生活环境，婴儿和成人的生活环境不同，比如婴儿需要奶粉，而成人需要馒头，米饭；对js来说，则分为两种环境：浏览器运行环境（前端） Node运行环境（后端）
不同的生活环境有相同之处：天空，大地，水，爸爸，妈妈；对js来说：两种运行环境则都有编译器/解释（执行）器（目前基本都用V8引擎）及内置库
当然我们需要注意的是虽然都是天空，大地，爸爸，妈妈，我们所看到的却是不同的天空，大地，喝的是不同的水，感受的是每个人自己爸爸妈妈的爱；对js来说，虽然都是内置库和V8引擎，但是里面实质性的内容却是有所不同的
生活环境里总是我们经常需要的东西，我们可以拿来就用（内置库），
当然有时候我们总想做点其他的事情，而平常的生活环境又提供不了所需要的资源。比如暑假想去美国散散心，我们需要坐飞机，但平常生活中我们并不需要这个工具，这时候就要寻求航空公司的帮助（第三方库）。
对js来说，除了需要可以直接调用的内置库外，还需要偶尔借用第三方库帮助我们更好更快达到目标。
3.学习js的方向
小白：掌握编程语言，知道代码怎么写能让机器根据自己写的代码一步步执行就能输出自己想要的结构
提高：了解和掌握重要的服务能力，知道人家提供给我们的一些工具，代码的作用，性能，知道自己在做哪些事情的时候可以使用这些工具、代码帮助自己更好更快的达到自己的目的
进阶：比较服务和技术之间的差异，知道有多种方式可以到达目的地，能够选择出最佳的方式来完成自己的目标
================================================
FILE: homework/lesson1/zhaoxiaoxin.md
================================================
【JavaScript第一次课后总结】
1.类比代码执行流程
写代码然后执行，类似在银行提出开户申请然后办理完成一样。
首先有需求，写代码也是为了满足自己的一个需求，就像需要办理开户一样。
办理开户，银行的核心业务是检查信息，批准开户。JS的也有自己的核心业务，执行代码命令。
办理开户，银行会提供一些辅助服务，比如身份证复印、申请单格式核对等。JS里也有内部库可以调用。
办理开户，银行还会提供一些第三方服务，比如身份信息核查等。JS也有一些外部库可以调用。
然后办理开户，普通用户有普通用户的办理环境，VIP有VIP的办理环境。两者的环境有不同之处，也有相同之处。就像JS有浏览器的执行环境和NODE的执行环境，两个环境有不同之处，也有相同之处。就像婴儿的成长环境与小学生的成长环境有不同之处，也有相同之处一样。
上课互动时，有个同学的类比，感觉也很形象。他说前端浏览器的执行，就像我们去饭店点菜一样，后端NOTE的执行，就像大厨在后面做菜炒菜一样。
2.运行环境
婴儿成长有个环境，有爸爸妈妈，玩具，家，商店等，这些都可以看做婴儿为满足自己成长需要可以调配的资源。
js运行环境，分为两个，一个是浏览器的运行环境，一个是NOTE的执行环境。所谓执行环境，可以看做为了执行代码，可以调动的资源总和，包括JS内置配置，内置库，外部库等。
3、V8引擎
就是运行代码的黑匣子
4、编译器/执行器
编译器：把编写的代码语言翻译成机器语言的设备
执行器：执行翻译后的机器语言的设备
5、内置库
存放JS自带的源代码的仓库，帮助我们更方便有效的编写代码。
6、第三方库
外部库，在JS外部，可以在JS编写代码时被调用，用于帮助我们方便快捷的编写代码，存放源代码的仓库。
7、学习JS的方向
小白阶段，掌握JS的代码编写方法，用代码调用服务以便于实现我们的需求
提升阶段，掌握内置库和第三方库的使用方法，用于满足我们的需求
进阶阶段，了解各种内置库与第三方库的差异，以便更好的实现我们的需求。
目前处于小白阶段，最重要的任务是打牢基础，掌握代码编写方法。
================================================
FILE: homework/lesson1/zhaoyinan.md
================================================
【第一次总结——初学JS对一些基础概念的总结】
author：赵一楠*
version：V1*
create_time：2017-08-11*
1. 类比代码执行流程
按照老师的类比，就好像是去银行办卡，先要填写表单（输入代码），然后提交审核（编译器编译），办理业务（执行器执行代码），最终拿卡（反馈结果）。此外，银行还提供了内部服务（内置库），还有第三方公司提供的便捷服务（第三方库）。
2. 运行环境
JS的运行环境分为”浏览器”和”node”，每种运行环境有着不同的内置服务（内置库）和第三方库。这就好比是每个人周边的环境都不一样，有着不同的（有时也有重叠）内置服务和第三方服务。
3. V8引擎
V8引擎为JS语言中负责预处理和执行代码的部分。
4. 编译器/解释（执行）器
应是V8引擎，对代码进行编译和执行。
5. 内置库
每种运行环境中，直接可供应用的内置库。
6. 第三方库
每种运行环境中，外部的可供应用的外部资源库
7. 学习JS的方向
焦点集中在我们写的代码上，我当前的目标就是熟练运用代码，熟练掌握编程语言。
================================================
FILE: homework/lesson1/zhouhong.md
================================================
1. 类比代码执行流程
写代码---编译器---解释器---输出
2. 运行环境
相当于银行的开户环境，运行环境就是我们干事请时需要的环境，浏览器运行环境和Nodejs运行环境不同。
3. V8引擎
包含编译和执行
4. 编译器/解释（执行）器
有的语言是编译型，有的是解释型
5. 内置库
属于运行环境的一部分
6. 第三方库
第三方提供服务的
7. 学习JS的方向
先学会写代码，知道自己要想做成一件什么事情。
================================================
FILE: homework/lesson1/zhouqizhou.md
================================================
# 总结
#### 1.类比代码执行的流程
将代码通过编译器逐条执行，传递系统所需要的参数，完成整个服务
#### 2.运行环境
js 主要运行于浏览器上，不过现在出现node js
#### v8引擎
是google 开发的一个代码解析器
#### 编译器／解释（执行）器
把代码编译成二进制 ，计算机只认识二进制。
#### 第三方库
是通过多次的总结归纳，那些经常使用的或者一些很复杂的集合 通过库的方式来调用
#### 学习js
的方向 能完成设计产品上线营销
================================================
FILE: homework/lesson1/zhouziqi.md
================================================
# 第一次课总结
## 类比代码执行流程
- 以银行开户流程作类比
- 一步步改进银行开户流程，最终形成与js运行环境类似的流程
## JS运行环境框架
### JS运行环境
#### 浏览器运行环境
- V8引擎——用来执行代码的黑盒子
- 内置服务——写代码时能用的内置服务
#### Nodejs运行环境
- V8引擎
- 内置服务
### 第三方库——从运行环境外调用的服务，大佬们智慧的结晶。熟悉第三方库很有用【虽然现在我还并不清楚有什么用】。
## 两种语言类型
### 编译型语言
- 运行效率高，开发效率低
- 执行流程：代码--编译器（分析词法、语法、语义病优化代码）---编译好的代码---执行器（解释代码、执行代码）---输出结果。
### 解释型语言
- 运行效率低，开发效率高
- 执行流程：代码--编译器/解释器--输出结果。
## 学习JS的方向
一步步跟着老师走，不懂就搜，搜不到或者看不懂再问。不怕失败不怕麻烦。
================================================
FILE: homework/lesson1/zhuningning.md
================================================
### 1. 类比代码执行流程
通过`银行开户流程`来类比代码执行流程：更好的模块化——抽离出常用的功能，单独作为内置服务；将预处理和执行模块分离开来；
>开户环境、内置服务、业务核心。
### 2.运行环境
JavaScript有两种运行环境
>浏览器运行环境： 基于浏览器的 javascript 前端 JS
> Node.js运行环境：基于服务端的 javascript 后端 Node.js
***
### 3.V8引擎
* V8是Google开发的开源JavaScript引擎。
* JavaScript 引擎的基本工作是把开发人员写的 JavaScript 代码转换成高效、优化的代码。
***
### 4.编译器/解释器
* 编译器。主要工作是将源代码编译成抽象语法树，然后在某些引擎中还包含将抽象语法树转换成字节码。
* 解释器。在某些引擎中，解释器主要是接受字节码，解释执行这个字节码，然后也依赖来及回收机制等。
***
### 5.内置库
内置库 通常都是环境自带的内置服务，提供开发所需的基本功能，包括基本的数据结构，模块，函数，等。
***
### 6.第三方库
拿来主义，第三方库一般都是指同种语言开发的拓展功能，以满足多样化的需求。
***
### 7.学习JS的方向
用计算机的思想来武装自己，丰富自己！
***
================================================
FILE: homework/lesson1/zhuting.md
================================================
// lesson1 作业
1. 类比代码执行流程
老师的意思是让我们用生活中的例子来说明代码执行流程吗？第一节课没赶上，只能靠猜测了，补作业，不废话！
首先代码肯定是为了解决问题的，也就是换种语言描述生活中的需要的场景，并能够高效执行的。比如计算器，比如百度搜索关键词JavaScript，以搜索为例子说明
1、用户打开百度网址；此时通过浏览器和和百度服务器链接上了，服务器端收到用户请求，等待用户输入；
2、用户输入关键字JavaScript点击搜索；此时提交了数据，需要服务器端搜索想要的东西
3、服务器端收到用户的关键字后，解析关键字，比如分词等等，然后根据搜索引擎的算法匹配客户需要的数据，并组装数据，返回数据给用户。（此处理过程是用户来说是黑盒的）
4、浏览器返回服务器端数据给客户。用户得到想要的信息或者链接。
2. 运行环境 （我理解是解析代码的程序，我们应该用工具来运行，比如浏览器／JDK/node.js等等，下面的为抄的，目前了解仅限于字面）
JavaScript有两种运行环境
浏览器运行环境： 基于浏览器的 javascript 前端 JS
Node.js运行环境：基于服务端的 javascript 后端 Node.js
3. V8引擎（更多的时候用浏览器，真没关注过浏览器的实现框架和逻辑）
V8是Google开发的开源JavaScript引擎。
JavaScript 引擎的基本工作是把开发人员写的 JavaScript 代码转换成高效、优化的代码， 这样就可以通过浏览器进行解释甚至嵌入到应用中。
4. 编译器/解释（执行）器
编译器：将JavaScript语言转换为机器能理解的二进制代码，机器只能读010101的语言
解释（执行）器 ：解析0110101是啥意思，如同人与机器的翻译软件
5. 内置库
使用工具的一部分吧，能够高效处理请求（浏览器）／编译代码（jdk／node.js）等等，都是将一些常用的函数封装，然后方便第三方调用
6. 第三方库
同内置库一样，只是属于第三方，不属于我们使用工具的本身，使用时需要引用
7. 学习JS的方向
当前诉求：看懂别人写的代码，终极目标：实现自己的需求
================================================
FILE: homework/lesson1/zhuxiaoping.md
================================================
## **类比代码执行流程**
代码，像是一个【病人】，本身带着需要解决的问题，有着相对明确的目标，最后要赢得【健康】而在特定的运行环境【医院】下奔波。
## **运行环境**
代码作为一个【病人】必需要去【医院】这个特殊的环境，才能向着解决本质问题的方向前进，但凡进了学校、菜市场根本无法辨识病症，更没办法解决问题。
## **V8引擎**
【医院】本身的等级三甲，二乙；本质上干的是一回事，就是档次有差，服务体验有差。
## **编译器**、解释（执行）器
编译器就是【医院】里的各种仪器设备，它们把【病人】通俗的人类民间语言翻译成医疗专用数据，化验单上的上下箭头，B超单上的图片数据等，再由解释（执行）器【医生】解读执行，最终对症下药，给出结果。
## **内置库**
内置库就是【医院】里各个科室，各自有各自的特长，处理专门的问题，需要哪科去哪科；吃饱了撑着或者土豪全都跑一遍，对于看病也没什么大问题，就是浪费。
## **第三方库**
第三方库就是【医院】外部相关单位，比如【血站】不是非要用上的，但是多少是相关的。
## **学习JS的方向**
1、牢固掌握基本知识：编程的语言的基础。
2、借助内置库和第三方库完善自我代码打包，完成任务。
3、对任务目标的不断优化，就如徐老师的银行开户业务，先要优化流程，优化代码，做到精益求精。
================================================
FILE: homework/lesson1/zhuyongjin.md
================================================
先说说执行流程，老师运用银行开卡的流程，类比介绍了代码的执行流程，运行环境就像是银行。而V8引擎就像是里面的各种库。有浏览器的库，也有Node库。不管是浏览器还是Node库。都是有内置库。然后就外面而言，除了JS库自身的库，还有很多公司在做第三方库。
我们，从内置库或者第三方库调用数据，然后生成一个自己的代码集，然后去执行（V8引擎），生成结果
学习JS的方向就是从内置库和第三方调用库编辑代码，用自己的。
当然，还有编译器和解释器，JS是属于解释器
================================================
FILE: homework/lesson2/Autumnchou.md
================================================
# 为什么编程中会有丰富化的数据格式
## 命名
老师用给人命名来类比声明并定义变量、给变量赋值，这是一个含义丰富的类比。
首先只有给人命名了，对人有一个称呼了，其他人才能操纵这个人。这就是声明并定义变量的目的，如果想要操纵、使用变量就要先声明并定义这个变量。
其次一个人的名字就等于这个人吗？当然不是，一个人的名字对应这个人身上的各种属性与关系的集合。一个人的各类属性与具体人之间的差别就是，当人的身高体重等方面有所改变时属性就发生了变化，但是具体的人这个概念不会发生改变。
我觉得这个区分非常重要，编程中我们声明并定义一个变量实际上是在定义这个变量的各类具体属性，而非定义变量的抽象概念。抽象概念不会因为属性的改变而发生变化，但是各类属性的集合是一定会被其中属性的变化所影响的。
## 丰富的数据化格式
正因为编程中要赋值给变量的是各类属性，所以编程中有多样化的数据格式。
就比如描述一个人的名字要用字符串，身高体重要用数字，是否有好友要用布尔值，喜欢的颜色要用数组；再复杂一点描述一个人就可以用对象，在对象中加入各种属性。
## 数据
程序的目的是“处理数据，得到结果。” 希望得到的结果不同，需要处理的数据也就不同，因此数据具有相对性。
如果希望得到的结果是身高，那么数据就是具体的身高（170）；如果需要的结果是小明，那么数据就是height，weight，student，age，sex
var xiaoming = {
height:170,
weight:90,
student:true,
age:18,
sex:man
}
[我的个人主页](https://autumnchou.github.io/mywebsite/)
================================================
FILE: homework/lesson2/GaoXianfeng.md
================================================
## JavaScript 入门第二课总结
### 现实生活场景举例类比 JS 声明变量与对变量进行赋值
一个男孩，名字为"小明"，他自身特征为：身高175cm，体重70kg，性别男，年龄21岁；爱好为：唱歌、旅行；亲戚关系为：爸爸、妈妈、爷爷、奶奶、妹妹等。
判断一个男孩是否是小明时，即可使用上述特征，若上述特征均满足，便可认为这个男孩是小明，否则不是。
在向外界介绍小明时，可说此人为"小明"，即，指代上述特征的一个男孩。
由上面描述可推倒出：`小明 = 身高175cm，体重70kg，性别男；爱好为：唱歌、旅行；亲戚关系为：爸爸、妈妈、爷爷、奶奶、妹妹等 的一个人。`
与 JS 中映射，"小明" 为变量名 "xiaoming"，小明自身特征、爱好、亲属关系这些特征为 "xiaoming" 这个变量的属性/值；
```
xiaoming = {
profile: {
height: 175,
weight: 70,
sex: 1,
age: 21,
},
hobby: ['travel', 'sing'],
relations: ['dad', 'mon', 'grandpa', 'grandma', 'sister'],
}
```
### 变量声明与定义
```
var name = 'zhang san'
```
等价于
```
var name // 声明一个变量 name
name = 'zhang san' // 定义这个变量 name，将其赋值为 'zhang san'
```
### 变量名命名、赋值及取值规则
#### 命令规则：驼峰式与蛇式
```
companyName // 驼峰式
```
```
company_name // 蛇式
```
#### 赋值规则：
```
// 每行声明一个变量并定义
var age = 10;
var name = 'zhang san';
// 在同一行声明并定义多个变量
var age = 10, name = 'zhang san'
```
#### 取值规则：
```
var myFavorColor = ['blue', 'yellow', 'red', 'green', 'black'];
// 通过数组下标方式取值
console.log(myFavorColor[0]);
console.log(myFavorColor[1]);
console.log(myFavorColor[2]);
console.log(myFavorColor[3]);
console.log(myFavorColor[4]);
// 对数组进行循环迭代取值
for (var i = 0; i < myFavorColor.length; i++) {
console.log(myFavorColor[i];
}
```
#### 字符串连接
```
var location = 'Beijing';
var companyName = '新生大学';
var compayBase = companyName + '位于' + location; // 新生大学位于Beijing
```
ps: 字符串与数字相加，结果为字符串
================================================
FILE: homework/lesson2/JayChen.md
================================================
# HW2
## 1. 编程中为什么会有丰富化的数据格式
当一个变量被申明时，这个变量就从无到有地诞生了，我个人粗浅的觉得如果能够类比成“怀孕并起名”会更为合适。
我们申明一个变量是为了今后更好地掌控并操作他们，因此在变量刚出现在这个世界上的时候，就需要分门别类地给他们安排一个专门的地方安置，并为今后更好地掌控他们提前做好安排。就好比如果有一个医院负责接生这世上所有的 object，那医院也需要先分门别类一下，人是人他妈生的，动物是动物他妈生的，数字是数字他妈生的，字符是字符他妈生的。。。。。。这样才不会混乱，才能各找各妈、各回各家，方便以后到时间上户口、做普查、划定规则规定某些数字只能在一个小区内打转转。。。。。。当然，听说某些生物还可以强制变种，相当于移民，这是后话。这个医院在接生的时候就把不同种类的宝宝绑上一个随身携带的标签（不会过分细致但是足以对不同的宝宝做区分）以快速归类，并放进合适位置的保温箱，这样就既方便又不会搞错了。
这就是我理解的为什么会有丰富化的数据格式的原因，纯属小白胡乱搜索以后的猜想。
## 2. github个人页面
https://flyrain78.github.io/page_test/
================================================
FILE: homework/lesson2/Jaykey_Guo.md
================================================
### 基础-第二课
##### 命名
一个名字背后包含很多的属性，有不同的描述，对应的数据表的标题和内容。
JS中采用的是山顶式的命名方法：
```Javascript
var userName = "liming";
var isAdmin = true;
console.log(userName);
/*一个很长的名字*/
var myJavaScriptUserName = {
student: name,
title: "xxxx",
};
```
需要注意的是，每一个JavaScript命令结束的时候使用**"*;*"**
在每一个属性之后使用的是**","**来分割不同的属性。
###### 程序：处理数据的工具，最终得到的对应的结果。
个人JS学习记录网页：https://jaygjianguo.github.io/js-study-record/
------
小结：
JS的命令格式有自己的特点，需要注意的是结束用分号，一个变量之中的不同属性用逗号，在Node的环境下运行的结果就是对应输出数据。
在变量的添加中，可以直接在原有变量的基础上进行添加，但是必须赋予对应的值，如果只是添加了变量的类型，没有赋予对应值，会出现报错。
JS中的循环与Java类似，都是三个部分完成，*变量；循环长度，递推方式。*
================================================
FILE: homework/lesson2/LiaoYuemin.md
================================================
## 编程中为什么会有丰富化的数据格式?
### 一切以命名开始
假如没有命名，世界上会发生什么？
你见到我的时候，由于我没有名字，你可能用手指指：“那个女人你过来一下”。但是很不凑巧，在我旁边还站着一个女人，这时我就搞不清楚你到底是在叫谁了。假如我身处人群，周围有一对女人，这时你如果叫“那个女人”，我相信所有的人都会很懵圈，“叫谁呢？”
如果我有名字，故事就不一样了。假如我的名字叫“小明”，即使身处人群，听到“小明”这两个字的时候，我立刻就会反应“是在叫我吧”。
名字的作用在于代指对象，减少冗长的描述带来的麻烦。
我们是如何识别人的？
你有两个好朋友，一个叫“张三”，一个叫“李四”。当他俩同时站在你们面前的时候，你是怎么区别这个是张三，那个是李四的呢？名字只能告诉我们这两个是不同的两个人，但却并不能从本质上把两个人区别开。而真正可以把人区别开的是人不同的属性和关系。比如张三长得很黑，李四要白一些；张三的脸大，李四是小脸；张三不苟言笑，李四活泼开朗。我们的大脑就像计算机处理数据一样，将这一个个特征正和名字做匹配，从而达到区分人的效果。
同理，程序的作用就是处理数据，输出结果。而面对大量的数据，计算机怎么识别这些数据去做相应的匹配呢？
首先需要取名，我们需要申明一个变量，类似给人取名字，当然也是为了方便处理数据。
> var name；//申明一个叫“name”的变量
其次我们需要定义赋值。一个变量只有申明定义了才有意义，才能拿来用。
> var name = “Xiaoming” //定义name这个变量并赋值Xiaoming
在定义赋值的时候，我们又会发现，赋值有多种类别，这就涉及到了数据类型。
### JS数据类型有哪些？
> JS数据类型包括**字符串、数字、布尔、数组、对象、Null、Undefined**。
我们在赋值的时候，我们可以单独选择一种数据类型，可以选择字符串，比如:
> var name = "Xiaoming";
也可以选择数字，比如:
>var weight = 170;
我们也可以选择多种数据叠加，比如；
> var locationBase = '北京';
> var company = locationBase + '大学';
还可以定义对象，比如：
> var myJavaScriptLessonInfo = {
> teacher: name,
> tittle: 'JavaScript编程入门',
> beginTime: '2017/8/8',
> endTime: '2017/9/4'
}
数据的多样性决定了数据需要按照一定的规则排列保存，才能方便计算机进行处理。由此涉及到一个数据格式的概念。
### 什么是数据格式？
> 数据格式（data format）是描述数据保存在文件或记录中的规则。
我理解的数据格式就是计算机处理数据的一套公式和逻辑。就像我们的语言中讲究主谓宾，如果你写成主宾谓（日语例外）可能听话者就不知道这句话是什么意思了。 这就是一种数据格式。
再回到标题的问题上来，**编程中为什么会有丰富化的数据格式?**
我觉得这是由数据本身的多样性决定的。丰富的数据决定了需要通过丰富化的数据格式可以满足更多的数据处理需求，节省时间提高工作效率。
***
*我的静态网页*
https://chaoshengluchi.github.io/My-first-web/
================================================
FILE: homework/lesson2/Liuzhengchun.md
================================================
## 第二次作业
### 编程中为什么会有丰富化的数据格式
1.这节课老师从*一切以命名开始*讲起，整节课我听的有点懵，脑海里一直带着这样的疑惑“这根编程有什么关系”，尽管我能理解老师讲的字面意思。
后面我看老师在作业区布置作业，我不知从何写起，课程总结就一直拖着没写，后面紧接着第三节课，第四节课就来了。我在把第三节课听完，又
去翻看了其他同学的总结，再回过头看老师的ppt，有那么点感觉了。
编程中的数据格式很丰富，有整数型、布尔值、字符串、数组等等，每种数据格式各有其用处，用在恰当的地方要么可以很好的表达其含义，让人一
了然，要么可以提高处理数据的结果，要么可以和其他数据进行很好的交互，用途多多。重要的是老师在课上提到的“处理数据，得到结果”，还有就
是提高“存储效率、计算效率、传递效率”。
在编程中，我们还会定义变量、函数，通过变量或者函数去操纵其他变量或函数，那么起一个好名字让人记住它，快速找到并调用它就很重要了，不
仅我们自己要能理解它，还要让其他人也能快速看懂。但是名字仅仅就是一个名字，决定它起什么作用的其实是数据，是它里面的数据与其他与其他
的变量产生联系，我们才能得到想要的结果。
2.在github上部署的静态网页：https://l328958741.github.io/my_first_webpage/
================================================
FILE: homework/lesson2/Rachel.md
================================================
### 一切以命名开始
整理一下，本次课程老师花了很多心思讲清楚了**变量和数据**之间的关系。
为什么要这么花心思讲变量和数据的关系呢？
因为程序的目的就是**“处理数据，得到结果**”。记得老师在上课的时候说：**数据都要赋值给变量**，程序才会处理它。现在每天我们面对海量的数据，仅仅这些数据无法告诉我们背后的逻辑和故事，那必然需要通过程序去处理它，去解读它。那么我们需要学会用程序可以理解的方式，告诉程序有哪些数据，需要它来帮我们干些什么。
**以下是课程笔记**
---
#### 关联名字和目标
小明=一个具体的人 ？
**我们是如何识别人的？**
我们大脑是中央处理器，当数据通过眼睛输入给大脑的时候，大脑通过对于特征的认识来分辨别人的。
“小明”对应了一组特征数据，比如属性数据、关系数据。
名字：小明 = 目标：一系列属性和关系
共同对于小明一系列的演化之后，慢慢演进出了一系列的代码。
从文字化方式=>格式化方式=>符号化方式=>伪代码方式描述小明
#### 程序的目的 - “处理数据，得到结果”
不论用内置库，还是第三方库都是帮助我们处理数据，快速解决问题，得到结果。
#### 数据、变量
变量 = 值（数据） 比如变量为“身高”，值为“170”，值**都**需要赋值给变量。
集合数据／数组数据
#### 代码
**var** output = "Hello, JS";
=> **var** output; #**声明**一个变量"output"
output = "Hello,JS"; #**定义**这个变量，并给它赋值为"Hello,JS"
#### 实际操作
================================================
FILE: homework/lesson2/Risexie.md
================================================
代码中为什么会有丰富的数据格式
=====
### 用“起名”作类比
老师在课程内容当中，用了较大一部分的时间来把代码“声明“和“定义”的过程与我们给婴儿起名作类比。
而在我把“声明“，”赋值“和”起名“对应起来理解之前，我们可以先分析一下这三个例子，其实是想说明什么？
#### 名字的作用
我们人类在指代一个物体之前，我们都会给这个物体，或者事物赋予一个名字。例如把我们还没起名字的孩子，叫宝贝。如果我们不把物体赋予一个名字，我们就很难去描述它。
例如我们会用杯子，来形容这个在桌子上体积为64立方的透明且中空的玻璃制造的圆柱形物体，名字可以非常方便地帮助我们来指定一个物体。
#### 名字与杯子之间的关系
同样使用上方的例子，我们把哪个“在桌子上体积为64立方的透明且中空的玻璃制造的圆柱形物体”叫做杯子。但是杯子有不同的大小、形状、材质。
我们可以把前方所提的物质叫做杯子，但如果只提“杯子”就不足以和前方的物体对应起来。“在桌子上体积为64立方的透明且中空的玻璃制造的圆柱形物体”和“杯子”的关系
是充分不必要的。而如果想讲两者对应起来，我们就需要更多的信息和条件。
#### 如何关联名字和目标
我们是如何将“在桌子上的物体”和杯子对应起来的？
如果光是“杯子”这个名词本身，我们可能会想到了保温杯、陶瓷杯、塑料杯，等等。但如果我们加上“体积为64立方的透明且中空的玻璃制造的圆柱形物体”这些条件和信息，我们就越能准确地指代一个事物。
当别人提起一个名字，我们脑海中回想起来的往往是这个人的相貌，身材，声音，走路的方式等等。可见我们是更多通过其他方面的信息，才真正把这个人和他的名字对应起来的。*想起一个人，我们对应的其实是大量的数据。*
**所以如果我们想要准确地将“名字”和“目标对应起来，我们就必须要给目标添加很多的属性、数据。来将这个目标具体化，而这个过程其实就是”赋值“。**
### 给计算机输入输入数据
在JS当中，我们是这样子来输入一个数据的。例如：`var name ='Risexie'`, `name`是这个变量的名称，而`Risexie`是这个变量的定义。
`var name ='Risexie'`这一行代码的含义，就是先声明一个叫做name的变量，然后将这个变量赋值为Risexie。
#### 当然变量定义的形式有很多种，可以是一个数值，可以是一个字符串，可以是字符串组。
`var Thenumberilike = 18 ` 数值
`var Thecolorilike ='白色'` 字符串
`var TheMusiciansilike =['陈奕迅‘,'张敬轩']` 字符串组
#### 当我在上面‘声明’并‘定义’了这些变量，我就可以使用它了
`var ThethingsAboutme = {我喜欢的数字：Thenubmerilike ,我喜欢的颜色：Thecolorilike,我喜欢的音乐人：TheMusiciansilike,}`
`console.log`这个代码其实就是输出它后方数据的意思
例如`console.log Thenubmerilike`
计算机就会输出18
`console.log ThegthingsAboutme`
计算机就会输出：我喜欢的数字：18，我喜欢的颜色：白色，我喜欢的音乐人：陈奕迅，张敬轩
#### 当然输出不一定要先定义，直接输出也行
`console.log（'--------------------')`
计算机输出--------------------
`console.log ('\n') `
计算机输出：两行空白
`console.log ('我是五个字') `
计算机输出：我是五个字
#### 如果我们定义了一个字符串组变量，我们甚至可以用游标来输出他们
`console.log TheMusiciansilike[0]`;
`console.log Themusiciansilike[1]`;
计算机输出：陈奕迅；张敬轩
**由此可见数据的格式可以有非常多种，而数据又可以嵌套数据。**
而这种丰富华的数据格式，可以让我们一边输入数据，同时又使用它。如此一来，只要我们最后将这些数据打包，就可以非常方便地调用这些我们输入的数据。
================================================
FILE: homework/lesson2/SunBo.md
================================================
# 编程中为什么会有丰富化的数据格式
> 孙博首次布属的静态网页：[https://ziyoubenteng.github.io/My-space-test/](https://ziyoubenteng.github.io/My-space-test/)
***
## 第一部分-各种数据格式举例
数字
var age=18;
文本
var locaitonBase = '北京';
布尔(真与假)
var student = false;
对象
var myJavaScriptLessionInfoObj = {
teacher: name,
teacherWeChat: wechat_user_name,
title: 'JavaScript编程入门',
beginTime: '2018/8/8',
endTime: '2018/9/4',
boysStudent: 417,
girlsStudent: 119,
lessionTarget: '帮助更多小白学习JavaScript',
githubUrl: 'https://github.com/xugy0926/getting-started-with-javascript'
};
数组（有length,可通过游标表示数组中的相对应的值）
var myLikeColorsList = ['blue', 'green', 'black', 'white'];
## 第二部分：为什么会有丰富化的数据格式
* 几乎世界上所有的事物者是需要分类的，数据格式也不例外。
* 语言的词汇需要分类，图书检索需要分类，程序中的“数据格式”也需要分类，我认为“丰富化的格式”的本质就是一种分类。
* 分类让我们所见的世界更清晰，更透彻，更便捷了。编程语言在执行过程中，程序员在编写过程中，丰富的数据格式让复杂的工作变得有章可循，让程序员的智慧通过驾驭各种恰当丰富的数据格式而实现。
================================================
FILE: homework/lesson2/WANG XUANDING.md
================================================
首先申明一点，我极度讨厌那种为了凑字数而大段大段复制黏贴百科注释的行为。同时，我遵循如无必要，勿增实体的原则，就是几句话就能说明的东西，绝对不鬼扯。
————————————————————————————————————————————————————————————
#编程中为什么会有丰富化的数据格式？
关键词，丰富化，数据格式，故而可从两方面入手分析
##1.为什么会丰富化
[字符，字符串，布尔，整形，浮点，其他。。]
如果没有丰富化的数据格式，会是怎么样的？程序不知道我们要求输出的a是a所指代的值还是a这个字母，或者字符串。同样的，0和1到底代表什么，当为了表达T/F时，应当把他们定义为布尔，当只是为了表示数字时，则是整形/浮点。由于计算机本身并不认识数字，所以我们人为的分割出整形和浮点。即使我们输入一个为整形的3.9，那么它对于计算机也只是代表3，而浮点型的3则代表3.0。
每一种数据格式都是为了满足人对于程序的特定的需求才有的。由于人编程的目的是为了服务自身，而工具的多样性、全能性对于办事效率来说是一个重要指标。由此，可得到不同类型的数据格式表示着人对于它的需求，可能是刚需，也可能能通过其他首先去实现，但是会比较麻烦，但是毕竟人是追求效率的。
##2.为什么有数据格式
不知道有没有理解错误，如果把数据名称叫做x，那么数据格式就是x所指代的东西。可以是之前所提及的几种类型中的任意一种。如果要让x在数学运算中有意义，那么就需要给予x一个具体的形体，而不能单单只是一个未知量。5x如果x没有数据格式并没有意义，相反，如果x是整数/浮点，则机器能知道5x是个数字，如果是字符，则知道5x是字符串。数据格式的意义就是让程序能运作起来。
================================================
FILE: homework/lesson2/WangChangQing.md
================================================
# 编程中为什么会有丰富化的数据格式？
## 1. 我的理解
编程中为什么会有丰富化的数据格式？因为编程中需要有丰富化的数据格式呗。
所谓“计算”，就是运用一定的规则，处理复杂的数据，得出一定的结果。所以“数据”很重要。
那么数据首先一定会包含单纯的数字，比如“1”、“3”、“10086”等等。这是最广泛的计算需求。
广义的“数据”还会包含文字，中文、英文，因为需要进行排列、组合，包括一定的说明和解释。
因此，数据格式一定会包含“数字”和“字符串”（也就是除了数字之外的文字）。
除此之外，数据还会包括“是（TURE）”和“否（FALSE）”。这样计算机才知道什么是对的，什么是错的，什么时候应该继续往前走，什么时候应该调头。
___
## 2. 高阳老师的范例代码
从高阳老师提供的范例代码中可以看到，类似于数学和物理，在计算之前，往往需要明确一系列的变量，以及变量的值。这样就会大大提高计算的效率，减少重复的输入，也可以让计算过程更加简洁、明了。
范例中定义了“变量”和“对象变量”两种变量，有数据、数组、字符串等等，“对象变量”包含相对比较多的内容和数据。
`console.log` 是“输出”， `console.log('\n')` 似乎是“空行”；
`console.log(某变量)[0]` 是从数组的第一个开始输出， `console.log(某变量)[1]` 是从数组的第二个开始输出；
> for (var i = 0; i < myLikeFoods.length; i++) {
> console.log(myLikeFoods[i]);
> }
这个的意思是：定义了一个i变量，将其赋值为从0开始的循环，i小于“myLikeFoods”这个数组的长度（长度也就是数组所包含数据的数量），i++不知道是什么意思，然后将i代入列表输出的`console.log(某变量)[0]`，就可以实现一个列表的输出了。
后来，范例重新定义了“xiaoming”这个变量，并做了输出。
后面又定义了一个“xiaoming2”，展示了一下语法糖的用法。
___
## 3. 我遇到的问题
主要还是静态网页的index文件不知道怎么修改，在浏览器的“检查”中做了修改和“另存为”之后，界面的排版有些乱，所以有些迷茫。
其次，不太清楚如何把JS代码放到浏览器的运行环境下执行，“复制”“粘贴”之后就不知道怎么做了。
**静态网页地址：**
https://wcqxmu.github.io/JAVAScript/
================================================
FILE: homework/lesson2/WuGaoxing.md
================================================
编程中为什么会有丰富化的数据格式？
编程是一个代码的世界，编程中的各种丰富数据和逻辑关系，代码来源于生活而有高于生活，生活的丰富多彩除了说写拍电影等来记录外，还可以通过代码来记录和演示，生活有多精彩数据就有多样的丰富，数据格式是与人类现实生活的参照和对比，同时又有现实世界中寻不到找不着的东西或逻辑，但是通过代码能够提现出啦，故编程世界中一定会有丰富化的数据格式，且远远不断的会丰富下去。
github上的静态网页：https://5glad.github.io/one/
================================================
FILE: homework/lesson2/Zhengchao.md
================================================
# **JavaScript Lesson2 学习心得**
[JS网页教程](https://www.w3schools.com/js/default.asp)
###### 第二课作业提要：“编程中为什么会有丰富的数据格式？”
### JS包含了多少数据格式（DataType）
- 数字（numbers），文本（strings），布尔（booleans），对象（objects），函数（function），数组（arrays），日期（Date），undefined和null；
- 数组和对象都包含了多个数据，不同的是，数组内的数据，同属于一个类型，比方说苹果，香蕉，葡萄；而对象内的数据，可以理解为一个由不同种类的数据构成的集合，比方说年纪，身高，体重，婚否等；
- 值得注意的是，空值属于文本，未赋值属于undefined；
- 数组使用的是方括号[ ]，对象使用的是大括号{}
### 为什么会有丰富的数据格式呢？
- 数据的格式（DataType）是数据的部分属性，举例：16可以是数字（numbers），也可以是字符串(Strings)；前者可以结合运算符（operator）做数学计算，后者可以当成字母来看待，如车牌号（var carNumber = '吉' + 'AW' + '18' + 'K' ）。顺带说一句，JS代码的执行器默认不处理空格的，空格只是为了增加代码的可读性。
<u>既然同一个数值可以用不同的角度去解读，那么定义好它的格式则显得尤为必要。</u>
### 浏览JS网页教程，列举如下知识点
- JS内的数据格式总是64位的浮点格式，即不分整型，长整型，短整型等；
- 不常见的运算符 ，如：x += y ；
- JS Style Guide很重要，比如【以分号‘；’结束一个简单语句】；【不以分号‘；结束一个复杂语句】；【以分号‘；’结束对一个对象的定义及赋值】；
- JS不支持连字符‘hyp-hens’，区分大小写（caseSensitive）
- 变量分两种，Global 和 Local
### 我的静态网页
[郑超的JS学习站](https://github.com/Tal170809/JSNote)
================================================
FILE: homework/lesson2/baoguoqiang.md
================================================
# 编程中为什么会有丰富化的数据格式？
## 首先什么是数据格式呢？
我个人理解数据格式就是数据类型；
- 在编程语言中，能够表示操作的值的类型称作数据 类型，编程语言最基本的特性就是能够支持多种数据类型（数据格式）。
- JavaScript的数据类型分为两类：
1.原始类型（数字、字符串、布尔值、null、undefined）;
2.对象类型：除了数字、字符串、布尔值、null、undefined之外的就是对象了。对象是属性的集合
## 为什么会有丰富化的数据格式？
每个属性都是由“名/值对”构成 ；（值可以是原始值，比如数字、字符串，也可以是对象） 随着值的不停的变化，属性也在变。
不同的对象我们要定义不同的值，所以就会变得丰富化。
我的静态网页url:https://baoguoqiang123.github.io/xinshen/
================================================
FILE: homework/lesson2/caozhen.md
================================================
## 编程中为什么会有丰富化的数据格式
### 程序中的各种数据，都是对客观世界的反映
- 人类与其它生物相比的最大优势就是人类具有学习能力+逻辑思维能力
- 为了将自己从简单机械的劳动中解放出来，使自己的生存环境更加方便舒适，人们开始探索并创造
- 在客观世界中，人们制造各种设备
- 而在虚拟世界中，人们创造了程序语言，描述并反映客观世界
### 客观世界是丰富多彩的，包括各种各样的内容（数据）
- 数字
- 字符
- 单字符
- 字符串
- 逻辑值
### 以上内容又可以组合
- 数组
- 列表
- 字典
- 类&对象
## 我的静态网页地址
https://caozhens.github.io/Javascript_Learning/
================================================
FILE: homework/lesson2/chengjun.md
================================================
## 编程中为什么会有丰富化的数据格式？程君的第二课作业(补交)
### 编程是什么？
要想知道编程世界中为什么会有丰富化的数据格式之前，我们需要首先知道编程到底是什么？
在我的思维里，编程就是用计算机能够读懂的语言，让计算机帮助我们处理数据并得到结果。那么计算机在处理数据时如果能进行一种分类，就可以快速的进行处理。
比如我们也会把现实世界的物质进行分类，当我们运用逻辑思维时经常会调用MECE方法来进行分析，而应用这种方法的分类就可以让我们无遗漏、无重复的进行分类。
因此，计算机面对的数据千变万化，在让计算机处理数据之前，对数据进行分类，使之拥有各种不同的格式，只是为了让计算机更加方便的去读懂，去调用。
### js都有哪些数据格式？
通过目前的学习，我了解到JS中分别有
> 数字、文本、布尔、对象、数组、函数
#### 分别事例
数字
> var age = 18;
文本
> var locaitonBase = '北京';
布尔
指代真假、开关、是否
> true 或者 false
对象
是由若干名/值对组成的映射表，名/值对中间用；分隔，名/值对之间用，分隔，整个映射表用{}扩起来。
> var myJavaScriptLessionInfoObj = {
teacher: name,
teacherWeChat: wechat_user_name,
title: 'JavaScript编程入门',
beginTime: '2018/8/8',
endTime: '2018/9/4',
boysStudent: 417,
girlsStudent: 119,
lessionTarget: '帮助更多小白学习JavaScript',
githubUrl: 'https://github.com/xugy0926/getting-started-with-javascript'
};
数组
> var myLikeColorsList = ['blue', 'green', 'black', 'write'];
函数
相当于一个黑盒子，黑盒子只被定义一次，就可以被调用任意次。
> function personA() {
console.log('1');
}
***
#### 程君静态网页请[点这里](https://qiezijun120.github.io/test/)访问主页
================================================
FILE: homework/lesson2/chenguoqiang.md
================================================
# 编程中为什么会有丰富化的数据格式？
数据格式这个概念，我是第一次听到。百度了一下它的概念
> 数据格式是描述数据保存在文件或记录中的规则。
>
> 形式：数值、字符或二进制数
虽然第一次接触，但是通过徐老师的讲解，理解起来并没有什么难度。把“数据格式”相信成一个人，人会有各种各样的需求，吃喝玩乐丰富多彩，这就不难理解，为什么会有丰富化的数据格式。这只是我自己的粗浅的理解，不知道理解的对不对，还请老师指正。
### 下面是我最近学习的一些感悟
第一次学习编程就碰到这么认真的老师，手把手的教，真的很幸福。我总结一下我学习过程中碰到的一些问题。
刚开始的时候“>",以为这个也是代码的一部分，导致输入的时候，终端里面一直没有反应。现在我知道了，这个符号是来告诉你这是一条指令。空格和要用英文的双引号，我觉得倒不是什么大问题。
实操过一遍git后，再去看教程，会清楚很多。当时的感觉就是两眼一抹黑，文字都认识，就是不知道说的是什么！
> 从Github上克隆一个项目仓库到本地项目仓库。 `git clone url`
>
> 修改项目。
>
> 添加修改到本地仓库的缓存区域。`git add -A`
>
> 把缓存区域的修改提交到本地仓库。`git commit -m "some logo"`
>
> 将本地仓库的提交推送到到远程仓库。 `git push origin master`
我回顾了一下群里的聊天，我问过的那些问题，仅仅过了几天时间，再去看那些问题都好幼稚。自己查一下基本都是可以解决，只是缺少了一些耐心，教程多读几遍都是可以解决的。
当我们面对未知的时候，多少都会有些“恐惧”心理，尤其是我回头看我自己问出下面这个问题，其实我只要自己勇敢的迈出第一步，就不会有下面这个问题。
当时我问了一个问题【”Pull request“，是不是就是”git“的实战？就是流程一样？这个作业不知道怎么下手。】
问这个问题，是因为自己没有看教程，因为不太懂，心里有些着急，所以就着急在群里问了，实际上，自己多看几遍教程，就可以解决问题。遇到不懂的一定要自己先去找答案，切记切记。
静态网页 https://chenguoqiang007.github.io/study/
================================================
FILE: homework/lesson2/chenqiong.md
================================================
# JavaScript 入门课第二课总结
## 使用 GitHub 免费生成静态网页的技巧
* 第一步：在 GitHub 上创建一个空项目，然后 git clone 到本地。
* 第二步：把写好的 HTML 页面复制到本地项目，git add ，git commit ,git push origin master。
* 第三步：回到 GitHub 找到刚才创建的项目，此时项目里面已经有 HTML 文件了，Settings，GitHub Pages，选择 master branch， save。
* 以后如果要修改，只需要在本地改好，push 到远程仓库，稍等片刻，就可以看到改动后的效果了。
* 我运用此方法，成功迁移了一个可以提高同事工作效率的工具，虽然还需手动添加信息，但是后续会尝试迭代 https://jacksparrow008.github.io/work/
## 一切从命名开始
### 变量命名的原则
* 变量名区分大小写，允许包含字母、数字、美元符号($)、下划线，但第一个字符不允许是数字，不允许包含空格、其它标点符号、中文。
* 长度尽量短，抓住要点。
* 避免使用无意义的变量名。
* 禁止使用 JavaScript 关键字、保留字命名。
### 驼峰命名法
当变量名和函数名由两个或者两个以上单词构成时，利用"驼峰式大小写"来表示，以增加变量和函数的可读性。
* 小驼峰式命名法：第一个单词首字母小写，后面每个单词的首字母都大写。例如：myLikeColorsList、locaitonBase。
* 大驼峰式命名法：每一个单词的首字母都采用大写。例如：FirstName、LastName。
* "驼峰式大小写"命名规则只是一种惯例，并没有绝对与强制，只是为了增加代码的可读性，降低后续维护难度。一旦设置并确定命名规则，在编写代码时应该保持格式的一致性。
### 不管采用何种命名方式，前面的四条原则必须遵守
## 创建一个变量的步骤
声明变量 -- 定义变量 -- 给变量赋值
``` javascript
var name = 'xiaoming';
```
``` javascript
var name;
name = 'xiaoming';
```
## 人脑要识别一个人，首先要通过感官系统观察，如果与之前存储在记忆里的信息匹配，才能认出一个人，电脑也一样，声明了一个变量之后，必须定义并给变量赋值，这样电脑才能识别并使用这个变量。
================================================
FILE: homework/lesson2/chenrushan.md
================================================
# Lesson02 总结
> 程序的目的是什么？
>
> **处理数据，得到结果**
为了处理数据，操作数据，就需要先对其进行命名，然后将名字与数据关联起来。
# 名字
> 一切从命名开始
先取名 -> 生小孩 -> 名字与孩子关联起来
第一步是先取名字。无论是小名、大名还是宝宝，我们都会对孩子有个称呼。就如万物都有各自的名字。
我们是如何描述一个人的？通过描述他的各种属性。
比如，我的朋友小白，他身高175，体重120，今年18岁，他有爸爸、妈妈、妹妹、爷爷、奶奶…
我们回忆一个人的时候，在我们脑子里搜索到“小白”，然后读取数据，读取的就是这个人的各种属性特点。
“小白”这个名字，在我们脑子里，代表的就是各种属性的集合数据。
# 数据
> 数据很重要
## 描述数据的方式
为什么我们投简历的时候不是写一篇长文章来介绍自己，而是分类、用比较格式化的形式来呈现？
因为后者更清晰，大脑处理起来更快嘛。
同理，用一定的格式去描述数据，程序处理起来更快。
```
小明={
属性：{
身高：170cm,
体重：70kg,
性别：男，
年龄：18
}
关系：{
家庭：[爸爸，妈妈，爷爷，奶奶]，
闺蜜：[], // 没有闺蜜 空值
同学：[a,b,c],
邻居：[s,m]
}
}
```
丰富的数据需要多样化的数据格式（type）。
身高、体重和年龄，用数字描述；性别用字符串描述；家庭、同学等有多个成员，用数组描述；身高、体重等具体的数据，可以打包成“属性”，成为组合性数据，用对象描述；等等。
### JavaScript的数据类型
JavaScript中，数据，或者说值（value），有多种类型（type），除了原始类型Primitive type），其他的都是对象类型（object type）。
- 原始类型（Primitive type）
- 数字（number）
- 字符串（string）
- 布尔值（boolean）
- 空（null）
- 未定义（undefined）
- 符号（symbol）
- 对象类型（object type）
- 数组（array）
- 函数（function）
- …
More：
- [JavaScript 数据类型和数据结构 | MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Data_structures)
- [标准库中更多的对象 | MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects)
# 名字和数据（变量和值）的关系
在程序中，变量（variable）就是前面说的名字，用来存储数据，也就是值（value）。
# 变量先声明，再定义
> 先声明，再定义（赋值只是一个过程）
先声明一个变量，再定义这个变量，给这个变量赋值。
```
var output = "Hello, JS"; // 等式左边是变量，右边是值
var output; // 先声明一个变量，变量名叫 output（此时变量的默认值是undefined）；
output = "Hello, JS"; // 再定义这个变量，给这个变量赋值("Hello, JS")。
```
# 阅读代码
1. string的引号，双/单引号都可以，尽量用单引号。（注意：不要混淆，JSON中必须用双引号）
2. 定义多变量时，可集中在一行，逗号隔开。eg. `const height = 170, weight = 120; `
3. 关于命名的惯例，有camelCase(lowerCamelCase)，PascalCase(UpCamelCase)等等。具体应用偏好，可参考热门代码风格指南[Airbnb](https://github.com/airbnb/javascript/blob/master/README.md#naming-conventions)、[Google](https://google.github.io/styleguide/jsguide.html#naming)。
4. 声明并定义了一个变量，就要去使用它，操作它。
5. 当“+”运算符用在字符串和变量之间时，如果变量是字符串，则连接两个字符串；如果变量是数字/布尔值，则转化为字符串，与字符串连接。（参考[Addition | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition)）。常用的字符串操作，还有用`string.length`查询字符串长度等（参考[String | MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String)）。
6. 数组，参考[Array | MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array)、犀牛书第7章。操作数组，用索引读取数组元素，遍历数组元素，可以用`for循环+索引`(较灵活)，也可以用`forEach方法+匿名函数`、`for…of`遍历。参考[JavaScript 的所有循环遍历方式](http://xugaoyang.com/post/5a62fb1d1d92b0371315ab35)。
7. 转义字符，参考犀牛书3.2.2。`\n`是换行符。
8. 对象，参考[Object | MDN](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object) 、犀牛书第6章。对象常见的用法是创建（create）、设置（set）、查找（query）、删除（delete）、检测（test）和枚举（enumerate）它的属性。对象属性的值，除了可以是基本数据类型之外，也可以拷贝其他变量的值。
9. 语法糖（Syntactic sugar），属性的简写。在ES6中，当属性名和局部变量名是一样时，我们可以省略它后面的冒号和值。参考[重新认识ES6中的语法糖 | segmentfault](https://segmentfault.com/a/1190000010159725#articleHeader0)。
================================================
FILE: homework/lesson2/chenziwen.md
================================================
# 第二课作业
## 作业要求
1. 熟读getting-started-with-javascript/study/lesson2/smaple_code.js代码。
2. 用node环境和浏览器环境运行一下代码（注意：浏览器运行请使用my_personal_info_page.html）
+ node环境与浏览器运行的输出结果是一致的,但是显示上是有差异的.
+ 差异:
+ 相同部分:"基本信息";"兴趣爱好";"课程信息".
+ 不同部分:从"JavaScript课程信息"后开始,浏览器把输出结果包含在"Object"中,其后还显示"get 变量名:reactiveSetter()","set 变量名:reactiveSetter(newVal)",目前不了解这样显示的目的是什么,以后有时间再进一步了解,先赶上课程进度!;node环境则是直接在终端按数据结构输出变量和值的结果.
3. 问题:编程中为什么会有丰富化的数据格式？
+ 回答:
+ 因为世界是丰富多样的,在映射到计算机系统里就有了丰富化的数据格式,计算机语言设计者又把多样的信息数据归纳为几个大类,由简入繁,由少到多.
+ >计算机程序的运行需要对值进行操作.在编程语言中,能够表示并操作的值的类型称做数据类型.
+ >JavaScript的数据类型:
>>原始类型
>>>1. 数字
>>>2. 字符串
>>>3. 布尔值
>>>4. 特殊值:null和undefined
>>对象类型
>>>Object:对象是属性的集合,每个属性都由"名/值"对应
>>>特殊对象:
>>>>**数组**,表示带编号的值的有序集合.
>>>>**函数**,函数是具有与它相关联的可执行代码的对象,通过调用函数来运行可执行代码,并返回运算结果.
## 附加作业要求
1. 在github上部署自己的静态网页，把网页地址放在总结文档里。
+ [我的静态网页地址](https://windblewsails.github.io/myFirst-repository/)
================================================
FILE: homework/lesson2/cloudyview.md
================================================
# 第二课作业 编程中为什么会有丰富化的数据格式？
[静态页面链接](https://cloudyview.github.io/learning-javascript/)
这是一篇课程总结，所以首先回答老师提出的问题，编程中为什么会有丰富化的数据格式？我认为丰富化的数据格式主要是为了满足方便描述对象特征和方便计算机数据处理两方面。
## 方便描述对象的特征
由于不同的对象有着不同的特征，所以数据格式会有多样化，丰富化的情况。以一个人为例，例如“小明”，针对这个人，我们需要描述一组非常复杂，相互之间无法直接替代的特征来对其进行描述。譬如身高，体重，年龄这些，就比较适合使用数字来描述。而性别，婚否这些，比较适合使用布尔值来描述，人生格言等比较适合采用字符串的方式，生日等比较适合采用日期格式等。还有一些离散型的特征，例如家属，需要利用数组类型来描述，而某些对象例如所属公司，或者项目，可能是一组属性的集合，将这组属性作为整体来描述。
根据所描述对象的不同，我们常常会用到组合型的数据格式，这些组合数据包含一组数据，这一组数据里同样可以有基本数据和组合数据。每种对象的特征，在不同的场合会有不同的抽象的方式方法和不同的视角，因此，也会导致数据格式的多样性。
对于这种复杂的情况，当然，我们也可以通过一大段文字来描述，将所有数据都放在一堆，让读的人自己去分析，去找。这样一来读起来是非常费劲的，而利用格式化和符号化的方式，则可以让人更加轻松的理解数据。
## 方便计算机进行数据处理
编程所编写的程序，采用的是计算机语言，而程序本身的目标则是处理数据，得到结果。也就是说，我们的程序所处理的数据，必须是计算机读得懂，容易处理的数据。
如果说，人类可以读得懂自然语言的文字所描述的各种数据，那么计算机实际上普遍并没有这么智能。计算机能够处理的肯定是经过了格式化和符号化的数据。而针对不同数据类型，计算机显然有不同的处理方式。例如都是数字，计算机就可以对其采用数学运算符来进行操作，而对于字符串，当然也可以有字符串的处理方式，如果非要对字符串进行加减乘除，显然没太多意义。
还有一点就是关于数据的存储了。早期计算机的资源很有限，所以基本上要充分利用每一个字节的存储资源，因此，数据类型里对数字要区分为整型，浮点型之类，为了减少对内存的消耗。因此，有一部分数据格式的设计是为了对计算机资源进行更为有效的利用。
以上是我对于数据格式的理解。
下面是对于课程的学习总结
## 命名
### 一切从命名开始
这一课的开端是：“一切从命名开始”，从命名开始，我们得以操纵变量和数据。这句话太赞。
以前感觉程序员可以从零开始构造一个体系，这个体系能够达成某些功能，实现某些目标，感觉非常神奇。但是对于程序员到底是如何做到这一点，理解的并不深刻。
而这句话———— 一切从命名开始，打开了这个结。
命名是针对变量进行的（这个理解不知道是不是以偏概全了，请老师指正），而通过变量，我们可以进一步去连接数据。所以，通过命名，我们可以去操纵数据。有了数据，我们就可以通过编程的手段对数据进行处理，然后得到我们想要的结果。而这样，我们就可以构建一个自我完备的，自洽的体系。
命名是非常重要的，相当于一个抓手，如果抓手没有了，找不到了，或者不好用了，操作数据等等都无从谈起。
### 驼峰大小写命名法
命名的书写方式，老师也给出了范例，实际上常见的有四种，即全部小写，下划线分割方式，单词首字母大写，第二个单词开始首字母大写，也就是：myname,my_name,MyName,myName。
老师今天提到了驼峰式命名，Camel Case，就是后两种命名书写方式。MyName这种叫做大驼峰方式，myName叫做小驼峰方式。
命名中间没有空格或者任何连接线，可以减少错误，而单词首字母大写，有利于加强可读性。
由于很多系统里面，实际上是不区分大小写字母的，所以，我推断，MyName和myName在计算机处理的时候，实际上是等价的，驼峰方式只是为了程序员阅读方便。
### 对于命名方式的思考
命名既然如此重要，那么肯定要充分的思考其特点。对于计算机来说，命名神马的无所谓。我们将文件放上一个系统，例如放上淘宝的图片空间，淘宝系统就会自动给一个命名。这个文件命名完全不具备可读性。但是，对于淘宝系统来说，却是无所谓的，因为它只需要让这个名字不重复，不冲突就好。
所以，命名方式，主要帮助对程序员增加对编程工作本身的控制力的。人类是需要意义才能够理解和记忆事务的，如果记忆毫无意义的信息，人类的能力非常差。所以，命名本身必须具有容易为自己和将来可能看到程序的人理解的意义。
同时，还必须保证不会重复，不会有冲突。
从这些角度出发，我推论（没经验，只能推论）：
> - 变量的命名最好以英文单词来构成。拼音似乎不应成为推荐的用法
> - 命名所构成的英文单词与其所对应的属性、内容有较强的关联
> - 不同类型的变量，最好带有规则，例如针对Animal的属性，就用譬如AnimalHeight,AnimalWeight.
## 程序的目的
程序的目的：处理数据，得到结果。
乍一看，好像没说完吧，程序能够通信，玩游戏，做文档，管生产等等。但是，如果认真的思考一下，就会发现，其实程序只有两件事情：数据，算法。所以，针对数据，进行处理（用算法来处理数据），得到结果。
## 变量的使用
变量的使用：声明变量，定义变量，赋值变量
定义变量的意思，我推断是要将变量究竟适合于何种数据格式要说清楚。也就是说，计算机底层的执行，是必须知道变量的类型的。而JS应该是在第一次赋值的时候，根据数据本身的类型对变量先做了一次定义，然后再使用的。
这里的问题是：究竟是第一次赋值的时候进行了定义，还是每次赋值都重新定义呢？一个变量在一个程序里可以随意改变自己的类型吗？如果是C的话，肯定是不可以。
================================================
FILE: homework/lesson2/cuimiao.md
================================================
#第二课笔记
老师先教给我们如何创建静态页面，又教给我们如何正确的提问题，比如遇到问题应该折腾自己，然后是搜索，再去讨论区看是否有其他同学提问过，最后最后，才能在微信群里提问，而且提问是需要技巧的，必须把自己的环境，步骤等都描述清楚，才能提问，给解答者带来方便。
#正题：
其实老师真正要教给我们的是编程的思想！
一切以命名开始
用名字来代表一组数据的集合，是一堆属性+关系+其它特征的集合，而名字就相当于是这组数据的代号。
用符号化的方式或者伪代码的方式来描述一个名字，会让我们更直观的认识它。
程序的目的是什么？处理数据，给出结果。
数据，包括小明的属性，关系等一切数据。
数据、变量 变量的名称和数据是一一对应的，通过变量名称，来使用，调用具体的数据。
声明一个变量，并对这个变量进行定义，对其赋值
多样化的数据格式，是为了更方便的定义那些变量。
#实操
再次提醒编程的世界里只有英文，除了字符串可以有中文。
变量之间可以用逗号隔开，这样可以节约代码行数，提高运行效率。
对象里，定义一组数据用的是冒号而不是等号。
================================================
FILE: homework/lesson2/dangfeipeng.md
================================================
### 为什么要有丰富化的数据格式？
现实世界是由万事万物以及各种关系和逻辑组成，人类通过数万年的进化，已经形成了一套完整的数据格式来帮助我们记录、处理、展示这个丰富多彩的世界，比如用数字表达财富，用文字或者语言表达情感，以及用图片、影像记录下难忘的精彩场面等等。
程序的目的是“处理数据，得到结果”，而这其中的数据就来源于现实世界，并且要映射到计算机当中，如果程序只有一种数据格式是否可行呢？理论上来说当然可行，毕竟程序最终都会被转化为计算机能够处理的数据-0和1的组合，但是那样做效率太低下了，所以程序就设计出恰当完备的数据格式，方便程序员通过对数据格式的各种组合来完成信息从现实世界到计算机世界的映射，进而利用计算机进行高效的处理，比如用整型表达整数，用字符串表达文字，用布尔型表达真假对错，用数组表达集合，用对象表达组合信息，而对象中的各个属性又可以是不同的数据类型，概括来说丰富的数据格式就是帮助程序员在计算机世界中准确、高效地表达信息。
================================================
FILE: homework/lesson2/dengxy0907.md
================================================
编程中为什么会有丰富化的数据格式
=================
### 1、我对编程的的看法
>如果事物都能数据化，那么通过编程就能定义数据，然后通过调用数据打成目的。
### 2、数据类型
> 布尔型、数组、字符串、null、资源，目前我只记得这些，我会赶紧复习、学习以跟上进度。
>关于数据类型为什么有这么多，确实没想过为什么，但是细思起来，确实不同情景下使用适合的类型会方便很多，应该也有方便计算机执行的作用。
### 3，静态网页
> [我的git网页](https://dengxy0907.github.io/text/)
> 课程的话我目前只看过一遍，因为时间关系，为了打通流程，仅仅写了一个最简单的页面。
================================================
FILE: homework/lesson2/diaozhicong.md
================================================
#第二次课总结：
##编程中为什么会有丰富化的数据格式？
+ 编程操作的对象是多种多样的，如名字、数值、属性、关系等。
+ 数据格式有数值、字符串、布尔、null和undefined、对象、数组、函数等。
+ 我们编程的目的是处理数据，得到结果。这个过程需要时间，而多样的数据格式可供选择与使用，可以缩短时间，节省大量内存，提高运算的效率。
+ 丰富的数据格式因为拆分的细，所以使用很灵活。即使碰到复杂的数据格式，也可以用基础类型通过搭积木的方式组合出来。
+ 多样的数据格式方便理解应用。多人协同工作的时候有标准可依、互相之间底层共识相同，大大提高协同工作效率。
###个人静态网页
https://sam-tiao.github.io/diaozhicong/
================================================
FILE: homework/lesson2/duhongxia.md
================================================
杜红霞的第二课作业
程序的目的：“处理数据 得到结果。”
课中用小明的例子来进行了说明：
我们通过程序来描述小明，那么就要对小明的数据进行处理。小明的数据包括哪些呢：有他自有的
基本属性（身高、年龄、体重、性别等数字、文本）再加上他的社会关系（家庭关系、朋友关系、同学
关系，这些构成数组数组）。那么描述小明的的数据就包含了文本、数字、数组等数据格式。
编程中为什么会有丰富的数据化格式？
同样的我们通过编程还会描述其他的事物，相应的为了更准确、更方便的描述我们就会有丰富化的数据
格式。
网页地址：
https://duhongxiaanna.github.io/dream/
================================================
FILE: homework/lesson2/fangqingyang.md
================================================
### JS入门第二课
#### 一切以命名开始
不命名的话，我们人，怎么操控那样一堆数据呢？输入了数据，计算机确实是有了数据，但是操纵不方便。就像我们和小明相处过，也确实在大脑里面存有小明的数据了，但如果没有小明这个名字，我们的大脑无法有意识的调出小明的数据，或者为了调用数据自动就换成“这个人”来代替“小明”。又比如，我们在说这是谁干的？别人说了一个名字，听到名字后，我们立刻能够在大脑里面调取出这个名字背后的数据（关系，属性），然后知道是谁干的，之后就有一系列动作。我们要找一个人，知道名字比知道外貌特征更方便，我们查资料，知道资料的名字比知道资料的某个特征更方便。一个名字背后代表着一个数据的集合。以“一”统多，是我们理性思考的能力，名字是“一”，背后的数据是“多”，否则我们将局限在一堆数据里面，局限在很小的范围里面，无法解决问题。写程序的目的是处理数据，得到结果，命名后，将名字与一堆数据挂钩（变量先声明后定义），我们就可以更好的操纵数据，也就可以处理数据了。
#### 数据格式怎么理解？为什么要有那么多的数据格式？
不同的数据格式能够让我们更好的根据我们需要解决的问题来描述数据，背后对应着不同的处理数据的方法，使我们能最简单最有效的处理数据。假设有多箱苹果，如果我们仅仅需要知道有多少苹果？那么把一箱苹果与一个数字对应会比把这箱苹果与一个字符串对应，来的方便。数字我们就可以让我们自由的使用加减法，然后得到我们想要的结果。随着问题的不同我们可以采用不同的数据格式，如果我们不仅需要知道有多少苹果，还需要知道苹果的种类，还需要。。。
多种数据格式是为了让我们更好的处理数据，得到结果。
================================================
FILE: homework/lesson2/fanqing.md
================================================
* [课程回顾](#1)
* [理论讲解](#1.1)
* [实操部分](#1.2)
* [心法记录](#1.3)
* [课程作业](#2)
* [作业-1](#2.1)
* [作业-2](#2.2)
* [作业-3](#2.3)
* [附加作业](#2.4)
* [其他学习](#3)
<h1 id="1">课程回顾</h1>
### 番外篇: gitthub静态网页搭建方法。
<h2 id="1.1">* 理论讲解</h2>
在信息技术高速发展的现在，我们可以这样理解，对人类来说的所有的信息都是对计算机来说的数据，因此可以想象，计算机可以涵盖的数据的多样化、丰富化。
### 一切从命名开始
#### 以人名举例讲解：我们对于一个人的概念，可以说是一堆属性和关系的集合。包括：姓名、身高、体重、年龄……
先取名再生小孩——把名字和小孩关联上。
用名字来操纵人——小明，快去写作业。
从姓名开始思考——丰富的属性、多样关系。
名字和目标——小明是一个具体的人，目标是一堆属性、关系等。
关联名字和目标——小明不等于一个具体的人，“小明”这个名字，只是一组数据的集合。
#### 各种描述递进：用格式化方式、符号化方式、伪代码方式描述“小明”，越来越接近代码的呈现。——能看懂伪代码了就能看懂代码了
我们是如何识别人的？——记住一个人的名字与其属性、关系的对应信息。
#### 程序的目标地是什么？——“处理数据、得到结果”
首先需要对数据进行命名（一切从命名开始）：
与C、Java等其他编程语言不同，JavaScript 里所有数据，不区分类型，都用“var”表示
语句：var output = “Hello, JS”
代表：1..声明：var output；2.定义：output = “Hello, JS”
即：声明这个变量，变量名output，再定义这个变量，给这个变量赋值。
#### 内行话——“先声明再定义”
命名方式：常用驼峰命名法，（还有带下划线的，具体内容自己了解）
学习补充：变量常用小驼峰法，类名、空间名等常用大驼峰法。
<h2 id="1.2">* 实操部分</h2>
分别在浏览器和Node环境运行样例，尝试修改内容，观察显示效果，对运行环境有初步感受。
<h2 id="1.3">* 心法记录</h2>
1、本课程重点是编程思想的讲解
2、代码不重要，掌握理解问题、解决问题的方法最重要。
3、一切从命名开始——体会：对于一个新的要表达、运用的信息或数据，名字起得好一定程度上代表思路、概念清晰。
4、学会、擅用画图的方法来进行思考。
<h1 id="2">课程作业</h1>
>【第二次作业】变量和值
>昨天我帮你们梳理了变量和值之间的关系。下面梳理一些知识点供大家参考，好好利用周末的时间把这块啃下来。
>1. 多样化的数据格式（数字、文本、布尔、对象、数组）
>2. 多样化的数据格式的操作方式。
>以上内容网上有很多教程，如果你想买书，我推荐“JavaScript权威指南—淘宝前端团队翻译的那本”
<h2 id="2.1">作业要求-1</h2>
>熟读getting-started-with-javascript/study/lesson2/smaple_code.js代码。用node环境和浏览器环境运行一下代码（注意：浏览器运行请使用my_personal_info_page.html）
#### Node运行环境截图：
#### 浏览器运行环境截图：
<h2 id="2.2">作业要求-2</h2>
>写一篇课程总结，题目为：编程中为什么会有丰富化的数据格式？
在信息化社会，数据几乎无所不包，所有可以想象到的信息都可以用数据来记录、存储。在快速更替的时代，我们希望有更高效、高质的工作、学习以及生活，丰富多样的实用软件、精准高效的数据分析处理工具都再发挥着越来越重要的作用。
如此纷繁的数据交给计算机来处理，需要有规范的数据格式，即数据类型，以便处理能力更有的放矢、更高效。
#### （一）数据大类
在JavaScript中数据类型分为两类：1.原始类型、2.对象类型。
原始类型：包括数字、字符串、布尔值。
有两个特殊的原始值：null（空）、undefined（未定义）。
对象类型：对象（object），数组（array）是一种特殊对象，函数是另一种特殊对象。
#### （二）具体说说：
##### 1．原始类型：
1-1．数字：
1-1-1. JavaScript的数字均采用IEEE 754标准定义的64位浮点格式表示，不区分整数值和浮点数值（与C和Java等不同），需要注意的是：JavaScript的实际操作，整数是基于32位整数。
1-1-2. JS程序中直接出现的数字称为数字直接量（numeric literal），包括整型直接量、浮点型直接量。
1-1-2-1. 整型直接量:包括十进制整型直接量、十六进制整型直接量。某些JS的实现支持八进制整型直接量，但不保证通用，因此一般不要使用八进制整型直接量。
1-1-2-2. 浮点型直接量:包括传统实数写法，例如：3.14、1.789；指数记数法，例如：6.02e23、2.987653E-32。浮点型直接量语法表示为：[digits][.digits][(E|e)[(+|-)]digits]
1-1-3. JS的算术运算：
1-1-3-1. 基本运算符包括加（+）、减（-）、乘（*）、除（/）和求余（%）
1-1-3-2. 复杂的算术运算：通过Math对象的属性定义的函数和常量来实现，例如：Math.pow(2,3) ->8，2的3次幂；Math.ceil(.6)->1，向上求整；Math.floor(.6) ->0，向下求整。
1-1-4. JS的算术运算在溢出(overflow)、下溢（underflow）或被零整除时不会报错。
1-1-4-1. 溢出(overflow)：即当数字运算结果超过了JS所能表示的数字上限，正数时以无穷大（Infinity）表示、负数时以负无穷大（-Infinity）表示。
1-1-4-2. 下溢（underflow）：即当运算结果无限接近于零并比JS能表示的最小值还小，此时JS会返回0。还有个“负零”概念，一般可忽略。
1-1-4-3. 被0整除，返回无穷大（Infinity）或负无穷大（-Infinity），0除以0、无穷大除以无穷大、给负数作开方或算术运算符与不是数字或无法转换为数字的操作数一起使用时，都将返回非数字，表示为NaN(not-a-number)。
NaN有一点特殊：它和任何值都不相等，包括自身。x==NaN不能表示x是NaN，可通过x!=x判断，当且仅当x为NaN时，x!=x为true。
1-1-5. 二进制浮点数和四舍五入错误
在JS的数值范围内，浮点数只能表示有限个数实数，而不是一般理解的无数个，会有些真实值只能近似表示。这是由于浮点数表示法是二进制表示法引起，只能精确的表示2的次方分之一的值，如：1/8、1/1024，而我们常会使用十进制分数，如：1/10、1/1000，二进制浮点数无法精确表示类似0.1这样简单的数字。会造成运算的尴尬，如0.3-0.2并不等于0.2-0.1。
这不是JS中才会出现，好在精确值非常精确，一般任务都能胜任，只有在比较两个数大小事才会遇到。以后的版本或许会针对此做改进。如涉及重要金融计算，建议使用“分”而不是“元”作单位。
1-1-6. 日期和时间的表示：JS语言包括Date（）构造函数，可以创建包括年月日时分秒的对象，进行日期、时间的特定值提取、使用，有些特殊规范，比如月份从0开始。
1-2. 字符串：
1-3. 布尔值：boolean，指代真或假、开或关、是或否，类型值只有两个：true和false。用于编程语言的控制结构。通常与比较语句结合使用，举例：
If(a==4)
b=b+1;
else
a=a+1;
这段代码判断a是否等于4，等于时，b加1；不等于时，a加1。
关于转换：任意JavaScript的值都可以转换为布尔值，其中undefined、null、0、-0、NaN、“”（空字符）六个会转换为false（有称“假值”(falsy value)），其他值均会转换为true（有称“真值”(truthy value)）。
布尔值支持三个布尔运算符、一个方法：”&&”(AND)、”||”(OR)、”!”(NOT) 以及toString()
##### 2．两个特殊的原始值：null（空）、undefined（未定义）。它们不是数字、字符串、布尔值这些原始类型，通常代表了各自特殊类型的唯一的成员。它们都不包含任何属性和方法。
##### 3. 对象类型：对象（object），数组（array）是一种特殊对象，函数是另一种特殊对象
3-1.对象（object）：（还需学习理解、补充）
3-2.数组（array）：是值的有序集合。每个值叫做一个元素，每个元素在数组中有一个位置索引数。数组元素可以是任意类型，也不一定是常量。数组能够表达不同类型的组合信息，比如一个人的相关信息等。
3-2-1.创建数组：
（1）数组直接量：
没有元素的数组：var empty=[];
有3个元素的数组：var array1=[1,2,3];
3个不同类型的元素和结尾的逗号：var array2=[1,“a”,true,](数组直接量语法允许有可选的结尾的逗号，所以是三个元素而非四个)
（2）调用构造函数Array()：
没有任何元素的空数组：var a = new Array()
指定长度作为参数：var a = new Array(10)——没有存储值及索引，预分配了一个数组空间。
显式指定方式：var a = new Array(5,4,3,“test”)；——这种方式不如使用数组直接量。
3-2-2.数组方法包括：join()、reverse()、sort()、concat()、slice()、splice()、push()和pop()、unshift()和shift()、toString()和toLocaleString()，前面这些是ECMAScript3中的方法，在ECMAScript5中还有forEach()、map()、filter()、every()和some()、reduce()和reduceRight()、indexOf()和lastIndexOf()
（还需在使用中逐渐深入理解）
<h2 id="2.3">作业要求-3</h2>
>如果有问题，在总结中把你的问题罗列出来，我会做解答。
### 遇到的问题
#### 1、 浏览器运行代码发现的情况：
##### 当打开my_personal_info_page.html页面后，同一部分内容，并未修改这部分代码，刷新前后显示效果不同。
##### 修改代码后直接点击浏览器的刷新后“console”页显示：（后来试过不做任何代码修改，直接刷新也会这样）
#### 想知道这是什么情况？
#### 2、更新Fork项目时报错：
需要更新老师的项目内容，从网上搜索到方法介绍（原文链接地址：http://blog.csdn.net/qq1332479771/article/details/56087333)，文中介绍了网站和终端两种方法。
先使用的终端方法，结果失败了，最后一步提示报错，后来使用了网站操作方式很顺利，更新成功。
##### 终端报错如下图，请老师帮忙分析下网站能成功、终端不成功是什么原因？谢谢~！
#### 3.关于Date（）函数，尝试执行 var now = new Date()，得到的返回值时间是晚于我们8小时的时间？
#### 4.另外想问，能不能推荐个MAC用的保存网页（好几屏）为图片的好办法？用chrome能不能实现？
<h2 id="2.4">附加作业</h2>
>1. 在github上部署自己的静态网页，把网页地址放在总结文档里。
在github上部署的静态网页：https://fanmilir.github.io/MyPage/
>【作业提交方式】
>1. 请向getting-started-with-javascript项目发起pull request。https://github.com/xugy0926/getting-started-with-javascript
>2. 文档格式，markdown。
>3. 提交homework/lesson2目录下。
<h1 id="2">其他学习</h1>
#### 学习使用MarkDown实现页内跳转
因为把课程学习内容都作为作业记录了下来，不知的作业是其中一部分，按顺序放在了后面，想实现页内跳转，方便查看。于是搜索，参考网页：http://www.cnblogs.com/JohnTsai/p/4027229.html
----
#### 禅定一刻
独立的人会感恩。因为对别人没有过多的苛求，所以获得帮助的时候常常感恩。因为感恩，也对其他人公平，所以公平也成了一个自然的性格特点。独立的人做事情的时候知道自己不会得到太多别人的帮助，所以也很少抱怨。没有达成目标的时候会持续地努力。独立的人很少会有情绪，所以也非常理性。——万维钢。
================================================
FILE: homework/lesson2/fengkai.md
================================================
为什么会有丰富化的数据格式:
对于不同场景下的变量或者是数据，能够将彼此相互关联起来，最终分解成机器能够理解的二进制0和1
1. 数据格式：
str 字符串
int 整型
float 浮点型
list 列表
array 数组
boolean 布尔型
object 对象数据 对象变量 组合形的数据
2. 变量
声明变量
定义（内存）
赋值
3. 变量编程的逻辑
顺序
分支（选择）
循环
个人主页：
https://fengkaiwater.github.io/myPage/
纯属个人理解
================================================
FILE: homework/lesson2/guowei.md
================================================
# 小白JS入门不放弃 lesson2
### Focus question: *编程中为什么会有丰富化的数据格式?*
***
编程中为什么会有丰富化的数据格式，想回答这个问题，先从**数据类型**这个概念开始剖析。
### 编程中的数据类型
在编程世界里，能够表示并操作的值的类型称作数据类型。而编程语言最基本的特性就是能够支持多种数据类型。
在JS中，数据类型分为两类：**原始类型和对象类型。**
**原始类型**包括：
+ 数字
+ 字符串
+ 布尔值
+ null（空）
+ undefined（未定义）
**对象类型**包括：
+ “命名值”的无序集合
+ 数组
+ 函数
***
### 什么是数据格式？
百度百科这么定义：
> 数据格式（data format）是数据保存在文件或记录中的编排格式。可为数值、字符或二进制数等形式。由数据类型及数据长度来描述。
***
### 为什么有如此丰富的数据格式？
数据格式的确定应该满足如下条件：
+保证记录所需要的全部信息；
+提高存贮效率，保证存贮空间的充分利用；
+ 格式标准化，保证有关数据处理系统间数据的交换。
**一言以蔽之：为了让我们能更有效率地记录和使用数据。**
***
### 该如何使用如此丰富的数据类型？
回归第一堂课的总结：
+ 学习学习再学习：熟悉每一种数据类型和对应的格式；
+ 使用使用再使用：在使用JS解决问题的过程中，熟练掌握.
***
## **第二课总结**
### 什么是程序
> **处理数据，得到结果。**
### 一切以命名开始
在JS中，对于变量的使用：
> 1.声明：声明要创建一个变量。
> 2.定义：给这个变量开辟一块内容。
> 3.赋值：最后才是赋值。
***
### 个人网站：https://wei02320.github.io/My-private-website/
================================================
FILE: homework/lesson2/hanmeng.md
================================================
#这是我的静态网页地址https://menhan.github.io/my_test/
目前只修改了链接地址，颜色。
#第二节课总结
##编程中为什么会有丰富化的数据格式？
***
我的理解，编程就是调用不同的指令，处理数据，最终得到想要的结果。
在调用指令处理数据之前，要先找到数据，并且要给这些数据起个名字，方便调用。如果只是找到一堆数据，不进行命名，不能被调用，是没有意义的。
***
找到很多数据以后，我们就按照程序语言的要求对数据进行分类，根据数据不的使用要去，定义成不同的格式。
================================================
FILE: homework/lesson2/hanwei.md
================================================
### 编程中为什么会有丰富化的数据格式？
在现实生活中，为了有效的交流我们要给事物一个名字，这样才能通过简洁的语言指向我们要表达的事物。这一点在程序中也是一样的，文件名、变量名、函数名、参数名。如果不使用名字，我们就很难快速的指向一个事物，进而每次要对这个事物进行呼唤、传播、操作的时候都会麻烦很多。而且，即便是没有给一个事物起名字，那些用来描述的它属性本身也是名字，如果一个名字都不使用我们就无法表达，更无法沟通了。
人的名字就是一个例子，比起说黑头发、180高、小眼睛、大鼻子来表述一个人，我们使用名字会更有效率。这样在沟通的过程中也会更有针对性，在计算机的世界里，命名更加有意义，因为比起使用内存地址，代码位置，机器语言通过名称调用更加快捷高效，而且在一个名称里面集成其他名称的函数、变量、方法越多，它越高效。
然而，名字虽然指向事物，但它并不等于事物。就拿人来说，人是一个非常具体的事物，如前面所说可能有黑头发、180高、小眼睛、大鼻子等等特性，这都是“人”这个事物实实在在的特质，是它们才将“人”同其他事物、其他人区分开来。而名字，仅仅是一个代号。它代表这个个体，但是并不等价于它。这在程序里也是一样的，一个变量名、函数名，它们只是指向了一个值、一段代码，具体的值和代码才是我们真正需要的东西。
所以，名字一定要和具体目标的特性相挂钩，这样才能明确指代关系。如人名，那么就要和这个人的长相、身高、国籍等等特性匹配起来，匹配的属性越多，他们的关联性也就越强。需要注意的是，一个人可以有几个名字，但是在实际使用名字的时候，一个名字只能是指定具体的一个人。在程序里，这个道理是一样的。一个值或者功能代码可以被不同的变量名或者函数名指向。但变量名、函数名在使用时只能指向一个具体的值或者功能代码。这样才能保证我们正确的使用函数和功能代码。
具体事物的特质，有他们自身的属性和他们与其他事物的关系。他们和事物的名称一起组成了关于该客观事物的完整数据。有了这些数据，我们才可以准确的指代和描述一个客观事物。在具体描述这些数据的时候我们可以有多种方式，语音的、文字描述的、图形图画还有通过编程语言来描述，不同的编程语言之间会有一些语句、语法、命名、定义规则等方面的不同，但所有的编程语言又都有一些相同的描述规则。
数据存储在计算机里面有两个特点，一个是要被使用，另一个是要占存储空间。针对这两点，自然而然就需要对不同的数据采用不同的存储方式。具体的就是为不同的数据使用不同的数据格式和对应的存储空间。使用不同的数据格式，就可以为不同类型的数据使用专门的数据处理方法，比如数值类型的数学运算、字符串类型的符号处理等等。同时，由于为不同的数据类型使用不同的数据格式，可以在很大程度上避免内存空间的浪费或者存储数据的丢失，这不但能节省本地的计算机资源，还能更有效的利用网络传输的带宽。 在js里常用的数据格式有数值、文本、字符串、数组、布尔、对象这些，其中除了数组根据数据个数相应变化空间占用的大小还有对象根据组成数据的个数和类型变化空间占用大小外，其他类型的数据占用的空间大小是固定。
为了做到这些，大部分的编程语言有一些相同的步骤。一般有三个步骤。第一个步骤，声明变量。这是给变量起名的过程，相当于告诉程序我准备要使用一个新的变量来存储数据，给这个变量起名XXX。第二步就是定义变量，这相当于告诉程序这个数据是什么类型，用什么数据格式，给他安排相对应的存储空间。第三步，则是为变量赋值，就是将具体的数据存到这个变量所指定的存储空间里。
这些步骤是在具体使用代码时完成的，对js来说，就是在node.js或者浏览器环境下执行代码完成的。在node.js环境下我们可以直接在终端里看到代码，但是在浏览器下我们只能去console后台看，这是他们不一样的地方。其他的执行代码的部分这是一样的，一样的数据类型和格式、一样的空间分配规则、一样的命名方式。
#### 静态网页地址
https://freedomsky11.github.io/library/
================================================
FILE: homework/lesson2/haohu.md
================================================
#编程中为什么会有丰富化的数据格式？
- 与现实世界对应: 不一样的东西就有不一样的描述方式，增加程序可读性
- 提高空间利用率: 不同的数据格式占用的空间不同，可根据实际需要分配
- 提高程序的性能: 不同的数据格式适用于不同的需求，使用合适的数据结构能大大增加程序性能
#部署自己的静态网页
- [郝户的静态网页](https://venivediveci.github.io/)
================================================
FILE: homework/lesson2/hewei.md
================================================
# 第二节课笔记
## 视频讲座
### 一切以命名开始
为什么要命名？就是为了方便开发者编写代码。
代码不只是让机器运行的，更是让人看的。现在的电脑性能已经让一般的开发者将重心放到实现功能上，而不是解决资源上。所以，书写易读易懂的代码，是非常重要的。
和学会编程的语法相比，学会编程的思想要远远重要得多！
学会了思想，就可以一法通万法通，玩熟了JS，Python也能迅速上手，C#也没问题。这凭的是什么？就是对表面的编程语法背后本质思想的真正理解。
语法只是术，背后的思想则是道。语法各有不同，道则大同小异，甚至可以说是基本相同的。
而所有的编程思想，都是从命名开始的。
人类之间是需要沟通的，不管是语言还是文字，我们在说世界上的万事万物时，都是用名字来指代的。即使是**道可道，非常道**，也是用**道**来指代这个玄妙的概念的。
在程序世界里，自然也少不了名字。用户注册，要输入用户名，要输入密码，如果不用名字来指代用户输入的各种信息，怎么能够使用它们呢？
在现实世界中，我们用一个名字来指代一个具体的人。
在程序世界中，我们用名字来指代内存中的一段数据。
### 如何识别不同的人？
小明，指的是一个具体的人。
但我们能不能说，一个具体的人，就等于小明呢？
这是不能的。我们头脑中的每个具体的人的概念，是根据这个人的各种特征来确定的。
而名字只是一个代号，是用来指代一个人的身上的各种特征的，但是不等于这个人。
也就是说：
```text
小明 = 一个人的一堆属性+关系+各种其它特征（这些特征的整体称为集合）
```
而每个不同的人，我们就是用他们各自独特的属性+关系+其它特征来识别的，然后再加上一个指代的称号，就是人的名字、昵称或者外号。
### 规范化描述方式
用格式化的方式，描述这个人的各种特征，就可以让我们对这个人的特征一目了然。
而进一步改进，用符号化的方式来描述，这种格式其实就和编程语言里的格式差不多了。
### 程序的目的是什么？
> 处理数据，给出结果。
所有的程序，做的都是这些事情。读入数据，进行处理，然后给出结果。
明白了这个基本的道理，在解决问题的时候，就应当贯彻基本的思想，选用合适的方法，尽量高效地完成自己的工作。
### 数据和变量
名字、名称和具体的数据对应才有意义。
代码中的变量名也是如此，变量的名称是和具体的数据一一对应的，通过变量名称，来使用、修改具体的数据。
什么是编程思想？就是要根据不同的需求，选用合适的数据类型来表征各种各样的事物。
### 声明、定义及赋值
`var output;`语句只是声明了一个`output`变量。
`output = "Hello, JS";`则是定义output变量后并进行赋值。
### 最终回：为什么要有各种数据格式？
我们人类写程序，都是为了解决各种各样的问题。程序是一种工具，来帮助我们更好地做事情。
男人喜欢各种五金工具，在做机械方面的工作时，合适的工具会很顺手。
女生的化妆品则是丰富多彩，唇膏、唇彩、唇蜜、唇釉各展所能。
而在程序的世界中，我们也需要各种可以合理指代现实或者虚拟事物的东西！
这个时候，数据格式就派上用场了。我要计算理财收入，那么就必须有数字；我要展示文章中的一句话，那么就需要字符串；要知道某个人今天是否来上班了，就要用布尔型变量；要列出家中的家具清单，就要用到数组；要记录一台电脑的配置和功能，就要用到对象了！
所有的这一些数据格式，都是为我们能够更方便地写程序来服务的。假设没有数组、没有对象，要列出电脑里的配件，就只能一个一个的列出来。要列出几十种不同型号电脑的配件呢？那就是个很可怕的工作了。但是有了数组、有了对象，每种型号的电脑都是一个对象，每个对象内部又有数组来指代各个电脑配件，这样清楚明白的结构，使用起来不是方便很多？
这还只是最基础的编程思想，要深入领悟这种思想，知其然并之气所以然，这样即使要学新的编程语言，也一样能迅速上手。如果把这个思想应用得更广泛一些的话，生活中的许多方面都是可以应用编程思想的，就像笑来老师那样。
所以说，举一反三非常重要！
## 建立自己的第一个个人主页
### 出现问题：Site not found
完全按照教程来操作，但是打开页面[https://dream4ever.github.io/test/](https://dream4ever.github.io/test/)时，显示的并不是所期望的网页内容，而是Github的提示页面：
```html
404
There isn't a GitHub Pages site here.
```
### 加餐：如何提出一个好问题？
以这次遇到的问题为例：Github Pages无法访问，我该如何求助？
```text
1. 基本环境：
操作系统：Windows 10 64位版本
浏览器：Chrome 60（常用浏览器的最新版，排除浏览器导致的故障）
网络状况：可正常访问Github，并可通过终端同步代码（说明不会是网络导致的故障）
2. 已做步骤：
- 将徐老师getting-started-with-javascript这个项目的最新版本同步至自己的项目。
- 在Github上新建了一个项目test并通过git clone到本地。
- 将徐老师getting-started-with-javascript/study/lesson2/github_index/目录下的所有文件，都复制到了test目录下。
- 在Github上的test项目的设置中，Github Pages这里的Source选项，选中了master branch，并进行了保存。
- 保存之后，Github也给出了提示：Your site is published at https://dream4ever.github.io/test/。
3. 存在问题：
访问https://dream4ever.github.io/test/，Github提示"404 There isn't a GitHub Pages site here."
4. 思考原因：
想起来自己以前也配置过Github Pages，当时就有人说过，这个配置要延迟几分钟才能生效。可能这次也是这个原因。
```
因为这次是自行解决了问题，所以给出自己的解决方案：
```text
5. 解决方案：
自己就把这件事情暂时放下，忙别的事情去了。过了一会儿再打开https://dream4ever.github.io/test/，果然可以正常访问了，完美！
```
================================================
FILE: homework/lesson2/huangjiashu.md
================================================
我知道，作业要从新做了，的确是没用心。实在是有付老师的期望。不过话说回来了，学习任何时候都是为自己学的。老师希望看到学生的努力和认真，很感谢老师对我第一次作业的肯定。言归正传：
## 提起命名
命名在程序中的确是不起眼又很重要的东西，好的命名让你可以不用看注释就知道表达的什么意思，糟糕的命名让人不知所云，不仔细看都不知道写的是啥，甚至有些命名需要靠猜才可以知道是什么意思。这就是名字起得不好。
一个好的命名是什么样的呢？就像老师讲的那样，把握两个原则：
1. 含义清晰
对比以下命名就能看出优劣
> var i,j,k var index
> var xiaoming var personObj
> var start var startTime
> var time var endTime
> var file var mdFilePath
> var up var upCount
> var down var downCount
> var id var nameId
2. 要what不要how
命名直接指出是什么，而不要让思考是什么，怎么来的
对比以下命名就能看出优劣
> var inputData var employeeData
那么如何做到清晰的命名的，就要多思考你的命名是要表达什么，一般来讲都是需要用英文来表述的，因此不懂的一定要勤查字典，我说的查字大多指的是直接在网上查词翻译，比如[谷歌翻译](https://translate.google.cn/?um=1&ie=UTF-8&hl=zh-CN&client=tw-ob#en/zh-CN/)。而那些命名方式如驼峰命名，匈牙利命名规则等，目的就是对每个单词有个明显的界线例如首字母大写，例如单词间以下划线分隔等。这些都只是命名工具，最为关键的还是选词。
命名的意义在于操作它和使用它，如果定义了变量却没有使用它，那么它是没有意义的。说到定义变量，不得不提到一点老师所说的：
> 声明：是在声明要创建一个变量
>
> 定义：是给这个变量开辟一块内
>
> 最后才是赋值
在向老师提问的时候，问过一个问题**为什么JavaScript是动态类型**老师举了个例子：
```
var xiaoming = '小明';
xiaoming = 1;
xiaoming = ['a','b','c'];
```
那么关于声明和定义来讲可以这么理解：
声明了1次：即声明了一个名为xiaoming的变量
定义了3次: 即每次赋值时都为此变量开辟了一块内存
赋值了3词：这个很好理解，有三个赋值语句。
## 数据类型
如果要说为什么有这么多丰富的数据类型，那么必然的要去了解这些数据类型有什么不同点。知道其特点及其用途自然就知道了为什么。关于此，我在网上搜索到了一篇[资料](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Data_structures)。以下内容大部分源于此：
JavaScript数据类型：ECMAScript 6 定义了7中数据类型
- 6种原始类型
- Number 数字类型 除了能表示浮点数外还有一些带符号的值，+Infinity,-Infinity和NaN(非数值),**它并没有为整数给出一种特定的类型**
- String 字符串类型 用来表示字符串，字符串是不可变的。但是可以基于原始字符串创建新的字符串
- Boolean 布尔值 表示一个逻辑实体，有两个值 true 和false 以区分真假
- Null 只有一个值null 目前常用于表示"没有对象",即此处不应该有值参见[null和undefined的区别](http://www.ruanyifeng.com/blog/2014/03/undefined-vs-null.html)
- Undefined 一个没有被赋值的变量会有一个默认值undefined，表示缺少值，就是此处应该有一个值，但是还有没有定义。
> （1）变量被声明了，但没有赋值时，就等于undefined。
>
> （2) 调用函数时，应该提供的参数没有提供，该参数等于undefined。
>
> （3）对象没有赋值的属性，该属性的值为undefined。
>
> （4）函数没有返回值时，默认返回undefined。
- Symbol (ECMAScript 6 新定义)符号类型是唯一的并且是不可修改的, 并且也可以用来作为Object的key
- 和Object 对象是指内存中的可以被 [标识符](https://developer.mozilla.org/en-US/docs/Glossary/Identifier)引用的一块区域.
在 Javascript 里，对象可以被看作是一组属性的集合。
> 用[对象字面量语法](https://developer.mozilla.org/en/JavaScript/Guide/Values,_variables,_and_literals#Object_literals)来定义一个对象时，会自动初始化一组属性。（也就是说，你定义一个var a = "Hello"，那么a本身就会有a.substring这个方法，以及a.length这个属性，以及其它；如果你定义了一个对象，var a = {}，那么a就会自动有a.hasOwnProperty及a.constructor等属性和方法。）而后，这些属性还可以被增减。属性的值可以是任意类型，包括具有复杂数据结构的对象。属性使用键来标识，它的键值可以是一个字符串或者符号值（Symbol）。
>
> ECMAScript定义的对象中有两种属性：数据属性和访问器属性。解释的太深了，我就不赘述了。
“标准的”对象和函数：
“标准的对象”就是键和值之间的映射。键是不可变的 字符串或者symbol 值可以是任意类型。
函数是一个附带可被调用功能的常规对象。
JavaScript有很多内建对象，比如 Date对象，有序集比如 数组是是一种使用整数作为键(integer-key-ed)属性和长度(length)属性之间关联的常规对象。
**这一点w3cschool中对数据类型的解释不太一样，w3cscholl把数组也作为了JavaScript的数据类型**
但是使用typeof 查看时返回的是object 所以还是把数组理解为对象。
可以使用typeof 查看数据类型
### 如何搭建个人主页
1. 在github创建一个项目
2. 在项目的设置中找到 GitHub Pages 将此项目的master分支设置为页面来源
3. 在项目创建index.html文件 会自动成为githhub寻找的网页
因为上面的东西github都已经给做了，所以个人搭建主页的关键就是编辑网页。
我目前还没想好做个什么样的个人主页，所以借老师的主页用几天，希望不要介意。我的主页地址是：
<https://mycolourfullife.github.io/youaremyworld/>
================================================
FILE: homework/lesson2/huangqi.md
================================================
##编程中为什么会有丰富化的数据格式
###编程中为什么会有丰富化的数据格式？我个人的理解是这个样子的：“精心选择的数据结构可以带来更高的运行或者储存效率，还有方便代码的调用吧”，我这个样子理解不知道对不对。请老师指正。
###我个人主页的地址
###https://yearnds.github.io/pande/.
================================================
FILE: homework/lesson2/huangzhihua.md
================================================
# 第二课总结 编程中为什么会有丰富化的数据格式？
编程中为什么会有丰富化的数据格式？
编程本质上是人类与计算机之间沟通的桥梁，计算机是0与1的世界，如果编程的过程之中，没有制定一些“规则”，那么计算机每次进行“解析”的时间一定会非常长，并且当人们在编写代码的时候也会增加大量重复低效的劳动。
而描述一个事物，所需要的数据非常复杂，为了让数据进行“有机的统一”，那么把数据划分类型，就可以极大的降低用数据描述一个事物的难度，就好比把一个“人”的数据进行拆分统计，比如说：“身高、年龄、性别、体重、姓名、家属关系……等等”。
### 以下这段“数据类型分类”我是从何伟的作业里复制过来的。我意识到没有跟上作业是一件非常吃亏的事情。
---
>在JS中，数据类型分为两类：**原始类型和对象类型。**
>**原始类型**包括：
>+ 数字
>+ 字符串
>+ 布尔值
>+ null（空）
>+ undefined（未定义）
>**对象类型**包括：
>+ “命名值”的无序集合
>+ 数组
>+ 函数
---
## 从第一节课到第二课遇到的坑，总结。
+ 从第一节课我就发现了，高阳老师的作业喜欢埋很多“坑”，但这种坑不全是故意的——比如说用md格式提交作业，但是第一节课的时间我错过了，完全不知道大家是如何写md格式的文档的，但我还是做了md格式的作业，原因是因为python课程里有教…… 但我用的是Jupyter写的文档，提交作业没有什么问题，当时没有仔细想这件事，直到后来装了VS（visual studio code）
// 打开了同学的作业，发现他们的格式和我完全不一样，有些同学的代码里一堆+、*…… ，关于这一点我意识到，虽然高阳老师的底线已经非常低了，但仍然还有更低的……发展空间。因为我在作业、ppt、js文档里，找不到相关信息，仿佛大家都知道怎么做一样，但是因为我对这部分知识是空白的，所以通过独立搜索需要花费更多的时间。
- 我搜了好几种方式的关键词，没有得到答案，最终我是看了markdown的语法说明才找到了问题所在，那就是“+、-、*”是一种无序的列表标记。就像我现在中每一段之前加的符号一样。
* 而关于同学们是如何写md的，我想到了简书或者是某一个软件，就像我做的一样，也可能有些同学用的是VS，但我找不到在VS里面直接输出md格式的方法。
# 个人静态主页：
* https://puppet163.github.io/PRESSONE/
```python
```
```python
```
================================================
FILE: homework/lesson2/huyong.md
================================================
#作业一 ：编程中为什么会有丰富的数据格式
数据格式我的理解是就像英文里面的26个字母，这些字母排列组合沟通了我们要表达的单词，语句，想法；
丰富的数据格式对应着更多的字母，如果只有3个字母，按照排列着它并不能构成太多的单词，更没有了丰富的思想表达
对于数据格式同样如此，如果格式不丰富就无法完成程序员对于目标的实现，我猜不同的变成语言应该会有不同的数据格式，
否则不同的代码在nd环境和浏览器环境怎么会有不同的结果呢，当然格式就对应着解析，同样的格式对于不同的解析器，
可能会有不同的输出结果，而不同的代码对于不同的解析器可能会有同样的输出结果，这可能也就是不同的实现可以通过
完全不同的语言和环境来实现的原因吧，我是小白，继续学习吧。
#作业二：对于代码在两种环境中的执行，我今天从上午是十点半开始捣鼓md完成第一次作业，结果弄得我差点
学习边编程的信心，就是搞不好，我就转而去安装那两个程序，然后问了下群里面，真是一点我就通了，我把代码在
两种环境中都敲门一部分通过敲代码我发现，我输入的速度实在是太慢了，我记得有一种键盘操作方式能够很快的敲出代码，
这个我需要找下，同时对于var我的理解是定义，console.log是输出，然后那些间隔啊，标点啊，真的很考验你的输入能力，
所以肯定有一种适合程序员的敲代码的习惯或者是输入法。
#作业三：静态网页网址：https://huyong007.github.io/LhyOwjVhistoryE/
================================================
FILE: homework/lesson2/jianglin.md
================================================
### 姜琳第二次课总结
#### 课程总结：编程中为什么会有丰富化的数据格式
#####多样化的数据格式用于不同的情况和操作
- 数字：用于计算；
- 文本：（字符串）用于表示是什么；
- 布尔：是/否，用于表示是非的逻辑；
- 对象：用于表示一个集合，包含各种属性或者变量的信息，可用于复杂的调用；
- 数组：用于表示一组变量，调用时可以以数组的形式依次调用。数字、文本、布尔、对象、数组）
##### 为什么会有丰富的数据格式
我的理解是在写程序的时候，需要实现不同的功能，就会用到不同的数据类型。就像常用的Excel表格中，会有单元格格式的不同，比如日期格式、文本格式、货币格式等，都是为了更好的服务于使用者。在定义变量的时候就想好这个变量的使用场景，就能确定这个变量的类型（虽然在用var定义时看不出来）。
买的指南还没到，目前只看了一些百度google的浅显内容，随着学习和实践，理解会更深刻。
#### 静态网页布置
https://andreajiang.github.io/html02/
好简陋，没增加内容，只做了一些替换。
#### 问题
1. Git的终端和win自带的终端有区别吗？操作指令看起来都是一样的。
2. 在运行sample_code.js时，一开始我怎么都运行不出来，总是报错：
>C:\Users\JL\my_project\sample_code.js:10
>
><<<<<<< HEAD
>
>^^
>
>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
后来各种查和试，在sample_code.js里把最开头附近的
`<<<<<<< HEAD`
`=======`
`>>>>>>> upstream/master`
这三行，删了或变成注释，再运行，才好了。但是不明白原理是什么。麻烦老师解答。
3. 在静态网页布置的时候，一开始我用老师的文件布置了一个，然后按照课上讲解的直接在GitHub上改动Html文档，但是改动了之后，点击原来的网址，网页没有更新内容，这是为什么呢？
#### 笔记
##### 部署一个静态网页
- 在项目里加入html的文件
- setting ——> GitHub Pages ——> Source（master branch）save
##### 一切以命名开始
先命名，再生小孩，再关联
属性，关系。名字和目标的关联：名字不代表这个具体的目标，而是代表属性和关系的集合。
程序的目的是什么：处理数据，得到结果。
var是js唯一的变量属性。var output="Hello,JS";
变量，要先声明再定义。
JS里单引号和双引号一样。
对象变量：定义用冒号，而不是等号。对象变量是包含各种变量、数组的集合（自己理解的概念）。
先用写代码的软件写好代码，再用node执行。
`>node simple.js`
================================================
FILE: homework/lesson2/langjianjun.md
================================================
第二节课总结 编程中为什么会有丰富化的数据格式？
丰富的数据格式是因程序要处理复杂的现实问题而产生的。
比如，字符串是对应生活中的文字的，需要保持原样；而数字则分为整数和浮点数，后者对应数学中的实数；而数组则可对应坐标、数据表格等。
正是因为这样的数学处理，电脑程序才能更好地解决问题。
作业拖了太久，马上要上课了，请老师原谅我这老学生草率的作业。
================================================
FILE: homework/lesson2/leizhen.md
================================================
编程中为什么会有丰富化的数据格式？
为了高效。
不同的格式可以互补短板
我把编程类比成雕刻师傅，数据格式类比成雕刻刀
雕刻刀的种类也有很多：平刀、斜刀......
用一把刀去雕刻当然是没有问题的，但是会用其他的刀，大大提高了效率嘛。
个人主页：https://rainyuzi.github.io/
================================================
FILE: homework/lesson2/lichen.md
================================================
###编程中为什么会有丰富化的数据格式？
一切从命名开始，从命名开始，我们得以操纵变量和数据。
这个世界所有的存在的事物背后都有很多属性、特征。
自然语言是人类用来处理特定目的。
数据就是语言的编码，从而处理数据，得到结果。
####为什么会有丰富化的数据格式？
方便描述对象的特征，有些特征比如身高体重年龄等比较适合用数字来描述；
性别、状态比较适合用布尔值来描述；
说话的内容可以用字符串的方式来描述；
集合性质的数据内容适合用数组来描述等。
也就是说不同的数据类型，我们可以使用不同的格式来对应它们，从而制定编程规则来操纵它们为我们实现目的。
拥有了不同的属性，我们就可以通过一系列方式将属性存储到对象上面，这样对象就等价于这些属性的集合。
####静态网页
github pages: https://lichen19844.github.io/static-web-page/
================================================
FILE: homework/lesson2/lingxiao.md
================================================
# 编程中为什么会有丰富化的数据格式-JavaScript第二次作业
## 作业
【作业要求】
1. 熟读getting-started-with-javascript/study/lesson2/smaple_code.js代码。用node环境和浏览器环境运行一下代码（注意：浏览器运行请使用my_personal_info_page.html）
2. 写一遍课程总结，题目为：编程中为什么会有丰富化的数据格式？
3. 如果有问题，在总结中把你的问题罗列出来，我会做解答。
【附加作业要求】
4. 在github上部署自己的静态网页，把网页地址放在总结文档里。
【提交方式】
5. 请向getting-started-with-javascript项目发起pull request。
https://github.com/xugy0926/getting-started-with-javascript
## 答案
1. **Demo代码运行结果**
| Node环境运行结果 | 浏览器环境运行结果 |
| :--------------------------------------: | :--------------------------------------: |
|  |  |
2. **编程中为什么会有丰富化的数据格式？**
为了描述这个世界，人类发明了计算机，而我们现在讨论的数据格式，也即是**数据类型**，其实更直接的是计算机里的数据类型。
> 数据类型(Data type)是用来约束数据的解释。在编程语言中，常见的数据类型包括原始类型（如：整数、浮点数或字元）、多元组、记录单元、代数数据类型、抽象数据类型、参考类型、类以及函式类型。数据类型描述了数值的表示法、解释和结构，并以算法操作，或是物件在内存中的储存区，或者其它储存装置。-- [wiki百科](https://zh.wikipedia.org/wiki/%E8%B3%87%E6%96%99%E9%A1%9E%E5%9E%8B)
大家知道，目前我们用的均是冯氏体系架构的计算机，其核心思想是存储程序，执行程序。而程序本身，也只是一种数据代码。即，数据从外在来看，可能就纯的数据本身，也可能是代表一段执行代码，也可能代表一定格式的程序或是文件。现代计算机，由于硬件设计上的限制，均采用的是二进制体系。那么在二进制的编码下，就产生了各种各样的数据类型。
尽管有各种各样的数据类型，但人们总是在想方设法的去追求一个目标，即，用尽可能少的空间，存储尽可能多的信息；就尽可能少的运算，呈现尽可能多的信息变换。而通过数据类型限定数据的范围，相当于加了范围约束，这种约束有如下好处：1）使用优化的存储格式，比如INT类型是四字节，存储格式为32位二进制字符，而varchar表示 “9999999999”则需要10字节（甚至更多，取决于DBMS类型）；2）在对该类约束数据实现某些操作就不再会报错，比如日期类型 ‘2017-3-28 00：00：00’就可以无障碍的通过内置函数转换为任何等价形式，比如"28/3/2017" 或者"2017年3月28日 0点"；3）通过数据类型约束可以减少非正常数据的存入，比如INT类型的列不应该存入字符串。一句话概括，有了数据类型,才能更好的分配管理内存,节省不必要的开支，可以处理一些非法输入。[^1]
在实际编程中，我们知道，任何编程语言（除了汇编，汇编只规定数据的字长），都会有自己的数据类型，而对一个程序员来讲，写代码的第一件事情就是定义数据类型。在数据类型背后，隐藏的是编译器或者解释器对数据处理方式的定义。知道了这个以后，我们在定义数据类型的时候，就应该知道，我们定义的这种数据类型，可以进行哪些操作，这些操作的规则是什么，这样我们才算真正掌握了这个数据类型。[^2]
3. 木有...
4. **我的静态网页：** https://lydialing.github.io/MyStaticWebpage/
[^1]: https://www.zhihu.com/question/54104439
[^2]: http://5412097.blog.51cto.com/5402097/1626125
================================================
FILE: homework/lesson2/linxiyao.md
================================================
编程中为什么会有丰富化的数据格式？
编程中有丰富的数据类型，比如数字数据（170）,数组数据（170，120，18）,文本/字符串数据（height），组合数据/对象（height:170,weight:120,age：18）,布尔数据（true or false）等。
不同的数据有不同的作用，可以实现多样化的目的。同时，不同的数据本身在系统中的存储、运算、传递效率不同，这些不同的数据类型决定了代码执行的效率。这样说来，编程中我们应该尽量选择简单的数据类型以提高代码执行效率吗？
个人静态网页https://linxiyaolxy.github.io/getting-started-with-javascript-homework-lesson2/
================================================
FILE: homework/lesson2/lipeng.md
================================================
## 编程中为什么会有丰富化的数据格式？
1
对应真实世界的数据状态。
比如我的年龄，那就是一个不超过3位数的整数。而提到我喜欢的食物，那么就是一大串了。
再比如，描述一个公司的架构，那么就是一层一层的金字塔结构。
2
统计所有业务中的数据类型，几乎是无限的，但这个无限，用编程语言的有限的数据格式表达出来，这相当于是某种程度格式化的数据，方便计算机高效处理。
网页地址：
https://5haydn.github.io/JS-Startup/
================================================
FILE: homework/lesson2/litao.md
================================================
# 编程中为什么会有丰富化的数据格式
标签（空格分隔）： 作业2
----------
世间存在的一切事物都要有个名字，即使用一个代号表示，也是对于它的一个命名，所以说命名是一切事物的基础。
而我们对于这个事物的认识，是通过了解它背后具有的属性、关系等信息获得的，所有这些信息都属于数据的范畴。将这些数据输入到我们的大脑，大脑就相当于电脑的中央处理系统，经过大脑对输入数据进行一系列的运算处理，最终得到我们想要的结果。
从输入到输出的中间处理过程，就类似在电脑上运行程序的过程。所以说，程序就是：处理数据，得到结果。编程就是要用计算机能识别的语言编写数据代码，让计算机处理运行这些程序，最终得到结果。
从我们对一个人起名字开始，我们要通过对这个人的属性特质职业等一系列内容的描述，人们才能清楚这个人是谁。由文字形式描述，到格式化方式描述，再到符号化方式、伪代码方式，最后到数据代码方式，经过这一系列的格式变化，我们看到每种格式的作用与不同。
由名字就引发出变量的定义，名字中包含许多变量，这么一堆不同的属性关系等变量就构成这个名字代表的一个事物，从而我们就识别出是什么事物。这些名字也相当于许多的数据，数据就要对应不同的数值。数据的表现形式，也就是数据格式也很多样化，根据变量的不同呈现出不同的数据格式。总的来说，编程面向的对象就是变量和数据。
在JS中，首先要声明一个变量，然后再定义这个变量，最后给这个变量赋值。
[李涛在GitHub上的静态网页][1]
[1]: https://www.github.com/litao0715/Melody-0715
================================================
FILE: homework/lesson2/liujuanjuan.md
================================================
## 听新生大学CTO讲JavaScript编程入门-2
by刘娟娟 2017-08-18
这堂课，老师依然用类比的方式，教我们认识编程世界的一个重要概念。
名字 = 变量
**命名**，是个哲学话题。现实世界中，为什么人、物、万事均有名字？没有一个名字，我们该如何指代ta呢？我们说到一个苹果，如果只能把那个苹果拿到眼前，那当我们吃掉它，或者在另外一个地方在谈论它时，又该如何指代它？
**等同吗？**名字能代表一个人吗？不能。名字用来指代一个人，但不能代表这个人。能代表这个人的，是他的一堆属性。比如身高、体重、性格、DNA、社交关系等等。_属性，除了属性的名字，还有属性的值。没有值的一个名，是没意义的。_
**以此类比**，在代码的世界里，我们用各种各样的**变量**名，来指代那些我们要用代码操控处理的对象。
我们需要命名，并把名字关联到具体的那个对象。变量需要先申明、再定义。
var myName;
myName = '刘娟娟';
这2行语句可以简写为：
var myName = '刘娟娟';
但，我需要记住的教训是：**只有变量名而无赋值的变量，是没意义的。**
在代码的世界里，变量有很多类型。有数字、字符串、数组、对象等等。为什么要有这么多的变量类型呢？因为变量本身就有那么多类型吖！_这个解释真是令人崩溃吖，老师此刻哭晕在办公室。_
**编程中为什么会有丰富化的数据格式？**
**不同的变量类型，是为了实现存储、传输、计算的效率最大化。**
存储占用硬盘空间，传输占用带宽流量，计算占用内存空间等等。不同变量类型所需要提供的字节大小是有差异的，既满足需求，又要实现效率最大化，于是发展出多种数据类型。
好消息是，**JavaScript中，变量的申明和定义，只需要一个var即可，它会自动处理变量的类型。**
## 本课知识点：
1、如何定义变量？ _直接用var+空格+变量名称;即可。_
2、JS如何处理变量类型？ _自动识别处理，无需编写代码的人操心。_
3、变量命名有哪些技巧或规范？ _英文，各种各样的形式，个人比较喜欢的是小写单词+后续单词首字母大写的驼峰模式。_
4、怎么掌握变量技巧和规范？ _不要背，看看老师和教程的sample，自己试着用用，用多了就融入骨子里。_
## 编写代码，本身如同讲话、写作，就是一种表达。
第2节课有一个令人印象深刻的演进过程，即从一段正常描述的文本，逐步拆解成程序的语言。让我等小白讶然：原来编写代码这么简单！
因为在写这篇小结时，我已经听了第3、4节课程，我越发觉得：把事情想复杂了，反而难以为继；简单点，恢复它的本原就好。
================================================
FILE: homework/lesson2/liujun.md
================================================
# 编程中为什么会有丰富化的数据格式？
## 数据格式的种类
数据格式有许多种，我目前知道的有：布尔型，字符串型，数组，整型，列表等。
它们也可以随意组合，任意调用。
## 编程为什么会有丰富化的数据格式？
老师讲课时，用定义小明的方式来类比编程里的变量和值。小明作为一个独一无二
的个人，有许多只属于他自己的特征，比如，DNA，身高，体重，家庭关系，兴趣
爱好等，这些都是用不同的方式表现出来的。这些类比到编程里，我们很容易得出
一个结论：单一的数据类型，不能满足我们的编程需要，用单一的数据类型，创造
不出一个丰富多彩的世界。我相信没有一个数据类型是多余的，是凭空造出来的。
每一个数据类型都有它独特的使用环境。
作为一个小白，刚开始学习编程的人来说，我觉得应该弄明白每一个数据类型的用
途，找到使用数据类型个最有效方式。以上是我的理解。
## 我的个人静态网页
https://liujun009.github.io/liujun/
================================================
FILE: homework/lesson2/liuliyuan.md
================================================
##第二次作业 变量和值
1、在编程语言中，能够表示并操作的值的类型称作数据类型。JavaScript的数据类型分为两类：
>原始类型:数字、字符串、布尔值，null/undefined
>对象类型：数组，函数，日期类，正则类，错误类
**Notice**：区分字符串和数组，字符串是一组由16位值组成的不可变的有序序列，JS通过字符串类型来表示文本；数组是带编号的值的有序集合。
---
2、JS中的数据类型转换非常灵活
刚开始看到这点其实是有困惑的，既然各种数据类型可以灵活转换，那为什么还要那么多种数据类型呢？
后来看到一段代码中有说字符串的length，才把我的注意力拉到存储空间上，应该是不同的数据类型存储空间不同，如果数据类型单一的话，都定义成大的话，耗费的存储空间就要大很多，运算速度也会很慢。
而JS中数据类型灵活转换，更是方便了我们进行运算，增快运行速度。
**Notice**：老师在第三节课所讲，不同的数据类型决定了代码执行的效率。效率包括：存储效率，计算效率，传递效率。
---
3、函数作用域和声明提前
JS函数作用域：变量在声明
gitextract_7orgddh0/
├── .gitignore
├── README.md
├── _config.yml
├── homework/
│ ├── lesson1/
│ │ ├── Autumn.md
│ │ ├── ElizabethZhouli.md
│ │ ├── GaoXianfeng.md
│ │ ├── Huang_Biling.md
│ │ ├── Jaykey.md
│ │ ├── Learner-Chen.md
│ │ ├── LiaoYuemin.md
│ │ ├── Liuzhengchun.md
│ │ ├── Rachel.md
│ │ ├── Risexie.md
│ │ ├── SunBo.md
│ │ ├── WangChangQing.md
│ │ ├── Wei.md
│ │ ├── WuGaoxing.md
│ │ ├── XGunn-lesson01.md
│ │ ├── ZhengChao.md
│ │ ├── anjiancai.md
│ │ ├── baoguoqiang.md
│ │ ├── caijinpeng.md
│ │ ├── caozhen.md
│ │ ├── chaigaoping.md
│ │ ├── chengjun.md
│ │ ├── chenlingmin.md
│ │ ├── chenqiong.md
│ │ ├── chenrushan.md
│ │ ├── chenyanxing.md
│ │ ├── chenzidong.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuimeng.md
│ │ ├── cuimiao.md
│ │ ├── dangfeipeng.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── donglili.md
│ │ ├── duhongxia.md
│ │ ├── fangqingyang.md
│ │ ├── fanliao.md
│ │ ├── fanqing.md
│ │ ├── feixiguang.md
│ │ ├── fengkai.md
│ │ ├── hanmeng.md
│ │ ├── hanwei.md
│ │ ├── haohu.md
│ │ ├── hewei.md
│ │ ├── huangjiashu.md
│ │ ├── huangqi.md
│ │ ├── huangxiaohui.md
│ │ ├── huangzhihua.md
│ │ ├── huxiaodan.md
│ │ ├── huyong.md
│ │ ├── ianyang.md
│ │ ├── jaychen.md
│ │ ├── jianglin.md
│ │ ├── langjianjun.md
│ │ ├── leizhen.md
│ │ ├── lichen.md
│ │ ├── linchunlong.md
│ │ ├── lingxiao.md
│ │ ├── linxiyao.md
│ │ ├── lipeng.md
│ │ ├── lipengyu.md
│ │ ├── litao.md
│ │ ├── liujuanjuan1984.md
│ │ ├── liujun-sh.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── liuqing.md
│ │ ├── liuruyong.md
│ │ ├── liushengsi.md
│ │ ├── liushengxin.md
│ │ ├── liuxiaohaohao.md
│ │ ├── lixiang.md
│ │ ├── lixiaoxin.md
│ │ ├── liyihang.md
│ │ ├── luoruijun.md
│ │ ├── maggiewong.md
│ │ ├── panqi.md
│ │ ├── panyong.md
│ │ ├── qiujingyu.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── sophieQi.md
│ │ ├── sunxl.md
│ │ ├── tangjianfeng.md
│ │ ├── taobao.md
│ │ ├── tuyilang.md
│ │ ├── wangmeiling.md
│ │ ├── wangshasha.md
│ │ ├── wangwei.md
│ │ ├── wangxuanding.md
│ │ ├── wangyuliang.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.md
│ │ ├── wenliuxin.md
│ │ ├── wenyunxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi.md
│ │ ├── xiaochaoge.md
│ │ ├── xieyuhui.md
│ │ ├── xiongliyu.md
│ │ ├── xugang.md
│ │ ├── xugaoyang.md
│ │ ├── xuli.md
│ │ ├── xuluchun.md
│ │ ├── xumin.md
│ │ ├── yammy.md
│ │ ├── yangchunguang.md
│ │ ├── yanglovewo.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yangyepeng.md
│ │ ├── yanqingmu.md
│ │ ├── yimiao.md
│ │ ├── yongfei.md
│ │ ├── youshilei.md
│ │ ├── yueruiqi.md
│ │ ├── yujianke.md
│ │ ├── zhanggaoyang.md
│ │ ├── zhanghuanyuan.md
│ │ ├── zhanghy.md
│ │ ├── zhanglina.md
│ │ ├── zhangqian.md
│ │ ├── zhangruirui.md
│ │ ├── zhangxuedong.md
│ │ ├── zhaokaili.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhouhong.md
│ │ ├── zhouqizhou.md
│ │ ├── zhouziqi.md
│ │ ├── zhuningning.md
│ │ ├── zhuting.md
│ │ ├── zhuxiaoping.md
│ │ └── zhuyongjin.md
│ ├── lesson2/
│ │ ├── Autumnchou.md
│ │ ├── GaoXianfeng.md
│ │ ├── JayChen.md
│ │ ├── Jaykey_Guo.md
│ │ ├── LiaoYuemin.md
│ │ ├── Liuzhengchun.md
│ │ ├── Rachel.md
│ │ ├── Risexie.md
│ │ ├── SunBo.md
│ │ ├── WANG XUANDING.md
│ │ ├── WangChangQing.md
│ │ ├── WuGaoxing.md
│ │ ├── Zhengchao.md
│ │ ├── baoguoqiang.md
│ │ ├── caozhen.md
│ │ ├── chengjun.md
│ │ ├── chenguoqiang.md
│ │ ├── chenqiong.md
│ │ ├── chenrushan.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuimiao.md
│ │ ├── dangfeipeng.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── duhongxia.md
│ │ ├── fangqingyang.md
│ │ ├── fanqing.md
│ │ ├── fengkai.md
│ │ ├── guowei.md
│ │ ├── hanmeng.md
│ │ ├── hanwei.md
│ │ ├── haohu.md
│ │ ├── hewei.md
│ │ ├── huangjiashu.md
│ │ ├── huangqi.md
│ │ ├── huangzhihua.md
│ │ ├── huyong.md
│ │ ├── jianglin.md
│ │ ├── langjianjun.md
│ │ ├── leizhen.md
│ │ ├── lichen.md
│ │ ├── lingxiao.md
│ │ ├── linxiyao.md
│ │ ├── lipeng.md
│ │ ├── litao.md
│ │ ├── liujuanjuan.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── liuqing.md
│ │ ├── liuruyong.md
│ │ ├── liushengsi.md
│ │ ├── liushengxin.md
│ │ ├── liuxiaohaohao.md
│ │ ├── lixiang.md
│ │ ├── liyihang.md
│ │ ├── luoruijun.md
│ │ ├── marshalcy.md
│ │ ├── panqi.md
│ │ ├── panyong.md
│ │ ├── qiujingyu.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── sophieQi.md
│ │ ├── tangjianfeng.md
│ │ ├── taobao.md
│ │ ├── tuyilang.md
│ │ ├── wangshasha.md
│ │ ├── wangwei.md
│ │ ├── wangying.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.md
│ │ ├── wenliuxin.md
│ │ ├── wenyunxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi.md
│ │ ├── xiongliyu.md
│ │ ├── xugaoyang.md
│ │ ├── xuli.md
│ │ ├── xuluchun.md
│ │ ├── xumin.md
│ │ ├── yammy.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yangyepeng.md
│ │ ├── yanqingmu.md
│ │ ├── yimiao.md
│ │ ├── yongfei.md
│ │ ├── youshilei.md
│ │ ├── yueruiqi.md
│ │ ├── yujianke.md
│ │ ├── zhanggaoyang.md
│ │ ├── zhanglina.md
│ │ ├── zhangqian.md
│ │ ├── zhangxuedong.md
│ │ ├── zhaokaili.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhengchengyan.md
│ │ ├── zhouhong.md
│ │ ├── zhouwenming.md
│ │ ├── zhuningning.md
│ │ ├── zhuting.md
│ │ ├── zhuxiaoping.md
│ │ ├── zhuyongjin.md
│ │ ├── zongjie-fanliao.md
│ │ ├── 第二次作业.md
│ │ ├── 第二次课程总结.html
│ │ └── 第二次课程总结.md
│ ├── lesson3/
│ │ ├── GaoXianfeng.md
│ │ ├── Jaykey_Guo.md
│ │ ├── LiaoYuemin.md
│ │ ├── Risexie.md
│ │ ├── WangChangQing.md
│ │ ├── caijinpeng.md
│ │ ├── cloudyview.md
│ │ ├── cuimiao.md
│ │ ├── dengxy0907.md
│ │ ├── fangqingyang.md
│ │ ├── guowei.md
│ │ ├── hanwei.md
│ │ ├── hewei.md
│ │ ├── huangBiLing.md
│ │ ├── jianglin.md
│ │ ├── leizhen.md
│ │ ├── lichen.md
│ │ ├── lipeng.md
│ │ ├── liujuanjuan1984.md
│ │ ├── liuxiaohaohao.md
│ │ ├── panqi.md
│ │ ├── sophieQi.md
│ │ ├── taobao.md
│ │ ├── wangwei.md
│ │ ├── wangyunfei_zongjie.md
│ │ ├── wenliuxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi3.md
│ │ ├── xiaochaoge.md
│ │ ├── xiaoyi.md
│ │ ├── xiongliyu.md
│ │ ├── xugaoyang.md
│ │ ├── yammy.md
│ │ ├── yanqingmu.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── 第三次作业 交互图.md
│ │ └── 谢玉辉.md.md
│ ├── lesson4/
│ │ ├── Jaykey.md
│ │ ├── Risexie.md
│ │ ├── WuGaoxing.md
│ │ ├── jianglin.md
│ │ ├── liujuanjuan1984.md
│ │ ├── panyong.md
│ │ ├── taobao.md
│ │ └── xiaochaoge.md
│ ├── lesson5/
│ │ ├── GaoXianfeng.md
│ │ ├── JayChen.md
│ │ ├── Jaykey_Guo.md
│ │ ├── LiaoYuemin.md
│ │ ├── LiuShengsi's homework of lesson5.md
│ │ ├── Risexie.md
│ │ ├── WANG Xuanding.md
│ │ ├── WuGaoxing.md
│ │ ├── Zhengchao.md
│ │ ├── anjiancai.md
│ │ ├── baoguoqiang.md
│ │ ├── caijinpeng.md
│ │ ├── caozhen.md
│ │ ├── chenguoqiang.md
│ │ ├── chenrushan.md
│ │ ├── chenyanxing.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuimiao.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── donglili.md
│ │ ├── fangqingyang.md
│ │ ├── fanliao.md
│ │ ├── fanqing.md
│ │ ├── fengkai.md
│ │ ├── guowei.md
│ │ ├── hanwei.md
│ │ ├── haohu.md
│ │ ├── hewei.md
│ │ ├── huangBiLing.md
│ │ ├── huangjiashu.md
│ │ ├── huyong.md
│ │ ├── jianglin.md
│ │ ├── langjj.md
│ │ ├── lichen.md
│ │ ├── limu.md
│ │ ├── lingxiao.md
│ │ ├── linxiyao-homework-lesson5.md
│ │ ├── lipeng-学习“异步实现一桌酒席”心得，代码难点分析.md
│ │ ├── lipeng.md
│ │ ├── liujuanjuan1984.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── liuruyong.md
│ │ ├── liushengxin.md
│ │ ├── lixiang.md
│ │ ├── luoruijun.md
│ │ ├── maggiewong.md
│ │ ├── marshalcy.md
│ │ ├── oyanagchun的作业
│ │ ├── panyong.md
│ │ ├── qiujingyu.md
│ │ ├── readme.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── sophieQi.md
│ │ ├── sunyan.md
│ │ ├── tangjianfeng.md
│ │ ├── taobao.md
│ │ ├── wangchangqing.md
│ │ ├── wangwei.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.md
│ │ ├── wengguihua.md
│ │ ├── wenliuxin.md
│ │ ├── wenyunxin.md
│ │ ├── wufan.md
│ │ ├── wukuipin.md
│ │ ├── xianengqi.md
│ │ ├── xiongliyu.md
│ │ ├── yammy.md
│ │ ├── yangchunguang.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yanqingmu.md
│ │ ├── yimiao li 5th.md
│ │ ├── youshilei.md
│ │ ├── zhanggaoyang.md
│ │ ├── zhanglina.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhouqizhou.md
│ │ ├── zhuningning.md
│ │ ├── zhutinglesson5.md
│ │ ├── zhuyongjin.md
│ │ └── 谢玉辉.md
│ ├── lesson6/
│ │ ├── GaoXianfeng.js
│ │ ├── LiuShengsi.js
│ │ ├── Risexie.js
│ │ ├── WANG_Xuanding.js
│ │ ├── Wei.js
│ │ ├── WuGaoxing.js
│ │ ├── anjiancai.js
│ │ ├── babysodme.js
│ │ ├── baoguoqiang.js
│ │ ├── caijinpeng.js
│ │ ├── caozhen.js
│ │ ├── caozhen.md
│ │ ├── chenrushan.js
│ │ ├── chenyanxing.js
│ │ ├── chenziwen.js
│ │ ├── cloudyview.js
│ │ ├── cuimiao.js
│ │ ├── cuiyuwei.js
│ │ ├── dangfeipeng.js
│ │ ├── dengxy0907.js
│ │ ├── diaozhicong.js
│ │ ├── donglili.js
│ │ ├── fangqingyang.js
│ │ ├── fanliao.js
│ │ ├── fengkai.js
│ │ ├── hanwei.js
│ │ ├── haohu.js
│ │ ├── hewei.js
│ │ ├── hitchhacker.js
│ │ ├── huangjiashu.js
│ │ ├── huyong.js
│ │ ├── jaykeyGuo.js
│ │ ├── jaykeyGuo.md
│ │ ├── jianglin.js
│ │ ├── langjianjun.js
│ │ ├── lesson9.md
│ │ ├── lianghf.js
│ │ ├── liaoyuemin.js
│ │ ├── lichen_async.js
│ │ ├── lichen_sync.js
│ │ ├── limingxing.js
│ │ ├── lingxiao.js
│ │ ├── lipeng.js
│ │ ├── liujuanjuan1984.js
│ │ ├── liujun.js
│ │ ├── liuliyuan.js
│ │ ├── liuliyuan.md
│ │ ├── liushengxin.js
│ │ ├── lixiang.js
│ │ ├── lixiang.md
│ │ ├── luoruijun.js
│ │ ├── mindongquan.js
│ │ ├── ouyangchun.js
│ │ ├── panyong.js
│ │ ├── qiujingyu.js
│ │ ├── readme.md
│ │ ├── shaozhen.js
│ │ ├── shenzhili.js
│ │ ├── sunyan.js
│ │ ├── tangjianfeng.js
│ │ ├── taobao.js
│ │ ├── tuyilang.js
│ │ ├── wangchangqing.js
│ │ ├── wangganzy.js
│ │ ├── wangshasha.js
│ │ ├── wangwei.js
│ │ ├── wangyunfei.js
│ │ ├── wangzhongbin.js
│ │ ├── weiyang.js
│ │ ├── wengguihua.js
│ │ ├── wenliuxin.js
│ │ ├── wenyunxin.js
│ │ ├── wufan.js
│ │ ├── wukuipin.js
│ │ ├── xianengqi.js
│ │ ├── xiongliyu.js
│ │ ├── yammy.js
│ │ ├── yangtieming.js
│ │ ├── yangxuewu.js
│ │ ├── yanqingmu.js
│ │ ├── yimiao.js
│ │ ├── youshilei.js
│ │ ├── zhanggaoyang.js
│ │ ├── zhanglina.js
│ │ ├── zhanglina.md
│ │ ├── zhaokaili.js
│ │ ├── zhaoxiaoxin.js
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.js
│ │ ├── zhengchao.js
│ │ ├── zhengchao.md
│ │ ├── zhuting.js
│ │ ├── zouhainan.js
│ │ └── 谢玉辉六课作业.js
│ ├── lesson7/
│ │ ├── GaoXianfeng.md
│ │ ├── anjiancai.md
│ │ ├── chenguoqiang.md
│ │ ├── chenrushan.md
│ │ ├── chenyanxing.md
│ │ ├── chenziwen.md
│ │ ├── cloudyview.md
│ │ ├── cuiyuwei.md
│ │ ├── dangfeipeng.md
│ │ ├── dengxy0907.md
│ │ ├── diaozhicong.md
│ │ ├── fangqingyang.md
│ │ ├── fengkai.md
│ │ ├── guowei.md
│ │ ├── hanwei.md
│ │ ├── hewei.md
│ │ ├── hitchhacker.md
│ │ ├── huangBiLing.md
│ │ ├── huangjiashu.md
│ │ ├── jaykeyGuoJian.md
│ │ ├── liaoyuemin.md
│ │ ├── lingxiao.md
│ │ ├── lipeng.md
│ │ ├── liujun.md
│ │ ├── liuliyuan.md
│ │ ├── lixiang.js
│ │ ├── lixiang.md
│ │ ├── luoruijun.md
│ │ ├── qiujingyu.md
│ │ ├── readme.md
│ │ ├── shaozhen.md
│ │ ├── shenzhili.md
│ │ ├── taobao.md
│ │ ├── wangwei.md
│ │ ├── wangyunfei.md
│ │ ├── wangzhongbin.js
│ │ ├── wangzhongbin.md
│ │ ├── weiyang.js
│ │ ├── wengguihua.md
│ │ ├── wenyunxin.md
│ │ ├── wukuipin.js
│ │ ├── wukuipin.md
│ │ ├── xieyuhui.md
│ │ ├── yammy.md
│ │ ├── yangtieming.md
│ │ ├── yangxuewu.md
│ │ ├── yanqingmu.md
│ │ ├── yimiaoli.md
│ │ ├── yinzhibao.md
│ │ ├── youshilei.md
│ │ ├── zhanglina.md
│ │ ├── zhaokaili.md
│ │ ├── zhaoxiaoxin.md
│ │ ├── zhaoyinan.md
│ │ ├── zhengchao.js
│ │ └── zhengchao.md
│ └── lesson9/
│ ├── GaoXianfeng.md
│ ├── dengxy0907.md
│ ├── fangqingyang.md
│ ├── guowei.md
│ ├── liujun.md
│ ├── wayne.md
│ ├── weiyang.html
│ ├── wukuipin.md
│ ├── yammy.md
│ └── yinzhibao.md
├── public/
│ ├── libs/
│ │ └── bootstrap-3.3.7-dist/
│ │ ├── css/
│ │ │ ├── bootstrap-theme.css
│ │ │ └── bootstrap.css
│ │ └── js/
│ │ ├── bootstrap.js
│ │ └── npm.js
│ └── style.css
├── script/
│ ├── checkHomework.js
│ ├── checkMyFile.js
│ ├── clean.js
│ ├── fs.js
│ ├── package.json
│ ├── run.js
│ ├── scan.js
│ ├── start.js
│ └── updateTeam.js
├── study/
│ ├── lesson10/
│ │ ├── first-web-app/
│ │ │ ├── app.js
│ │ │ ├── bin/
│ │ │ │ └── www
│ │ │ ├── package.json
│ │ │ ├── public/
│ │ │ │ ├── style.css
│ │ │ │ ├── stylesheets/
│ │ │ │ │ └── style.css
│ │ │ │ └── words.js
│ │ │ ├── routes/
│ │ │ │ ├── index.js
│ │ │ │ └── users.js
│ │ │ └── views/
│ │ │ ├── error.ejs
│ │ │ └── index.ejs
│ │ └── github_index/
│ │ ├── index.html
│ │ └── public/
│ │ └── style.css
│ ├── lesson2/
│ │ ├── github_index/
│ │ │ ├── index.html
│ │ │ └── public/
│ │ │ └── style.css
│ │ ├── my_personal_info_page.html
│ │ ├── sample1.html
│ │ ├── sample2.html
│ │ ├── sample3.html
│ │ └── sample_code.js
│ ├── lesson3/
│ │ ├── name_style.js
│ │ └── statement.js
│ ├── lesson4/
│ │ ├── build_a_human.js
│ │ ├── kitchen_workflow.js
│ │ ├── object.js
│ │ ├── readme.md
│ │ ├── sound_off.js
│ │ ├── sound_off_2.js
│ │ ├── sound_off_3.js
│ │ └── vue/
│ │ └── index.html
│ ├── lesson5/
│ │ ├── async_function.js
│ │ ├── flight_schedule_1.js
│ │ ├── flight_schedule_2.js
│ │ ├── flight_schedule_3.js
│ │ ├── indirect.js
│ │ ├── indirect_call.js
│ │ ├── kitchen_workflow_async.js
│ │ ├── readme.md
│ │ ├── type_array_sample.js
│ │ ├── type_boolean_sample.js
│ │ ├── type_number_sample.js
│ │ ├── type_object_sample.js
│ │ └── type_string_sample.js
│ ├── lesson6/
│ │ ├── scan_files_async.js
│ │ ├── scan_files_sync.js
│ │ ├── write_file_async.js
│ │ └── write_file_sync.js
│ ├── lesson7/
│ │ ├── all_words.json
│ │ ├── error_data.json
│ │ ├── github_index/
│ │ │ ├── easy_vue.html
│ │ │ ├── index.html
│ │ │ └── public/
│ │ │ └── style.css
│ │ ├── homework_readme.md
│ │ ├── homework_sample.js
│ │ ├── package.json
│ │ ├── read_a_json_file.js
│ │ ├── readme.md
│ │ ├── sound_off.js
│ │ ├── test_data/
│ │ │ └── data.json
│ │ └── write_a_json_file.js
│ └── lesson9/
│ ├── chain_function_call.js
│ ├── github_index/
│ │ ├── index.html
│ │ └── public/
│ │ └── style.css
│ └── readme.md
├── topics/
│ ├── Git实战笔记.md
│ ├── JS函数.md
│ ├── JavaScript的语法学习指引.md
│ ├── MAC-Terminal-command-list.md
│ ├── Win-Command-list.md
│ ├── callback函数的设计学.md
│ ├── js重要语句.md
│ ├── 两种定义函数方式的差异.md
│ ├── 了不起的axios(http).md
│ ├── 代码就是由这些组成的.md
│ ├── 作品征集.md
│ ├── 函数 - 定义完就执行.md
│ ├── 匿名函数使用技巧.md
│ ├── 变量命名简明技巧.md
│ ├── 同步函数的两种返回结果的方式.md
│ ├── 图床教程.md
│ ├── 在Heroku上快速部署自己的JS项目.md
│ ├── 如何从主项目更新fork的项目.md
│ ├── 如何在终端执行代码.md
│ ├── 如何查看git push和pr的提交结果.md
│ ├── 安装nvm.md
│ ├── 定义变量.md
│ ├── 相对路径.md
│ ├── 第一个webapp.md
│ ├── 第一次pull-request.md
│ ├── 第一次pull-request错误汇总.md
│ ├── 第一次使用Git.md
│ ├── 第一次使用JSON.md
│ └── 让github-wiki变成图床.md
└── webapp/
├── package.json
├── src/
│ ├── app.js
│ ├── bin/
│ │ └── www
│ ├── config/
│ │ ├── index.dev.js
│ │ ├── index.js
│ │ └── index.pro.js
│ ├── middleware/
│ │ └── courseInfo.js
│ ├── public/
│ │ ├── libs/
│ │ │ └── bootstrap-3.3.7-dist/
│ │ │ ├── css/
│ │ │ │ ├── bootstrap-theme.css
│ │ │ │ └── bootstrap.css
│ │ │ └── js/
│ │ │ ├── bootstrap.js
│ │ │ └── npm.js
│ │ └── stylesheets/
│ │ ├── anim.css
│ │ ├── github-markdown.css
│ │ └── style.css
│ ├── request.js
│ ├── routes/
│ │ ├── homework.js
│ │ ├── index.js
│ │ ├── sayToTeacher.js
│ │ ├── studentWorks.js
│ │ ├── topics.js
│ │ └── words.js
│ └── views/
│ ├── _head.ejs
│ ├── _header.ejs
│ ├── _nav.ejs
│ ├── _slider.ejs
│ ├── error.ejs
│ ├── homework.ejs
│ ├── homeworkList.ejs
│ ├── index.ejs
│ ├── sayToTeacher.ejs
│ ├── sayToTeacher2.ejs
│ ├── studentWorks.ejs
│ ├── topics.ejs
│ └── words.ejs
└── test/
├── routes_api.test.js
└── routes_page.test.js
SYMBOL INDEX (241 symbols across 92 files)
FILE: homework/lesson6/LiuShengsi.js
function read_file_result (line 11) | function read_file_result(err, files) {
function write_file_result (line 28) | function write_file_result(err) {
FILE: homework/lesson6/Risexie.js
function callback1 (line 10) | function callback1(err,files){
function callback2 (line 51) | function callback2(err){
FILE: homework/lesson6/WANG_Xuanding.js
function read_callback (line 15) | function read_callback(err, files) {
function write_callback (line 31) | function write_callback(err) {
FILE: homework/lesson6/Wei.js
function read_callback (line 31) | function read_callback(err, files) {
function write_callback (line 48) | function write_callback(err) {
FILE: homework/lesson6/anjiancai.js
function readcallback (line 19) | function readcallback(err, files) {
function readcallback (line 43) | function readcallback(err, files) {
function writecallback (line 58) | function writecallback(err) {
FILE: homework/lesson6/babysodme.js
function callbackScanFiles (line 5) | function callbackScanFiles(err, files){
function callbackWriteFiles (line 18) | function callbackWriteFiles(files){
FILE: homework/lesson6/baoguoqiang.js
function callback (line 36) | function callback(err,files) {
function callback (line 58) | function callback(err) {
FILE: homework/lesson6/caozhen.js
function readCallback (line 38) | function readCallback(err, files2) {
function writeCallback (line 62) | function writeCallback(err) {
FILE: homework/lesson6/chenyanxing.js
function read_callback (line 14) | function read_callback(err, files) {
function write_callback (line 28) | function write_callback(err) {
FILE: homework/lesson6/cloudyview.js
function callback (line 19) | function callback(err , files) {
function writeCallback (line 39) | function writeCallback(err) {
function fileListCallback (line 50) | function fileListCallback(files) {
FILE: homework/lesson6/cuimiao.js
function callback (line 10) | function callback(err,files){
function writecallback (line 33) | function writecallback(err) {
FILE: homework/lesson6/cuiyuwei.js
function readCallback (line 35) | function readCallback(err, files) {
function writeCallback (line 60) | function writeCallback(err) {
FILE: homework/lesson6/diaozhicong.js
function callback (line 23) | function callback(err) {
FILE: homework/lesson6/donglili.js
function callback (line 13) | function callback(err, files) {
function callback1 (line 26) | function callback1(err) {
FILE: homework/lesson6/fangqingyang.js
function callback (line 15) | function callback(err) {
FILE: homework/lesson6/fanliao.js
function callback (line 3) | function callback(err, files) {
function call (line 16) | function call(err) {
FILE: homework/lesson6/fengkai.js
function callback (line 29) | function callback(err, files) {
function callbackforwrite (line 50) | function callbackforwrite(err) {
FILE: homework/lesson6/hanwei.js
function read (line 21) | function read(err, files) {
function write (line 38) | function write(err) {
FILE: homework/lesson6/haohu.js
function readCallback (line 6) | function readCallback(err, files) {
function writeCallback (line 18) | function writeCallback(err) {
function writeToTxtFile (line 26) | function writeToTxtFile(filesArray) {
FILE: homework/lesson6/hewei.js
function processJsonFileNames (line 25) | function processJsonFileNames() {
function getJsonFileNamesFromDirectory (line 53) | function getJsonFileNamesFromDirectory(userChoice) {
function writeToFile (line 75) | function writeToFile() {
function searchCurrentDirectory (line 95) | function searchCurrentDirectory() {
function searchWithGlob (line 118) | function searchWithGlob() {
function searchRecursive (line 170) | function searchRecursive(pathString) {
function traverse (line 183) | function traverse(dir) {
FILE: homework/lesson6/hitchhacker.js
function callback (line 14) | function callback(err, files) {
function callback2 (line 30) | function callback2(err) {
FILE: homework/lesson6/huangjiashu.js
function readFileList (line 8) | function readFileList(dirPath,writeToFile){
function writeToFile (line 46) | function writeToFile(filePath,contents) {
FILE: homework/lesson6/jaykeyGuo.js
function callbackForWrite (line 8) | function callbackForWrite(err) {
function callbackForRead (line 17) | function callbackForRead(err, files){
FILE: homework/lesson6/jianglin.js
function dirCallback (line 9) | function dirCallback(err,files){
function outputCallback (line 32) | function outputCallback(err){
FILE: homework/lesson6/langjianjun.js
function callback (line 35) | function callback(err) {
FILE: homework/lesson6/liaoyuemin.js
function readCallback (line 25) | function readCallback(err, files) {
function readCallback (line 117) | function readCallback(err, files) {
function writeCallback (line 134) | function writeCallback(err) {
function readCallback (line 145) | function readCallback(err, files) {
function writeCallback (line 162) | function writeCallback(err) {
FILE: homework/lesson6/lichen_async.js
function callbackScan (line 13) | function callbackScan(err, files) {
function fileArrayToString (line 26) | function fileArrayToString(files) {
function callbackWrite (line 36) | function callbackWrite(err) {
FILE: homework/lesson6/lichen_sync.js
function fileArrayToString (line 19) | function fileArrayToString(files) {
FILE: homework/lesson6/limingxing.js
function callback (line 22) | function callback(err) {
FILE: homework/lesson6/lingxiao.js
function read_callback (line 34) | function read_callback(err,files) {
function write_callback (line 55) | function write_callback(err) {
FILE: homework/lesson6/lipeng.js
function readCallback (line 17) | function readCallback(err, files){
function writeCallback (line 32) | function writeCallback(err){
FILE: homework/lesson6/liujuanjuan1984.js
function scanCallback (line 25) | function scanCallback(err, files){
function writeCallback (line 67) | function writeCallback(err,files){
FILE: homework/lesson6/liujun.js
function readCallback (line 9) | function readCallback(err, files) {
function writeCallback (line 24) | function writeCallback(err) {
FILE: homework/lesson6/liuliyuan.js
function scan_callback (line 6) | function scan_callback(err,files) {
function write_callback (line 24) | function write_callback (err) {
FILE: homework/lesson6/liushengxin.js
function callback (line 15) | function callback(err) {
FILE: homework/lesson6/lixiang.js
function callback (line 11) | function callback(err, files) {
function callback2 (line 29) | function callback2(err){
FILE: homework/lesson6/luoruijun.js
function callback (line 4) | function callback(err, files) {
function callback1 (line 17) | function callback1(err) {
function scanAndWriteFiles_async (line 25) | function scanAndWriteFiles_async(callback){
FILE: homework/lesson6/mindongquan.js
function dirPathTest (line 19) | function dirPathTest(dirPathString) {
function collectJsonFilesNameToTxt (line 32) | function collectJsonFilesNameToTxt(dirPathString) {
function workFlow (line 53) | function workFlow() {
FILE: homework/lesson6/ouyangchun.js
function callback (line 14) | function callback(err,files){
function writecallback (line 28) | function writecallback(err){
FILE: homework/lesson6/panyong.js
function scan_write_files_sync (line 4) | function scan_write_files_sync(dirPathString,outputPathString)
function write_callback (line 29) | function write_callback(err) {
function read_callback (line 38) | function read_callback(err,files){
FILE: homework/lesson6/qiujingyu.js
function callback (line 19) | function callback(err, files) {
function callback2 (line 34) | function callback2(err) {
FILE: homework/lesson6/shaozhen.js
function read_callback (line 29) | function read_callback(err, files) {
function write_callback (line 46) | function write_callback(err) {
FILE: homework/lesson6/tangjianfeng.js
function callback (line 8) | function callback(err, files) {
function callbackwrite (line 19) | function callbackwrite(err) {
FILE: homework/lesson6/taobao.js
function writeFile (line 17) | function writeFile() {
function scanFile (line 30) | function scanFile() {
FILE: homework/lesson6/tuyilang.js
function readCallback (line 22) | function readCallback(err, files) {
function writeCallback (line 35) | function writeCallback(err) {
FILE: homework/lesson6/wangchangqing.js
function callback (line 19) | function callback(err, files) {
function callback (line 34) | function callback(err) {
FILE: homework/lesson6/wangganzy.js
function weixin (line 5) | function weixin(err){
FILE: homework/lesson6/wangshasha.js
function callback (line 6) | function callback(err, files) {
FILE: homework/lesson6/wangyunfei.js
function readcallback (line 41) | function readcallback(err,files){
function writecallback (line 52) | function writecallback(err){
FILE: homework/lesson6/wengguihua.js
function readCallback (line 17) | function readCallback(err,files){
function writeCallback (line 33) | function writeCallback(err) {
FILE: homework/lesson6/wenliuxin.js
function callback (line 5) | function callback(err, files) {
function callback_writing (line 28) | function callback_writing(err) {
FILE: homework/lesson6/wenyunxin.js
function callback (line 6) | function callback(err, files) {
FILE: homework/lesson6/wufan.js
function readCallback (line 38) | function readCallback(err, files) {//读取的回调函数，按照API文档的语法规则去写
function writeCallback (line 54) | function writeCallback(err) {//写入的回调函数
function read (line 75) | function read(err, files) {//定义读取文件的函数read
function write (line 88) | function write(err) {//定义写入文件的函数write
FILE: homework/lesson6/wukuipin.js
function callbackRead (line 7) | function callbackRead(err, files) {
function callbackWrite (line 23) | function callbackWrite(err) {
function fileContent (line 31) | function fileContent(fileContent) {
FILE: homework/lesson6/xianengqi.js
function name_callback (line 20) | function name_callback(err, files) {
function nameCallback (line 36) | function nameCallback(err) {
FILE: homework/lesson6/yangtieming.js
function read (line 32) | function read(err,files){
function write (line 50) | function write(err){
FILE: homework/lesson6/yangxuewu.js
function callback_read (line 13) | function callback_read(err, files) {
function fileArray (line 24) | function fileArray(files) {
function callback_write (line 32) | function callback_write(err) {
FILE: homework/lesson6/yanqingmu.js
function write (line 5) | function write(err){
FILE: homework/lesson6/yimiao.js
function callback (line 17) | function callback(err, files) {
function callback (line 35) | function callback(err) {
FILE: homework/lesson6/youshilei.js
function read_callback (line 30) | function read_callback(err, files) {
function wirte_callback2 (line 44) | function wirte_callback2(err) {
FILE: homework/lesson6/zhanggaoyang.js
function callback (line 20) | function callback(err, files) {
function callback2 (line 39) | function callback2(err) {
FILE: homework/lesson6/zhanglina.js
function callback (line 20) | function callback(err, files) {
function callback (line 39) | function callback(err) {
FILE: homework/lesson6/zhaoxiaoxin.js
function callback1 (line 4) | function callback1(err,files){
function callback (line 20) | function callback(err) {
FILE: homework/lesson6/zhaoyinan.js
function readCallback (line 7) | function readCallback(err, files) {
function writeCallback (line 23) | function writeCallback(err) {
FILE: homework/lesson6/zhengchao.js
function readOutcome (line 11) | function readOutcome(err, files) {
function writeOutcome (line 25) | function writeOutcome(err) {
FILE: homework/lesson6/zhuting.js
function callback1 (line 10) | function callback1(err, files) {
function callback (line 29) | function callback(err) {
FILE: homework/lesson6/谢玉辉六课作业.js
function c (line 35) | function c(err, files) {
function callback (line 49) | function callback(err) {
FILE: homework/lesson7/zhengchao.js
function readOutcome (line 8) | function readOutcome(err, files) {
FILE: public/libs/bootstrap-3.3.7-dist/js/bootstrap.js
function transitionEnd (line 34) | function transitionEnd() {
function removeElement (line 126) | function removeElement() {
function Plugin (line 142) | function Plugin(option) {
function Plugin (line 251) | function Plugin(option) {
function Plugin (line 475) | function Plugin(option) {
function getTargetFromTrigger (line 695) | function getTargetFromTrigger($trigger) {
function Plugin (line 707) | function Plugin(option) {
function getParent (line 774) | function getParent($this) {
function clearMenus (line 787) | function clearMenus(e) {
function Plugin (line 880) | function Plugin(option) {
function Plugin (line 1208) | function Plugin(option, _relatedTarget) {
function complete (line 1574) | function complete() {
function Plugin (line 1750) | function Plugin(option) {
function Plugin (line 1859) | function Plugin(option) {
function ScrollSpy (line 1902) | function ScrollSpy(element, options) {
function Plugin (line 2022) | function Plugin(option) {
function next (line 2131) | function next() {
function Plugin (line 2177) | function Plugin(option) {
function Plugin (line 2334) | function Plugin(option) {
FILE: script/checkHomework.js
function start (line 18) | function start() {
function readFolders (line 35) | function readFolders() {
function filterFolders (line 54) | function filterFolders(files) {
function getNames (line 68) | function getNames(folders) {
function readNames (line 79) | function readNames(folder) {
function filterNames (line 105) | function filterNames(folder, names) {
function countNames (line 127) | function countNames(names) {
function sortNames (line 135) | function sortNames() {
function writeNames (line 157) | function writeNames(result) {
FILE: script/clean.js
function clean (line 3) | function clean() {
FILE: script/fs.js
function done (line 21) | function done(err) {
FILE: script/run.js
function format (line 1) | function format(time) {
function run (line 5) | function run(fn, options) {
FILE: script/scan.js
function scan (line 3) | async function scan(path) {
FILE: script/start.js
function lesson (line 16) | async function lesson(type) {
function start (line 36) | async function start() {
FILE: script/updateTeam.js
function start (line 9) | async function start() {
FILE: study/lesson4/kitchen_workflow.js
function buyFoods (line 2) | function buyFoods() {
function prepare (line 9) | function prepare() {
function cooking (line 16) | function cooking(foodsList) {
function startWork (line 25) | function startWork() {
FILE: study/lesson4/sound_off.js
function soldierA (line 8) | function soldierA() {
function soldierB (line 12) | function soldierB() {
function soldierC (line 16) | function soldierC() {
function soldierD (line 20) | function soldierD() {
function soldierE (line 24) | function soldierE() {
function startSoundOff (line 30) | function startSoundOff() {
FILE: study/lesson4/sound_off_2.js
function soldierA (line 9) | function soldierA() {
function soldierB (line 14) | function soldierB() {
function soldierC (line 19) | function soldierC() {
function soldierD (line 24) | function soldierD() {
function soldierE (line 29) | function soldierE() {
function startSoundOff (line 34) | function startSoundOff() {
FILE: study/lesson4/sound_off_3.js
function startSoundOff (line 44) | function startSoundOff() {
FILE: study/lesson5/async_function.js
function callback (line 4) | function callback() {
FILE: study/lesson5/flight_schedule_1.js
function checkFlightSchedule (line 1) | function checkFlightSchedule() {
FILE: study/lesson5/flight_schedule_2.js
function checkFlightSchedule (line 7) | function checkFlightSchedule(callback) {
function callback (line 22) | function callback(startTime) {
FILE: study/lesson5/flight_schedule_3.js
function checkFlightSchedule (line 1) | function checkFlightSchedule(callback) {
function callback (line 18) | function callback(startTime) {
FILE: study/lesson5/indirect.js
function callback (line 2) | function callback() {
function run (line 7) | function run(2b) {
FILE: study/lesson5/indirect_call.js
function callback (line 2) | function callback() {
function run (line 7) | function run(cb) {
FILE: study/lesson5/kitchen_workflow_async.js
function buyFoods (line 2) | function buyFoods(callback) {
function prepare (line 14) | function prepare() {
function cooking (line 20) | function cooking(foodsList, callback) {
function startWork (line 36) | function startWork() {
FILE: study/lesson6/scan_files_async.js
function callback (line 17) | function callback(err, files) {
FILE: study/lesson6/write_file_async.js
function callback (line 20) | function callback(err) {
FILE: study/lesson7/sound_off.js
function soldierA (line 1) | function soldierA(number, allCount) {
function soldierB (line 11) | function soldierB(number, allCount) {
function soldierC (line 20) | function soldierC(number, allCount) {
function soldierD (line 29) | function soldierD(number, allCount) {
function soldierE (line 38) | function soldierE(number, allCount) {
function startSoundOff (line 48) | function startSoundOff() {
FILE: webapp/src/public/libs/bootstrap-3.3.7-dist/js/bootstrap.js
function transitionEnd (line 34) | function transitionEnd() {
function removeElement (line 126) | function removeElement() {
function Plugin (line 142) | function Plugin(option) {
function Plugin (line 251) | function Plugin(option) {
function Plugin (line 475) | function Plugin(option) {
function getTargetFromTrigger (line 695) | function getTargetFromTrigger($trigger) {
function Plugin (line 707) | function Plugin(option) {
function getParent (line 774) | function getParent($this) {
function clearMenus (line 787) | function clearMenus(e) {
function Plugin (line 880) | function Plugin(option) {
function Plugin (line 1208) | function Plugin(option, _relatedTarget) {
function complete (line 1574) | function complete() {
function Plugin (line 1750) | function Plugin(option) {
function Plugin (line 1859) | function Plugin(option) {
function ScrollSpy (line 1902) | function ScrollSpy(element, options) {
function Plugin (line 2022) | function Plugin(option) {
function next (line 2131) | function next() {
function Plugin (line 2177) | function Plugin(option) {
function Plugin (line 2334) | function Plugin(option) {
FILE: webapp/src/request.js
function get (line 3) | async function get({ url, query }) {
function post (line 22) | async function post({ url, body }) {
function put (line 42) | async function put({ url, body }) {
Condensed preview — 684 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,008K chars).
[
{
"path": ".gitignore",
"chars": 122,
"preview": "# Ignore Mac OS desktop services store\n.DS_Store\npackage-lock.json\nnode_modules\ndist\n.vscode\nscript/result\nscript/teams."
},
{
"path": "README.md",
"chars": 165,
"preview": "## 美好的回忆\n\n该项目记录了一群小白学习js的过程，现封存该项目供所有人回忆。\n\n感谢大家的努力\n\n请[点这里](https://js.7xinsheng.com/)访问我们的家！\n\n![](https://ws4.sinaimg.cn"
},
{
"path": "_config.yml",
"chars": 26,
"preview": "theme: jekyll-theme-hacker"
},
{
"path": "homework/lesson1/Autumn.md",
"chars": 955,
"preview": "第一节课老师运用银行开户的类比帮助我们理解JS（或者说是理解编程）。\n###### 1.银行（内部服务➕核心服务）—> 运行环境（内置库➕V8引擎） ; 客户—> 代码 \n开户的环境是银行，在这个环境中客户可以得到内部服务以及核心服务，通"
},
{
"path": "homework/lesson1/ElizabethZhouli.md",
"chars": 467,
"preview": "**#** **learning-javascript lesson 1** \n\n**1. 类比代码执行流程**\n\n方式：用“银行为用户开户这一”具象业务架构“一对一抽象成“JS运行环境框架“，框架包含：JS运行环境［浏览器运行环境（v8引"
},
{
"path": "homework/lesson1/GaoXianfeng.md",
"chars": 753,
"preview": "## JavaScript 第一课总结\n\n### 现实生活场景举例类比 JS 代码执行流程及相关概念\n客户去银行办理业务，在正式办理业务前填写相关资料，随后将填写好的资料提交给银行办理业务工作人员，工作人员对已填写好的材料进行审核，然后将办"
},
{
"path": "homework/lesson1/Huang_Biling.md",
"chars": 978,
"preview": "## 作业_JavaScript编程入门_第一节\n\n1. \t类比代码执行流程\n\n\t代码，是人的需要转化成的、对智能机械的命令。执行命令需要资料和数据。得到资料数据后，还要先将它们审核通过后再送去执行，为的是不让错误卡住执行流程，导致混乱。\n"
},
{
"path": "homework/lesson1/Jaykey.md",
"chars": 725,
"preview": "### 基础-第一课\n\n###### JS运行环境：\n\n1. 浏览器\n2. Nodejs\n\n都含有V8引擎（对代码进行预处理）和内置服务（不同环境有不同）。\n\n核心是**“内置库”**，如何调用会输出什么结果。\n\n###### Javasc"
},
{
"path": "homework/lesson1/Learner-Chen.md",
"chars": 502,
"preview": "Javascript第一次课程总结\n\n第一次上课，主要是对于编程感兴趣。现在社会的互联网、人工智能持续火爆，也是大势所趋。所以一只很感兴趣。看到新生大学改版后开课，就第一时间报了名去学习。\n\n徐老师讲解JS时，通过对生活中常见的银行开户流程"
},
{
"path": "homework/lesson1/LiaoYuemin.md",
"chars": 1360,
"preview": "## Story of Lesson 1 \n\n我有一个做运营的朋友，她一直觉得编程很重要，但是却没有多少兴趣去学。其实我也是。但是作为一个软件行业的测试者，还是觉得应该学一些编程的东西。\n\n第一节课后跟她分享上课的感受，我跟她说第一节课的"
},
{
"path": "homework/lesson1/Liuzhengchun.md",
"chars": 1001,
"preview": "##第一次作业\n\n距离第一节课过去好几天了，终于抽出时间来写作业了，作业的主题就是理解徐老师在课上讲的那几个概念，用自己的话把它说出来。\n\n这么久才交作业甚是惭愧，第一节课的内容也有些模糊了，不过我会迎头赶上的，这里先给自己鼓励一下，也谢"
},
{
"path": "homework/lesson1/Rachel.md",
"chars": 678,
"preview": "### 一个总结\n\n如果用一句话来总结第一节学的内容，我想是用**银行开户流程**这个类比，非常清楚地阐述整个**业务架构的模式**，以及其中的**重要概念**。\n\n我非常喜欢最后的总结：\n\n“开户环境提供集**预处理、执行**于一体的核心"
},
{
"path": "homework/lesson1/Risexie.md",
"chars": 1301,
"preview": "第一节课总结\n===========\n\n * ### 类比代码执行流\n\n老师使用了一个在银行创建户口的例子，为我们说明了在js当中代码的执行流程，帮助我们理解“在终端输入代码”，到“终端返回我们结果”这样一个过程，是如何实现的。\n我们在终端"
},
{
"path": "homework/lesson1/SunBo.md",
"chars": 1071,
"preview": "第一次作业 \n# 类比代码执行流程\n\n自己是第一次接触真正的编程，徐老师课上的类比的方式不仅印象深刻，而且感觉是从底层上告诉了自己，JS或者说一种编程语言到底是怎样的一种存在。自己以前看过一些平面设计软件的教程，html,css一些最基础的"
},
{
"path": "homework/lesson1/WangChangQing.md",
"chars": 1323,
"preview": "# 第一节课总结 form 王长庆\n因为之前一直在忙别的事情，所以直到这两天才开始疯狂赶进度。好在课程开始之前有做过徐高阳老师布置的准备作业，所以只需要重温一下，便可以上手了。\n\n看完了第一节课的视频回放，感觉似乎并不是特别难理解。我把我的"
},
{
"path": "homework/lesson1/Wei.md",
"chars": 979,
"preview": "# 小白学JS 第一课总结 20170811\n\n### 1.银行开户类比JS代码执行流程\n\n银行开户流程\n* 填写申请单\n* 审核\n* 发卡\n\n具体开户业务\n\n1.开户环境：提供一组服务，该服务包含接受申请、检验申请单信息和核对资格。提供内"
},
{
"path": "homework/lesson1/WuGaoxing.md",
"chars": 265,
"preview": "运用下面这些关键词，把你知道的写出来\n1. 类比代码执行流程：医生诊治病人的过程，学生上学的顺序，社会运行的次序\n2. 运行环境：由不同事物组成的特定套路，环境不同 套路不同\n3. V8引擎： 一个隐藏很深 较底层的平台 提供机器与代码的交"
},
{
"path": "homework/lesson1/XGunn-lesson01.md",
"chars": 297,
"preview": "\\# 第一课总结\n\n\\## 1.类比代码执行流程\n\n以银行受理客户业务流程类别代码执行流程。\n\n\\## 2.运行环境\n\nJS运行环境包括浏览器运行环境和Nodejs运行环境，运行环境是用来处理和执行代码并输出结果。\n\n\\## 3.V8引擎\n"
},
{
"path": "homework/lesson1/ZhengChao.md",
"chars": 372,
"preview": "## JavaScript Lesson1 学习心得\n\n#### JS两大构成部分\n\n##### JS代码\n\n1. ###### 两个概念：编译型语言（比如C,C++）和解释性语言（JS）\n\n2. ###### JS代码属于解释性语言\n\n3"
},
{
"path": "homework/lesson1/anjiancai.md",
"chars": 1082,
"preview": "# 第一次学习Javascript总结\n\n\n标签（空格分隔）： 未分类\n\n---\n\n#类比银行开户流程环境讲解程序运行环境\n通过不断优化银行开户的步骤，最终完成一套设计完美的流程。\n![优化后的开户流程][1]\n\n\n 整个流程设计两"
},
{
"path": "homework/lesson1/baoguoqiang.md",
"chars": 512,
"preview": "#类比代码执行流程\n首先引入生活中在银行开户的这么一个流程，讲解了在开户过程中所需求的种种，我们把这些种种叫做开户环境；一步一步进行优化处理，最后达到满意的效果；\n从这个生活中的例子引导到javascript的运行环境；\n#运行环境\njav"
},
{
"path": "homework/lesson1/caijinpeng.md",
"chars": 653,
"preview": "## 第一次作业\n### 提交人：Marshalcy\n\n#### 代码执行环境\n我用过调用各种库（内置库和第三方库）写好我的代码后，打包成工程代码，发给解释器；这个过程好比是我去银行开户，通过大堂经理等人的帮助后，将我的个人信息完整准确的填"
},
{
"path": "homework/lesson1/caozhen.md",
"chars": 1390,
"preview": "# 第一次作业\n\n### 代码执行流程的类比\n\n#### 描述\n\n老师课上通过零基础的**类比方法**，让我们理解了代码执行是怎么回事；\n\n在银行开户案例中；谈到了几个弊端和改进：\n\n- 银行开户的**核心业务动作**是：先审核材料，再执行"
},
{
"path": "homework/lesson1/chaigaoping.md",
"chars": 399,
"preview": "\n1.类比代码执行流程\n 代码传入到编译器和解释器之后，经过编译/解释处理，然后输出结果。\n\n2.运行环境\n运行环境就是能够使代码条用内置服务的一个环境，里面包含了两个运行环境：浏览器运行环境和nodejs运行环境。两者都有V8引擎，它可"
},
{
"path": "homework/lesson1/chengjun.md",
"chars": 942,
"preview": "\n###【程君的课后总结】-**javascript**\n\n\n1.类比代码执行流程\n\n 银行的开户流程\n\n 请求——输入——输出\n\n 请求：内置服务\n\n 输入：预处理\n\n 输出：执行\n\n 可以把预处理与执行合起来，"
},
{
"path": "homework/lesson1/chenlingmin.md",
"chars": 1681,
"preview": "# 【Javascript第一次作业】总结——陈玲敏\n\n\n\n## 类比代码执行流程\n\n| JavaScript | 解释 | 银行 | 解释 "
},
{
"path": "homework/lesson1/chenqiong.md",
"chars": 885,
"preview": "# JavaScript 入门课第一课总结\n\n## 用现实生活中的例子来类比代码执行流程\n老师用银行开户的流程类比代码执行的流程，并通过几个版本的演进来类比业务的持续迭代。这些迭代可以说都是在之前版本的执行过程中，观察总结，进而演进而来，一"
},
{
"path": "homework/lesson1/chenrushan.md",
"chars": 982,
"preview": "# Hello, JavaScript 总结\n\n从设计一个银行开户流程，一次次升级，然后抽象出\b业务架构，类比到JavaScript运行环境架构，清晰易懂。\n\n我们写代码让计算机满足我们的需求，就如我们提交申请，让银行帮我们开户，这个过程需"
},
{
"path": "homework/lesson1/chenyanxing.md",
"chars": 849,
"preview": "##【第一次作业】\n————————————————————————————————————————\n#####--*author：陈燕杏*\n#####--*version：V1*\n#####--*create_time：2017-08-1"
},
{
"path": "homework/lesson1/chenzidong.md",
"chars": 464,
"preview": "第一课 git到的JS知识\n\n# 初步了解，整体印象。\n 通过银行开户的类比，把JS运行的流程，一些大家都熟悉的概念，送到大家的认知里。印象最深的是开户窗口，预处理，和执行，对应JS里的 网页窗口，编译器，和执行器。还有流程可以不断优化，以"
},
{
"path": "homework/lesson1/chenziwen.md",
"chars": 1547,
"preview": "1. 类比代码执行流程\n + 就是把现实的事件流程抽象出来，用最精简的方式来描述一个事件的执行流程，方便思考，方便转化为代码。\n2. 运行环境\n + 运行+环境\n + 运行：就是执行代码并期望得到想要的结果。\n + "
},
{
"path": "homework/lesson1/cloudyview.md",
"chars": 919,
"preview": "听徐老师的课，感觉从类比入手，体会比自己看书要好多了，理解深入了。\n\n## 1.类比代码执行流程\n代码的执行方式有两种，即解释型语言和编译型语言的的执行方式。\n### 解释型语言的代码执行流程\n简单说就是一条一条的执行，看到一句代码，解释一"
},
{
"path": "homework/lesson1/cuimeng.md",
"chars": 868,
"preview": "# 第一次JavaScript课堂总结\n\n\n\n> 由于自己在大学期间有过相关的编程语言的学习经历，后来的工作需要也写过一些小程序，本堂课的内容对我来讲理解起来还算相对容易。然而收获依然很大，对编程语言的运行机制有了比较系统的认知。\n\n\n\n#"
},
{
"path": "homework/lesson1/cuimiao.md",
"chars": 424,
"preview": "#小小白崔淼的学习之路——lesson 1 \n\n1. 类比代码执行流程\n按照老师的类比，就好像是去银行办卡，先要填写表单（输入代码），然后提交审核（编译器编译），办理业务（执行器执行代码），最终拿卡（反馈结果）。此外，银行还提供了内部服务（"
},
{
"path": "homework/lesson1/dangfeipeng.md",
"chars": 605,
"preview": "### 用类比的方式推导 JS 框架\n\n徐老师用“银行开户流程”的四次改进，由浅入深、层层递进地推导出 JS 框架，通过类比让我们借助熟悉的“银行开会流程”在很短的时间内对陌生的 JS 框架产生了感性认识，了解了主要的组成部分以及各部分之间"
},
{
"path": "homework/lesson1/dengxy0907.md",
"chars": 269,
"preview": "第一次课作业\n===========\n### 类比代码执行流程\n> 老师通过银行开户流程类比了代码，代码就是一个个功能的体现，一个个具体的功能通过翻译让计算机执行，达到获取结果的目的\n### 运行环境\n>运行环境是能够执行代码的环境\n###"
},
{
"path": "homework/lesson1/diaozhicong.md",
"chars": 1104,
"preview": "#【第一次作业】写一篇总结\n\n\n##1. 类比代码执行流程\n用银行开户流程的优化类比让我们理解整个代码执行流程，比较形象，也让我们小白更好的理解。另外一点我的感受是，流程图是一个很好的理解工具，未来需要好好打磨。\n\n##2. 运行环境\n运行"
},
{
"path": "homework/lesson1/donglili.md",
"chars": 369,
"preview": "## 第一次作业\n\n执行代码就好像去银行办开户业务。本质上就是输入信息、获得结果。\b\n\n而运行环境相当于银行，就是我们要“办事”的地方，也可以理解我们要执行代码的地方。我们的代码是针对运行环境而写的，只有在运行环境下才能够正确执行。\n\nV8"
},
{
"path": "homework/lesson1/duhongxia.md",
"chars": 650,
"preview": "杜红霞第一课总结\n\n1. 类比代码执行流程\n\n 用去银行开户这一具体流程类比JS运行环境框架，框架包含：\n \n JS运行环境［浏览器运行环境（v8引擎＋内置环境）＋Nodejs运行环境（v8引擎＋内置环境）］——\n 第三方"
},
{
"path": "homework/lesson1/fangqingyang.md",
"chars": 995,
"preview": "### JS第一课总结：\n\n#### 1运行环境（Nodejs和浏览器）\n\n我们写了一份代码，放到运行环境里面，运行环境为我们提供所需要的各种服务如用V8引擎来执行代码，提供内置库来满足我们的需求等。需要注意的是：JavaScript有两种"
},
{
"path": "homework/lesson1/fanliao.md",
"chars": 392,
"preview": "新生大学第一次JS课作业\n\n1. 类比代码执行流程\n老师以一般的银行开户流程作为例子，类比了我们从代码的输入到编译执行到输出结果，使一个抽象的过程具体的展现在我们眼前。\n\n2. 运行环境\nJS运行环境分为浏览器环境和Node环境，不同的环境"
},
{
"path": "homework/lesson1/fanqing.md",
"chars": 2168,
"preview": "# 第一课作业\n\n经过好几天逐渐加码的预热练习，JS同学的学习热情都已被调动起来，17年8月8日，我们的第一次正式课开课。\n\n第一课是Javascript的概况讲解课，并同时老师很有心的与初学者进行了学习方法的探讨，对如何利用这门课、该如何"
},
{
"path": "homework/lesson1/feixiguang.md",
"chars": 1806,
"preview": "# 第一课总结\n\n### 1.类比代码执行流程\n使用银行开户方式\n* 1.填写申请单\n* 2.去柜台开户\n* 3.发卡\n\n***\n\n类比一套业务架构：\n* 开户环境：提供一组服务，该服务包含接受申请、检验申请单信息和核对资格。\n（开户环境提"
},
{
"path": "homework/lesson1/fengkai.md",
"chars": 289,
"preview": "\n1.类比代码执行流程\n\nJS运行环境框架类比于银行体系的业务构架；\n浏览器运行环境相当于普通用户的开户环境；\nNodejs运行环境相当于VIP用户的开发环境；\nV8引擎相当于银行的业务核心；\n内置库=内置服务；\n第三方库相当于第三方服务；"
},
{
"path": "homework/lesson1/hanmeng.md",
"chars": 777,
"preview": "Javascript第一课总结\n\n1. 类比代码执行流程\n首先，老师运用“银行开户流程”类比了代码执行流程\n银行这大环境类比JavaScript，在银行的大环境中有普通用户环境和VIP用户开户环境，分别对应了JavaScript环境中的浏览"
},
{
"path": "homework/lesson1/hanwei.md",
"chars": 966,
"preview": "## 第一次作业\n\n执行代码就好像去银行办开户业务。本质上就是输入信息、获得结果。\b\n\n而运行环境相当于银行，就是我们要“办事”的地方，也可以理解我们要执行代码的地方。我们的代码是针对运行环境而写的，只有在运行环境下才能够正确执行。\n\n我们"
},
{
"path": "homework/lesson1/haohu.md",
"chars": 549,
"preview": "###1. 类比代码执行流程\r\n\r\n代码 + 库(内置库&第三方库) -> 运行环境(浏览器 or NodeJS) -> 执行结果\r\n种子 + 养分(水&阳光空气) -> 土壤 -> 大树\r\n\r\n###2. 运行环境\r\n\r\n可能不准，但能帮"
},
{
"path": "homework/lesson1/hewei.md",
"chars": 1466,
"preview": "# 第一次作业 - 讲座总结\n\n## 流程优化，事半功倍\n\n徐老师一开始先用`设计银行开户流程`的方式，来**类比代码执行流程**。\n\n笑来老师就说过，一个得体的比喻，可以让人很好地理解一个之前并不了解的概念。\n\n徐老师通过不断地优化银行"
},
{
"path": "homework/lesson1/huangjiashu.md",
"chars": 1564,
"preview": "## 写一篇总结\n听完课，感受还是颇深的，老师讲的还不错，我觉得最好的就是接待代码如何运作的那个图，就是在ppt中多次提到的那张图。下面试根据老师的提示写的总结\n\n\n\n### 类比代码执行流程\n老师"
},
{
"path": "homework/lesson1/huangqi.md",
"chars": 584,
"preview": "## 总结 ##\n\n**2017年8月8日**我跟随老师学习了JavaScript的第一节课，认识了几个概念：“JavaScript的运行环境、V8引擎、编译器、执行器、内置库、第三方库” ，还有一个类比代码执行流程，也打开了我从JavaS"
},
{
"path": "homework/lesson1/huangxiaohui.md",
"chars": 358,
"preview": "\njavascript第一节课总结\n\n\n1.1.类比代码执行流程\n\n以银行开户流程为例，将优化后银行开户流程——分为普通用户和VIN用户两大业务模块，类比JS的浏览器和NodeJS这两种运行环境下，代码调用内\n置库进行进行编写完成后输入到"
},
{
"path": "homework/lesson1/huangzhihua.md",
"chars": 1149,
"preview": "\n\n\n\n\n\n\n\n # JavaScript 第一课作业 总结——黄志华\n\n运用下面这些关键词，把你知道的写出来。\n\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. "
},
{
"path": "homework/lesson1/huxiaodan.md",
"chars": 523,
"preview": "## 1.类比代码执行流程\n类比银行开户流程。用户向银行开户环境提交申请，银行通过内置服务、预处理和执行后，将结果反馈给用户。\n## 2. 运行环境\n运行环境提供集预处理、执行于一体的核心业务处理单元，同时还提供内置服务方面用户的业务办理"
},
{
"path": "homework/lesson1/huyong.md",
"chars": 522,
"preview": "编程第一课总结\n#内容分为三个部分\n##第一部分是对与之前预习作业的回顾，点出了大家在写代码的时候常犯的一些错误，比如写代码的时候，\n需要用全英文的书写格式，尤其是像引号顿号等的使用\n##第二部分是代码学习的引导和未来的路如何走，开头给了我"
},
{
"path": "homework/lesson1/ianyang.md",
"chars": 613,
"preview": "【第一次作业】写一篇总结\n\n1. 类比代码执行流程\n老师以银行开户流程为类比，也可套用其他服务型行业的标准流程，比如物流、零售。这个类比让我认识到，从输入代码到编译执行到输出结果，不仅是商业社会的具体运作方式，也可类比人与人的沟通模式，难"
},
{
"path": "homework/lesson1/jaychen.md",
"chars": 762,
"preview": "# HW1 Lesson1总结\n\n## 1. 类比代码执行流程\n\n\t老师用银行户流程的类比让我瞬间明白了代码执行流程，开场非常精彩！我们输入代码后，调用了内置服务和第三方库对代码进行处理，再把结果喂给核心业务，核心业务类似于黑盒对代码进行预"
},
{
"path": "homework/lesson1/jianglin.md",
"chars": 502,
"preview": "1. 类比代码执行流程：代码执行流程就像银行开户，要先确认信息准确（编译）再进行开户操作（执行），对于JavaScript，是边编译边执行，易开发难执行；对于C/C++，是先编译后执行，难开发易执行。\n2. 运行环境：运行环境是代码的环境，"
},
{
"path": "homework/lesson1/langjianjun.md",
"chars": 752,
"preview": "第一节课总结\n \n 1. 类比代码执行流程\n 用人去饭店吃饭做类比：饭店类似于软件的运行环境，客人从菜谱上点菜相当于输入某些指令，自动化的点菜系统类似于V8引擎，而厨师则是编译器/解释器，根据菜单做菜相当于执行一系列的程序包，这些程序"
},
{
"path": "homework/lesson1/leizhen.md",
"chars": 650,
"preview": "\n\n用银行开户流程类比代码执行过程，通过细分项目和需求，一步一步优化流程，来完成一个完整的框架结构。\n\n我用炒菜的过程来说明我对几个概念的理解（我想了很久，但还是不够贴切）\n\n厨房是一个大的集合：【锅， 燃气灶， 调味料， 食材， 道具， "
},
{
"path": "homework/lesson1/lichen.md",
"chars": 2784,
"preview": "# 总结\n\n### 一、引言\n\n#### 1、运用类比：设计一个银行开户流程\n\n\n\n#### 2、流"
},
{
"path": "homework/lesson1/linchunlong.md",
"chars": 909,
"preview": "运用下面这些关键词，把知道的写出来：\n<p>1. 类比代码执行流程\n<p>2. 运行环境\n<p>3. V8引擎\n<p>4. 编译器/解释（执行）器\n<p>5. 内置库\n<p>6. 第三方库\n<p>7. 学习JS的方向\n**<p>我的总结是："
},
{
"path": "homework/lesson1/lingxiao.md",
"chars": 3265,
"preview": "\n\n# JavaScript第一次作业\n## 前言\n2017年8月8日徐高阳老师《JavaScript编程入门》第一次作业。\n\n[TOC]\n\n## 作业\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 "
},
{
"path": "homework/lesson1/linxiyao.md",
"chars": 439,
"preview": "\n8月8日第一节课，听完感觉秒懂，到做作业写总结却有点傻眼，看来感觉靠不住，于是听了一遍回放，试试用自己有限的理解来描述。\n\n代码执行流程类似于写说明文的过程：代码就像各种特定素材，先输入到大脑，经过大脑这个黑盒进行梳理、阐释（编译、解析）"
},
{
"path": "homework/lesson1/lipeng.md",
"chars": 830,
"preview": "#### 【第一次作业】写一篇总结\n\n1 \n\n**类比代码执行流程**\n\n用户在银行开户的过程，就是代码的执行过程。\n\n这个类比引出了JS运行环境框架，无论是浏览器的环境，还是NodeJS的环境，都包括 业务核心和内置服务。\n\n写JS代码就"
},
{
"path": "homework/lesson1/lipengyu.md",
"chars": 484,
"preview": "## 第一次上课总结\n\n本次课程以银行开户流程为例子，由银行的业务架构引出JS的**运行环境**框架，生动易于理解。\n### JS运行环境\n1. 浏览器运行环境\n * V8引擎\n * 内置库\n2. Nodejs运行环境\n * V8引擎"
},
{
"path": "homework/lesson1/litao.md",
"chars": 749,
"preview": "第一次课听下来，由于老师用生活中常见的事物进行类比，讲的通俗易懂，使得这些抽象的概念比较容易理解。尽管如此，还是又听了一次回放，才感觉不那么晦涩了。\n\n反而是课前的预习作业，对git工具和GitHub社区的陌生，让我反反复复地阅读老师的操"
},
{
"path": "homework/lesson1/liujuanjuan1984.md",
"chars": 1497,
"preview": "## 听新生大学CTO讲JavaScript编程入门-1\n\nby 刘娟娟 2017-08-17\n\n第一课，是切换认识世界的视角，从现实世界切换到编程世界。\n\n用**类比**的方式，来学习新知识，新知识显得那么亲切。_不愧是李笑来老师的新生大"
},
{
"path": "homework/lesson1/liujun-sh.md",
"chars": 607,
"preview": "# 第一课总结\n\n## 1.类比代码执行流程\n代码的执行流程就好比我们去银行办理银行卡，首先你需要填写表格（编写代码），当你在填写表格的时候发现需要打印身份证（打印机就好比内置库，你调用了打印机可以打印图片的功能），如果你还需要办理贷款业务"
},
{
"path": "homework/lesson1/liujun.md",
"chars": 489,
"preview": "\nJavaScript第一课课后总结\n\n1.类比代码执行流程\n用银行开户的的流程类比代码执行的流程。用户类比代码，银行类比运行环境，开户流程中的审查、执行类比代码执行中的内置库和V8引擎。\n再通过定义板块，环境、内置服务、业务核心、第三方"
},
{
"path": "homework/lesson1/liuliyuan.md",
"chars": 1017,
"preview": "# 第一节 JavaScript编程入门 课程总结\n###一、关键词\n\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. 学习JS的方向\n\n###二、课程总结\n\n以在"
},
{
"path": "homework/lesson1/liuqing.md",
"chars": 1566,
"preview": "# 第一次课程总结\n在完成徐老师布置的课前预习作业时，还一脸懵圈，只知道生搬硬套过来，虽然还是完成了，也有了学习编程的信心，但是对开始的编程课还是有些忐忑，生怕自己听不懂。\n没想到小白的编程之旅——第一堂课会是以“银行开会流程”来切入的，跟"
},
{
"path": "homework/lesson1/liuruyong.md",
"chars": 467,
"preview": "#1. 类比代码执行流程\n高级语言写的代码 > 编译后的中间代码 > 不同平台的机器码 > 机器指令\n中央文件 > 官僚系统传递 > 各地根据当地情况做解读 > 群众去执行\n#2. 运行环境\n运行时需要的支撑环境，运行依赖的库。\n#3. "
},
{
"path": "homework/lesson1/liushengsi.md",
"chars": 1630,
"preview": "# 小白学JavaScript：JavaScript的怎么玩儿？\n\n#### JavaScript是怎么一回事儿？\n\n###### 1. 银行办理业务类比JavaScript执行代码\n\n回想一下我们在生活中是怎么办理银行业务的：\n- 我去到"
},
{
"path": "homework/lesson1/liushengxin.md",
"chars": 806,
"preview": "# 开始学习javascript第一节课总结\n\n\n## 1. 类比代码执行流程\n代码其实就是把现实中的流程规范化，通过类比、对两者都加深了印象。一是现实生活中你觉得寻常的流程其实都需要严密的逻辑、也可以进一步的升级，可以加快流程的进度。二是"
},
{
"path": "homework/lesson1/liuxiaohaohao.md",
"chars": 931,
"preview": "Title: JavaScript第一次总结作业\nCreated On: 2017-08-11 19:43:28 +0800\n\n其实，来学这门课是想要逼自己一把，觉得自己太久没有从零开始学什么东西了，想要找回一种学生时代的认真感吧！\n\n“"
},
{
"path": "homework/lesson1/lixiang.md",
"chars": 448,
"preview": "\n\n\n<b>运行环境</b>就像是一个人的大脑，负责处理接收到的信息，比如一条新闻，一个故事。\n\n<b>V8引擎</b>是人脑中最智能的核心，至于它具体是怎么工作的，诸如神经元之间的链接之类，我们现阶段不需要掌握。\n\n<b>编译器</b>就"
},
{
"path": "homework/lesson1/lixiaoxin.md",
"chars": 1996,
"preview": "# Javascript 初探\n\n## 【第一次作业】\n运用下面这些关键词，把你知道的写出来。\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. 学习JS的方向\n\n\n"
},
{
"path": "homework/lesson1/liyihang.md",
"chars": 394,
"preview": "#1. 类比代码执行流程\n类比银行开户，加入了计算机的部分概念思想，如预处理，封装，uml图\n输入-》处理-》输出\n\n#2. 运行环境\nJavascript的运行环境有，浏览器和node\nVC的运行环境就是runtime， 包含各种dll等"
},
{
"path": "homework/lesson1/luoruijun.md",
"chars": 414,
"preview": "# 第一课作业\n1. 代码的执行流程：输入代码到运行环境，调用运行环境中内置库的服务，或调用第三方库的服务，送入运行环境中的v8引擎进行预处理和执行。\n2. 运行环境是代码执行的环境，提供内置库的服务和v8引擎对代码的预处理和执行。JS运行"
},
{
"path": "homework/lesson1/maggiewong.md",
"chars": 883,
"preview": "# 作业1——总结第一节课的内容\n\n\n\n1.类比代码执行流程\n\n将代码执行流程和银行开户类比：JavaScript的运行环境分为浏览器运行环境和Nodejs运行环境，针对这两个运行环境有各自的核心V8引擎和内置服务，有一大批第三方库满足Ja"
},
{
"path": "homework/lesson1/panqi.md",
"chars": 590,
"preview": "#第一次课程总结\n\n##代码执行流程：编写代码，解释并执行，输出内容。\n\n##JS运行环境：多样化，浏览器（前端）和Nodejs（后端）两种环境，拥有相同的JS内置对象，不同的内置库和第三方库。\n\n##V8引擎：用于完成预处理和执行等核心任"
},
{
"path": "homework/lesson1/panyong.md",
"chars": 1320,
"preview": "# 【第一次作业】写一篇总结\n\n运用下面这些关键词，把你知道的写出来。\n\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. 学习JS的方向\n\n\n## 总结\n\n现在是8"
},
{
"path": "homework/lesson1/qiujingyu.md",
"chars": 779,
"preview": "#### 第一节课作业：总结\n\n\n\n##### 1. 类比代码执行流程\n\n与银行开户流程进行类比：\n\n+ 用户相当于程序员\n+ 普通用户相当于：开发前端使用js的程序员\n+ VIP用户相当于：开发后端使用js的程序员\n+ 开户申请相当于代码"
},
{
"path": "homework/lesson1/shaozhen.md",
"chars": 667,
"preview": "#JavaScript第一堂课学习总结\n\n###徐老师通过讲解如何优化银行柜台工作流程，抛砖引玉类比出JavaScript代码的执行流程，深入浅出的介绍了JavaScript的总体面貌，令人印象深刻。\n\n###随后老师使用同样方式通过介绍婴"
},
{
"path": "homework/lesson1/shenzhili.md",
"chars": 949,
"preview": "# 第一节课的总结\n\n\n## 1. 类比代码执行流程\n老师课上讲了一个非常棒的类比：银行开户流程与JS代码运行环境。直播开始先讲银行开户流程，先是一头雾水地听了一段，后是恍然大悟。当徐高阳老师\n将银行开户流程和JS运行环境的框架对应的时候，"
},
{
"path": "homework/lesson1/sophieQi.md",
"chars": 804,
"preview": "第一次课程作业\n\n老师在可用用类比的方式，用银行的办卡的服务流程推导出了代码的执行流程，用已知解释未知。\n\n从程序的执行方式上分为编译器和解释（执行）器。\n\n- 编译型是先编译后执行，需要一个专门的编译过程，通过编译器翻译成及其语言，运行效"
},
{
"path": "homework/lesson1/sunxl.md",
"chars": 292,
"preview": "## 小白学JavaScript\n\n\n## 共建小白用的JavaScript技术文档\n\n1. 用去银行开户的流程来类比代码的执行流程\n2. 运行环境有nodejs和chrome浏览器，V8引擎暂时不用理他。\n3. 编译器/解释器 chrom"
},
{
"path": "homework/lesson1/tangjianfeng.md",
"chars": 1108,
"preview": "##1、用开户流程来类比JS运行环境框架\n用银行的开户流程来类比Js运行环境框架，JS代码类似对银行有服务需求的客户，以v8引擎对应业务核心（即预处理和执行），用内置服务对应内置库，用第三方服务对应第三方库。同时了解到运行环境包含浏览器运行"
},
{
"path": "homework/lesson1/taobao.md",
"chars": 649,
"preview": "【第一次作业】写一篇总结\n\n运用下面这些关键词，把你知道的写出来。\n\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. 学习JS的方向\n\n提交方式：\n1. 请向get"
},
{
"path": "homework/lesson1/tuyilang.md",
"chars": 745,
"preview": "### JavaScript编程入门第一节课总结：学习JavaScript的最少必要知识\n\n老师先后通过两个类比向我们展示了学习JavaScript的最少必要知识。\n\n##### 第一个类比\n\n用银行开户流程的优化过程类比出代码的执行流程，"
},
{
"path": "homework/lesson1/wangmeiling.md",
"chars": 449,
"preview": "【第一次作业】写一篇总结\n\n运用下面这些关键词，把你知道的写出来。\n\n1. 类比代码执行流程\n银行开户流程，由客户和桂圆的简单分工，到银行方面有了内置的服务，比如打印身份证；到有了第三方，比如派出所。\n通过银行开户流程的逐步优化到全面介绍代"
},
{
"path": "homework/lesson1/wangshasha.md",
"chars": 560,
"preview": "# lesson1 homework 王沙沙\n\n标签（空格分隔）： javascript\n\n2017.8.13\n\n##对编程的感性认知\n就像去办银行卡，基本服务和增值服务分窗口，每个窗口执行特定功能，但都在银行里面完成的，偶尔特殊功能银行"
},
{
"path": "homework/lesson1/wangwei.md",
"chars": 540,
"preview": "1. 类比代码执行流程\n > 比如去银行开一个户,先要填写申请单,对应的就是编写代码,把申请单交给银行工作人员审核,就是编译器和解释器 编译执行的过程, 然后是银行给出一个结果,或者有错误,重新修改代码,或者是通过,给出一个结果\n2."
},
{
"path": "homework/lesson1/wangxuanding.md",
"chars": 718,
"preview": "第一次作业\n=\n1. 类比代码执行流程\n---\n代码执行流程，就像银行开卡，我们把要求填写的资料都填完（代码），银行职员（程序）检验我们的输入是否正确，正确则往下执行，有错误，则提示有错误，申请退回\n\n\n2. 运行环境\n--\n运行环境就是银"
},
{
"path": "homework/lesson1/wangyuliang.md",
"chars": 659,
"preview": "##【第一次作业】写一篇总结\n\n###1. 类比代码执行流程\n 通过银行开户，输入开户人信息类比代码的输入，通过银行的处理类比编译器/解释器，然后输出结果。而JavaScript通过类比它是非常高效的，输入代码，通过内置库和编译器、执行器"
},
{
"path": "homework/lesson1/wangyunfei.md",
"chars": 2338,
"preview": "## 第一课作业\n\n经过了连续几天的折腾，终于走到了交第一课总结作业的地步，感觉好不容易。下面我以一个小白的理解，来叙述一下第一课的感悟。\n\n\n### 一、运用类比\n\n课程一开始，老师并没有着急直接讲专业的编程知识，而是讲了一个银行开户的例"
},
{
"path": "homework/lesson1/wangzhongbin.md",
"chars": 2456,
"preview": "第一节课的总结.md\n---\n\n周二听老师的课，第一次不是从字面，而是从普通人去银行开户的场景来了解整个js,对js的环境、执行逻辑有新的认知。\n受益匪浅，类比是帮助理解的绝佳方法。\n\n> ps: 这次是根据老师的建议，结合ppt,进行的"
},
{
"path": "homework/lesson1/wenliuxin.md",
"chars": 530,
"preview": "### 1.\t类比代码执行流程：\na)\t银行开户程序有用户，内置服务（打印、照相等），业务办理（核对申请表基本格式、审查申请内容是否符合标准）\nb)\t编程中，用户就是代码，内置服务就是编译器，业务就是执行器。\nc)\t代码执行流程类比银行开户"
},
{
"path": "homework/lesson1/wenyunxin.md",
"chars": 466,
"preview": "## 1、类比代码执行流程\r\n 代码的执行流程就好比人根据一项说明说去完成某件事情，比如制作番茄炒鸡蛋，根据食谱的说明，调用准备的材料，按照某种顺序将材料进行加工，最后完成制作。\r\n## 2、运行环境 \r\n 未查找资料我的"
},
{
"path": "homework/lesson1/wufan.md",
"chars": 2335,
"preview": "# 类比代码执行流程\n\n## 1开户的流程\n\n个人到大厅填写申请，递交给窗口工作人员，然后，由工作人员校验/审核资质（这个过程包括1检查信息格式2检查信息准确性；核对1征信2资格），最后要么通过发证，要么驳回重新填写。\n\n优点是结构很简单，"
},
{
"path": "homework/lesson1/wukuipin.md",
"chars": 666,
"preview": "1. 类比代码执行流程\n> 当你去银行开户，将开户申请表提交到银行窗口，银行接收申请，在后台处理，通过审查和执行申请，然后返回结果。如果信息审核通过，银行就通过申请，这样就开好银行账户了。\n\n2. 运行环境\n> 运行环境分为（前端）浏览器的"
},
{
"path": "homework/lesson1/xianengqi.md",
"chars": 54,
"preview": "# \n\n+要熟练掌握`编程语言`\n##\n+要熟练运用`内置库`\n###\n+运用编程语言灵活运用`第三方库`\n"
},
{
"path": "homework/lesson1/xiaochaoge.md",
"chars": 3400,
"preview": "# JavaScript 的基本概念\n## **一、理解篇**\n### **1.1 类比代码执行流程**\n\n银行开户的流程演进就是程序语言一步一步演进的历史：\n1. 最早开始的开户流程，主要依赖于用户自身和银行的交互，用户通过发出开户申请，"
},
{
"path": "homework/lesson1/xieyuhui.md",
"chars": 1520,
"preview": " 带你走进Java script\n\n\n1. 当你去银行开户，你需要填写表格然后提交至窗口，静等银行工作人员校验、审核。通过之后你的开户任务就完成了。\n http://t3.qpic.cn/mblogpic/66"
},
{
"path": "homework/lesson1/xiongliyu.md",
"chars": 1068,
"preview": "-----\n# 第一次作业\n ## 1.类比代码执行流程\n\n 老师用银行开户的流程来类比代码执行流程，首先把开户的流程大致的分为 了三步，从这三个步骤触发，逐一思考如何改进流程，发现了4各个需求：\n1. 银行工作压力大 。\n2. 用"
},
{
"path": "homework/lesson1/xugang.md",
"chars": 737,
"preview": "# lesson1 学编程，为更好--xugang(徐钢) \n\n## 更高、更快、更强\n\n计算机、互联网处理信息、传递信息的效率很高、成本很低。如简单类比，处理信息对应生产，传递信息对应交易。一个行业生产、交易的效率高、成本低。这样的行业不"
},
{
"path": "homework/lesson1/xugaoyang.md",
"chars": 272,
"preview": "【第一次作业】写一篇总结\n\n运用下面这些关键词，把你知道的写出来。\n\n1. 类比代码执行流程\n2. 运行环境\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. 学习JS的方向\n\n提交方式：\n1. 请向get"
},
{
"path": "homework/lesson1/xuli.md",
"chars": 1836,
"preview": "# Lesson 1 上课心得-许丽\n\b\n## 写在前面\n\n当课程进行到了后1／2，我才来提交lesson 1的作业，其实还真是相当惭愧。\b\n认真分析自己如此拖延的根源在于：\n1. 自己的探索能力真心不够，卡在一个环节后，不进行各种方式去自"
},
{
"path": "homework/lesson1/xuluchun.md",
"chars": 212,
"preview": "<h1> 许路春第一课总结 <h1>\n<h3>牢记学习的方向</h3>\n<ul>\n <li>入门，掌握编程语言</li>\n <li>掌握，经常使用的库</li>\n <li>进阶，熟习各种库，并能够比较其优缺点</li>\n</ul"
},
{
"path": "homework/lesson1/xumin.md",
"chars": 1186,
"preview": "# JavaScript入门第一次作业小结 \n\n> 参考：markdown语法 [http://wowubuntu.com/markdown/]\n\n> 回顾：pull request [https://github.com/xugy0926"
},
{
"path": "homework/lesson1/yammy.md",
"chars": 2561,
"preview": "# 第一节 JavaScript 课程总结\n今晚在新大学了第一节 JavaScript 课程，以下是课程总结：\n\n1. 类比代码执行流程\n\n徐老师开场用一个银行开户的流程来类比代码的执行流程。\n\n首先，我们知道，开户的大致流程可以分成三个部"
},
{
"path": "homework/lesson1/yangchunguang.md",
"chars": 461,
"preview": "##第一次作业\n\n第一次提交作业，还不懂如何使用GitHub，就当跟它混个脸熟吧。\n上编程课给我最大的感受就是，提出一个问题，会引出一堆问题来，这些问题好像没有穷尽，以至于差点放弃。我争取跟上大部队的进度。\n感谢高阳老师耐心授课，感觉学不会"
},
{
"path": "homework/lesson1/yanglovewo.md",
"chars": 110,
"preview": "【第一次作业】写一篇总结\n\n1. 类比代码执行流程\n2. 运行环境：终端，浏览器\n3. V8引擎\n4. 编译器/解释（执行）器 \n5. 内置库\n6. 第三方库\n7. 学习JS的方向:想要完成专门课程，实现从0到0.5."
},
{
"path": "homework/lesson1/yangtieming.md",
"chars": 715,
"preview": "# JavaScrip Lesson 1 homework.\n\n对于编译型语言，原始的代码需要经过**编译器**的加工处理，把它先变成**解释器/执行器**可读懂并可执行的代码，然后再交由**解释器/执行器**执行。\n这个过程就像我们过年时"
},
{
"path": "homework/lesson1/yangxuewu.md",
"chars": 1680,
"preview": "# 第一节课总结\n\n## 1. 代码执行流程\n\n老师通过“到银行开户”这样一个事件需要操作的流程，把用户比作代码，银行内部操作比作运行环境，银行提供的第三方服务比作第三方库。用户与银行以及第三方服务之间的关系，即代码与运行环境及第三方库之间"
},
{
"path": "homework/lesson1/yangyepeng.md",
"chars": 1203,
"preview": "## Lession one homework **javascript**\n\n### 1. 类比代码执行流程\n以银行开户流程来为例，用户要开银行账户，需要先填写申请表，准备申请资料等信息。\n然后申请表和申请资料需要提交给银行大厅工作人员或"
},
{
"path": "homework/lesson1/yanqingmu.md",
"chars": 1528,
"preview": "# 编程世界类比理解大法\n\n本文是JavaScript编程入门第一节课的作业，之所以起这个名字，是因为徐高阳老师活用类比的方法，重新刷新了我对编程的认知。\n\n过去我学习编程的经历是这样的，翻开一本编程教程，一上来就是数据类型、变量、数组、指"
},
{
"path": "homework/lesson1/yimiao.md",
"chars": 462,
"preview": "### 第一次作业\n## yimiao\n\n学会了java的基本组成：\n1. 类比代码执行流程\n按照老师的类比，就好像是去银行办卡，先要填写表单（输入代码），然后提交审核（编译器编译），办理业务（执行器执行代码），最终拿卡（反馈结果）。此外，"
},
{
"path": "homework/lesson1/yongfei.md",
"chars": 510,
"preview": "\n**类比代码执行流程**\n* 代码 输入 执行 输出\n* 类比：银行开户 申请 检查 反馈\n\n**运行环境**\n* Javascript的环境，一种是chrome浏览器，一种是Node.js\n* 类比：婴儿的生存环境 家、游"
},
{
"path": "homework/lesson1/youshilei.md",
"chars": 461,
"preview": "#【第一次作业】写一篇总结\n\n\n\n### 1. 类比代码执行流程\n\n用银行办卡业务流程做类比，形象的解释了JavaScript的运行方式。\n\n### 2. 运行环境\n\n主要是软件环境，有浏览器环境和NODEJS的环境。\n\n### 3. V"
},
{
"path": "homework/lesson1/yueruiqi.md",
"chars": 752,
"preview": "# 作业1\n\nJS课程1总结\n---\n**1.类比代码执行流程**\n\n 以银行开户流程类比代码执行流程。\n - 提交开户申请：对应代码输入。\n - 银行的各项服务及内部处理\n：对应代码进入编译器/解释器后的各自分析，解释，执行。\n - 银"
},
{
"path": "homework/lesson1/yujianke.md",
"chars": 389,
"preview": "1. 类比代码执行流程\n --编写代码--编译器分析代码--输出结果。\n\n2. 运行环境\n --有浏览器和Nodejs。\n\n3. V8引擎\n --对代码的预处理，检查代码是否有错误。\n\n4. 编译器/解释（执行）器\n"
},
{
"path": "homework/lesson1/zhanggaoyang.md",
"chars": 362,
"preview": "看了大家的总结，有几篇总结写的非常到位，让人一目了然，但是看到文章末尾发现也是小白，自愧不如。看到大家都是对老师整个讲课过程进行的总结，我决定对讲课思路进行总结。\n\n可以注意到全程都是建立在银行开户流程改进这个类比上的。由一个简单的流程一步"
},
{
"path": "homework/lesson1/zhanghuanyuan.md",
"chars": 1154,
"preview": "1. 类比代码执行流程\n + 就是把现实的事件流程抽象出来，用最精简的方式来描述一个事件的执行流程，方便思考，方便转化为代码。\n2. 运行环境\n + 运行+环境\n + 运行：就是执行代码并期望得到想要的结果。\n + "
},
{
"path": "homework/lesson1/zhanghy.md",
"chars": 1546,
"preview": "1. 类比代码执行流程\n + 就是把现实的事件流程抽象出来，用最精简的方式来描述一个事件的执行流程，方便思考，方便转化为代码。\n2. 运行环境\n + 运行+环境\n + 运行：就是执行代码并期望得到想要的结果。\n + "
},
{
"path": "homework/lesson1/zhanglina.md",
"chars": 1189,
"preview": "##【第一次作业】\n————————————————————————————————————————\n#####--*author：张丽娜*\n#####--*version：V1*\n#####--*create_time：2017-08-0"
},
{
"path": "homework/lesson1/zhangqian.md",
"chars": 621,
"preview": "### 第一课作业\n####1、类比代码执行流程\n好比我们去银行办理汇款业务，先要填写申请单，到柜台交给工作人员核对数据，他们在录入系统进行再次比对，然后产出结果，代码执行的流程就是我们把相关语言输入到电脑的软件，软件对输入的语言解析，从而"
},
{
"path": "homework/lesson1/zhangruirui.md",
"chars": 1156,
"preview": "js第一次作业\n1.类比代码执行流程\n 对于js这样的解释性代码的执行流程，我觉得有点像请客吃饭，你和朋友先到了餐馆，点好几道菜，厨房立马看是什么菜，开始做了起来，什么菜先做，什么菜后做，口味是重是轻等等等等，谁知中途有别的朋友知道你俩在"
},
{
"path": "homework/lesson1/zhangxuedong.md",
"chars": 804,
"preview": "# JS第一课总结\n## 类比代码执行流程\n代码执行流程类似用户在银行开户：\n1.**银行提供开户环境**：提供一组服务包括接受申请、检验申请单信息和核对资格。\n2.**内置服务**:帮助用户填写订单提供复印、拍照、查询逾期、查询外国人入境"
},
{
"path": "homework/lesson1/zhaokaili.md",
"chars": 1584,
"preview": "\n【JavaScript第一次课后总结】\n\n1.类比代码执行流程\n \n 语言分为编译型语言和解释性语言，两种语言对应代码的执行流程自然也不同：\n\n 拿敲章来类比，假设现在有一本投标书，要求每页都要盖公章和法人章。\n \n （"
},
{
"path": "homework/lesson1/zhaoxiaoxin.md",
"chars": 887,
"preview": "\n【JavaScript第一次课后总结】\n\n1.类比代码执行流程\n写代码然后执行，类似在银行提出开户申请然后办理完成一样。\n首先有需求，写代码也是为了满足自己的一个需求，就像需要办理开户一样。\n办理开户，银行的核心业务是检查信息，批准开户"
},
{
"path": "homework/lesson1/zhaoyinan.md",
"chars": 473,
"preview": "【第一次总结——初学JS对一些基础概念的总结】\nauthor：赵一楠*\nversion：V1*\ncreate_time：2017-08-11*\n1. 类比代码执行流程\n按照老师的类比，就好像是去银行办卡，先要填写表单（输入代码），然后提交审"
},
{
"path": "homework/lesson1/zhouhong.md",
"chars": 209,
"preview": "1. 类比代码执行流程\n写代码---编译器---解释器---输出\n2. 运行环境\n相当于银行的开户环境，运行环境就是我们干事请时需要的环境，浏览器运行环境和Nodejs运行环境不同。\n3. V8引擎\n包含编译和执行\n4. 编译器/解释（执行"
},
{
"path": "homework/lesson1/zhouqizhou.md",
"chars": 531,
"preview": "# 总结\n#### 1.类比代码执行的流程 \n将代码通过编译器逐条执行，传递系统所需要的参数，完成整个服务 \n![](https://ws3.sinaimg.cn/large/006tNc79gy1ficlkyz1qzj30f70cy754"
},
{
"path": "homework/lesson1/zhouziqi.md",
"chars": 429,
"preview": "# 第一次课总结\n\n## 类比代码执行流程\n- 以银行开户流程作类比\n- 一步步改进银行开户流程，最终形成与js运行环境类似的流程\n\n## JS运行环境框架\n### JS运行环境\n#### 浏览器运行环境\n- V8引擎——用来执行代码的黑"
},
{
"path": "homework/lesson1/zhuningning.md",
"chars": 587,
"preview": "\n### 1. 类比代码执行流程\n通过`银行开户流程`来类比代码执行流程：更好的模块化——抽离出常用的功能，单独作为内置服务；将预处理和执行模块分离开来；\n\n>开户环境、内置服务、业务核心。\n\n### 2.运行环境\nJavaScript有两"
},
{
"path": "homework/lesson1/zhuting.md",
"chars": 928,
"preview": "// lesson1 作业\n1. 类比代码执行流程\n老师的意思是让我们用生活中的例子来说明代码执行流程吗？第一节课没赶上，只能靠猜测了，补作业，不废话！\n首先代码肯定是为了解决问题的，也就是换种语言描述生活中的需要的场景，并能够高效执行的。"
},
{
"path": "homework/lesson1/zhuxiaoping.md",
"chars": 587,
"preview": "## **类比代码执行流程**\n \n 代码，像是一个【病人】，本身带着需要解决的问题，有着相对明确的目标，最后要赢得【健康】而在特定的运行环境【医院】下奔波。\n \n## **运行环境**\n代码作为一个【病人】必需要去【医院】这个特"
},
{
"path": "homework/lesson1/zhuyongjin.md",
"chars": 230,
"preview": "\n先说说执行流程，老师运用银行开卡的流程，类比介绍了代码的执行流程，运行环境就像是银行。而V8引擎就像是里面的各种库。有浏览器的库，也有Node库。不管是浏览器还是Node库。都是有内置库。然后就外面而言，除了JS库自身的库，还有很多公司"
},
{
"path": "homework/lesson2/Autumnchou.md",
"chars": 781,
"preview": "# 为什么编程中会有丰富化的数据格式\n## 命名\n老师用给人命名来类比声明并定义变量、给变量赋值，这是一个含义丰富的类比。 \n首先只有给人命名了，对人有一个称呼了，其他人才能操纵这个人。这就是声明并定义变量的目的，如果想要操纵、使用变量就"
},
{
"path": "homework/lesson2/GaoXianfeng.md",
"chars": 1399,
"preview": "## JavaScript 入门第二课总结\n\n### 现实生活场景举例类比 JS 声明变量与对变量进行赋值\n一个男孩，名字为\"小明\"，他自身特征为：身高175cm，体重70kg，性别男，年龄21岁；爱好为：唱歌、旅行；亲戚关系为：爸爸、妈妈"
},
{
"path": "homework/lesson2/JayChen.md",
"chars": 541,
"preview": "# HW2\r\n\r\n## 1. 编程中为什么会有丰富化的数据格式\r\n\n\t当一个变量被申明时，这个变量就从无到有地诞生了，我个人粗浅的觉得如果能够类比成“怀孕并起名”会更为合适。\n\n\t我们申明一个变量是为了今后更好地掌控并操作他们，因此在变量刚"
},
{
"path": "homework/lesson2/Jaykey_Guo.md",
"chars": 586,
"preview": "### 基础-第二课\n\n##### 命名\n\n一个名字背后包含很多的属性，有不同的描述，对应的数据表的标题和内容。\n\nJS中采用的是山顶式的命名方法：\n\n```Javascript\nvar userName = \"liming\";\nvar i"
},
{
"path": "homework/lesson2/LiaoYuemin.md",
"chars": 1536,
"preview": "## 编程中为什么会有丰富化的数据格式? \n\n\n### 一切以命名开始 \n\n假如没有命名，世界上会发生什么？ \n你见到我的时候，由于我没有名字，你可能用手指指：“那个女人你过来一下”。但是很不凑巧，在我旁边还站着一个女人，这时我就搞不"
},
{
"path": "homework/lesson2/Liuzhengchun.md",
"chars": 588,
"preview": "## 第二次作业\n\n### 编程中为什么会有丰富化的数据格式\n\n1.这节课老师从*一切以命名开始*讲起，整节课我听的有点懵，脑海里一直带着这样的疑惑“这根编程有什么关系”，尽管我能理解老师讲的字面意思。 \n后面我看老师在作业区布置作业，"
},
{
"path": "homework/lesson2/Rachel.md",
"chars": 758,
"preview": "### 一切以命名开始\n\n整理一下，本次课程老师花了很多心思讲清楚了**变量和数据**之间的关系。\n\n为什么要这么花心思讲变量和数据的关系呢？\n\n因为程序的目的就是**“处理数据，得到结果**”。记得老师在上课的时候说：**数据都要赋值给变"
},
{
"path": "homework/lesson2/Risexie.md",
"chars": 1815,
"preview": "代码中为什么会有丰富的数据格式\n=====\n### 用“起名”作类比\n老师在课程内容当中，用了较大一部分的时间来把代码“声明“和“定义”的过程与我们给婴儿起名作类比。\n而在我把“声明“，”赋值“和”起名“对应起来理解之前，我们可以先分析一下"
},
{
"path": "homework/lesson2/SunBo.md",
"chars": 898,
"preview": "# 编程中为什么会有丰富化的数据格式\n\n> 孙博首次布属的静态网页：[https://ziyoubenteng.github.io/My-space-test/](https://ziyoubenteng.github.io/My-spac"
},
{
"path": "homework/lesson2/WANG XUANDING.md",
"chars": 735,
"preview": "\n首先申明一点，我极度讨厌那种为了凑字数而大段大段复制黏贴百科注释的行为。同时，我遵循如无必要，勿增实体的原则，就是几句话就能说明的东西，绝对不鬼扯。\n————————————————————————————————————————————"
},
{
"path": "homework/lesson2/WangChangQing.md",
"chars": 1102,
"preview": "# 编程中为什么会有丰富化的数据格式？\n\n\n## 1. 我的理解\n\n编程中为什么会有丰富化的数据格式？因为编程中需要有丰富化的数据格式呗。\n\n所谓“计算”，就是运用一定的规则，处理复杂的数据，得出一定的结果。所以“数据”很重要。\n\n那么数据"
},
{
"path": "homework/lesson2/WuGaoxing.md",
"chars": 237,
"preview": "编程中为什么会有丰富化的数据格式？\n编程是一个代码的世界，编程中的各种丰富数据和逻辑关系，代码来源于生活而有高于生活，生活的丰富多彩除了说写拍电影等来记录外，还可以通过代码来记录和演示，生活有多精彩数据就有多样的丰富，数据格式是与人类现实生"
},
{
"path": "homework/lesson2/Zhengchao.md",
"chars": 961,
"preview": "# **JavaScript Lesson2 学习心得**\n\n[JS网页教程](https://www.w3schools.com/js/default.asp)\n\n###### 第二课作业提要：“编程中为什么会有丰富的数据格式？”\n\n\n\n"
},
{
"path": "homework/lesson2/baoguoqiang.md",
"chars": 404,
"preview": "# 编程中为什么会有丰富化的数据格式？\n \n ## 首先什么是数据格式呢？\n \n 我个人理解数据格式就是数据类型；\n- 在编程语言中，能够表示操作的值的类型称作数据 类型，编程语言最基本的特性就是能够支持多种数据类型（数据格"
},
{
"path": "homework/lesson2/caozhen.md",
"chars": 338,
"preview": "## 编程中为什么会有丰富化的数据格式\n\n### 程序中的各种数据，都是对客观世界的反映\n\n- 人类与其它生物相比的最大优势就是人类具有学习能力+逻辑思维能力\n- 为了将自己从简单机械的劳动中解放出来，使自己的生存环境更加方便舒适，人们开"
},
{
"path": "homework/lesson2/chengjun.md",
"chars": 1058,
"preview": "## 编程中为什么会有丰富化的数据格式？程君的第二课作业(补交)\n\n### 编程是什么？\n\n要想知道编程世界中为什么会有丰富化的数据格式之前，我们需要首先知道编程到底是什么？\n\n在我的思维里，编程就是用计算机能够读懂的语言，让计算机帮助我们"
},
{
"path": "homework/lesson2/chenguoqiang.md",
"chars": 954,
"preview": "# 编程中为什么会有丰富化的数据格式？\n\n数据格式这个概念，我是第一次听到。百度了一下它的概念\n\n> 数据格式是描述数据保存在文件或记录中的规则。\n>\n> 形式：数值、字符或二进制数\n\n虽然第一次接触，但是通过徐老师的讲解，理解起来并没有什"
},
{
"path": "homework/lesson2/chenqiong.md",
"chars": 1049,
"preview": "# JavaScript 入门课第二课总结\n\n## 使用 GitHub 免费生成静态网页的技巧\n* 第一步：在 GitHub 上创建一个空项目，然后 git clone 到本地。\n* 第二步：把写好的 HTML 页面复制到本地项目，git "
},
{
"path": "homework/lesson2/chenrushan.md",
"chars": 3079,
"preview": "# Lesson02 总结\n\n> 程序的目的是什么？\n> \n> **处理数据，得到结果**\n\n\b为了处理数据，操作数据，\b就需要先对其进行命名，然后将名字与数据关联起来。\n\n# 名字\n\n> 一切从命名开始\n\n先取名 -> 生小孩 -> 名字"
},
{
"path": "homework/lesson2/chenziwen.md",
"chars": 953,
"preview": "# 第二课作业\n## 作业要求\n1. 熟读getting-started-with-javascript/study/lesson2/smaple_code.js代码。\n2. 用node环境和浏览器环境运行一下代码（注意：浏览器运行请使用m"
},
{
"path": "homework/lesson2/cloudyview.md",
"chars": 2457,
"preview": "# 第二课作业 编程中为什么会有丰富化的数据格式？\n\n[静态页面链接](https://cloudyview.github.io/learning-javascript/)\n\n这是一篇课程总结，所以首先回答老师提出的问题，编程中为什么会有丰"
},
{
"path": "homework/lesson2/cuimiao.md",
"chars": 468,
"preview": "#第二课笔记\n老师先教给我们如何创建静态页面，又教给我们如何正确的提问题，比如遇到问题应该折腾自己，然后是搜索，再去讨论区看是否有其他同学提问过，最后最后，才能在微信群里提问，而且提问是需要技巧的，必须把自己的环境，步骤等都描述清楚，才能提"
},
{
"path": "homework/lesson2/dangfeipeng.md",
"chars": 427,
"preview": "### 为什么要有丰富化的数据格式？\n\n现实世界是由万事万物以及各种关系和逻辑组成，人类通过数万年的进化，已经形成了一套完整的数据格式来帮助我们记录、处理、展示这个丰富多彩的世界，比如用数字表达财富，用文字或者语言表达情感，以及用图片、影像"
},
{
"path": "homework/lesson2/dengxy0907.md",
"chars": 316,
"preview": "编程中为什么会有丰富化的数据格式\n=================\n### 1、我对编程的的看法\n>如果事物都能数据化，那么通过编程就能定义数据，然后通过调用数据打成目的。\n### 2、数据类型\n> 布尔型、数组、字符串、null、资源"
},
{
"path": "homework/lesson2/diaozhicong.md",
"chars": 338,
"preview": "\n#第二次课总结：\n##编程中为什么会有丰富化的数据格式？\n+ 编程操作的对象是多种多样的，如名字、数值、属性、关系等。\n+ 数据格式有数值、字符串、布尔、null和undefined、对象、数组、函数等。\n+ 我们编程的目的是处理数据，得"
},
{
"path": "homework/lesson2/duhongxia.md",
"chars": 302,
"preview": "杜红霞的第二课作业\n\n程序的目的：“处理数据 得到结果。”\n\n课中用小明的例子来进行了说明：\n\n我们通过程序来描述小明，那么就要对小明的数据进行处理。小明的数据包括哪些呢：有他自有的\n基本属性（身高、年龄、体重、性别等数字、文本）再加上"
},
{
"path": "homework/lesson2/fangqingyang.md",
"chars": 713,
"preview": "### JS入门第二课\n\n#### 一切以命名开始\n\n不命名的话，我们人，怎么操控那样一堆数据呢？输入了数据，计算机确实是有了数据，但是操纵不方便。就像我们和小明相处过，也确实在大脑里面存有小明的数据了，但如果没有小明这个名字，我们的大脑无"
},
{
"path": "homework/lesson2/fanqing.md",
"chars": 6429,
"preview": "* [课程回顾](#1)\n\n * [理论讲解](#1.1)\n\n * [实操部分](#1.2)\n\n* [心法记录](#1.3)\n\n* [课程作业](#2)\n\n * [作业-1](#2.1)\n\n * [作业-2](#2."
},
{
"path": "homework/lesson2/fengkai.md",
"chars": 258,
"preview": "为什么会有丰富化的数据格式:\n对于不同场景下的变量或者是数据，能够将彼此相互关联起来，最终分解成机器能够理解的二进制0和1\n\n1. 数据格式：\n\nstr 字符串\n\nint 整型\n\nfloat 浮点型\n\nlist 列表\n\narray 数组\n\n"
},
{
"path": "homework/lesson2/guowei.md",
"chars": 833,
"preview": "# 小白JS入门不放弃 lesson2\n\n### Focus question: *编程中为什么会有丰富化的数据格式?* \n\n\n***\n\n编程中为什么会有丰富化的数据格式，想回答这个问题，先从**数据类型**这个概念开始剖析。\n\n### 编"
},
{
"path": "homework/lesson2/hanmeng.md",
"chars": 254,
"preview": "#这是我的静态网页地址https://menhan.github.io/my_test/ \n目前只修改了链接地址，颜色。\n\n#第二节课总结\n\n ##编程中为什么会有丰富化的数据格式？\n\n***\n我的理解，编程就是调用不同的指令，处理数据，"
},
{
"path": "homework/lesson2/hanwei.md",
"chars": 1681,
"preview": "### 编程中为什么会有丰富化的数据格式？\n在现实生活中，为了有效的交流我们要给事物一个名字，这样才能通过简洁的语言指向我们要表达的事物。这一点在程序中也是一样的，文件名、变量名、函数名、参数名。如果不使用名字，我们就很难快速的指向一个事物"
},
{
"path": "homework/lesson2/haohu.md",
"chars": 197,
"preview": "#编程中为什么会有丰富化的数据格式？\n\n- 与现实世界对应: 不一样的东西就有不一样的描述方式，增加程序可读性\n- 提高空间利用率: 不同的数据格式占用的空间不同，可根据实际需要分配\n- 提高程序的性能: 不同的数据格式适用于不同的需求，使"
},
{
"path": "homework/lesson2/hewei.md",
"chars": 2784,
"preview": "# 第二节课笔记\n\n## 视频讲座\n\n### 一切以命名开始\n\n为什么要命名？就是为了方便开发者编写代码。\n\n代码不只是让机器运行的，更是让人看的。现在的电脑性能已经让一般的开发者将重心放到实现功能上，而不是解决资源上。所以，书写易读易懂的"
},
{
"path": "homework/lesson2/huangjiashu.md",
"chars": 3347,
"preview": "我知道，作业要从新做了，的确是没用心。实在是有付老师的期望。不过话说回来了，学习任何时候都是为自己学的。老师希望看到学生的努力和认真，很感谢老师对我第一次作业的肯定。言归正传：\n\n## 提起命名\n\n命名在程序中的确是不起眼又很重要的东西，好"
},
{
"path": "homework/lesson2/huangqi.md",
"chars": 167,
"preview": "##编程中为什么会有丰富化的数据格式\n\n###编程中为什么会有丰富化的数据格式？我个人的理解是这个样子的：“精心选择的数据结构可以带来更高的运行或者储存效率，还有方便代码的调用吧”，我这个样子理解不知道对不对。请老师指正。\n\n###我个人主"
},
{
"path": "homework/lesson2/huangzhihua.md",
"chars": 1150,
"preview": "\n\n\n\n\n\n\n \n\n # 第二课总结 编程中为什么会有丰富化的数据格式？\n\n\n 编程中为什么会有丰富化的数据格式？\n \n 编程本质上是人类与计算机之间沟通的桥梁，计算机是0与1的世界，如果编程的过程之中，没有制定一些“"
},
{
"path": "homework/lesson2/huyong.md",
"chars": 637,
"preview": "#作业一 ：编程中为什么会有丰富的数据格式\r\n数据格式我的理解是就像英文里面的26个字母，这些字母排列组合沟通了我们要表达的单词，语句，想法；\r\n丰富的数据格式对应着更多的字母，如果只有3个字母，按照排列着它并不能构成太多的单词，更没有了丰"
},
{
"path": "homework/lesson2/jianglin.md",
"chars": 1795,
"preview": "### 姜琳第二次课总结\n\n#### 课程总结：编程中为什么会有丰富化的数据格式\n\n#####多样化的数据格式用于不同的情况和操作\n\n- 数字：用于计算；\n- 文本：（字符串）用于表示是什么；\n- 布尔：是/否，用于表示是非的逻辑；\n- 对"
},
{
"path": "homework/lesson2/langjianjun.md",
"chars": 179,
"preview": "第二节课总结 编程中为什么会有丰富化的数据格式？\n \n丰富的数据格式是因程序要处理复杂的现实问题而产生的。\n\n比如，字符串是对应生活中的文字的，需要保持原样；而数字则分为整数和浮点数，后者对应数学中的实数；而数组则可对应坐标、数据表格等。\n"
},
{
"path": "homework/lesson2/leizhen.md",
"chars": 157,
"preview": " 编程中为什么会有丰富化的数据格式？\n\n为了高效。\n\n不同的格式可以互补短板\n\n\n我把编程类比成雕刻师傅，数据格式类比成雕刻刀\n雕刻刀的种类也有很多：平刀、斜刀......\n用一把刀去雕刻当然是没有问题的，但是会用其他的刀，大大提高了效率嘛"
},
{
"path": "homework/lesson2/lichen.md",
"chars": 407,
"preview": "###编程中为什么会有丰富化的数据格式？\n\n一切从命名开始，从命名开始，我们得以操纵变量和数据。\n\n这个世界所有的存在的事物背后都有很多属性、特征。\n\n自然语言是人类用来处理特定目的。\n\n数据就是语言的编码，从而处理数据，得到结果。\n\n##"
},
{
"path": "homework/lesson2/lingxiao.md",
"chars": 2187,
"preview": "# 编程中为什么会有丰富化的数据格式-JavaScript第二次作业\n## 作业\n【作业要求】\n1. 熟读getting-started-with-javascript/study/lesson2/smaple_code.js代码。用nod"
},
{
"path": "homework/lesson2/linxiyao.md",
"chars": 331,
"preview": "编程中为什么会有丰富化的数据格式？\n\n编程中有丰富的数据类型，比如数字数据（170）,数组数据（170，120，18）,文本/字符串数据（height），组合数据/对象（height:170,weight:120,age：18）,布尔数据（"
},
{
"path": "homework/lesson2/lipeng.md",
"chars": 235,
"preview": "## 编程中为什么会有丰富化的数据格式？\n\n1\n\n对应真实世界的数据状态。\n\n比如我的年龄，那就是一个不超过3位数的整数。而提到我喜欢的食物，那么就是一大串了。\n\n再比如，描述一个公司的架构，那么就是一层一层的金字塔结构。\n\n2\n\n统计所有"
},
{
"path": "homework/lesson2/litao.md",
"chars": 698,
"preview": "# 编程中为什么会有丰富化的数据格式\n\n标签（空格分隔）： 作业2\n\n\n----------\n世间存在的一切事物都要有个名字，即使用一个代号表示，也是对于它的一个命名，所以说命名是一切事物的基础。\n而我们对于这个事物的认识，是通过了解它背"
},
{
"path": "homework/lesson2/liujuanjuan.md",
"chars": 1128,
"preview": "## 听新生大学CTO讲JavaScript编程入门-2\n\nby刘娟娟 2017-08-18\n\n这堂课，老师依然用类比的方式，教我们认识编程世界的一个重要概念。\n\n名字 = 变量\n\n**命名**，是个哲学话题。现实世界中，为什么人、物、万事"
},
{
"path": "homework/lesson2/liujun.md",
"chars": 453,
"preview": "# 编程中为什么会有丰富化的数据格式？\n \n## 数据格式的种类\n数据格式有许多种，我目前知道的有：布尔型，字符串型，数组，整型，列表等。\n\n它们也可以随意组合，任意调用。\n\n## 编程为什么会有丰富化的数"
},
{
"path": "homework/lesson2/liuliyuan.md",
"chars": 800,
"preview": "##第二次作业 变量和值\n\n1、在编程语言中，能够表示并操作的值的类型称作数据类型。JavaScript的数据类型分为两类：\n>原始类型:数字、字符串、布尔值，null/undefined\n>对象类型：数组，函数，日期类，正则类，错误类\n\n"
},
{
"path": "homework/lesson2/liuqing.md",
"chars": 866,
"preview": "## 编程中为什么会有丰富化的数据格式？\n\n在照着老师的sample_code.js文件自己一字不差敲了一遍之后，才慢慢加深了对语句中的各种类型代码的熟悉感。\n一方面，各种不同的数据类型有不同的格式要求；另一方面，在定义一个变量的时候，也有"
},
{
"path": "homework/lesson2/liuruyong.md",
"chars": 395,
"preview": "# 编程中为什么会有丰富化的数据格式？\n现实生活就是复杂的，像课上讲的小明的例子，身高是有小数的、年龄一般用整数、朋友关系要用数组表示、每个朋友都是一个独立的对象。。。\n\n为了描述现实生活中的问题，就需要相对应的数据类型存储数据。由此抽出了"
},
{
"path": "homework/lesson2/liushengsi.md",
"chars": 688,
"preview": "# 编程中为什么会有丰富化的数据格式？\n\n#### 1. 我们为什么要编程呢？\n\n人类的进化史可以说是一部效率的提高史。进入现代文明社会后，我们的现实世界越来越复杂，比之前古老的农耕文明社会不知道复杂了多少倍。然后计算机诞生了！计算机的工作"
},
{
"path": "homework/lesson2/liushengxin.md",
"chars": 420,
"preview": "# lesson2 编程中为什么会有丰富化的数据格式？ \n## 2017年8月13日\n\n某一方面，我认为程序在一定程度上是真实世界的映射。\n\n这就是为什么编程中会有丰富的数据格式。\n\n编程中的数据格式包括这几类。\n\n数字、文本、布尔、对象"
},
{
"path": "homework/lesson2/liuxiaohaohao.md",
"chars": 851,
"preview": "#JS第二节课总结\n##学习的习惯养成\n1.微信不是学习编程的唯一途径，不要过分依赖。\n2.遇到问题先尝试思考，自己动手去解决。\n3.解决不了，自己去谷歌，百度搜索，寻找答案。\n4.最后实在不行了，再回来到群里寻求小伙伴的帮助。但寻求帮助"
},
{
"path": "homework/lesson2/lixiang.md",
"chars": 922,
"preview": "# 编程中为什么会有丰富化的数据格式\n\n\n\n\n标签（空格分隔）： 未分类\n\n---\n\nPS: [作业链接][1] \nhttps://ideal1985.github.io/ideal/\n\n**A. 体现真实而丰富的世界** （输入角度）\n"
},
{
"path": "homework/lesson2/liyihang.md",
"chars": 259,
"preview": "#为什么有丰富化的数据格式？\n\n##数学思想\n编程的数据是基于数学来设计的，有部分数据结构的思想来自数学，基本的自然数，无理数，集合，序列,布尔。\n\n##计算机思想\n根据数据的特性结合内存物理特性，把数字分浮点和整形。\n根据软件工程理论，出"
},
{
"path": "homework/lesson2/luoruijun.md",
"chars": 217,
"preview": "# 编程中为什么会有丰富化的数据格式\n数据格式有：基本数据（数字、文本、布尔等）、数组、组合数据（对象数据），不同的类型的数据操作方式不同。编程要有不同的数据格式，估计是和计算机对数据的辨识有关，处理不同类型的数据是用不同的方式的，不同数据"
},
{
"path": "homework/lesson2/marshalcy.md",
"chars": 713,
"preview": "##编程中为什么会有丰富化的数据格式？\n###提交人：Marshalcy\n####已知数据格式\n现在，我知道的数据格式有：数字，文本、数组，对象，布尔。<br>\n#####1）数字\n1.1）数字可以带小数点，也可以不带；<br>\nvar x"
},
{
"path": "homework/lesson2/panqi.md",
"chars": 1779,
"preview": "# 第二次作业\n## 上周末补写作业遇到的问题\n### node环境无法运行代码。老师和同学们通过不同渠道给出了方法，自己尝试着照做仍然不对，当时最大的困惑是不知道应该进入哪里完成。开始进入了电脑终端，找错了地方；后来进入vscode终端"
},
{
"path": "homework/lesson2/panyong.md",
"chars": 350,
"preview": "# 【第二次作业】变量和值\n\n【作业要求】\n1. 熟读getting-started-with-javascript/study/lesson2/smaple_code.js代码。用node环境和浏览器环境运行一下代码（注意：浏览器运行请使"
},
{
"path": "homework/lesson2/qiujingyu.md",
"chars": 591,
"preview": "## 编程中为什么会有丰富化的数据格式？\n\n#### 学习代sample_code.js码心得\n\n+ 用var来声明变量，用的是赋值语句。\n+ 定义变量时，\"=\" 不是代表等于，而是指“得到或者赋值”，等于是\"==\"，严格相等是\"===\"。"
}
]
// ... and 484 more files (download for full content)
About this extraction
This page contains the full source code of the xugy0926/getting-started-with-javascript GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 684 files (1.2 MB), approximately 536.5k tokens, and a symbol index with 241 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.