JavaScript第四日学习笔记

一：嵌套循环业务数据

嵌套循环是指在一个循环语句中包含另一个或多个循环语句的编程概念。在JavaScript中，嵌套循环可以让你在一个循环内部执行另一个循环，从而实现更复杂的迭代逻辑。

嵌套循环通常使用嵌套的for循环来实现。语法上，你可以将一个for循环放在另一个for循环的循环体内部。这样在每次外部循环迭代时，内部循环都会完整地执行一次。

使用嵌套循环时要注意控制循环的条件和循环变量的变化，以避免无限循环或不必要的迭代次数。嵌套循环的执行次数等于外部循环迭代次数乘以内部循环迭代次数，因此在处理大量数据或复杂逻辑时需要特别小心。

实例：

 var arr = [[10, 20, 30], ["JavaScript", "HTML/css", "MySQL", "TypeScript", "框架"], [true, false, "hello", 123, 0.5, 0.9]];
         var obj = { name: "karen", son: [{ name: "jack", age: 1 }, { name: "tom", age: 5 }, { name: "show", age: 10 }] }
         for (var i = 0; i < obj.son.length; i++) {
             console.log(obj.son[i].name, obj.son[i].age)
         }

运行结果：jack 1
         tom 5
         show 10


   var arr = [[10, 20, 30], ["JavaScript", "HTML/css", "MySQL", "TypeScript", "框架"], [true, false, "hello", 123, 0.5, .9]];
         console.log(arr[0][1])
         console.log(arr[1][4])

     for (var i = 0; i < arr.length; i++) {
             console.log(arr[0])

         }

运行结果：20  框架  [10,20,30]

二：函数的设计

在JavaScript中，函数是一种可重复使用的代码块，它接收输入（参数），执行特定的任务，并返回一个值。函数设计是指如何定义和组织函数以便有效地实现所需的功能。

以下是一些关于JavaScript函数设计的概念：

1. 功能单一性：每个函数应该只负责实现一个具体的功能。这有助于提高函数的可读性、可维护性和可复用性。如果一个函数的功能过于复杂，可以考虑将其拆分为几个更小的函数。

2. 参数设计：函数可以接收零个或多个参数。在设计函数时，要考虑到所需的输入，并通过参数进行传递。参数可以帮助函数根据不同的输入执行不同的操作，提高函数的通用性。

3. 返回值：函数可以选择返回一个值或不返回任何值。返回值可以用于将函数的计算结果传递给调用它的代码，也可以用于控制流程的状态。

4. 命名规范：函数应该使用有意义的名称来描述其功能。好的函数命名可以提高代码的可读性和可维护性。

5. 可重用性：设计具有可重用性的函数是很重要的。尽量使函数与具体的应用场景解耦，使其在不同的上下文中都能进行重复使用。

6. 函数注释：良好的函数设计应该包括对函数的注释，描述函数的目的、输入参数和返回值等信息。注释有助于理解和维护代码。

7. 函数的单一职责原则：每个函数应该只负责完成一个单一的任务，遵循函数的单一职责原则。这有助于代码的可读性和可维护性。

8. 函数的封装性：函数应该尽可能地封装内部实现细节，只暴露必要的接口和功能。封装性有助于隔离功能，减少代码的依赖性和耦合度。

以上是一些常见的JavaScript函数设计概念。设计良好的函数可以提高代码的可读性、可维护性和可重用性，使代码更加清晰和易于维护。

数据处理: 传入一个数据 ，然后给你处理成另外一种结果，返回出去。

实例练习：

//判断一个数是否为质数
             function fn(n) {
             if (n == 1) { return false }
             var i = 2;
             while (i < n) {
                 if (n % i == 0) { return false }
                 i++
             }
             return true;
         }
            var num = 1997
            var re = fn(num)
            console.log(re)

            console.log(fn(1))
            console.log(fn(99))

运行结果：true false false


        var arr = [23, 345, 434, 456, 5, 76, 6578, 7, 98]
         function fm(n1) {
             var temp = Infinity;//23 345
             for (var i = 0; i < n1.length; i++) {
                 if (n1[i] < temp) {
                    temp = n1[i]
                 }
             }

             return temp;
         }
         console.log(fm(arr))

运行结果：5

              function func(arg) {
              var arg= { x: 100, y: 200 }
              return arg.x + arg.y

        }

        var a = { x: 100, y: 200 }
        var obj = func(a)
         console.log(obj)

运行结果：300

第二段代码是一个找出数组中最小值的函数`fm`，并对给定的数组`arr`进行了测试。

