欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

程序员文章站 2022-04-17 19:03:35
...

声明一个带名字的函数:

  1. // 函数
  2. // 声明函数
  3. let name = "名";
  4. // 声明带名字的函数
  5. function namez(name) {
  6. return name + "字";
  7. }
  8. console.log(namez(name));

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

声明一个带俩对象名字的函数
  1. // 声明俩参数 参数的值为1和2
  2. let a = 1;
  3. let b = 2;
  4. // 声明名字为namey的函数
  5. function namey(a, b) {
  6. return a + b;
  7. }
  8. console.log(namey(a, b));
声明一个立即执行的函数
  1. // ↓↓↓↓↓↓下面声明一个立即执行的函数↓↓↓↓↓
  2. function namew(wang) {
  3. console.log("我的名字是" + wang);
  4. }
  5. namew("王");
  6. // 上面这是立即执行的,感觉怪怪的,中间一个打印,
  7. console.log(
  8. (function namer(liu) {
  9. return "我的姓名是" + liu;
  10. })("刘")
  11. );
  12. // 尝试了好几遍才对,需要包含在打印的()里面,填写函数namer中liu的值↑
  13. // ↑↑↑↑上面这两种,是阅后即焚的声明函数↑↑↑↑↑

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

函数表达式;

看代码的意思是,声明一个变量,变量的值是一个函数,如下

  1. const Name = function naMe(dog) {
  2. return "狗英文单词是" + dog;
  3. };
  4. console.log(Name("dog"));
  5. console.log(Name);
  6. // 看到这个符号了吧,以后问别人这是什么意思,一定说是函数表达式 别被笑话
  7. // 上面这种就是声明一个参数,参数的值是一个函数↑↑↑↑↑↑↑↑↑↑
  8. // 匿名函数
  9. let name_a = function (niu) {
  10. return "这是" + niu + "的意思";
  11. };
  12. console.log(name_a("牛牛"));

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

匿名函数

代码:

  1. // 匿名函数
  2. let name1 = function (Name) {
  3. return '我的名字是' + Name
  4. }
  5. console.log(name1('名字'))
  6. // 箭头函数的简写
  7. let name2 = function (a, b) {
  8. return a + b
  9. }
  10. console.log(name2(1, 2))
  11. // 上面的简写写法为以下
  12. name2 = (a, b) => {
  13. return a + b
  14. }
  15. console.log(name2(2, 3))
  16. // 上面简写的是去掉了functin,在()后面增加了=>胖头鱼符号{}
  17. // 上面是因为声明的参数中的函数有2个值,所以已经是最简方法了,但是当函数内就一个值的时候,还可以继续简写
  18. // 先写一个非简写法
  19. let name3 = function (Name3) {
  20. return Name3
  21. }
  22. console.log(name3('非简写'))
  23. // 下面是简写写法
  24. name3 = (Name3) => {
  25. return Name3
  26. }
  27. console.log(name3('简写'))
  28. // 上面这是就一个值,下面再练习一下
  29. let name4 = function (Name4) {
  30. return '这是非' + Name4 + '写法'
  31. }
  32. console.log(name4('简体'))
  33. name4 = (Name4) => {
  34. return '这是' + Name4 + '写法'
  35. }
  36. console.log(name4('简体'))
  37. // 上面这种写法 还可以简写 因为只有一个参数,且参数仅有一个return返回值简写方式如下
  38. name4 = (Name4) => '这是' + Name4 + '因为就一个return,所以更简单的写法'
  39. console.log(name4('更简单的写法。'))
  40. // 还有,就是没有参数时,一定要把()写上,也就是匿名的时候,简体写法
  41. // 非简体匿名函数先写一段
  42. const name5 = function () {
  43. return '还原后学习到了,是因为返回值里面,也是个空参数 ,且非简体的时候,return这个返回值要写'
  44. }
  45. console.log(name5())
  46. //本来想更新一下的,发现声明用的const,不能再次声明了
  47. let name6 = () =>
  48. '还原后学习到了,是因为返回值里面,也是个空参数 ,且非简体的时候,return这个返回值要写'
  49. console.log(name6())
  50. // 刚刚上面不会写,拿了老师的,还原了一下,看看我是哪里出错的
  51. // let f1 = () => '今天天气很好'
  52. // console.log(f1());
  53. // 还原
  54. // f1 = function () {
  55. // return '今天天气很好'
  56. // }
  57. // console.log(f1())

为了能更好的看懂代码,直接上代码图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

匿名函数:
  1. // 匿名函数
  2. let name_a = function (niu) {
  3. return "这是" + niu + "的意思";
  4. };
  5. console.log(name_a("牛牛"));
  6. // 匿名函数
  7. let name1 = function (Name) {
  8. return "我的名字是" + Name;
  9. };
  10. console.log(name1("名字"));
  11. // 箭头函数的简写

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

