博客列表 >js初步学习命名规范及常量标识符以及函数,作用域变量

js初步学习命名规范及常量标识符以及函数,作用域变量

卢先生
卢先生原创
2021年12月29日 23:20:41521浏览

js学习

声明一个变量并输出

  1. let head = 10;
  2. let body = 20;
  3. console.log(head + body);

示例图:

更新一个变量并进行运算

  1. body = 50;
  2. 这里注意的是更新变量不需要let
  3. console.log(head + body);
  4. // 带+ - * /是运算
  5. console.log(body / head);
  6. console.log(body * head);
  7. // 也可以不用运算符号
  8. console.log(body, head);
  9. // 声明函数

示例图:

复用代码及调用函数:
代码示例:

  1. function min() {
  2. return function () {
  3. // 这里试了下,一定要注意,虽然可以链式调用,但是,需要都给return给返回值,否则,报错
  4. return function () {
  5. return function (a, b) {
  6. a = 1;
  7. b = 1;
  8. let laoshi = 2;
  9. // 试了下,新增声明函数,需要用let,更新不需要,否则报错
  10. return a + b;
  11. };
  12. };
  13. };
  14. }
  15. console.log(min()()()());

示例截图:

函数的书写规范:

  1. const AA_66 = 1;
  2. const $AA_55 = 2;
  3. const anDt_Dm = 3;
  4. // 上面声明了常用声明
  5. function Aa(AA_66, $AA_55, anDt_Dm) {
  6. return AA_66 + $AA_55 + anDt_Dm;
  7. }
  8. console.log(Aa(AA_66, $AA_55, anDt_Dm));

示例截图:

