初级函数返回值

 返回值

什么是函数返回值：函数执行后的结果外部需要使用的时候，我们不能直接给予，是需要通过return返回。

1、执行函数完毕之后，返回的数据

2、有return的函数就有返回值，反之则没有返回undefined

3、把函数内部的值赋值给外边

    var j=fn(2,3);
    console.log(j);
    function  fn(a,b) {
        var c=a+b;
        // 如果我们想把函数内部的值赋值给外部，必须使用return;
        //如果没有return或则return没有值，函数返回undefine
        return c;
    }

4、如果没有return或则return没有值，函数返回undefined

5、函数通过运算来的值是半成品，需要二次加工

    外边要哪个值，我们就返回哪个值

  function  fn() {
        var sum=0;
        for(var i=1; i<=100; i++){
            sum+=i
        }
        //外边要用那个值，就返回那个值
        return sum;
    }
   var tu=fn()+50；
    console.log(tu)

6、函数返回值，必须执行得到

7、函数执行完return后会立即结束，return后面的代码不会执行

 function fn(){
        console.log(1);
        console.log(2);
        return;
        //函数执行完return后会立即结束，return后面的代码不会执行
        console.log(3)
    };
    fn()

8、函数的返回值必须要执行才可以得到

9、return 可以截断循环

 

案例

    //求园的面积 pi*r的平方
    function getArea(r){
        //通俗版
        var pi=3.14;
        var a=pi*r*r;
        return a;

        //精简版
        var pi=Math.PI;
        var a=pi*Math.pow(r,2);
        return a;

        //最终版
        return Math.PI*Math.pow(r,2)
    }
    var area1=getArea(1);
    console.log(area1)

  //求俩个数中最大值
  function  fu(num1,num2) {
         if(num1>num2){
             return num1
         }else{
             return num2
         }
         if(num1>num2){
             return num1
         }
         return num2;
         return num1>num2? num1: num2;
     }
     console.log(fu(1,3))

//求三个数中最大值
    function  fn(a,b,c) {
        var j=a>b? a: b;
        return j>c? j: c;
        //经典版
        return (a>b? a:b)>c?(a>b? a: b):c;
        
        if(a>b){
            if(a>c){
                return a
            }else{
                return c
            }
        }else if(d>c){
            return d
        }else {
            return c
        }
    }
    console.log(fn(1,3,5))

   //求三个数中最大值
    var arr=[-1,-2,0,2,3];
    function fu(array) {
        //用的必须是形参的数组中的第一项
        var max=array[0];
        //判断数组中的每一项，如果大于max,那么把他赋值给max
        for(var i=1; i<=array.length; i++){
            if(array[i]>max){
                max=array[i];
            }
        }
        //书写位置要注意，一定是整个for循环执行完毕之后再返回。
        return max;
    }
    console.log(fu(arr))

//翻转数组，返回一个新数组 （）

    //用俩种方法做，第一种创建新数组， 建议使用这个
    var arr=[1,2,3,4,5];
    var arr2=fu(arr);
    console.log(arr2);
    function fu(newArr){
        //定义一个新数组，吧老数组中的元素反向添加到新数组中
        var arrs=[];
        for(var i=newArr.length-1; i>=0; i--){
            arrs[arrs.length]=newArr[i]
        }
        return arrs;
    }

    //第二种直接修改原数组 没有return是原数组修改，不建议
    var arr=[1,2,3,4,5];

    //console.log(fu(arr));//这个方法没有返回值，返回的undefined 不建议用

    function fu(newArr){
        for(var i=0; i<newArr.length/2; i++ ){
            var temp=newArr[i]; //把原来的数组放在里面，以便调换
            newArr[i]=newArr[newArr.length-1-i];
            newArr[newArr.length-1-i]=temp
        }
        return newArr;
    }
    fu(arr);//是普通的调用函数,可以不用返回值
    console.log(arr)

 //对数组排序，从小到大，用到冒泡
    var arr=[2,5,3,1,6,4];
    function fn(newArr) {
        //外循环控制轮数（元素-1）
        for(var i=0; i<newArr.length-1; i++){
            //开闭原则（标志，标识，旗帜）
            var flag=true;
            //内循环控制次数（元素-1）
            for(var j=0; j<newArr.length-1-i; j++){
                if(newArr[j]>newArr[j+1]){
                    //判断符合标准就交换位置
                    var nemy=newArr[j];
                    newArr[j]=newArr[j+1];
                    newArr[j+1]=nemy;
                    flag=false;
                }
            }
            if(flag){
                return newArr;
            }
        }
    }
    var aa=fn(arr);
    console.log(aa);