箭头函数
多值函数简写:
  1. let name2 = function (a, b) {
  2. return a + b;
  3. };
  4. console.log(name2(1, 2));
  5. // 上面的简写写法为以下
  6. name2 = (a, b) => {
  7. return a + b;
  8. };
  9. console.log(name2(2, 3));
  10. // 上面简写的是去掉了functin,在()后面增加了=>胖头鱼符号{}
  11. // 上面是因为声明的参数中的函数有2个值,所以已经是最简方法了,但是当函数内就一个值的时候,还可以继续简写

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

简写之单值简写:

代码部分:

  1. // 先写一个非简写法
  2. let name3 = function (Name3) {
  3. return Name3;
  4. };
  5. console.log(name3("非简写"));
  6. // 下面是简写写法
  7. name3 = Name3 => {
  8. return Name3;
  9. };
  10. console.log(name3("简写"));
  11. // 上面这是就一个值,下面再练习一下
  12. let name4 = function (Name4) {
  13. return "这是非" + Name4 + "写法";
  14. };
  15. console.log(name4("简体"));
  16. name4 = Name4 => {
  17. return "这是" + Name4 + "写法";
  18. };
  19. console.log(name4("简体"));
  20. // 上面这种写法 还可以简写 因为只有一个参数,且参数仅有一个return返回值简写方式如下
  21. name4 = Name4 => "这是" + Name4 + "因为就一个return,所以更简单的写法";
  22. console.log(name4("更简单的写法。"));

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

匿名函数简写

代码部分:

  1. / 还有,就是没有参数时,一定要把()写上,也就是匿名的时候,简体写法
  2. // 非简体匿名函数先写一段
  3. const name5 = function () {
  4. return "还原后学习到了,是因为返回值里面,也是个空参数 ,且非简体的时候,return这个返回值要写";
  5. };
  6. console.log(name5());
  7. //本来想更新一下的,发现声明用的const,不能再次声明了
  8. let name6 = () => "还原后学习到了,是因为返回值里面,也是个空参数 ,且非简体的时候,return这个返回值要写";
  9. console.log(name6());
  10. // 刚刚上面不会写,拿了老师的,还原了一下,看看我是哪里出错的
  11. // let f1 = () => '今天天气很好'
  12. // console.log(f1());
  13. // 还原
  14. // f1 = function () {
  15. // return '今天天气很好'
  16. // }
  17. // console.log(f1())

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂
整段代码附上:

  1. // 函数
  2. // 声明函数
  3. let name = "名";
  4. // 声明带名字的函数
  5. function namez(name) {
  6. return name + "字";
  7. }
  8. console.log(namez(name));
  9. // 声明俩参数 参数的值为1和2
  10. let a = 1;
  11. let b = 2;
  12. // 声明名字为namey的函数
  13. function namey(a, b) {
  14. return a + b;
  15. }
  16. console.log(namey(a, b));
  17. function nameq(php) {
  18. return "我爱" + php;
  19. }
  20. // 这里打印的时候要注意,参数的值需要用"",数字好像不需要↓
  21. console.log(nameq("php"));
  22. // ↓↓↓↓↓↓下面声明一个立即执行的函数↓↓↓↓↓
  23. function namew(wang) {
  24. console.log("我的名字是" + wang);
  25. }
  26. namew("王");
  27. // 上面这是立即执行的,感觉怪怪的,中间一个打印,
  28. console.log(
  29. (function namer(liu) {
  30. return "我的姓名是" + liu;
  31. })("刘")
  32. );
  33. // 尝试了好几遍才对,需要包含在打印的()里面,填写函数namer中liu的值↑
  34. // ↑↑↑↑上面这两种,是阅后即焚的声明函数↑↑↑↑↑
  35. // 函数表达式;
  36. // 看代码的意思是,声明一个变量,变量的值是一个函数,如下↓↓↓↓↓
  37. const Name = function naMe(dog) {
  38. return "狗英文单词是" + dog;
  39. };
  40. console.log(Name("dog"));
  41. console.log(Name);
  42. // 看到这个符号了吧,以后问别人这是什么意思,一定说是函数表达式 别被笑话
  43. // 上面这种就是声明一个参数,参数的值是一个函数↑↑↑↑↑↑↑↑↑↑
  44. // 匿名函数
  45. let name_a = function (niu) {
  46. return "这是" + niu + "的意思";
  47. };
  48. console.log(name_a("牛牛"));
  49. // 匿名函数
  50. let name1 = function (Name) {
  51. return "我的名字是" + Name;
  52. };
  53. console.log(name1("名字"));
  54. // 箭头函数的简写
  55. let name2 = function (a, b) {
  56. return a + b;
  57. };
  58. console.log(name2(1, 2));
  59. // 上面的简写写法为以下
  60. name2 = (a, b) => {
  61. return a + b;
  62. };
  63. console.log(name2(2, 3));
  64. // 上面简写的是去掉了functin,在()后面增加了=>胖头鱼符号{}
  65. // 上面是因为声明的参数中的函数有2个值,所以已经是最简方法了,但是当函数内就一个值的时候,还可以继续简写
  66. // 先写一个非简写法
  67. let name3 = function (Name3) {
  68. return Name3;
  69. };
  70. console.log(name3("非简写"));
  71. // 下面是简写写法
  72. name3 = Name3 => {
  73. return Name3;
  74. };
  75. console.log(name3("简写"));
  76. // 上面这是就一个值,下面再练习一下
  77. let name4 = function (Name4) {
  78. return "这是非" + Name4 + "写法";
  79. };
  80. console.log(name4("简体"));
  81. name4 = Name4 => {
  82. return "这是" + Name4 + "写法";
  83. };
  84. console.log(name4("简体"));
  85. // 上面这种写法 还可以简写 因为只有一个参数,且参数仅有一个return返回值简写方式如下
  86. name4 = Name4 => "这是" + Name4 + "因为就一个return,所以更简单的写法";
  87. console.log(name4("更简单的写法。"));
  88. // 还有,就是没有参数时,一定要把()写上,也就是匿名的时候,简体写法
  89. // 非简体匿名函数先写一段
  90. const name5 = function () {
  91. return "还原后学习到了,是因为返回值里面,也是个空参数 ,且非简体的时候,return这个返回值要写";
  92. };
  93. console.log(name5());
  94. //本来想更新一下的,发现声明用的const,不能再次声明了
  95. let name6 = () => "还原后学习到了,是因为返回值里面,也是个空参数 ,且非简体的时候,return这个返回值要写";
  96. console.log(name6());
  97. // 刚刚上面不会写,拿了老师的,还原了一下,看看我是哪里出错的
  98. // let f1 = () => '今天天气很好'
  99. // console.log(f1());
  100. // 还原
  101. // f1 = function () {
  102. // return '今天天气很好'
  103. // }
  104. // console.log(f1())