首先，声明了一个包含一些数字的数组`arr`。

然后，定义了函数`fm`，该函数接受一个参数`n1`，表示一个数字数组。

在函数内部，声明了一个变量`temp`并赋值为正无穷，作为初始比较值。

接下来，通过循环遍历数组`n1`，依次比较数组中的每个元素是否小于`temp`。如果有更小的值，则将`temp`更新为当前元素的值。

最后，返回最小的值`temp`。

在代码的最后，通过`console.log(fm(arr))`来输出函数`fm`对数组`arr`的运行结果，即最小值。

因此，该代码的输出结果应该是5。

三：函数的参数

总的来说，函数参数分为两类：函数显式参数(Parameters)与隐式参数(Arguments) 。也就是我们所说的形参和实参。

函数也是一种引用数据，因为它也是一种特殊的对象，只要是对象就能使用点语法 访问成员(属性)，函数的length属性保存了这个函数的形参个数。

实参多了:不会有任何问题,只是代码性能不好，比如：

var re = fn(100, 200, 300, 400)     console.log(re)

实例练习：

         function fn(a, b) {
         var a=arguments[0]
         var b=arguments[1]

             console.log(arguments)//数组  里面装的是实参
             console.log(arguments.length)//实参个数
             console.log(a, b)
         }
         fn.length

        fn(10, 23, 3, 23, 3, 4)

        fn(100, 200)

        fn(666, 1, 1, 23, 1, 23)

运行结果：[10,23,3,23,3,4]  6    10,23
         [100,200]    2       100,23
         [666,1,1,23,1,23]  6   666,1

四：函数的返回值

在JavaScript中，函数的返回值是指函数执行完毕后返回给调用者的值。当函数被调用时，它可以执行一系列的操作，并返回一个值给调用者。

函数的返回值可以使用return语句指定。当函数执行到return语句时，它会立即停止执行，并将return后面的表达式的值作为返回值返回给调用者。

 函数调用一定可以生成一个结果,只不过函数生成的结果，可以使用，也可以不使用。

       1. 没有执行return ；

       2.执行了return 但是只有return,后面没有表达式；

       1,2都会生成undfined；

       3.有return 而且后面还有表达式 (原始,成员访问,函数调用,计算表达式) 把表达式的结果生成后返回出去。

实例练习：

         function fn(a) {
            return a + arguments[1]
        }

         function fm(n) {
             var a = n * n
           var re = fn(a, a - 1)
             return fn(a, a - 1)
         }

      var b = fm(5)
      console.log(b)

运行结果：49

五：函数的执行顺序

标识符的作用域

1.一个标识符，它在哪些地方能被正常使用，这些地方就是这个标识符起作用的地方，称之为标识符的作用域。

全局都能被访问的标识符就是全局标识符。

语法规则

1.函数内部的标识符只能在函数内部使用，函数外部不能使用。

2.访问一个标识符时，先访问当前作用域，没有就访问外层作用域，直到全局作用域。

访问：存和取

3.函数调用一次就会运行一次，而且函数调用如果在A作用域，它是在B作用域生成的，那么函数运行代码在B作用域。

参数和作用域

   在作用域生成时，用四个字概括：形（变），实，函，运。

   1.形参或者局部变量的声明

   2.实参赋值给形参变量

   3.内部的函数会声明

   4.运行代码

       
       //函数内部的标识符只能在函数内部使用 函数外部不能使用
        var a = 200
        function fn() {
             a--
             console.log(a)
         }
         fn();
         fn();

运行结果：199  198

      function fn() {
             var a = 200
            a--
            console.log(a)
         }
        fn();
        fn();

运行结果：199  199
 
       //访问一个标识符时  先访问当前作用域,没有就访问外层作用域 直到全局作用域
          var a = 20;
         function fn() {
             var a = 30;
             function fm() {
                 console.log(a)
                 c = 90
             }
             fm()
         }
         fn()
         console.log(c)

运行结果：30 90

       //函数调用一次就会运行一次,而且函数调用如果在A作用域 它是在B作用域生成的 那么函数运行代码在B作用域
          var a = 100
         function fn() {
             var a = 20
             function fm() { console.log(a) }
             return fm
         }
         var re = fn()
           re()
      运行结果：20

          var a = 10;
         function fn(a) {
             console.log(a)
             var a = 20
             console.log(a)
             function a() { }
           console.log(a)
         }
        console.log(a)
         fn(a)
根据四字口诀，可以很快地做出这道题。
运行结果：f a() {}  20  20  10  10