num += class 經典 加工 代碼 執行函數 undefined 結果

返回值

什麽是函數返回值：函數執行後的結果外部需要使用的時候，我們不能直接給予，是需要通過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);

初級函數返回值