数据类型:

原始类型:

  1. // 原始类型有以下
  2. // number, string, boolean, undefined, null
  3. // 数字 字符 true false 未定义 空
  4. // 不可再分,是构成其他复合类型的基本单元
查看函数的原始类型:

代码:

  1. console.log(123, typeof 123);
  2. console.log("php", typeof "php");
  3. console.log(true, typeof true);
  4. console.log(undefined, typeof undefined);
  5. console.log(null, typeof null);

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂
上面是老师写的
下面是自己写的

  1. console.log(123, typeof 123);
  2. console.log("php", typeof "php");
  3. // 字符串的时候需要加''引号
  4. console.log(true, typeof true);
  5. console.log(false, typeof false);
  6. console.log(undefined, typeof undefined);
  7. console.log(null, typeof null);
  8. // Object 对象

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

原始类型的-单值类型:
  1. // 原始类型, 简单类型, 基本类型: 一个变量,存一个值
  2. // 单值类型
  3. let a = 1;
  4. console.log(typeof a);
  5. a = "php";
  6. console.log(typeof a);
  7. // 动态语言: 变量的类型, 由它的值的类型决定
  8. // ! 2. 引用类型
  9. // 引用类型, 都是对象, 默认返回 object ,函数除外 function
  10. // * array, object, function
  11. // 引用类型: 类似其它语言中的"复用类型", 集合类型
  12. // 引用类型的数据,由一个或多个, 相同, 或不同类型的"原始类型"的值构造
  13. // 是一个典型的: 多值类型

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

刚刚发现,这是老师写的
下面上自己写的
  1. //原始类型 又叫简单类型 单值类型, 比如声明一个变量a a的值=1
  2. let a = 1;
  3. console.log(a);
  4. console.log(a, typeof a);
  5. console.log(typeof a);
  6. // 瞎捣鼓的,老师的是最后这样写法
  7. a = "php";
  8. console.log(typeof a);
  9. a = "";
  10. console.log(typeof a);
  11. // 带了引号就是字符???
  12. // 从上面可以看得出来,变量 a 的类型由 值 a的值来决定的

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

引用类型:
  1. //引用类型
  2. // 引用类型, 都是对象, 默认返回 object ,函数除外 function
  3. // * array, object, function
  4. // 引用类型: 类似其它语言中的"复用类型", 集合类型
  5. // 引用类型的数据,由一个或多个, 相同, 或不同类型的"原始类型"的值构造
  6. // 是一个典型的: 多值类型
  7. // 这几句话是复制老师的
  8. // // // // // // // // //
  9. // 引用类型之数组类型
  10. // // // // // // // // //
引用类型—数组类型
  1. // 引用类型--数组类型
  2. let sz = ["app", 123, 8888];
  3. // 当前数组排序,我理解为0=app,1=123,2=8888
  4. // 打印一下看看
  5. console.log(sz);
  6. // 打印一下其中的值
  7. console.log(sz[1]);
  8. console.log(sz[2]);
  9. // 打印数组类型的正确方法
  10. console.log(Array.isArray(sz));
  11. // boolean 布尔类型

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

引用类型—对象类型

