JS里的函数/求质数

118 阅读4分钟

函数

     * 什么是 函数
     *      首先排除 不是数学中的函数
     *
     *  函数 可以理解为一个盒子
     *
     *      为什么要有函数, 函数功能是什么
     *          帮我们把项目中多个 地方使用到的功能(代码段), 抽离出来(就把他拿到那个小盒子, 就不需要在多个地方书写重复的功能)
     *          然后在需要的地方 调用函数即可
    
    // for (var i = 0; i < 3; i++) {   // 假设 这是我当前项目中 多次使用到的一个常用功能, 比如说这个for循环在 20个地方都有用到
    //     console.log(i)
    // }

    /**
     * 写一个函数(或者说一个完整的函数)
     *      分为两部分
     *          1. 定义阶段 function fn(){}
     *          2. 调用阶段 fn()
    */
    
    

函数的定义:

/**
     * 函数的定义
     * 
     *  语法:   function () {}
     * 
     * 两种定义函数的方式
     *      1. 赋值式定义
     *          var fn = function () {}
     *      2. 声明式定义
     *          function 函数名() {}
    */
    // 赋值式定义
    var fn = function () {
        console.log(fn)
    }
    

    // 声明式定义
    function fn1() {
        console.log(fn1)
    }
    

    /**
     *  function () {}  ---> 匿名函数
     *      function    关键字, 表明后续紧跟一段代码, 是函数
     *      ()          内部书写, 参数      后续讲,暂时先记住, 暂时理解为 固定写法 
     *      {}          内部书写, 函数调用执行时 的代码(可以理解为 要执行的代码)
     * 
     *  function fn1() {}   ---> 具名函数
     *      funtion     关键字, 同上
     *      fn1         函数名, 将来可以通过 这个名字(变量) 去调用(去找到)本函数
     *      ()          参数, 同上
     *      {}          要执行的代码段, 同上
    */
    
    

函数的调用:

 赋值式定义
    var fn = function () {
        console.log(111)
    }    
     他没有函数名, 但是存储在变量 fn 中, 所以我们可以把 fn 理解为当前这段函数的函数名


     声明式定义
    function fn1() {
        console.log(222)
    }

   
     *  不管函数定义是如何定义的, 调用方式永远只有一种
     *  
     *      语法:   函数名()
    

    fn()
    fn1()

函数的声明式和赋值式:

   * 函数声明式和赋值式的区别
     * 
     *  1. 书写不同
     *  2. 打印时, 声明式 会带上函数名, 赋值式没有
     * 
     *  3. 调用时有差异
     *      声明式: 可以在函数定义前 调用
    */
     var fn = function () {}
     function fn1 () {}


    fn1()    111
    function fn1() {
        console.log(111)
    }
    fn1()    111

    fn()     fn is not a function
    var fn = function () {
        console.log(222)
    }
    fn()    // 222

 
     * 正常书写
     *      var fn = function () {
                console.log(222)
            }

        浏览器 做 变量提升
            var fn; 备注: 这一行会在当前最开始的哪一行, 第一行

            fn()    fn is not a function     原因在于, 此时 fn 经过变量提升后, 有 fn, 但 值为 undefined
            fn = function () {
                console.log(222)
            }
            
     

函数的参数:

         *  函数的参数是做什么
     * 
     *      我们的函数在不写参数的时候, 可以正常执行
     *      但! 功能相对单一
     * 
     *      如果函数想要真正的灵活起来, 在多个地方调用时 有不同的执行, 那么 我们可以通过 函数的参数来完成
     * 
     *  参数分为两个
     *      形参    函数名后(function) 后边的小括号内部, 每书写一个 就相当于在函数内部声明一个变量, 可以在函数内部去调用
     *      实参    调用函数时的小括号内部书写的值, 就是实参, 实参与形参为 一一对应的关系
     * 
     *  形参与实参会一一对应
     *          如果实参数量 少于 形参  那么前边的形参对应接受值, 没有对应实参 的 形参 值 为 undefined
     *          如果形参数量 少于 实参  那么会一一对应后, 多余的实参 无法通过 参数获取
    

    // function fn1(a, b) {    // 相当于 在函数内部创建两个变量 叫做 a 和 b, 他们的值有 实参决定
    //     console.log(a, b)
    // }
    // fn1(1, 2)   // 1 , 2
    // fn1('aaa', 'bbb')   // 'aaa'    'bbb'

    function add(a, b) {
        console.log(a + b)
    }

    add(1, 2)   // 3
    add(1, '2')   // '12'
    
    

求质数:

  判断一个数字  是不是质数
   除了1 和本身 ,其他都不能整除
   循环,从 1 开始,到自己本身结束
      1和自己本身不需要考虑
      可以从 2 开始
      当大于数字的一半的时候,肯定不能整除
      
 var num = prompt('请输入一个数字, 用于检测是否为质数') - 0
    // var count = 0
    // for (var i = 2; i < num; i++) {
    //     if (num % i == 0) {
    //         count = count + 40
    //     }
    // }

   
     *  需不需要参数
     *      需要 1个
     *  需不需返回值
     *      需要, 并最好是布尔值 是质数返回true, 不是质数返回false
 

   function fn(a) {
         1. 判断传入参数是否为质数
        var count = 0   // 计数器
        for (var i = 2; i < a; i++) {
            if (a % i == 0) {
                count = count + 20  // 只是为了让 count 有变化, 具体+40 还是加多少, 无所谓
            }
        }

        // 2. 根据传入的参数决定返回什么值
        if (count == 0) {
            // 应该是 质数
            return true
        } else {
            // 这里 不是 质数
            return false
        }
    }
    var a = fn(9)   // 9 不是质数, 所以最终返回值应该是 false
    console.log(a)

    var a1 = fn(7)   // 7 是质数, 所以最终返回值应该是 true
    console.log(a1)