老师那华丽的代码(非作业部分,保留以防以后忘记回头学习):

  1. // TODO 代码中的成员:
  2. // * 1. 数据
  3. // * 2. 操作
  4. // Chrome控制台: 内置的JS执行器, 浏览器中用的
  5. // console.log(): 将计算结果输出到控制台,可以用在node中
  6. // * 程序: 描述任务的操作流程, 默认"顺序执行"
  7. // * 顺序执行: 计算机中专业的叫法"同步执行"
  8. // * 同步执行: 代码执行顺序与书写顺序一致
  9. // console.log(1);
  10. // console.log(2);
  11. // ! (1) 数据
  12. 10;
  13. 20;
  14. // * 字面量: 直接可以看到值
  15. // 如果10, 20, 后面还要用?
  16. // 可以用一个容器, 将他们缓存起来, 这个临时存放数据的容器: "变量"
  17. // 为了数据的复用: 使用了"变量"
  18. // * 只要涉及到了"复用", 必须要有2步:
  19. // * 1. 声明过程: 仅定义, 不执行, 方便编译预处理
  20. // * 2. 执行过程: 复用的过程, 可以多次,多个地方调用声明的语句
  21. // * 第一步: 变量声明
  22. // 为了将变量与"作用域"进行绑定
  23. let a;
  24. let b;
  25. // * 第二步: 执行, 赋值(第一次叫:初始化)
  26. a = 10;
  27. b = 20;
  28. // 第二次赋值叫什么? 更新 / 修改
  29. a = 15;
  30. // 删除
  31. // a = null;
  32. // 按名使用, 才能实现:数据复用
  33. console.log(a, b);
  34. // 变量禁止重复声明
  35. // let a;
  36. // *--------------------------------------------------/
  37. // ! (2) 操作
  38. // 操作写到哪? 写到代码块中
  39. // 代码块: 一段由"大括号 {...}"包裹的代码
  40. {
  41. // 代码块
  42. }
  43. // 以二数求和为例
  44. {
  45. a + b;
  46. }
  47. // * 使用代码块的目的, 是为了"代码复用"
  48. // 如果是一次性的执行,不需要代码块
  49. console.log(a + b);
  50. // 复用代码必分二步:
  51. // 1. 声明过程
  52. // 2. 执行过程
  53. // * 1. 声明函数
  54. // function : 声明函数
  55. // sum: 函数名称
  56. // (a,b): 参数列表
  57. // return : 返回结果
  58. function sum(a, b) {
  59. return a + b;
  60. // 下面这条语句永不执行,因为上面return
  61. // console.log(123);
  62. }
  63. // * 2. 调用函数
  64. console.log(sum(15, 20));
  65. console.log(sum(a, b));
  66. a = 30;
  67. b = 50;
  68. console.log(sum(a, b));
  69. /**
  70. * todo 总结:
  71. * * 1. 代码主要成员: 变量与函数
  72. * * 2. 变量与函数: 代码复用技术
  73. */
  74. /**
  75. * todo 变量总结:
  76. * * 1. 变量: 数据复用
  77. * * 2. 变量声明: let
  78. * * 3. 变量引用: 变量名
  79. */
  80. /**
  81. * todo 函数总结
  82. * * 1. 函数: 操作复用
  83. * * 2. 声明: function
  84. * * 3. 调用: 函数名(...)
  85. */
  1. // todo 变量,函数与作用域
  2. /**
  3. * * 1. 块作用域
  4. * * 2. 函数作用域
  5. * * 3. 全局作用域(默认)
  6. */
  7. // * 1. 块作用域
  8. {
  9. // 代码块
  10. // 将变量的声明与赋值(初始化)二合一
  11. // 私有成员
  12. let a = 123;
  13. // 等价于以下二条:
  14. // let a;
  15. // a = 123;
  16. // 块中变量在块中可以访问到
  17. console.log(a);
  18. }
  19. // 块中成员,在块的外部不可访问/不可见
  20. // console.log(a);
  21. // * 2. 函数作用域
  22. function sum(a, b) {
  23. // 在函数中声明一个变量
  24. // 私有变量
  25. let res = a + b;
  26. // 函数内部声明的成员可以内部访问
  27. console.log(res);
  28. }
  29. sum(30, 50);
  30. // 但是在函数外部访问不到
  31. // console.log(res);
  32. // ? 私有成员: 在块/函数内部声明的成员, 仅限内部使用, 外部不可见
  33. // * 3. 全局作用域
  34. // 位于"代码块/函数"之外的空间, 叫"全局作用域"
  35. // qq: 全局变量, 公共变量
  36. let qq = "498668472";
  37. // ! 全局成员(变量/函数)在代码的任何地方,都是可用的
  38. {
  39. console.log(qq);
  40. }
  41. {
  42. {
  43. {
  44. console.log(qq);
  45. }
  46. }
  47. }
  48. function f1() {
  49. console.log(qq);
  50. }
  51. f1();
  52. function f2() {
  53. return function () {
  54. return function () {
  55. console.log(qq);
  56. };
  57. };
  58. }
  59. // 因为函数嵌套了三层,所以调用了三次
  60. f2()()();
  61. //! 总结: 全局 ---> 块 / 函数,访问顺序像链条一个, 形成了一条"作用域链"
  62. // * 要解决二个问题
  63. // * 问题1: 在块/函数中, 访问一个不存在的成员 , 会发生什么?
  64. {
  65. // 块中没有username
  66. // console.log(username);
  67. }
  68. // 全局
  69. let username = "猪老湿";
  70. {
  71. {
  72. {
  73. console.log(username);
  74. }
  75. }
  76. }
  77. function f3() {
  78. // 没有username
  79. let username = "灭绝师妹";
  80. console.log(username);
  81. }
  82. f3();
  83. /**
  84. * * 块和函数中, 如果存在与上一级作用域同名的成员,则当前成员会覆盖上一级同名成员
  85. * * 当前作用域的访问优先级 > 上一级作用域
  86. * * 简单记忆: 作用域中, 总是优先访问, 离它声明最近的成员
  87. */
  88. // ! 总结: 作用域, 由外向内允许, 由内向外受限, 从而形成一条具有优先级的"作用域链"
  89. // ! 作用域: 成员的可见范围
  90. // ! 作用域链: 成员的访问顺序
  91. // * 成员: 变量, 函数
  1. // todo 常量是什么?
  2. // todo 什么标识符? 它的命名规范是什么?
  3. // ! 1. 常量是什么?
  4. // 当一个数据,需要在多处被引用,为了防止引用时发生数据不一致,需要将它的值固定下来
  5. // 这样的数据,应该声明为"常量"
  6. // 所谓"常量",就是经常被使用到的变量, 简称"常量"
  7. // 例如: 性别, 对象, 数据,函数等,都应该声明为常量
  8. // 常量也是为了实现:数据复用
  9. // 声明
  10. const APP_NAME = "在线商城";
  11. // 使用
  12. console.log(APP_NAME);
  13. // 常量的值不可变,所以必须在声明时初始化
  14. // 禁止更新
  15. // APP_NAME = "我的博客";
  16. // 变量与常量在使用时,如何选择?
  17. // 尽可能首选"常量", 除非这个值用到循环变量中,或者肯定会被更新,才用变量
  18. // ! 2. 标识符命名规范
  19. /**
  20. * * 标识符: 代码中有意义的符号, 例如: 变量, 函数等
  21. * * 标识符有二类:
  22. * * 系统标识符: 关键字, 保留字, 是JS提供给开发者, 直接拿来用,不需要声明
  23. * * 自定义标识符: 必须 "先声明, 再使用", 例如 email, password, get...
  24. * * 标识符可使用的字符:
  25. * * 必须是: 字母,数字, 下划线"_", "$"(四种),其它字符均是非法符号
  26. * * 首字母不得使用"数字"
  27. * * 标识符命名规范:
  28. * * 驼峰式: 第二个单词首字母大写, 第一个单词首字母是否大小取决于用途,例如构造函数/类的首字母要大写
  29. * * 蛇形式: 每个单词之间使用"下划线"分割
  30. */
  31. // let let = 1;
  32. // 关键字,保留字
  33. // let const function class ...
  34. // 自定义
  35. // 合法的
  36. // myEmail, user_name, UserController/类/构造函数
  37. // _ , $, $_, $_123, 朱老师
  38. // let 我的姓名 = '猪老师';
  39. // console.log(我的姓名);
  40. // 非法的
  41. // my#email, 123aaa, $_user@ElementInternals.com
  42. // 驼峰式: 小驼峰,首字母小写, 大驼峰: 首字母大写
  43. // myEmail, getUserInfo, UserInfo, StuModel
  44. // 蛇形式:
  45. // user_name, get_email, 常量 APP_NAME
声明:本文内容转载自脚本之家,由网友自发贡献,版权归原作者所有,如您发现涉嫌抄袭侵权,请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言,请遵守新闻评论服务协议