示例代码:

  1. //引用类型--对象类型
  2. // 对象类型类似数组类型
  3. let duixiang = { name: "对象", shuzi: 123, shuzi2: 678 };
  4. // 其中对象赋值的时候,要用英文的: ,不能用=
  5. // 下面调佣一下看看
  6. console.log(duixiang["name"]);
  7. // 声明的参数之后,这里需要用[''] 来调佣,注意注意
  8. // 那如果全部调佣改如何调佣呢?看下面
  9. console.log(duixiang);
  10. // 全部调佣不需要再加[]
  11. // 还有另外一种方式调用,例如全部调佣,
  12. console.log(duixiang.name, duixiang.shuzi, duixiang.shuzi2);
  13. // 直接使用变量.对象,来实现,不过这必须是合法对象,非合法对象不适用,例如下面的
  14. let duixiang2 = { "name mingzi": "名字", "name _mz": "名字2", name3: "名字3" };
  15. console.log(duixiang2["name _mz"]);
  16. // 上面是当对象是非法对象时,就必须以数组的方式来访问,必须用 变量[''] 这样
  17. // * 对象最吸引人的,不是数组的语义化封装, 而是对数据操作的封装, 方法(语法与函数是一样的)
  18. // 本质上来说, 对象, 就是变量与函数的封装, 内部, 变量->属性, 函数 -> 方法
  19. // 先声明一个对象

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂
声明一组对象且对象内包含函数:

  1. let os = {
  2. l: "linux",
  3. shuliang: 3,
  4. jiage: 100,
  5. zongji: function () {
  6. // let sl =
  7. // '当前' +
  8. // os.l +
  9. // '数量为' +
  10. // os.shuliang +
  11. // '单价为' +
  12. // os.jiage +
  13. // '总价为' +
  14. // os.shuliang * os.jiage +
  15. // '元'
  16. // return sl
  17. // 需要返回一下 return
  18. // 上面是使用常规方式来实现的,下面是用this来实现
  19. let sl =
  20. "当前" + this.l + "数量为" + this.shuliang + "单价为" + this.jiage + "总价为" + this.shuliang * os.jiage + "元";
  21. return sl;
  22. // 这里的this,相当于声明的那个变量 os的替换变量,当变量os改了之后,并不需要在对象里面的函数里面,挨个更改
  23. },
  24. };
  25. console.log(os.zongji());
  26. // console.log(os['zongji'])这是一个错误的写法,
  27. // 自己试了试,其实可以这么理解,虽然声明的对象里面,如果出现了函数,就以函数的方式调佣,比如console.log(os.zongji())
  28. // 打印上面的数据类型
  29. console.log(typeof os);
  30. // 上面提示的是对象
  31. console.log(os instanceof Object);
  32. // 上面提示的是布尔型

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂
在实际工作中,数组和对象一般都是一起使用,使用演示如下
代码部分:

  1. os = [
  2. { name: "linux服务器", shuliang: 2, jiage: 100 },
  3. { name: "win7服务器", shuliang: 2, jiage: 100 },
  4. ];
  5. console.log(os[0]);
  6. console.log(os[1]);
  7. // let res = obj.map(item => item.num * item.price).reduce((acc, cur) => acc + cur);
  8. // console.log(res);老师的js,也不知道怎么用

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

函数

代码部分:

  1. // 函数是一种数据类型 , 并且 还是 对象
  2. console.log(typeof function () {});
  3. // 函数即是函数, 也是对象
  4. console.log(function () {} instanceof Object);
  5. // 这句拿的老师的,
  6. // ! (一) 函数是数据类型的好处?
  7. // 可以当成普通值来使用, 例如充当函数的参数,或者函数的返回值
  8. // 这个很重要, 当参数,就是回调函数, 当返回值,可以创建一个闭包
  9. // js中很多高级应用, 都严重依赖这二个功能, 这也是"高阶函数"的基本特征
  10. // * 应用场景1: 函数做为参数使用, 回调
  11. function f1(hanshu) {
  12. return console.log(hanshu());
  13. }
  14. ///应用场景1,没看懂,得后面学习
  15. // 调用f1, 匿名函数当成f1的参数
  16. f1(function () {
  17. return "Hello 朱老师";
  18. });
  19. // 这里挑起了定义的function函数,
  20. //函数是可以当成一个值的!
  21. //既然可以看成一个值,那么就可以当作参数传递给函数!f1函数的参数就是一个函数类型!
  22. //所以在调用的时候就需要给它传入一个函数!这样才能和上面的函数声明对应上
  23. //还学不会,就去看视频去吧,记住 , 凡是像 123 这样的值, 能出现的地方, 函数都可以出现
  24. // * 应用场景2: 函数当成返回值, 闭包
  25. function f2() {
  26. let a = 1;
  27. return function () {
  28. return a++;
  29. };
  30. }
  31. function f3() {
  32. let a = 5;
  33. return function () {
  34. return a++;
  35. };
  36. }
  37. // f2()返回值是一个函数
  38. console.log(f2());
  39. const f = f2();
  40. console.log(f);
  41. console.log(f());
  42. console.log(f());
  43. console.log(f());
  44. console.log(f());
  45. console.log(f());
  46. console.log(f());
  47. console.log(f3());
  48. let d = f3();
  49. console.log(d);
  50. console.log(d());
  51. console.log(d());
  52. console.log(d());
  53. console.log(d());
  54. //* 以上的 回调 + 闭包, 都 是 函数当成"值"来用的经典应用场景
  55. // * 以下是函数当成对象来用
  56. // * 对象有属性和方法, 当然函数也有属性有方法
  57. function func(a, b) {
  58. return a + b;
  59. }
  60. // 查看函数名
  61. console.log(func.name);
  62. // 查看函数需要几个参数
  63. console.log(func.length);
  64. func.email = "498668472@qq.com";
  65. console.log(func.email);
  66. console.log(func(2, 3));
  67. // ! 函数当成对象有啥用呢?
  68. // * 用处太大了, 整个JS语言体系就靠它撑着了
  69. // * 就算是你没学过编程, 至少听说过面向对象编程, 对象可以被继承,实现代码复用
  70. // * 而JS就是基于原型,实现的继承, 而原型,就是在函数上创建一个普通对象而已
  71. // console.log(func.prototype);
  72. // * 后面要学到的类class,构造函数, 他们都是基于"函数是对象"这个前提的

示例截图:
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂
声明函数立即执行函数及匿名函数,以及函数的简写,和查看数据类型的原始类型以及以数组及对象的引用类型,函数类型的应用场景目前稀里糊涂

自己写的代码如下:
  1. // 数据类型
  2. // 原始类型有以下
  3. // number, string, boolean, undefined, null
  4. // 数字 字符 true false 未定义 空
  5. // 不可再分,是构成其他复合类型的基本单元
  6. console.log(123, typeof 123)
  7. console.log('php', typeof 'php')
  8. // 字符串的时候需要加''引号
  9. console.log(true, typeof true)
  10. console.log(false, typeof false)
  11. console.log(undefined, typeof undefined)
  12. console.log(null, typeof null)
  13. // Object 对象
  14. //原始类型 又叫简单类型 单值类型, 比如声明一个变量a a的值=1
  15. let a = 1
  16. console.log(a)
  17. console.log(a, typeof a)
  18. console.log(typeof a)
  19. // 瞎捣鼓的,老师的是最后这样写法
  20. a = 'php'
  21. console.log(typeof a)
  22. a = ''
  23. console.log(typeof a)
  24. // 带了引号就是字符???
  25. // 从上面可以看得出来,变量 a 的类型由 值 a的值来决定的
  26. //引用类型
  27. // 引用类型, 都是对象, 默认返回 object ,函数除外 function
  28. // * array, object, function
  29. // 引用类型: 类似其它语言中的"复用类型", 集合类型
  30. // 引用类型的数据,由一个或多个, 相同, 或不同类型的"原始类型"的值构造
  31. // 是一个典型的: 多值类型
  32. // 这几句话是复制老师的
  33. // // // // // // // // //
  34. // 引用类型之数组类型
  35. // // // // // // // // //
  36. // 引用类型--数组类型
  37. let sz = ['app', 123, 8888]
  38. // 当前数组排序,我理解为0=app,1=123,2=8888
  39. // 打印一下看看
  40. console.log(sz)
  41. // 打印一下其中的值
  42. console.log(sz[1])
  43. console.log(sz[2])
  44. // 打印数组类型的正确方法
  45. console.log(Array.isArray(sz))
  46. // boolean 布尔类型
  47. //引用类型--对象类型
  48. // 对象类型类似数组类型
  49. let duixiang = { name: '对象', shuzi: 123, shuzi2: 678 }
  50. // 其中对象赋值的时候,要用英文的: ,不能用=
  51. // 下面调佣一下看看
  52. console.log(duixiang['name'])
  53. // 声明的参数之后,这里需要用[''] 来调佣,注意注意
  54. // 那如果全部调佣改如何调佣呢?看下面
  55. console.log(duixiang)
  56. // 全部调佣不需要再加[]
  57. // 还有另外一种方式调用,例如全部调佣,
  58. console.log(duixiang.name, duixiang.shuzi, duixiang.shuzi2)
  59. // 直接使用变量.对象,来实现,不过这必须是合法对象,非合法对象不适用,例如下面的
  60. let duixiang2 = { 'name mingzi': '名字', 'name _mz': '名字2', name3: '名字3' }
  61. console.log(duixiang2['name _mz'])
  62. // 上面是当对象是非法对象时,就必须以数组的方式来访问,必须用 变量[''] 这样
  63. // * 对象最吸引人的,不是数组的语义化封装, 而是对数据操作的封装, 方法(语法与函数是一样的)
  64. // 本质上来说, 对象, 就是变量与函数的封装, 内部, 变量->属性, 函数 -> 方法
  65. // 先声明一个对象
  66. let os = {
  67. l: 'linux',
  68. shuliang: 3,
  69. jiage: 100,
  70. zongji: function () {
  71. // let sl =
  72. // '当前' +
  73. // os.l +
  74. // '数量为' +
  75. // os.shuliang +
  76. // '单价为' +
  77. // os.jiage +
  78. // '总价为' +
  79. // os.shuliang * os.jiage +
  80. // '元'
  81. // return sl
  82. // 需要返回一下 return
  83. // 上面是使用常规方式来实现的,下面是用this来实现
  84. let sl =
  85. '当前' +
  86. this.l +
  87. '数量为' +
  88. this.shuliang +
  89. '单价为' +
  90. this.jiage +
  91. '总价为' +
  92. this.shuliang * os.jiage +
  93. '元'
  94. return sl
  95. // 这里的this,相当于声明的那个变量 os的替换变量,当变量os改了之后,并不需要在对象里面的函数里面,挨个更改
  96. },
  97. }
  98. console.log(os.zongji())
  99. // console.log(os['zongji'])这是一个错误的写法,
  100. // 自己试了试,其实可以这么理解,虽然声明的对象里面,如果出现了函数,就以函数的方式调佣,比如console.log(os.zongji())
  101. // 打印上面的数据类型
  102. console.log(typeof os)
  103. // 上面提示的是对象
  104. console.log(os instanceof Object)
  105. // 上面提示的是布尔型
  106. // 在实际工作中,数组和对象一般都是一起使用,使用演示如下
  107. os = [
  108. { name: 'linux服务器', shuliang: 2, jiage: 100 },
  109. { name: 'win7服务器', shuliang: 2, jiage: 100 },
  110. ]
  111. console.log(os[0])
  112. console.log(os[1])
  113. // let res = obj.map(item => item.num * item.price).reduce((acc, cur) => acc + cur);
  114. // console.log(res);老师的js,也不知道怎么用
  115. // ! 3. 函数
  116. // 函数是一种数据类型 , 并且 还是 对象
  117. console.log(typeof function () {})
  118. // 函数即是函数, 也是对象
  119. console.log(function () {} instanceof Object)
  120. // 这句拿的老师的,
  121. // ! (一) 函数是数据类型的好处?
  122. // 可以当成普通值来使用, 例如充当函数的参数,或者函数的返回值
  123. // 这个很重要, 当参数,就是回调函数, 当返回值,可以创建一个闭包
  124. // js中很多高级应用, 都严重依赖这二个功能, 这也是"高阶函数"的基本特征
  125. // * 应用场景1: 函数做为参数使用, 回调
  126. function f1(hanshu) {
  127. return console.log(hanshu())
  128. }
  129. ///应用场景1,没看懂,得后面学习
  130. // 调用f1, 匿名函数当成f1的参数
  131. f1(function () {
  132. return 'Hello 朱老师'
  133. })
  134. // 这里挑起了定义的function函数,
  135. //函数是可以当成一个值的!
  136. //既然可以看成一个值,那么就可以当作参数传递给函数!f1函数的参数就是一个函数类型!
  137. //所以在调用的时候就需要给它传入一个函数!这样才能和上面的函数声明对应上
  138. //还学不会,就去看视频去吧,记住 , 凡是像 123 这样的值, 能出现的地方, 函数都可以出现
  139. // * 应用场景2: 函数当成返回值, 闭包
  140. function f2() {
  141. let a = 1
  142. return function () {
  143. return a++
  144. }
  145. }
  146. function f3() {
  147. let a = 5
  148. return function () {
  149. return a++
  150. }
  151. }
  152. // f2()返回值是一个函数
  153. console.log(f2())
  154. const f = f2()
  155. console.log(f)
  156. console.log(f())
  157. console.log(f())
  158. console.log(f())
  159. console.log(f())
  160. console.log(f())
  161. console.log(f())
  162. console.log(f3())
  163. let d = f3()
  164. console.log(d)
  165. console.log(d())
  166. console.log(d())
  167. console.log(d())
  168. console.log(d())
  169. //* 以上的 回调 + 闭包, 都 是 函数当成"值"来用的经典应用场景
  170. // * 以下是函数当成对象来用
  171. // * 对象有属性和方法, 当然函数也有属性有方法
  172. function func(a, b) {
  173. return a + b
  174. }
  175. // 查看函数名
  176. console.log(func.name)
  177. // 查看函数需要几个参数
  178. console.log(func.length)
  179. func.email = '498668472@qq.com'
  180. console.log(func.email)
  181. console.log(func(2, 3))
  182. // ! 函数当成对象有啥用呢?
  183. // * 用处太大了, 整个JS语言体系就靠它撑着了
  184. // * 就算是你没学过编程, 至少听说过面向对象编程, 对象可以被继承,实现代码复用
  185. // * 而JS就是基于原型,实现的继承, 而原型,就是在函数上创建一个普通对象而已
  186. // console.log(func.prototype);
  187. // * 后面要学到的类class,构造函数, 他们都是基于"函数是对象"这个前提的

老师的代码学习部分

  1. // ! 细说函数
  2. // ! 1. 命名函数
  3. // 有名字的函数
  4. // 命名: 动 + 名
  5. // 声明
  6. function getName(username) {
  7. return "Hello " + username;
  8. }
  9. // 调用
  10. console.log(getName("猪老师"));
  11. // ! 2. 匿名函数
  12. // 没有名字的函数
  13. // function (username) {
  14. // return "Hello " + username;
  15. // }
  16. // * 执行方式1: 立即执行
  17. // * 立即执行函数( IIFE ): 声明 + 执行 2合1
  18. // ! 2.1 IIFE
  19. (function (username) {
  20. console.log("Hello " + username);
  21. })("灭绝老师");
  22. console.log(
  23. (function (username) {
  24. return "Hello " + username;
  25. })("灭绝老师")
  26. );
  27. // * IIFE: 阅后即焚, 不会给全局环境带来任何的污染,用来创建临时作用域
  28. // node 模块, 就是用 IIFE 来写的
  29. // * 执行方式2: 保存到一个变量中,
  30. // ! 2.2 函数表达式
  31. // 现在, "函数声明", 就变成了"变量声明", 只不过, 变量的值,是一个函数声明
  32. const getUserName = function (username) {
  33. return "Hello " + username;
  34. };
  35. // ! 表达式: 任何一个可以计算出确定 "值" 的过程
  36. // * 100, 12+45, 'a'+'c',
  37. console.log(getUserName("马老师"));
  38. console.log(getUserName);
  39. // ! 3. 箭头函数
  40. // 匿名函数: 函数表达式, 将函数声明保存到一个变量中, 以后使用这个变量来引用这个函数
  41. let f1 = function (a, b) {
  42. return a + b;
  43. };
  44. console.log(f1(10, 20));
  45. // 使用 箭头函数 来简化匿名函数的声明
  46. // 匿名函数 --> 箭头函数的语法
  47. // * 1. 去掉 function
  48. // * 2. 在参数括号(...) 与 大括号{...} 之间使用 胖箭头 => 连接
  49. f1 = (a, b) => {
  50. return a + b;
  51. };
  52. console.log(f1(8, 9));
  53. // 只有一个参数的时候, 括号可以不要了
  54. f1 = username => {
  55. return "Hello " + username;
  56. };
  57. // 如果只有一条语句,return ,可以不写大括号
  58. // 因为只有一条语句,默认就是return ,所以 return 也可以不写的
  59. f1 = x => {
  60. return x * 2;
  61. };
  62. f1 = x => x * 2;
  63. console.log(f1(40));
  64. console.log(f1(90));
  65. // 没有参数时, 括号一定要写上
  66. f1 = () => "今天天气很好";
  67. console.log(f1());
  68. f1 = $ => 100 + 200;
  69. console.log(f1());
  70. f1 = _ => 100 + 200;
  71. console.log(f1());
  72. // 箭头函数, 内部的 this, 是固定的, 与它的上下文绑定 , 不能充当构造函数来创建对象
  73. // 箭头函数内部没有 arguments 对象
  74. // ! 使用场景
  75. // 1. 如果函数需要多次调用, 用命名, 函数表达式, 都可以
  76. // 2. 如果代码要求,必须遵循"先声明, 再调用"的规则, 那就必须用"函数表达式"
  77. // 3. 如果只有完成一些特定的,一次性的工作, 不想留下任何痕迹, 用"IIFE", 模块
  78. // 4. 如果调用函数时,需要一个函数充当参数,例如:回调, 就可以使用箭头函数来简化 匿名函数的 声明
  1. // ! 数据类型
  2. // ! 1. 原始类型
  3. // * number, string, boolean, undefined, null
  4. // 不可再分, 是构成其它复合类型的基本单元
  5. console.log(123, typeof 123);
  6. console.log("php", typeof "php");
  7. console.log(true, typeof true);
  8. console.log(undefined, typeof undefined);
  9. console.log(null, typeof null);
  10. // 原始类型, 简单类型, 基本类型: 一个变量,存一个值
  11. // 单值类型
  12. let a = 1;
  13. console.log(typeof a);
  14. a = "php";
  15. console.log(typeof a);
  16. // 动态语言: 变量的类型, 由它的值的类型决定
  17. // ! 2. 引用类型
  18. // 引用类型, 都是对象, 默认返回 object ,函数除外 function
  19. // * array, object, function
  20. // 引用类型: 类似其它语言中的"复用类型", 集合类型
  21. // 引用类型的数据,由一个或多个, 相同, 或不同类型的"原始类型"的值构造
  22. // 是一个典型的: 多值类型
  23. // ! 2.1 数组
  24. // 声明
  25. const arr = ["手机", 2, 5000];
  26. console.log(arr);
  27. // 数组的索引是从0开始递增的正整数, 0, 1, 2
  28. console.log(arr[0]);
  29. console.log(arr[1]);
  30. console.log(arr[2]);
  31. console.log(arr[3]);
  32. console.log(typeof arr);
  33. // 判断数组类型的正确方法
  34. console.log(Array.isArray(arr));
  35. // 为了更直观的表达数据之间的关联, 可以将 数字索引 换 有意义 的"字符串"
  36. // const arr1 = { 0: "手机", 1: 2, 2: 5000 };
  37. // console.log(arr1);
  38. // console.log(arr1[0]);
  39. // console.log(arr1[1]);
  40. // ! 2.2 对象
  41. // 对象 更像一个语义化的 数组
  42. // name, num , price : 属性,类似于变量
  43. let obj = { name: "手机", num: 2, price: 5000 };
  44. console.log(obj);
  45. console.log(obj["name"]);
  46. console.log(obj["num"]);
  47. console.log(obj["price"]);
  48. // 因为对象的属性名称都是合法的标识符,可以使用点来访问
  49. console.log(obj.name, obj.num, obj.price);
  50. // 当属性名是非常标识符时, 必须使用数组的方式来访问对象的属性
  51. obj = { "my email": "admin@php.cn" };
  52. console.log(obj["my email"]);
  53. // * 对象最吸引人的,不是数组的语义化封装, 而是对数据操作的封装, 方法(语法与函数是一样的)
  54. // 本质上来说, 对象, 就是变量与函数的封装, 内部, 变量->属性, 函数 -> 方法
  55. obj = {
  56. // name, num, price: 属性, 类似于变量
  57. name: "手机",
  58. num: 3,
  59. price: 7000,
  60. // total: 方法,实际上还是一个属性,只不过它的值是一个函数
  61. total: function () {
  62. // let str = obj.name + " 总计: " + obj.num * obj.price + " 元 ";
  63. // 模板字面量, 来简化, 内部有变量的字符串
  64. // let str = obj.name + " 总计: " + obj.num * obj.price + " 元 ";
  65. // 反引号声明的模板字符串, 可以插入变量/表达式, 这叫"插值"
  66. // 应该是对象内部, 使用 当前对象的一个引用, 这样才独立于外部对象
  67. // let str = `${obj.name} 总计 ${obj.num * obj.price} 元`;
  68. // this: 始终与当前对象绑定(执行环境 / 执行上下文 )
  69. // this = obj
  70. let str = `${this.name} 总计 ${this.num * this.price} 元`;
  71. return str;
  72. },
  73. };
  74. console.log(obj.total());
  75. console.log(typeof obj);
  76. console.log(obj instanceof Object);
  77. // 实际工作中, 而是将数组与对象组合起来一起用
  78. // obj是一个由三个对象构成的数组
  79. obj = [
  80. { name: "手机", num: 2, price: 5000 },
  81. { name: "电脑", num: 2, price: 5000 },
  82. { name: "相机", num: 2, price: 5000 },
  83. ];
  84. // 求三个商品的总和
  85. let res = obj.map(item => item.num * item.price).reduce((acc, cur) => acc + cur);
  86. console.log(res);
  87. // ! 3. 函数
  88. // 函数是一种数据类型 , 并且 还是 对象
  89. console.log(typeof function () {});
  90. // 函数即是函数, 也是对象
  91. console.log(function () {} instanceof Object);
  92. // ! (一) 函数是数据类型的好处?
  93. // 可以当成普通值来使用, 例如充当函数的参数,或者函数的返回值
  94. // 这个很重要, 当参数,就是回调函数, 当返回值,可以创建一个闭包
  95. // js中很多高级应用, 都严重依赖这二个功能, 这也是"高阶函数"的基本特征
  96. // 函数是js的一等公民, 就是通过这个体现的
  97. // * 应用场景1: 函数做为参数使用, 回调
  98. function f1(callback) {
  99. // 参数 callback 是一个函数
  100. console.log(callback());
  101. }
  102. // 调用f1, 匿名函数当成f1的参数
  103. f1(function () {
  104. return "Hello 朱老师";
  105. });
  106. // * 应用场景2: 函数当成返回值, 闭包
  107. function f2() {
  108. let a = 1;
  109. return function () {
  110. return a++;
  111. };
  112. }
  113. // f2()返回值是一个函数
  114. console.log(f2());
  115. const f = f2();
  116. console.log(f);
  117. console.log(f());
  118. console.log(f());
  119. console.log(f());
  120. console.log(f());
  121. console.log(f());
  122. console.log(f());
  123. //* 以上的 回调 + 闭包, 都 是 函数当成"值"来用的经典应用场景
  124. // * 以下是函数当成对象来用
  125. // * 对象有属性和方法, 当然函数也有属性有方法
  126. function func(a, b) {
  127. return a + b;
  128. }
  129. // 查看函数名
  130. console.log(func.name);
  131. // 查看函数需要几个参数
  132. console.log(func.length);
  133. func.email = "498668472@qq.com";
  134. console.log(func.email);
  135. console.log(func(1, 2));
  136. console.log(func);
  137. // ! 函数当成对象有啥用呢?
  138. // * 用处太大了, 整个JS语言体系就靠它撑着了
  139. // * 就算是你没学过编程, 至少听说过面向对象编程, 对象可以被继承,实现代码复用
  140. // * 而JS就是基于原型,实现的继承, 而原型,就是在函数上创建一个普通对象而已
  141. // console.log(func.prototype);
  142. // * 后面要学到的类class,构造函数, 他们都是基于"函数是对象"这个前提的